koffi 2.6.0 → 2.6.2

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ### Koffi 2.6
 
+#### Koffi 2.6.2 (2023-10-13)
+
+- Add indirect loading script to help some bundlers
+
+#### Koffi 2.6.1 (2023-09-18)
+
+- Support string direction qualifiers in classic function definitions
+- Fix possible off-by-one array access when parsing type name
+
 #### Koffi 2.6.0 (2023-09-13)
 
 **New features:**

package/doc/contribute.md

@@ -138,8 +138,8 @@ First, you must update the code in three steps:
 Once this is done, you can publish a new release with the following commands:
 
 ```sh
-node qemu.js test # If not done before
-node qemu.js dist
+node tools/qemu.js test # If not done before
+node tools/qemu.js dist
 
 cd build/dist
 npm publish

package/doc/packaging.md

@@ -36,6 +36,14 @@ resources/
 MyApp.exe
 ```
 
+## Indirect loader
+
+*New in Koffi 2.6.2*
+
+Some bundlers (such as vite) don't like when require is used with native modules.
+
+In this case, you can use `js require('koffi/indirect')` but you will need to make sure that the native Koffi modules are packaged properly.
+
 ## Packaging examples
 
 ### Electron with electron-builder

package/doc/variables.md

@@ -97,4 +97,4 @@ console.log(koffi.decode(my_int, 'int')) // Prints -1
 console.log(koffi.decode(my_string, 'const char *')) // Prints "Hello World!"
 ```
 
-When encoding strings (either directly or embedded in arrays or structs), the memory will be bound to the raw pointer value and managed by Koffi. You can assign to the same string again and again with any leak or risk of use-after-free.
+When encoding strings (either directly or embedded in arrays or structs), the memory will be bound to the raw pointer value and managed by Koffi. You can assign to the same string again and again without any leak or risk of use-after-free.

package/{src/index.js → index.js}

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.0",
-      stable: "2.6.0",
+      version: "2.6.2",
+      stable: "2.6.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -400,8 +400,8 @@ var require_package = __commonJS({
         email: "niels.martignene@protonmail.com",
         url: "https://koromix.dev/"
       },
-      main: "src/index.js",
-      types: "src/index.d.ts",
+      main: "./index.js",
+      types: "./index.d.ts",
       scripts: {
         test: "node tools/qemu.js test",
         prepack: `echo 'Use "npm run prepare" instead' && false`,
@@ -430,7 +430,7 @@ var require_package = __commonJS({
   }
 });
 
-// build/dist/src/koffi/src/index.js
+// build/dist/src/koffi/index.js
 var util = require("util");
 var fs = require("fs");
 var { get_napi_version, determine_arch } = require_tools();
@@ -451,77 +451,77 @@ try {
   switch (triplet) {
     case "darwin_arm64":
       {
-        native = require("../build/koffi/darwin_arm64/koffi.node");
+        native = require("./build/koffi/darwin_arm64/koffi.node");
       }
       break;
     case "darwin_x64":
       {
-        native = require("../build/koffi/darwin_x64/koffi.node");
+        native = require("./build/koffi/darwin_x64/koffi.node");
       }
       break;
     case "freebsd_arm64":
       {
-        native = require("../build/koffi/freebsd_arm64/koffi.node");
+        native = require("./build/koffi/freebsd_arm64/koffi.node");
       }
       break;
     case "freebsd_ia32":
       {
-        native = require("../build/koffi/freebsd_ia32/koffi.node");
+        native = require("./build/koffi/freebsd_ia32/koffi.node");
       }
       break;
     case "freebsd_x64":
       {
-        native = require("../build/koffi/freebsd_x64/koffi.node");
+        native = require("./build/koffi/freebsd_x64/koffi.node");
       }
       break;
     case "linux_arm32hf":
       {
-        native = require("../build/koffi/linux_arm32hf/koffi.node");
+        native = require("./build/koffi/linux_arm32hf/koffi.node");
       }
       break;
     case "linux_arm64":
       {
-        native = require("../build/koffi/linux_arm64/koffi.node");
+        native = require("./build/koffi/linux_arm64/koffi.node");
       }
       break;
     case "linux_ia32":
       {
-        native = require("../build/koffi/linux_ia32/koffi.node");
+        native = require("./build/koffi/linux_ia32/koffi.node");
       }
       break;
     case "linux_riscv64hf64":
       {
-        native = require("../build/koffi/linux_riscv64hf64/koffi.node");
+        native = require("./build/koffi/linux_riscv64hf64/koffi.node");
       }
       break;
     case "linux_x64":
       {
-        native = require("../build/koffi/linux_x64/koffi.node");
+        native = require("./build/koffi/linux_x64/koffi.node");
       }
       break;
     case "openbsd_ia32":
       {
-        native = require("../build/koffi/openbsd_ia32/koffi.node");
+        native = require("./build/koffi/openbsd_ia32/koffi.node");
       }
       break;
     case "openbsd_x64":
       {
-        native = require("../build/koffi/openbsd_x64/koffi.node");
+        native = require("./build/koffi/openbsd_x64/koffi.node");
       }
       break;
     case "win32_arm64":
       {
-        native = require("../build/koffi/win32_arm64/koffi.node");
+        native = require("./build/koffi/win32_arm64/koffi.node");
       }
       break;
     case "win32_ia32":
       {
-        native = require("../build/koffi/win32_ia32/koffi.node");
+        native = require("./build/koffi/win32_ia32/koffi.node");
       }
       break;
     case "win32_x64":
       {
-        native = require("../build/koffi/win32_x64/koffi.node");
+        native = require("./build/koffi/win32_x64/koffi.node");
       }
       break;
   }
@@ -529,6 +529,7 @@ try {
 }
 if (native == null) {
   let names = [
+    `/build/koffi/${process.platform}_${arch}/koffi.node`,
     `/koffi/${process.platform}_${arch}/koffi.node`,
     `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`
   ];

package/indirect.js

@@ -0,0 +1,480 @@
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// build/dist/src/cnoke/src/tools.js
+var require_tools = __commonJS({
+  "build/dist/src/cnoke/src/tools.js"(exports2, module2) {
+    "use strict";
+    var crypto = require("crypto");
+    var fs2 = require("fs");
+    var http = require("https");
+    var path = require("path");
+    var zlib = require("zlib");
+    async function download_http(url, dest) {
+      if (Array.isArray(url)) {
+        let urls = url;
+        for (let url2 of urls) {
+          try {
+            await download_http(url2, dest);
+            return;
+          } catch (err) {
+            if (err.code != 404)
+              throw err;
+          }
+        }
+        throw new Error("All URLs returned error 404");
+      }
+      console.log(">> Downloading " + url);
+      let [tmp_name, file] = open_temporary_stream(dest);
+      try {
+        await new Promise((resolve, reject) => {
+          let request = http.get(url, (response) => {
+            if (response.statusCode != 200) {
+              let err = new Error(`Download failed: ${response.statusMessage} [${response.statusCode}]`);
+              err.code = response.statusCode;
+              reject(err);
+              return;
+            }
+            response.pipe(file);
+            file.on("finish", () => file.close(() => {
+              try {
+                fs2.renameSync(file.path, dest);
+              } catch (err) {
+                if (err.code != "EBUSY")
+                  reject(err);
+              }
+              resolve();
+            }));
+          });
+          request.on("error", reject);
+          file.on("error", reject);
+        });
+      } catch (err) {
+        file.close();
+        try {
+          fs2.unlinkSync(tmp_name);
+        } catch (err2) {
+          if (err2.code != "ENOENT")
+            throw err2;
+        }
+        throw err;
+      }
+    }
+    function open_temporary_stream(prefix) {
+      let buf = Buffer.allocUnsafe(4);
+      for (; ; ) {
+        try {
+          crypto.randomFillSync(buf);
+          let suffix = buf.toString("hex").padStart(8, "0");
+          let filename = `${prefix}.${suffix}`;
+          let file = fs2.createWriteStream(filename, { flags: "wx", mode: 420 });
+          return [filename, file];
+        } catch (err) {
+          if (err.code != "EEXIST")
+            throw err;
+        }
+      }
+    }
+    function extract_targz(filename, dest_dir, strip = 0) {
+      let reader = fs2.createReadStream(filename).pipe(zlib.createGunzip());
+      return new Promise((resolve, reject) => {
+        let header = null;
+        let extended = {};
+        reader.on("readable", () => {
+          try {
+            for (; ; ) {
+              if (header == null) {
+                let buf = reader.read(512);
+                if (buf == null)
+                  break;
+                if (!buf[0])
+                  continue;
+                header = {
+                  filename: buf.toString("utf-8", 0, 100).replace(/\0/g, ""),
+                  mode: parseInt(buf.toString("ascii", 100, 109), 8),
+                  size: parseInt(buf.toString("ascii", 124, 137), 8),
+                  type: String.fromCharCode(buf[156])
+                };
+                Object.assign(header, extended);
+                extended = {};
+                header.filename = header.filename.replace(/\\/g, "/");
+                if (!header.filename.length)
+                  throw new Error(`Insecure empty filename inside TAR archive`);
+                if (path_is_absolute(header.filename[0]))
+                  throw new Error(`Insecure filename starting with / inside TAR archive`);
+                if (path_has_dotdot(header.filename))
+                  throw new Error(`Insecure filename containing '..' inside TAR archive`);
+                for (let i = 0; i < strip; i++)
+                  header.filename = header.filename.substr(header.filename.indexOf("/") + 1);
+              }
+              let aligned = Math.floor((header.size + 511) / 512) * 512;
+              let data = header.size ? reader.read(aligned) : null;
+              if (data == null) {
+                if (header.size)
+                  break;
+                data = Buffer.alloc(0);
+              }
+              data = data.subarray(0, header.size);
+              if (header.type == "0" || header.type == "7") {
+                let filename2 = dest_dir + "/" + header.filename;
+                let dirname = path.dirname(filename2);
+                fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
+                fs2.writeFileSync(filename2, data, { mode: header.mode });
+              } else if (header.type == "5") {
+                let filename2 = dest_dir + "/" + header.filename;
+                fs2.mkdirSync(filename2, { recursive: true, mode: header.mode });
+              } else if (header.type == "L") {
+                extended.filename = data.toString("utf-8").replace(/\0/g, "");
+              } else if (header.type == "x") {
+                let str = data.toString("utf-8");
+                try {
+                  while (str.length) {
+                    let matches = str.match(/^([0-9]+) ([a-zA-Z0-9\._]+)=(.*)\n/);
+                    let skip = parseInt(matches[1], 10);
+                    let key = matches[2];
+                    let value = matches[3];
+                    switch (key) {
+                      case "path":
+                        {
+                          extended.filename = value;
+                        }
+                        break;
+                      case "size":
+                        {
+                          extended.size = parseInt(value, 10);
+                        }
+                        break;
+                    }
+                    str = str.substr(skip).trimStart();
+                  }
+                } catch (err) {
+                  throw new Error("Malformed PAX entry");
+                }
+              }
+              header = null;
+            }
+          } catch (err) {
+            reject(err);
+          }
+        });
+        reader.on("error", reject);
+        reader.on("end", resolve);
+      });
+    }
+    function path_is_absolute(path2) {
+      if (process.platform == "win32" && path2.match(/^[a-zA-Z]:/))
+        path2 = path2.substr(2);
+      return is_path_separator(path2[0]);
+    }
+    function path_has_dotdot(path2) {
+      let start = 0;
+      for (; ; ) {
+        let offset = path2.indexOf("..", start);
+        if (offset < 0)
+          break;
+        start = offset + 2;
+        if (offset && !is_path_separator(path2[offset - 1]))
+          continue;
+        if (offset + 2 < path2.length && !is_path_separator(path2[offset + 2]))
+          continue;
+        return true;
+      }
+      return false;
+    }
+    function is_path_separator(c) {
+      if (c == "/")
+        return true;
+      if (process.platform == "win32" && c == "\\")
+        return true;
+      return false;
+    }
+    function determine_arch2() {
+      let arch2 = process.arch;
+      if (arch2 == "riscv32" || arch2 == "riscv64") {
+        let buf = read_file_header(process.execPath, 512);
+        let header = decode_elf_header(buf);
+        let float_abi = (header.e_flags & 6) >> 1;
+        switch (float_abi) {
+          case 0:
+            {
+              arch2 += "sf";
+            }
+            break;
+          case 1:
+            {
+              arch2 += "hf32";
+            }
+            break;
+          case 2:
+            {
+              arch2 += "hf64";
+            }
+            break;
+          case 3:
+            {
+              arch2 += "hf128";
+            }
+            break;
+        }
+      } else if (arch2 == "arm") {
+        arch2 = "arm32";
+        let buf = read_file_header(process.execPath, 512);
+        let header = decode_elf_header(buf);
+        if (header.e_flags & 1024) {
+          arch2 += "hf";
+        } else if (header.e_flags & 512) {
+          arch2 += "sf";
+        } else {
+          throw new Error("Unknown ARM floating-point ABI");
+        }
+      }
+      return arch2;
+    }
+    function read_file_header(filename, read) {
+      let fd = null;
+      try {
+        let fd2 = fs2.openSync(filename);
+        let buf = Buffer.allocUnsafe(read);
+        let len = fs2.readSync(fd2, buf);
+        return buf.subarray(0, len);
+      } finally {
+        if (fd != null)
+          fs2.closeSync(fd);
+      }
+    }
+    function decode_elf_header(buf) {
+      let header = {};
+      if (buf.length < 16)
+        throw new Error("Truncated header");
+      if (buf[0] != 127 || buf[1] != 69 || buf[2] != 76 || buf[3] != 70)
+        throw new Error("Invalid magic number");
+      if (buf[6] != 1)
+        throw new Error("Invalid ELF version");
+      if (buf[5] != 1)
+        throw new Error("Big-endian architectures are not supported");
+      let machine = buf.readUInt16LE(18);
+      switch (machine) {
+        case 3:
+          {
+            header.e_machine = "ia32";
+          }
+          break;
+        case 40:
+          {
+            header.e_machine = "arm";
+          }
+          break;
+        case 62:
+          {
+            header.e_machine = "amd64";
+          }
+          break;
+        case 183:
+          {
+            header.e_machine = "arm64";
+          }
+          break;
+        case 243:
+          {
+            switch (buf[4]) {
+              case 1:
+                {
+                  header.e_machine = "riscv32";
+                }
+                break;
+              case 2:
+                {
+                  header.e_machine = "riscv64";
+                }
+                break;
+            }
+          }
+          break;
+        default:
+          throw new Error("Unknown ELF machine type");
+      }
+      switch (buf[4]) {
+        case 1:
+          {
+            buf = buf.subarray(0, 68);
+            if (buf.length < 68)
+              throw new Error("Truncated ELF header");
+            header.ei_class = 32;
+            header.e_flags = buf.readUInt32LE(36);
+          }
+          break;
+        case 2:
+          {
+            buf = buf.subarray(0, 120);
+            if (buf.length < 120)
+              throw new Error("Truncated ELF header");
+            header.ei_class = 64;
+            header.e_flags = buf.readUInt32LE(48);
+          }
+          break;
+        default:
+          throw new Error("Invalid ELF class");
+      }
+      return header;
+    }
+    function unlink_recursive(path2) {
+      try {
+        if (fs2.rmSync != null) {
+          fs2.rmSync(path2, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+        } else {
+          fs2.rmdirSync(path2, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+      }
+    }
+    function get_napi_version2(napi, major) {
+      if (napi > 8)
+        return null;
+      const support = {
+        6: ["6.14.2", "6.14.2", "6.14.2"],
+        8: ["8.6.0", "8.10.0", "8.11.2"],
+        9: ["9.0.0", "9.3.0", "9.11.0"],
+        10: ["10.0.0", "10.0.0", "10.0.0", "10.16.0", "10.17.0", "10.20.0", "10.23.0"],
+        11: ["11.0.0", "11.0.0", "11.0.0", "11.8.0"],
+        12: ["12.0.0", "12.0.0", "12.0.0", "12.0.0", "12.11.0", "12.17.0", "12.19.0", "12.22.0"],
+        13: ["13.0.0", "13.0.0", "13.0.0", "13.0.0", "13.0.0"],
+        14: ["14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.0.0", "14.12.0", "14.17.0"],
+        15: ["15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.0.0", "15.12.0"]
+      };
+      const max = Math.max(...Object.keys(support).map((k) => parseInt(k, 10)));
+      if (major > max)
+        return major + ".0.0";
+      if (support[major] == null)
+        return null;
+      let required = support[major][napi - 1] || null;
+      return required;
+    }
+    function cmp_version(ver1, ver2) {
+      ver1 = String(ver1).replace(/-.*$/, "").split(".").reduce((acc, v, idx) => acc + parseInt(v, 10) * Math.pow(10, 2 * (5 - idx)), 0);
+      ver2 = String(ver2).replace(/-.*$/, "").split(".").reduce((acc, v, idx) => acc + parseInt(v, 10) * Math.pow(10, 2 * (5 - idx)), 0);
+      let cmp = Math.min(Math.max(ver1 - ver2, -1), 1);
+      return cmp;
+    }
+    module2.exports = {
+      download_http,
+      extract_targz,
+      path_is_absolute,
+      path_has_dotdot,
+      determine_arch: determine_arch2,
+      unlink_recursive,
+      get_napi_version: get_napi_version2,
+      cmp_version
+    };
+  }
+});
+
+// build/dist/src/koffi/package.json
+var require_package = __commonJS({
+  "build/dist/src/koffi/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "koffi",
+      version: "2.6.2",
+      stable: "2.6.2",
+      description: "Fast and simple C FFI (foreign function interface) for Node.js",
+      keywords: [
+        "foreign",
+        "function",
+        "interface",
+        "ffi",
+        "binding",
+        "c",
+        "napi"
+      ],
+      repository: {
+        type: "git",
+        url: "https://github.com/Koromix/koffi"
+      },
+      homepage: "https://koffi.dev/",
+      author: {
+        name: "Niels Martign\xE8ne",
+        email: "niels.martignene@protonmail.com",
+        url: "https://koromix.dev/"
+      },
+      main: "./index.js",
+      types: "./index.d.ts",
+      scripts: {
+        test: "node tools/qemu.js test",
+        prepack: `echo 'Use "npm run prepare" instead' && false`,
+        prepublishOnly: `echo 'Use "npm run release" instead' && false`,
+        release: "node tools/qemu.js publish"
+      },
+      license: "MIT",
+      devDependencies: {
+        chalk: "^4.1.2",
+        esbuild: "^0.19.2",
+        "ffi-napi": "^4.0.3",
+        "ffi-rs": "^1.0.12",
+        minimatch: "^5.0.1",
+        "node-ssh": "^12.0.3",
+        raylib: "^0.9.2",
+        "ref-napi": "^3.0.3",
+        "ref-struct-di": "^1.1.1",
+        tar: "^6.1.11"
+      },
+      cnoke: {
+        output: "build/koffi/{{ platform }}_{{ arch }}",
+        napi: 8,
+        require: "./src/index.js"
+      }
+    };
+  }
+});
+
+// build/dist/src/koffi/indirect.js
+var util = require("util");
+var fs = require("fs");
+var { get_napi_version, determine_arch } = require_tools();
+var pkg = require_package();
+if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
+  let major = parseInt(process.versions.node, 10);
+  let required = get_napi_version(pkg.cnoke.napi, major);
+  if (required != null) {
+    throw new Error(`Project ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+  } else {
+    throw new Error(`Project ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+  }
+}
+var arch = determine_arch();
+var triplet = `${process.platform}_${arch}`;
+var native = null;
+{
+  let names = [
+    `/build/koffi/${process.platform}_${arch}/koffi.node`,
+    `/koffi/${process.platform}_${arch}/koffi.node`,
+    `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`
+  ];
+  for (let name of names) {
+    if (fs.existsSync(__dirname + name)) {
+      native = require(__dirname + name);
+      break;
+    }
+  }
+  if (native == null && process.resourcesPath != null) {
+    for (let name of names) {
+      if (fs.existsSync(process.resourcesPath + name)) {
+        native = require(process.resourcesPath + name);
+        break;
+      }
+    }
+  }
+}
+if (native == null)
+  throw new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+if (native.version != pkg.version)
+  throw new Error("Mismatched native Koffi modules");
+module.exports = {
+  ...native,
+  // Deprecated functions
+  handle: util.deprecate(native.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
+  callback: util.deprecate(native.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
+};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.6.0",
-    "stable": "2.6.0",
+    "version": "2.6.2",
+    "stable": "2.6.2",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -22,8 +22,8 @@
         "email": "niels.martignene@protonmail.com",
         "url": "https://koromix.dev/"
     },
-    "main": "src/index.js",
-    "types": "src/index.d.ts",
+    "main": "./index.js",
+    "types": "./index.d.ts",
     "scripts": {
         "install": "node src/cnoke/cnoke.js -p . -d src/koffi --prebuild"
     },

package/src/core/libcc/libcc.cc

@@ -3265,7 +3265,7 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
         case (int)OpenFlag::Append: {
             access = GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = CREATE_ALWAYS;
+            creation = OPEN_ALWAYS;
             attributes = FILE_ATTRIBUTE_NORMAL;
             oflags = _O_WRONLY | _O_CREAT | _O_APPEND | _O_BINARY | _O_NOINHERIT;
         } break;
@@ -3293,7 +3293,15 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
     }
     share |= FILE_SHARE_DELETE;
 
-    HANDLE h;
+    HANDLE h = nullptr;
+    int fd = -1;
+    RG_DEFER_N(err_guard) {
+        close(fd);
+        if (h) {
+            CloseHandle(h);
+        }
+    };
+
     if (win32_utf8) {
         h = CreateFileA(filename, access, share, nullptr, creation, attributes, nullptr);
     } else {
@@ -3321,15 +3329,20 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
         return ret;
     }
 
-    int fd = _open_osfhandle((intptr_t)h, oflags);
+    fd = _open_osfhandle((intptr_t)h, oflags);
     if (fd < 0) {
         LogError("Cannot open '%1': %2", filename, strerror(errno));
-        CloseHandle(h);
+        return OpenResult::OtherError;
+    }
 
+    if ((flags & (int)OpenFlag::Append) && _lseeki64(fd, 0, SEEK_END) < 0) {
+        LogError("Cannot move file pointer: %1", strerror(errno));
         return OpenResult::OtherError;
     }
 
+    err_guard.Disable();
     *out_fd = fd;
+
     return OpenResult::Success;
 }
 
@@ -4871,15 +4884,20 @@ const char *GetUserConfigPath(const char *name, Allocator *alloc)
     const char *xdg = getenv("XDG_CONFIG_HOME");
     const char *home = getenv("HOME");
 
+    const char *path = nullptr;
+
     if (xdg) {
-        const char *path = Fmt(alloc, "%1%/%2", xdg, name).ptr;
-        return path;
+        path = Fmt(alloc, "%1%/%2", xdg, name).ptr;
     } else if (home) {
-        const char *path = Fmt(alloc, "%1%/.config/%2", home, name).ptr;
-        return path;
-    } else {
-        return nullptr;
+        path = Fmt(alloc, "%1%/.config/%2", home, name).ptr;
+    } else if (!getuid()) {
+        path = Fmt(alloc, "/root/.config/%1", name).ptr;
     }
+
+    if (path && !EnsureDirectoryExists(path))
+        return nullptr;
+
+    return path;
 }
 
 const char *GetUserCachePath(const char *name, Allocator *alloc)
@@ -4889,15 +4907,20 @@ const char *GetUserCachePath(const char *name, Allocator *alloc)
     const char *xdg = getenv("XDG_CACHE_HOME");
     const char *home = getenv("HOME");
 
+    const char *path = nullptr;
+
     if (xdg) {
-        const char *path = Fmt(alloc, "%1%/%2", xdg, name).ptr;
-        return path;
+        path = Fmt(alloc, "%1%/%2", xdg, name).ptr;
     } else if (home) {
-        const char *path = Fmt(alloc, "%1%/.cache/%2", home, name).ptr;
-        return path;
-    } else {
-        return nullptr;
+        path = Fmt(alloc, "%1%/.cache/%2", home, name).ptr;
+    } else if (!getuid()) {
+        path = Fmt(alloc, "/root/.cache/%1", name).ptr;
     }
+
+    if (path && !EnsureDirectoryExists(path))
+        return nullptr;
+
+    return path;
 }
 
 const char *GetSystemConfigPath(const char *name, Allocator *alloc)
@@ -5122,7 +5145,8 @@ static RG_THREAD_LOCAL Size rnd_offset;
 
 static void InitChaCha20(uint32_t state[16], uint32_t key[8], uint32_t iv[2])
 {
-    static const uint32_t *const magic = (const uint32_t *)"expand 32-byte k";
+    alignas(uint32_t) static char str[] = "expand 32-byte k";
+    const uint32_t *magic = (const uint32_t *)str;
 
     state[0] = LittleEndian(magic[0]);
     state[1] = LittleEndian(magic[1]);

package/src/koffi/src/parser.cc

@@ -35,7 +35,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
 
     Tokenize(str);
 
-    out_func->ret.type = ParseType();
+    out_func->ret.type = ParseType(nullptr);
     if (!CanReturnType(out_func->ret.type)) {
         MarkError("You are not allowed to directly return %1 values (maybe try %1 *)", out_func->ret.type->name);
         return false;
@@ -62,17 +62,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
                 break;
             }
 
-            if (Match("_In_")) {
-                param.directions = 1;
-            } else if (Match("_Out_")) {
-                param.directions = 2;
-            } else if (Match("_Inout_")) {
-                param.directions = 3;
-            } else {
-                param.directions = 1;
-            }
-
-            param.type = ParseType();
+            param.type = ParseType(&param.directions);
 
             if (!CanPassType(param.type, param.directions)) {
                 MarkError("Type %1 cannot be used as a parameter", param.type->name);
@@ -145,7 +135,7 @@ void PrototypeParser::Tokenize(const char *str)
     }
 }
 
-const TypeInfo *PrototypeParser::ParseType()
+const TypeInfo *PrototypeParser::ParseType(int *out_directions)
 {
     Size start = offset;
 
@@ -166,7 +156,7 @@ const TypeInfo *PrototypeParser::ParseType()
 
     while (offset >= start) {
         Span<const char> str = MakeSpan(tokens[start].ptr, tokens[offset].end() - tokens[start].ptr);
-        const TypeInfo *type = ResolveType(env, str);
+        const TypeInfo *type = ResolveType(env, str, out_directions);
 
         if (type) {
             offset++;

package/src/koffi/src/parser.hh

@@ -49,7 +49,7 @@ public:
 private:
     void Tokenize(const char *str);
 
-    const TypeInfo *ParseType();
+    const TypeInfo *ParseType(int *out_directions);
     const char *ParseIdentifier();
 
     bool Consume(const char *expect);

package/src/koffi/src/util.cc

@@ -153,6 +153,22 @@ static inline bool IsIdentifierChar(char c)
     return IsAsciiAlphaOrDigit(c) || c == '_';
 }
 
+static inline Span<const char> SplitIdentifier(Span<const char> str)
+{
+    Size offset = 0;
+
+    if (str.len && IsIdentifierStart(str[0])) {
+        offset++;
+
+        while (offset < str.len && IsIdentifierChar(str[offset])) {
+            offset++;
+        }
+    }
+
+    Span<const char> token = str.Take(0, offset);
+    return token;
+}
+
 const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_directions)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -160,8 +176,31 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
     int indirect = 0;
     uint8_t disposables = 0;
 
+    // Consume parameter direction qualifier
+    if (out_directions) {
+        if (str.len && str[0] == '_') {
+            Span<const char> qualifier = SplitIdentifier(str);
+
+            if (qualifier == "_In_") {
+                *out_directions = 1;
+                str = str.Take(5, str.len - 5);
+            } else if (qualifier == "_Out_") {
+                *out_directions = 2;
+                str = str.Take(6, str.len - 6);
+            } else if (qualifier == "_Inout_") {
+                *out_directions = 3;
+                str = str.Take(8, str.len - 8);
+            } else {
+                *out_directions = 1;
+            }
+        } else {
+            *out_directions = 1;
+        }
+    }
+
     // Skip initial const qualifiers
-    while (str.len >= 6 && StartsWith(str, "const") && IsAsciiWhite(str[5])) {
+    str = TrimStr(str);
+    while (SplitIdentifier(str) == "const") {
         str = str.Take(6, str.len - 6);
         str = TrimStr(str);
     }
@@ -173,13 +212,10 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
     for (;;) {
         remain = TrimStr(remain);
 
-        if (!remain.len || !IsIdentifierStart(remain[0]))
+        Span<const char> token = SplitIdentifier(remain);
+        if (!token.len)
             break;
-
-        do {
-            remain.ptr++;
-            remain.len--;
-        } while (remain.len && IsIdentifierChar(remain[0]));
+        remain = remain.Take(token.len, remain.len - token.len);
     }
 
     Span<const char> name = TrimStr(MakeSpan(str.ptr, remain.ptr - str.ptr));
@@ -197,7 +233,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         } else if (remain[0] == '!') {
             remain = remain.Take(1, remain.len - 1);
             disposables |= (1u << indirect);
-        } else if (remain.len >= 6 && StartsWith(remain, "const") && !IsIdentifierStart(remain[6])) {
+        } else if (SplitIdentifier(remain) == "const") {
             remain = remain.Take(6, remain.len - 6);
         } else {
             break;
@@ -263,9 +299,6 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         RG_ASSERT(type);
     }
 
-    if (out_directions) {
-        *out_directions = 1;
-    }
     return type;
 }