is_symlink in MEX if not native

Author: scivision

+stdlib/is_char_device.m

@@ -0,0 +1,25 @@
+%% IS_CHAR_DEVICE is path a character device
+% e.g. NUL, /dev/null
+% false if file does not exist
+
+function ok = is_char_device(p)
+arguments
+    p (1,1) string
+end
+
+if stdlib.isoctave()
+  ok = S_ISCHR(stat(p).mode);
+else
+  ok = is_char_device_mex(p);
+end
+
+end
+
+%!assert (!is_exe(''))
+%!test
+%! if ispc
+%!   n = "NUL";
+%! else
+%!   n = "/dev/null";
+%! end
+%! assert (is_char_device(n))

+stdlib/is_symlink.m

@@ -9,22 +9,21 @@
 try
   ok = isSymbolicLink(p);
 catch e
-  % must be absolute path
-  % NOT .canonical or symlink is gobbled!
-  p = stdlib.absolute(p, "", false);
-  op = javaPathObject(p);
-
-% https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/nio/file/Files.html#isSymbolicLink(java.nio.file.Path)
-% https://dev.java/learn/java-io/file-system/links/
-
   if strcmp(e.identifier, "MATLAB:UndefinedFunction")
-    ok = java.nio.file.Files.isSymbolicLink(op);
+    try
+      ok = is_symlink_mex(p);
+    catch e
+      if strcmp(e.identifier, "MATLAB:UndefinedFunction")
+        ok = java.nio.file.Files.isSymbolicLink(javaPathObject(stdlib.absolute(p, "", false)));
+      else
+        rethrow(e)
+      end
+    end
   elseif strcmp(e.identifier, "Octave:undefined-function")
-    ok = javaMethod("isSymbolicLink", "java.nio.file.Files", op);
+    ok = S_ISLNK(stat(p).mode);
   else
     rethrow(e)
   end
-
 end
 
 end

buildfile.m

@@ -16,8 +16,6 @@
 
   msvc = startsWith(cxx.ShortName, "MSVCPP");
 
-  % disp("Mex using: " + cxx.Name + " " + cxx.Version)
-
   std = "-std=c++17";
   compiler_id = "";
   % FIXME: Windows oneAPI
@@ -34,7 +32,7 @@
       if s == 0
         compiler_id = "CXX=g++-10";
       else
-        warning("GCC 10 not found, using default, may fail on runtime")
+        warning("GCC 10 not found, using default GCC " + cxx.Version + " may fail on runtime")
       end
     end
   end
@@ -51,7 +49,15 @@
 
   plan("clean") = matlab.buildtool.tasks.CleanTask;
 
-  plan("mex:is_char_device") = matlab.buildtool.tasks.MexTask("is_char_device.cpp", bindir, ...
+  plan("mex:is_char_device_mex") = matlab.buildtool.tasks.MexTask("src/is_char_device.cpp", bindir, ...
+    Options=[compiler_id, compiler_opt]);
+
+  is_symlink_src = ["src/is_symlink.cpp"];
+  if ispc
+    is_symlink_src(end+1) = "src/windows.cpp";
+  end
+
+  plan("mex:is_symlink_mex") = matlab.buildtool.tasks.MexTask(is_symlink_src, bindir, ...
     Options=[compiler_id, compiler_opt]);
 
   plan("test").Dependencies = "mex";

example/java/is_symlink.m

@@ -0,0 +1,12 @@
+function ok = is_symlink(p)
+% must be absolute path
+% NOT .canonical or symlink is gobbled!
+p = stdlib.absolute(p, "", false);
+op = javaPathObject(p);
+
+% https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/nio/file/Files.html#isSymbolicLink(java.nio.file.Path)
+% https://dev.java/learn/java-io/file-system/links/
+
+ok = java.nio.file.Files.isSymbolicLink(op);
+
+end

src/is_symlink.cpp

@@ -0,0 +1,76 @@
+// C++ Matlab MEX function using C++17 <filesystem>
+// https://www.mathworks.com/help/matlab/matlab_external/data-types-for-passing-mex-function-data-1.html
+
+#include "mex.hpp"
+#include "mexAdapter.hpp"
+
+#include <string>
+// note: <string_view> causes compile failures with MSVC at least
+
+#include <vector>
+#include <memory>
+
+#if defined(_WIN32)
+# include "win32_fs.h"
+#endif
+
+#if __has_include(<filesystem>)
+# include <filesystem>
+# include <system_error>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+
+static bool fs_is_symlink(std::string path)
+{
+
+#if defined(__MINGW32__) || (defined(_WIN32) && !defined(__cpp_lib_filesystem))
+  return fs_win32_is_symlink(path);
+#elif defined(__cpp_lib_filesystem)
+// std::filesystem::symlink_status doesn't detect symlinks on MinGW
+  std::error_code ec;
+  const auto s = std::filesystem::symlink_status(path, ec);
+  return !ec && std::filesystem::is_symlink(s);
+#else
+  struct stat s;
+  return lstat(path.data(), &s) == 0 && S_ISLNK(s.st_mode);
+#endif
+}
+
+
+class MexFunction : public matlab::mex::Function {
+public:
+  void operator()(matlab::mex::ArgumentList outputs, matlab::mex::ArgumentList inputs) {
+// boilerplate engine & ArrayFactory setup
+    std::shared_ptr<matlab::engine::MATLABEngine> matlabPtr = getEngine();
+
+    matlab::data::ArrayFactory factory;
+// boilerplate input checks
+    if (inputs.size() != 1) {
+      matlabPtr->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("One input required") }));
+    }
+    if (inputs[0].getType() != matlab::data::ArrayType::MATLAB_STRING) {
+      matlabPtr->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Input must be a string") }));
+    }
+    if (inputs[0].getNumberOfElements() != 1) {
+      matlabPtr->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Input must be a scalar string") }));
+    }
+
+// Matlab strings are an array, so we use [0][0] to get the first element
+    std::string inputStr = inputs[0][0];
+
+// actual function algorithm / computation
+    bool y = fs_is_symlink(inputStr);
+
+// convert to Matlab output -- even scalars are arrays in Matlab
+// https://www.mathworks.com/help/matlab/matlab_external/create-matlab-array-with-matlab-data-cpp-api.html
+// https://www.mathworks.com/help/matlab/apiref/matlab.data.arrayfactory.html
+
+    outputs[0] =  factory.createArray<bool>({1,1}, {y});
+  }
+};

src/win32_fs.h

@@ -0,0 +1 @@
+bool fs_win32_is_symlink(std::string path);

src/windows.cpp

@@ -0,0 +1,120 @@
+#include <string>
+#include <cstddef>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <winioctl.h>
+
+#include "win32_fs.h"
+
+
+// create type PREPARSE_DATA_BUFFER
+// from ntifs.h, which can only be used by drivers
+// typedef is copied from https://gitlab.kitware.com/utils/kwsys/-/blob/master/SystemTools.cxx
+// that has a BSD 3-clause license
+typedef struct _REPARSE_DATA_BUFFER
+{
+  ULONG ReparseTag;
+  USHORT ReparseDataLength;
+  USHORT Reserved;
+  union
+  {
+    struct
+    {
+      USHORT SubstituteNameOffset;
+      USHORT SubstituteNameLength;
+      USHORT PrintNameOffset;
+      USHORT PrintNameLength;
+      ULONG Flags;
+      WCHAR PathBuffer[1];
+    } SymbolicLinkReparseBuffer;
+    struct
+    {
+      USHORT SubstituteNameOffset;
+      USHORT SubstituteNameLength;
+      USHORT PrintNameOffset;
+      USHORT PrintNameLength;
+      WCHAR PathBuffer[1];
+    } MountPointReparseBuffer;
+    struct
+    {
+      UCHAR DataBuffer[1];
+    } GenericReparseBuffer;
+    struct
+    {
+      ULONG Version;
+      WCHAR StringList[1];
+      // In version 3, there are 4 NUL-terminated strings:
+      // * Package ID
+      // * Entry Point
+      // * Executable Path
+      // * Application Type
+    } AppExecLinkReparseBuffer;
+  } DUMMYUNIONNAME;
+} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
+
+
+static bool fs_win32_get_reparse_buffer(std::string path, std::byte* buffer)
+{
+// this function is adapted from
+// https://gitlab.kitware.com/utils/kwsys/-/blob/master/SystemTools.cxx
+// that has a BSD 3-clause license
+
+  const DWORD attr = GetFileAttributesA(path.data());
+// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfileattributesa
+
+// https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
+  if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_REPARSE_POINT))
+    return false;
+
+  // Using 0 instead of GENERIC_READ as it allows reading of file attributes
+  // even if we do not have permission to read the file itself
+
+  // A reparse point may be an execution alias (Windows Store app), which
+  // is similar to a symlink but it cannot be opened as a regular file.
+  // We must look at the reparse point data explicitly.
+
+  // FILE_ATTRIBUTE_REPARSE_POINT means:
+  // * a file or directory that has an associated reparse point, or
+  // * a file that is a symbolic link.
+  HANDLE h = CreateFileA(
+    path.data(), 0, 0, nullptr, OPEN_EXISTING,
+    FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, nullptr);
+
+  if (h == INVALID_HANDLE_VALUE)
+    return false;
+
+  DWORD bytesReturned = 0;
+
+  BOOL ok = DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, nullptr, 0, buffer,
+                        MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &bytesReturned,
+                        nullptr);
+
+  CloseHandle(h);
+
+  return ok;
+}
+
+
+bool fs_win32_is_symlink(std::string path)
+{
+// distinguish between Windows symbolic links and reparse points as
+// reparse points can be unlike symlinks.
+//
+// this function is adapted from
+// https://gitlab.kitware.com/utils/kwsys/-/blob/master/SystemTools.cxx
+// that has a BSD 3-clause license
+
+  std::byte buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
+  // Since FILE_ATTRIBUTE_REPARSE_POINT is set this file must be
+  // a symbolic link if it is not a reparse point.
+  if (!fs_win32_get_reparse_buffer(path, buffer))
+    return GetLastError() == ERROR_NOT_A_REPARSE_POINT;
+
+  ULONG reparseTag =
+    reinterpret_cast<PREPARSE_DATA_BUFFER>(&buffer[0])->ReparseTag;
+
+  return (reparseTag == IO_REPARSE_TAG_SYMLINK) ||
+         (reparseTag == IO_REPARSE_TAG_MOUNT_POINT);
+
+}