mex: set_permissions()

Author: scivision

+stdlib/is_char_device.m

@@ -4,13 +4,13 @@
 
 function ok = is_char_device(p)
 arguments
-    p (1,1) string
+  p (1,1) string
 end
 
 if stdlib.isoctave()
   ok = S_ISCHR(stat(p).mode);
 else
-  ok = is_char_device_mex(p);
+  error("need to 'buildtool mex' or 'legacy_mex_build()' first")
 end
 
 end

+stdlib/is_symlink.m

@@ -10,15 +10,7 @@
   ok = isSymbolicLink(p);
 catch e
   if strcmp(e.identifier, "MATLAB:UndefinedFunction")
-    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
+    ok = java.nio.file.Files.isSymbolicLink(javaPathObject(stdlib.absolute(p, "", false)));
   elseif strcmp(e.identifier, "Octave:undefined-function")
     ok = S_ISLNK(stat(p).mode);
   else

private/get_mex_sources.m

@@ -5,13 +5,20 @@
 
 %% source C++
 
-srcs = {fullfile(top, "src/is_char_device.cpp")};
+% Matlab and Java don't have these functions
+srcs = {fullfile(top, "src/is_char_device.cpp"), ...
+  fullfile(top, "src/set_permissions.cpp"), ...
+};
+
+% isSymbolicLink() new in R2024b
+if ~isMATLABReleaseOlderThan("R2024b")
 
 s = fullfile(top, "src/is_symlink.cpp");
 if ispc
   s(end+1) = fullfile(top, "src/windows.cpp");
 end
-
 srcs{end+1} = s;
 
 end
+
+end

src/set_permissions.cpp

@@ -0,0 +1,101 @@
+// 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 __has_include(<filesystem>)
+# include <filesystem>
+# include <system_error>
+#endif
+
+
+static bool fs_set_permissions(std::string path, int readable, int writable, int executable)
+{
+#ifdef __cpp_lib_filesystem
+
+#if defined(__cpp_using_enum)  // C++20
+  using enum std::filesystem::perms;
+#else
+  constexpr std::filesystem::perms owner_read = std::filesystem::perms::owner_read;
+  constexpr std::filesystem::perms owner_write = std::filesystem::perms::owner_write;
+  constexpr std::filesystem::perms owner_exec = std::filesystem::perms::owner_exec;
+#endif
+
+  std::filesystem::path p(path);
+  std::error_code ec;
+  // need to error if path doesn't exist and no operations are requested
+  if(!std::filesystem::exists(p))
+    ec = std::make_error_code(std::errc::no_such_file_or_directory);
+
+  if (!ec && readable != 0)
+    std::filesystem::permissions(p, owner_read,
+      (readable > 0) ? std::filesystem::perm_options::add : std::filesystem::perm_options::remove,
+      ec);
+
+  if (!ec && writable != 0)
+    std::filesystem::permissions(p, owner_write,
+      (writable > 0) ? std::filesystem::perm_options::add : std::filesystem::perm_options::remove,
+      ec);
+
+  if (!ec && executable != 0)
+    std::filesystem::permissions(p, owner_exec,
+      (executable > 0) ? std::filesystem::perm_options::add : std::filesystem::perm_options::remove,
+      ec);
+
+  if(!ec)
+    return true;
+
+#endif
+  return false;
+
+}
+
+
+
+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() != 4) {
+      matlabPtr->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Four inputs 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") }));
+    }
+    if (inputs[1].getType() != matlab::data::ArrayType::DOUBLE ||
+        inputs[2].getType() != matlab::data::ArrayType::DOUBLE ||
+        inputs[3].getType() != matlab::data::ArrayType::DOUBLE) {
+      matlabPtr->feval(u"error", 0,
+        std::vector<matlab::data::Array>({ factory.createScalar("Permission inputs must be doubles") }));
+    }
+
+// 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_set_permissions(inputStr, inputs[1][0], inputs[2][0], inputs[3][0]);
+
+// 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});
+  }
+};

test/TestJava.m

@@ -127,7 +127,12 @@ function test_is_regular_file(tc)
 
 
 function test_touch_modtime(tc)
-fn = tempname;
+import matlab.unittest.fixtures.TemporaryFolderFixture
+
+fixture = tc.applyFixture(TemporaryFolderFixture);
+
+fn = fullfile(fixture.Folder, "modtime.txt");
+
 tc.verifyTrue(stdlib.touch(fn, datetime("yesterday")))
 t0 = stdlib.get_modtime(fn);
 

test/TestPermissions.m

@@ -7,6 +7,7 @@
 methods (Test)
 
 function test_get_permissions(tc, Ps)
+
 import matlab.unittest.constraints.StartsWithSubstring
 import matlab.unittest.constraints.IsOfClass
 
@@ -21,6 +22,34 @@ function test_get_permissions(tc, Ps)
 
 end
 
+
+function test_set_permissions(tc)
+
+import matlab.unittest.constraints.StartsWithSubstring
+import matlab.unittest.fixtures.TemporaryFolderFixture
+
+fixture = tc.applyFixture(TemporaryFolderFixture);
+
+nr = fullfile(fixture.Folder, "no-read");
+
+tc.verifyTrue(stdlib.touch(nr))
+tc.verifyTrue(stdlib.set_permissions(nr, -1, 0, 0))
+p = stdlib.get_permissions(nr);
+
+if ~ispc
+tc.verifyThat(p, StartsWithSubstring("-"), "non-read permission failed to set")
+end
+
+nw = fullfile(fixture.Folder, "no-write");
+
+tc.verifyTrue(stdlib.touch(nw))
+tc.verifyTrue(stdlib.set_permissions(nw, 0, -1, 0))
+p = stdlib.get_permissions(nw);
+
+tc.verifyThat(p, StartsWithSubstring("r-"), "non-write permission failed to set")
+
+end
+
 end
 
-end
+end