vm.cc

#include <assert.h>
#include <map>
#include <vector>
#include <string>
#include <pthread.h>
#include <unistd.h>

#include "libplatform/libplatform.h"
#include "v8.h"

#include "report.h"
#include "debug.h"
#include "packet.h"
#include "vm.h"

using namespace v8;
using namespace std;

struct TimeoutHandlerArgs {
    VM* vm;
    long timeout;
};

void* TimeoutHandler(void *arg) {
    struct TimeoutHandlerArgs *args = (struct TimeoutHandlerArgs*)arg;

    FTRACE("Timeout handler started: %li\n", args->timeout);
    usleep((unsigned int)args->timeout * 1000);
    TRACE("Timeout expired. Terminating execution.\n");

    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0x00);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0x00);

    args->vm->TerminateExecution();

    return NULL;
}

VM::VM(Platform* platform_, Isolate* isolate_) {
    isolate = isolate_;
    platform = platform_;
}


bool VM::CreateContext(uint32_t ref) {
    HandleScope handle_scope(isolate);

    Local<v8::ObjectTemplate> global = ObjectTemplate::New(isolate);
    Local<Context> context = Context::New(isolate, NULL, global);

    Persistent<Context, CopyablePersistentTraits<Context>> pcontext(isolate, context);

    Context::Scope context_scope(context);

    contexts[ref] = pcontext;

    Local<String> tt = String::NewFromUtf8(isolate, "context created").ToLocalChecked();
    Report(isolate, tt, OP_OK);

    return true;
}

bool VM::DestroyContext(uint32_t ref) {
    Persistent<Context> pcontext (isolate, contexts[ref]);
    if (pcontext.IsEmpty()) {
        Local<String> tt = String::NewFromUtf8(isolate, "empty contextz").ToLocalChecked();
        Report(isolate, tt, OP_INVALID_CONTEXT);
        return false;
    } else {
        pcontext.Reset();
        contexts.erase(ref);
        Local<String> tt = String::NewFromUtf8(isolate, "context destroyed").ToLocalChecked();
        Report(isolate, tt, OP_OK);
        return true;
    }
}

Isolate* VM::GetIsolate() {
    return isolate;
}

void VM::PumpMessageLoop() {
    while (v8::platform::PumpMessageLoop(platform, isolate)) continue;
}

void VM::TerminateExecution() {
    isolate->TerminateExecution();
    FTRACE("Isolate terminated: %i\n", 10);
}

int VM::Size() {
    FTRACE("Context size: %zd\n", contexts.size());
    return (int)contexts.size();
}

void VM::Eval(Packet* packet) {
    HandleScope handle_scope(isolate);
    TryCatch try_catch(isolate);

    Local<Context> context = Local<Context>::New(isolate,
            contexts[packet->ref]);

        TRACE("Marker \n");
    if (context.IsEmpty()) {
        Local<String> tt = String::NewFromUtf8(isolate, "empty context").ToLocalChecked();
        Report(isolate, tt, OP_INVALID_CONTEXT);
    } else {
        Context::Scope context_scope(context);

        string input = packet->data;

        TRACE("Marker\n");
        Local<String> json_data = String::NewFromUtf8(isolate, input.c_str()).ToLocalChecked();
        Local<Object> instructions = Local<Object>::Cast(
            JSON::Parse(context, json_data).ToLocalChecked()
        );

        TRACE("Marker\n");
        Local<String> timeout_key = String::NewFromUtf8(isolate, "timeout").ToLocalChecked();
        Local<String> source_key = String::NewFromUtf8(isolate, "source").ToLocalChecked();

        Local<String> source = instructions->Get(context, source_key).ToLocalChecked()->ToString(context).ToLocalChecked();
        Local<Integer> timeout = instructions->Get(context, timeout_key).ToLocalChecked()->ToInteger(context).ToLocalChecked();

        TRACE("Marker\n");
        Local<Script> script = Script::Compile(context, source).ToLocalChecked();

        if (script.IsEmpty()) {
            assert(try_catch.HasCaught());
            ReportException(isolate, &try_catch);
        } else {
            pthread_t t;
            void *res;
            struct TimeoutHandlerArgs timeout_handler_args = {
                this,
                (long)timeout->Int32Value(context).ToChecked()
            };

            pthread_create(&t, NULL, TimeoutHandler, &timeout_handler_args);
            TRACE("Fork\n");

            MaybeLocal<Value> result = script->Run(context);

            pthread_cancel(t);
            pthread_join(t, &res);

            FTRACE("Join: %p\n", res);

            if (result.IsEmpty()) {
                assert(try_catch.HasCaught());
                if (try_catch.Message().IsEmpty() && try_catch.StackTrace(context).IsEmpty()) {
                    TRACE("Execution timed out.\n");
                    Local<String> tt = String::NewFromUtf8(isolate, "timeout").ToLocalChecked();
                    Report(isolate, tt, OP_TIMEOUT);
                } else {
                    TRACE("Regular error\n");
                    ReportException(isolate, &try_catch);
                }
                // vm.CreateContext(packet->ref);
            } else {
                ReportOK(isolate, result.ToLocalChecked());
            }
        }
    }
}

void VM::Call(Packet* packet) {
    HandleScope handle_scope(isolate);
    TryCatch try_catch(isolate);

    string input = packet->data;

    Local<Context> context = Local<Context>::New(isolate,
            contexts[packet->ref]);

    if (context.IsEmpty()) {
        Local<Value> tt = String::NewFromUtf8(isolate, "empty context").ToLocalChecked();
        Report(isolate, tt, OP_INVALID_CONTEXT);
    } else {
        Context::Scope context_scope(context);

        Local<String> json_data = String::NewFromUtf8(isolate, input.c_str()).ToLocalChecked();
        Local<Object> instructions = Local<Object>::Cast(
                JSON::Parse(context, json_data).ToLocalChecked()
        );

        Local<Object> global = context->Global();

        Local<String> function_key = String::NewFromUtf8(isolate, "function").ToLocalChecked();
        Local<String> function_name = instructions->Get(context, function_key).ToLocalChecked()->ToString(context).ToLocalChecked();

        Local<String> timeout_key = String::NewFromUtf8(isolate, "timeout").ToLocalChecked();
        Local<String> args_key = String::NewFromUtf8(isolate, "args").ToLocalChecked();
        Local<Value> args_value = instructions->Get(context, args_key).ToLocalChecked();
        Local<Array> raw_args = Local<Array>::Cast(args_value);
        Local<Integer> timeout = instructions->Get(context, timeout_key).ToLocalChecked()->ToInteger(context).ToLocalChecked();

        std::vector<Local<Value>> args(raw_args->Length());
        std::generate(args.begin(), args.end(), [&, idx = 0]() mutable {
            return raw_args->Get(context, idx++).ToLocalChecked();
        });

        // we cannot simply retrieve the function from the global scope as the
        // name can be something like `lol.flop['hi']`. wrapping the call in a
        // temporary function is much simpler than attempting to split the name
        // and check all the individual parts.
        Local<String> prefix = String::NewFromUtf8(isolate,
                "function __call() { return ").ToLocalChecked();
        Local<String> suffix = String::NewFromUtf8(isolate,
                ".apply(null, arguments); }").ToLocalChecked();
        Local<String> source = String::Concat(isolate, String::Concat(isolate, prefix,
                    function_name), suffix);
        Local<Script> script = Script::Compile(context, source).ToLocalChecked();

        pthread_t t;
        void *res;
        struct TimeoutHandlerArgs timeout_handler_args = {
            this,
            (long)timeout->Int32Value(context).ToChecked()
        };

        pthread_create(&t, NULL, TimeoutHandler, &timeout_handler_args);
        TRACE("Fork\n");

        Local<Value> eval_result = script->Run(context).ToLocalChecked();

        pthread_cancel(t);
        pthread_join(t, &res);
        FTRACE("Join: %p\n", res);

        if (eval_result.IsEmpty()) {
            assert(try_catch.HasCaught());
            ReportException(isolate, &try_catch);
        } else {
            Local<String> fn = String::NewFromUtf8(isolate, "__call").ToLocalChecked();
            Local<Function> function = Local<Function>::Cast(global->Get(context, fn).ToLocalChecked());
            MaybeLocal<Value> result = function->Call(context, global, (int)args.size(), args.data());

            if (result.IsEmpty()) {
                assert(try_catch.HasCaught());
                ReportException(isolate, &try_catch);
            } else {
                ReportOK(isolate, result.ToLocalChecked());
            }
        }
    }
}