koffi 2.6.0 → 2.6.1

package/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ### Koffi 2.6
 
+#### 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/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/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.6.0",
-    "stable": "2.6.0",
+    "version": "2.6.1",
+    "stable": "2.6.1",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/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.1",
+      stable: "2.6.1",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

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;
 }