mex: add read_symlink()

Author: scivision

private/get_mex_sources.m

@@ -3,25 +3,29 @@
   top (1,1) string  % package directory
 end
 
-win = string.empty;
+limits = fullfile(top, "src/limits_fs.cpp");
+
+win = limits;
 if ispc
-win = fullfile(top, "src/windows.cpp");
+win(end+1) = fullfile(top, "src/windows.cpp");
 end
 
 mac = fullfile(top, "src/macos.cpp");
 
 sym = fullfile(top, "src/symlink_fs.cpp");
 
+
 srcs = {fullfile(top, "src/is_char_device.cpp"), ...
   fullfile(top, "src/set_permissions.cpp"), ...
   [fullfile(top, "src/is_rosetta.cpp"), mac], ...
-  [fullfile(top, "src/windows_shortname.cpp"), win]
+  [fullfile(top, "src/windows_shortname.cpp"), win], ...
 };
 
 %%  new in R2024b
 if isMATLABReleaseOlderThan("R2024b")
 srcs{end+1} = [fullfile(top, "src/is_symlink.cpp"), win, sym];
 srcs{end+1} = [fullfile(top, "src/create_symlink.cpp"), win, sym];
+srcs{end+1} = [fullfile(top, "src/read_symlink.cpp"), win, sym];
 end
 
 end

src/create_symlink.cpp

@@ -2,7 +2,6 @@
 #include "mexAdapter.hpp"
 
 #include <string>
-// note: <string_view> causes compile failures with MSVC at least
 
 #include <vector>
 #include <memory>

src/limits_fs.cpp

@@ -0,0 +1,23 @@
+#include <cstdlib>
+
+#if defined(__APPLE__) && defined(__MACH__)
+#include <sys/syslimits.h>
+#endif
+
+#if __has_include(<limits.h>)
+#include <limits.h>
+#endif
+
+#include "limits_fs.h"
+
+
+std::size_t fs_get_max_path()
+{
+#if defined(PATH_MAX)
+  return PATH_MAX;
+#elif defined(_WIN32)
+  return _MAX_PATH;
+#else
+  return 1024;
+#endif
+}

src/limits_fs.h

@@ -0,0 +1,3 @@
+#include <cstddef>
+
+std::size_t fs_get_max_path();

src/read_symlink.cpp

@@ -0,0 +1,45 @@
+// 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>
+
+#include <vector>
+#include <memory>
+
+#include "symlink_fs.h"
+
+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> matlabEng = getEngine();
+
+    matlab::data::ArrayFactory factory;
+// wrangle inputs
+    std::string in;
+
+    if (inputs.size() != 1) {
+      matlabEng->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("One input required") }));
+    }
+    if ((inputs[0].getType() == matlab::data::ArrayType::MATLAB_STRING && inputs[0].getNumberOfElements() == 1)){
+        matlab::data::TypedArray<matlab::data::MATLABString> stringArr = inputs[0];
+        in = stringArr[0];
+    } else if (inputs[0].getType() == matlab::data::ArrayType::CHAR){
+        matlab::data::CharArray charArr = inputs[0];
+        in.assign(charArr.begin(), charArr.end());
+    } else {
+        matlabEng->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Mex: First input must be a scalar string or char vector") }));
+    }
+
+// actual function algorithm / computation
+    std::string out = fs_read_symlink(in);
+
+// convert to Matlab output
+    outputs[0] = factory.createScalar(out);
+  }
+};

src/symlink_fs.cpp

@@ -1,7 +1,7 @@
 #if defined(_WIN32)
 # include "win32_fs.h"
 #else
-# include "unistd.h" // for symlink()
+# include "unistd.h" // for symlink(), readlink()
 #endif
 
 #include <string>
@@ -14,9 +14,11 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include "limits_fs.h"
 #include "symlink_fs.h"
 
 
+
 bool fs_create_symlink(std::string target, std::string link)
 {
   // confusing program errors if target is "" -- we'd never make such a symlink in real use.
@@ -77,3 +79,32 @@ bool fs_is_symlink(std::string path)
   return lstat(path.data(), &s) == 0 && S_ISLNK(s.st_mode);
 #endif
 }
+
+
+std::string fs_read_symlink(std::string path)
+{
+
+  if(!fs_is_symlink(path))
+    return {};
+
+  std::error_code ec;
+
+#if defined(__MINGW32__) || (defined(_WIN32) && !defined(__cpp_lib_filesystem))
+  return fs_win32_final_path(path);
+#elif defined(__cpp_lib_filesystem)
+  if(auto p = std::filesystem::read_symlink(path, ec); !ec)
+    return p.generic_string();
+#else
+  // https://www.man7.org/linux/man-pages/man2/readlink.2.html
+  std::string r(fs_get_max_path(), '\0');
+
+  const ssize_t Lr = readlink(path.data(), r.data(), r.size());
+  if (Lr > 0){
+    // readlink() does not null-terminate the result
+    r.resize(Lr);
+    return r;
+  }
+#endif
+
+  return {};
+}

src/symlink_fs.h

@@ -2,3 +2,4 @@
 
 bool fs_is_symlink(std::string);
 bool fs_create_symlink(std::string, std::string);
+std::string fs_read_symlink(std::string);

src/win32_fs.h

@@ -3,3 +3,5 @@
 bool fs_win32_is_symlink(std::string);
 
 std::string fs_shortname(std::string);
+
+std::string fs_as_posix(std::string);

src/windows.cpp

@@ -1,11 +1,13 @@
 #include <string>
 #include <cstddef>
-#include <cstdlib> // for _MAX_PATH
+#include <cstdlib>
+#include <algorithm> // for std::replace
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <winioctl.h>
 
+#include "limits_fs.h"
 #include "win32_fs.h"
 
 
@@ -55,6 +57,18 @@ typedef struct _REPARSE_DATA_BUFFER
 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 
 
+std::string fs_as_posix(std::string path)
+{
+  std::string s(path);
+
+#if defined(_WIN32)
+    std::replace(s.begin(), s.end(), '\\', '/');
+#endif
+
+  return s;
+}
+
+
 static bool fs_win32_get_reparse_buffer(std::string path, std::byte* buffer)
 {
 // this function is adapted from
@@ -97,6 +111,48 @@ static bool fs_win32_get_reparse_buffer(std::string path, std::byte* buffer)
 }
 
 
+std::string fs_win32_final_path(std::string path)
+{
+  // resolves Windows symbolic links (reparse points and junctions)
+  // it also resolves the case insensitivity of Windows paths to the disk case
+  // PATH MUST EXIST
+  //
+  // References:
+  // https://stackoverflow.com/a/50182947
+  // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+  // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlea
+
+#if defined(_WIN32)
+  // dwDesiredAccess=0 to allow getting parameters even without read permission
+  // FILE_FLAG_BACKUP_SEMANTICS required to open a directory
+  HANDLE h = CreateFileA(path.data(), GENERIC_READ, FILE_SHARE_READ, nullptr,
+              OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
+  if(h == INVALID_HANDLE_VALUE)
+    return {};
+
+  std::string r(fs_get_max_path(), '\0');
+
+  const DWORD L = GetFinalPathNameByHandleA(h, r.data(), static_cast<DWORD>(r.size()), FILE_NAME_NORMALIZED);
+  CloseHandle(h);
+  if(L == 0)
+    return {};
+
+  r.resize(L);
+
+#ifdef __cpp_lib_starts_ends_with  // C++20
+  if (r.starts_with("\\\\?\\"))
+#else  // C++98
+  if (r.substr(0, 4) == "\\\\?\\")
+#endif
+    r = r.substr(4);
+
+  return fs_as_posix(r);
+#else
+  return std::string(path);
+#endif
+}
+
+
 bool fs_win32_is_symlink(std::string path)
 {
 // distinguish between Windows symbolic links and reparse points as
@@ -126,7 +182,7 @@ std::string fs_shortname(std::string in)
 // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getshortpathnamew
 // the path must exist
 
-  std::string out(_MAX_PATH, '\0');
+  std::string out(fs_get_max_path(), '\0');
 // size does not include null terminator
   if(auto L = GetShortPathNameA(in.data(), out.data(), static_cast<DWORD>(out.size()));
       L > 0 && L < out.length()){

src/windows_shortname.cpp

@@ -42,16 +42,12 @@ class MexFunction : public matlab::mex::Function {
     }
 
 // actual function algorithm / computation
+  std::string out = "";
 #if defined(_WIN32)
-    std::string s = fs_shortname(in);
-#else
-    std::string s = "";
+  out = fs_shortname(in);
 #endif
 
-// 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.createScalar(s);
+// convert to Matlab output
+    outputs[0] = factory.createScalar(out);
   }
 };