Support des modules a tester

clibs/chibrax/file.cc

@@ -0,0 +1,49 @@
+#include <node.h>
+#include <string>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define nodeparam v8::FunctionCallbackInfo<v8::Value>
+
+namespace fileNode {
+    void nodeOpen(const nodeparam& args) {
+        v8::Isolate* isolate = args.GetIsolate();
+
+        if (args.Length() < 2 || !args[0]->IsString() || !args[1]->IsUint32() || ( args.Length() == 3 && !( args[2]->IsUndefined() || args[2]->IsUint32()))) {
+            isolate->ThrowException(v8::Exception::TypeError(
+                v8::String::NewFromUtf8(isolate, "Argument 1 must be a path, 2 must be a number").ToLocalChecked()));
+            return;
+        }
+
+        v8::String::Utf8Value str(isolate, args[0]);
+        std::string path(*str);
+        int flags = args[1].As<v8::Number>()->Value();
+
+        if(args.Length() == 3 && args[2]->IsUndefined()) {
+            mode_t mode = args[2].As<v8::Number>()->Value();
+            args.GetReturnValue().Set(open(path.c_str(), flags, mode));
+        } else {
+            args.GetReturnValue().Set(open(path.c_str(), flags));
+        }
+    }
+
+    void nodeClose(const nodeparam& args) {
+        v8::Isolate* isolate = args.GetIsolate();
+
+        if (args.Length() < 1 || !args[0]->IsUint32()) {
+            isolate->ThrowException(v8::Exception::TypeError(
+                v8::String::NewFromUtf8(isolate, "Argument 1 must be a file descriptor (number)").ToLocalChecked()));
+            return;
+        }
+
+        close(args[1].As<v8::Number>()->Value());
+    }
+
+    void Initialize(v8::Local<v8::Object> exports) {
+        NODE_SET_METHOD(exports, "open", nodeOpen);
+        NODE_SET_METHOD(exports, "close", nodeClose);
+    }
+
+    NODE_MODULE(file_api, Initialize)
+}

clibs/chibrax/syscall.cc

@@ -2,19 +2,71 @@
 #include <sys/reboot.h>
 #include <unistd.h>
 #include <node.h>
+#include <errno.h>
+#include <list>
 
+#define returnjs(val) args.GetReturnValue().Set(val);
 namespace syscallNode {
+    void freeList(std::list<std::string *> &list) {
+        std::list<std::string *>::iterator it = list.begin();
+        for(; it != list.end(); it++) {
+            delete *it;
+        }
+    }
+
     void nodeSyscall(const v8::FunctionCallbackInfo<v8::Value>& args) {
         v8::Isolate* isolate = args.GetIsolate();
 
-        if (!args[0]->IsNumber()) {
-            isolate->ThrowException(v8::Exception::TypeError(
-                v8::String::NewFromUtf8(isolate, "Argument must be a number").ToLocalChecked()));
+        std::list<std::string *> memoryToClean;
+
+        //les registres rdi, rsi, rdx ...
+        long int registers[args.Length()];
+
+        for(int i=0; i < args.Length(); i++) {
+            if(args[i]->IsNumber()) {
+                registers[i] = args[i].As<v8::Number>()->Value();
+            } else if(args[i]->IsString()) {
+                v8::String::Utf8Value argv8(isolate, args[i]);
+                std::string *argStr = new std::string(*argv8);
+                //un pointer c'est un u_int32_t donc sa deverais passer
+                registers[i] = (long int)argStr->c_str();
+                memoryToClean.push_front(argStr);
+            } else {
+                freeList(memoryToClean);
+                //respond -1 is something went wrong
+                returnjs(-1);
+                return;
+            }
+        }
+        long int syscallReturnValue;
+
+        switch(memoryToClean.size()) {
+        case 1:
+            syscallReturnValue = syscall(registers[0]);
+            return;
+        case 2:
+            syscallReturnValue = syscall(registers[0], registers[1]);
+            return;
+        case 3:
+            syscallReturnValue = syscall(registers[0], registers[1], registers[2]);
+            return;
+        case 4:
+            syscallReturnValue = syscall(registers[0], registers[1], registers[2], registers[3]);
+            return;
+        case 5:
+            syscallReturnValue = syscall(registers[0], registers[1], registers[2], registers[3], registers[4]);
+            return;
+
+        default:
+            //unsuported length
+            returnjs(-2);
             return;
         }
 
-        long argsValue = args[0].As<v8::Number>()->Value();
-        syscall(argsValue);
+        freeList(memoryToClean);
+        if(syscallReturnValue = -1) {
+            returnjs(errno);
+        }
     }
 
     void nodeReboot(const v8::FunctionCallbackInfo<v8::Value>& args) {