--- /dev/null
+/*
+ * rpcd - UBUS RPC server - ucode plugin
+ *
+ * Copyright (C) 2021 Jo-Philipp Wich <jo@mein.io>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <limits.h>
+
+#include <libubox/blobmsg.h>
+#include <libubox/blobmsg_json.h>
+
+#include <libubus.h>
+
+#include <ucode/compiler.h>
+#include <ucode/lib.h>
+#include <ucode/vm.h>
+
+#include <rpcd/plugin.h>
+
+#define RPC_UCSCRIPT_DIRECTORY INSTALL_PREFIX "/share/rpcd/ucode"
+
+static struct blob_buf buf;
+static int request_timeout;
+
+/*
+ * Track script instances and registered ubus objects in these lists.
+ *
+ * This is primarily done to make Valgrind happy and to mark the
+ * related memory as reachable. Since we don't have a teardown
+ * mechanism in rpcd plugins we can't orderly free the related
+ * ubus object and ucode VM memory anyway.
+ */
+static LIST_HEAD(scripts);
+static LIST_HEAD(uuobjs);
+
+typedef struct {
+ struct list_head list;
+ uc_vm_t vm;
+ uc_resource_type_t *requesttype;
+ uc_value_t *pending_replies;
+ char *path;
+} rpc_ucode_script_t;
+
+typedef struct {
+ struct list_head list;
+ rpc_ucode_script_t *script;
+ uc_value_t *signature;
+ struct ubus_object ubusobj;
+} rpc_ucode_ubus_obj_t;
+
+typedef struct {
+ struct ubus_context *ubus;
+ struct ubus_request_data req;
+ struct uloop_timeout timeout;
+ rpc_ucode_script_t *script;
+ uc_value_t *func;
+ uc_value_t *args;
+ uc_value_t *info;
+ bool replied;
+} rpc_ucode_call_ctx_t;
+
+static uc_parse_config_t config = {
+ .strict_declarations = false,
+ .lstrip_blocks = true,
+ .trim_blocks = true
+};
+
+
+static rpc_ucode_script_t *
+rpc_ucode_obj_to_script(struct ubus_object *obj)
+{
+ rpc_ucode_ubus_obj_t *uo = container_of(obj, rpc_ucode_ubus_obj_t, ubusobj);
+
+ return uo->script;
+}
+
+static uc_value_t *
+rpc_ucode_obj_to_signature(struct ubus_object *obj)
+{
+ rpc_ucode_ubus_obj_t *uo = container_of(obj, rpc_ucode_ubus_obj_t, ubusobj);
+
+ return uo->signature;
+}
+
+static void
+rpc_ucode_ucv_array_to_blob(uc_value_t *val, struct blob_buf *blob);
+
+static void
+rpc_ucode_ucv_object_to_blob(uc_value_t *val, struct blob_buf *blob);
+
+static void
+rpc_ucode_ucv_to_blob(const char *name, uc_value_t *val, struct blob_buf *blob)
+{
+ int64_t n;
+ void *c;
+
+ switch (ucv_type(val)) {
+ case UC_NULL:
+ blobmsg_add_field(blob, BLOBMSG_TYPE_UNSPEC, name, NULL, 0);
+ break;
+
+ case UC_BOOLEAN:
+ blobmsg_add_u8(blob, name, ucv_boolean_get(val));
+ break;
+
+ case UC_INTEGER:
+ n = ucv_int64_get(val);
+
+ if (errno == ERANGE)
+ blobmsg_add_u64(blob, name, ucv_uint64_get(val));
+ else if (n >= INT32_MIN && n <= INT32_MAX)
+ blobmsg_add_u32(blob, name, n);
+ else
+ blobmsg_add_u64(blob, name, n);
+
+ break;
+
+ case UC_DOUBLE:
+ blobmsg_add_double(blob, name, ucv_double_get(val));
+ break;
+
+ case UC_STRING:
+ blobmsg_add_string(blob, name, ucv_string_get(val));
+ break;
+
+ case UC_ARRAY:
+ c = blobmsg_open_array(blob, name);
+ rpc_ucode_ucv_array_to_blob(val, blob);
+ blobmsg_close_array(blob, c);
+ break;
+
+ case UC_OBJECT:
+ c = blobmsg_open_table(blob, name);
+ rpc_ucode_ucv_object_to_blob(val, blob);
+ blobmsg_close_table(blob, c);
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void
+rpc_ucode_ucv_array_to_blob(uc_value_t *val, struct blob_buf *blob)
+{
+ size_t i;
+
+ for (i = 0; i < ucv_array_length(val); i++)
+ rpc_ucode_ucv_to_blob(NULL, ucv_array_get(val, i), blob);
+}
+
+static void
+rpc_ucode_ucv_object_to_blob(uc_value_t *val, struct blob_buf *blob)
+{
+ ucv_object_foreach(val, k, v)
+ rpc_ucode_ucv_to_blob(k, v, blob);
+}
+
+static uc_value_t *
+rpc_ucode_blob_to_ucv(uc_vm_t *vm, struct blob_attr *attr, bool table, const char **name);
+
+static uc_value_t *
+rpc_ucode_blob_array_to_ucv(uc_vm_t *vm, struct blob_attr *attr, size_t len, bool table)
+{
+ uc_value_t *o = table ? ucv_object_new(vm) : ucv_array_new(vm);
+ uc_value_t *v;
+ struct blob_attr *pos;
+ size_t rem = len;
+ const char *name;
+
+ if (!o)
+ return NULL;
+
+ __blob_for_each_attr(pos, attr, rem) {
+ name = NULL;
+ v = rpc_ucode_blob_to_ucv(vm, pos, table, &name);
+
+ if (table && name)
+ ucv_object_add(o, name, v);
+ else if (!table)
+ ucv_array_push(o, v);
+ else
+ ucv_put(v);
+ }
+
+ return o;
+}
+
+static uc_value_t *
+rpc_ucode_blob_to_ucv(uc_vm_t *vm, struct blob_attr *attr, bool table, const char **name)
+{
+ void *data;
+ int len;
+
+ if (!blobmsg_check_attr(attr, false))
+ return NULL;
+
+ if (table && blobmsg_name(attr)[0])
+ *name = blobmsg_name(attr);
+
+ data = blobmsg_data(attr);
+ len = blobmsg_data_len(attr);
+
+ switch (blob_id(attr)) {
+ case BLOBMSG_TYPE_BOOL:
+ return ucv_boolean_new(*(uint8_t *)data);
+
+ case BLOBMSG_TYPE_INT16:
+ return ucv_int64_new((int16_t)be16_to_cpu(*(uint16_t *)data));
+
+ case BLOBMSG_TYPE_INT32:
+ return ucv_int64_new((int32_t)be32_to_cpu(*(uint32_t *)data));
+
+ case BLOBMSG_TYPE_INT64:
+ return ucv_int64_new((int64_t)be64_to_cpu(*(uint64_t *)data));
+
+ case BLOBMSG_TYPE_DOUBLE:
+ ;
+ union {
+ double d;
+ uint64_t u64;
+ } v;
+
+ v.u64 = be64_to_cpu(*(uint64_t *)data);
+
+ return ucv_double_new(v.d);
+
+ case BLOBMSG_TYPE_STRING:
+ return ucv_string_new(data);
+
+ case BLOBMSG_TYPE_ARRAY:
+ return rpc_ucode_blob_array_to_ucv(vm, data, len, false);
+
+ case BLOBMSG_TYPE_TABLE:
+ return rpc_ucode_blob_array_to_ucv(vm, data, len, true);
+
+ default:
+ return NULL;
+ }
+}
+
+static int
+rpc_ucode_validate_call_args(struct ubus_object *obj, const char *ubus_method_name, struct blob_attr *msg, uc_value_t **res)
+{
+ rpc_ucode_script_t *script = rpc_ucode_obj_to_script(obj);
+ const struct ubus_method *method = NULL;
+ const struct blobmsg_hdr *hdr;
+ struct blob_attr *attr;
+ bool found;
+ size_t i;
+ int len;
+
+ for (i = 0; i < obj->n_methods; i++) {
+ if (!strcmp(obj->methods[i].name, ubus_method_name)) {
+ method = &obj->methods[i];
+ break;
+ }
+ }
+
+ if (!method)
+ return UBUS_STATUS_METHOD_NOT_FOUND;
+
+ len = blob_len(msg);
+
+ __blob_for_each_attr(attr, blob_data(msg), len) {
+ if (!blobmsg_check_attr_len(attr, false, len))
+ return UBUS_STATUS_INVALID_ARGUMENT;
+
+ if (!blob_is_extended(attr))
+ return UBUS_STATUS_INVALID_ARGUMENT;
+
+ hdr = blob_data(attr);
+ found = false;
+
+ for (i = 0; i < method->n_policy; i++) {
+ if (blobmsg_namelen(hdr) != strlen(method->policy[i].name))
+ continue;
+
+ if (strcmp(method->policy[i].name, (char *)hdr->name))
+ continue;
+
+ /* named argument found but wrong type */
+ if (blob_id(attr) != method->policy[i].type)
+ goto inval;
+
+ found = true;
+ break;
+ }
+
+ /* named argument not found in policy */
+ if (!found)
+ goto inval;
+ }
+
+ *res = rpc_ucode_blob_array_to_ucv(&script->vm, blob_data(msg), blob_len(msg), true);
+
+ return UBUS_STATUS_OK;
+
+inval:
+ *res = NULL;
+
+ return UBUS_STATUS_INVALID_ARGUMENT;
+}
+
+static uc_value_t *
+rpc_ucode_gather_call_info(uc_vm_t *vm,
+ struct ubus_context *ctx, struct ubus_request_data *req,
+ struct ubus_object *obj, const char *ubus_method_name)
+{
+ uc_value_t *info, *o;
+
+ info = ucv_object_new(vm);
+
+ o = ucv_object_new(vm);
+
+ ucv_object_add(o, "user", ucv_string_new(req->acl.user));
+ ucv_object_add(o, "group", ucv_string_new(req->acl.group));
+ ucv_object_add(o, "object", ucv_string_new(req->acl.object));
+
+ ucv_object_add(info, "acl", o);
+
+ o = ucv_object_new(vm);
+
+ ucv_object_add(o, "id", ucv_uint64_new(obj->id));
+ ucv_object_add(o, "name", ucv_string_new(obj->name));
+
+ if (obj->path)
+ ucv_object_add(o, "path", ucv_string_new(obj->path));
+
+ ucv_object_add(info, "object", o);
+
+ ucv_object_add(info, "method", ucv_string_new(ubus_method_name));
+
+ return info;
+}
+
+static void
+rpc_ucode_request_finish(rpc_ucode_call_ctx_t *callctx, int code, uc_value_t *reply)
+{
+ rpc_ucode_script_t *script = callctx->script;
+ uc_resource_t *r;
+ size_t i;
+
+ if (callctx->replied)
+ return;
+
+ if (reply) {
+ blob_buf_init(&buf, 0);
+ rpc_ucode_ucv_object_to_blob(reply, &buf);
+ ubus_send_reply(callctx->ubus, &callctx->req, buf.head);
+ }
+
+ ubus_complete_deferred_request(callctx->ubus, &callctx->req, code);
+
+ callctx->replied = true;
+
+ for (i = 0; i < ucv_array_length(script->pending_replies); i++) {
+ r = (uc_resource_t *)ucv_array_get(script->pending_replies, i);
+
+ if (r && r->data == callctx) {
+ ucv_array_set(script->pending_replies, i, NULL);
+ break;
+ }
+ }
+}
+
+static void
+rpc_ucode_request_timeout(struct uloop_timeout *timeout)
+{
+ rpc_ucode_call_ctx_t *callctx = container_of(timeout, rpc_ucode_call_ctx_t, timeout);
+
+ rpc_ucode_request_finish(callctx, UBUS_STATUS_TIMEOUT, NULL);
+}
+
+static int
+rpc_ucode_script_call(struct ubus_context *ctx, struct ubus_object *obj,
+ struct ubus_request_data *req, const char *ubus_method_name,
+ struct blob_attr *msg)
+{
+ rpc_ucode_script_t *script = rpc_ucode_obj_to_script(obj);
+ uc_value_t *func, *args = NULL, *reqobj, *reqproto, *res;
+ rpc_ucode_call_ctx_t *callctx;
+ size_t i;
+ int rv;
+
+ rv = rpc_ucode_validate_call_args(obj, ubus_method_name, msg, &args);
+
+ if (rv != UBUS_STATUS_OK)
+ return rv;
+
+ func = ucv_object_get(
+ ucv_object_get(rpc_ucode_obj_to_signature(obj), ubus_method_name, NULL),
+ "call", NULL
+ );
+
+ if (!ucv_is_callable(func))
+ return UBUS_STATUS_METHOD_NOT_FOUND;
+
+ /* allocate deferred method call context */
+ callctx = calloc(1, sizeof(*callctx));
+
+ if (!callctx)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ callctx->ubus = ctx;
+ callctx->script = script;
+
+ ubus_defer_request(ctx, req, &callctx->req);
+
+ /* create ucode request type object and set properties */
+ reqobj = uc_resource_new(script->requesttype, callctx);
+ reqproto = ucv_object_new(&script->vm);
+
+ ucv_object_add(reqproto, "args", args);
+ ucv_object_add(reqproto, "info",
+ rpc_ucode_gather_call_info(&script->vm, ctx, req, obj, ubus_method_name));
+
+ ucv_prototype_set(ucv_prototype_get(reqobj), reqproto);
+
+ /* push handler and request object onto stack */
+ uc_vm_stack_push(&script->vm, ucv_get(func));
+ uc_vm_stack_push(&script->vm, ucv_get(reqobj));
+
+ /* execute request handler function */
+ switch (uc_vm_call(&script->vm, false, 1)) {
+ case EXCEPTION_NONE:
+ res = uc_vm_stack_pop(&script->vm);
+
+ /* The handler function invoked a nested aync ubus request and returned it */
+ if (ucv_resource_dataptr(res, "ubus.deferred")) {
+ /* Install guard timer in case the reply callback is never called */
+ callctx->timeout.cb = rpc_ucode_request_timeout;
+ uloop_timeout_set(&callctx->timeout, request_timeout);
+
+ /* Add wrapped request context into registry to prevent GC'ing
+ * until reply or timeout occurred */
+ for (i = 0;; i++) {
+ if (ucv_array_get(script->pending_replies, i) == NULL) {
+ ucv_array_set(script->pending_replies, i, ucv_get(reqobj));
+ break;
+ }
+ }
+ }
+
+ /* Otherwise, when the function returned an object, treat it as
+ * reply data and conclude deferred request immediately */
+ else if (ucv_type(res) == UC_OBJECT) {
+ blob_buf_init(&buf, 0);
+ rpc_ucode_ucv_object_to_blob(res, &buf);
+ ubus_send_reply(ctx, &callctx->req, buf.head);
+
+ ubus_complete_deferred_request(ctx, &callctx->req, UBUS_STATUS_OK);
+ callctx->replied = true;
+ }
+
+ /* If neither a deferred ubus request, nor a plain object were
+ * returned and if reqobj.reply() hasn't been called, immediately
+ * finish deferred request with UBUS_STATUS_NO_DATA. The */
+ else if (!callctx->replied) {
+ ubus_complete_deferred_request(ctx, &callctx->req, UBUS_STATUS_NO_DATA);
+ callctx->replied = true;
+ }
+
+ ucv_put(res);
+ break;
+
+ /* if the handler function invoked exit(), forward exit status as ubus
+ * return code, map out of range values to UBUS_STATUS_UNKNOWN_ERROR. */
+ case EXCEPTION_EXIT:
+ rv = script->vm.arg.s32;
+
+ if (rv < UBUS_STATUS_OK || rv >= __UBUS_STATUS_LAST)
+ rv = UBUS_STATUS_UNKNOWN_ERROR;
+
+ ubus_complete_deferred_request(ctx, &callctx->req, rv);
+ callctx->replied = true;
+ break;
+
+ /* treat other exceptions as unknown error */
+ default:
+ ubus_complete_deferred_request(ctx, &callctx->req, UBUS_STATUS_UNKNOWN_ERROR);
+ callctx->replied = true;
+ break;
+ }
+
+ /* release request object */
+ ucv_put(reqobj);
+
+ /* garbage collect */
+ ucv_gc(&script->vm);
+
+ return UBUS_STATUS_OK;
+}
+
+static uc_function_t *
+rpc_ucode_script_compile(const char *path, uc_source_t *src)
+{
+ char *syntax_error = NULL;
+ uc_function_t *progfunc;
+
+ progfunc = uc_compile(&config, src, &syntax_error);
+
+ if (!progfunc)
+ fprintf(stderr, "Unable to compile ucode script %s: %s\n",
+ path, syntax_error);
+
+ uc_source_put(src);
+ free(syntax_error);
+
+ return progfunc;
+}
+
+static bool
+rpc_ucode_script_validate(rpc_ucode_script_t *script)
+{
+ uc_value_t *signature = uc_vm_registry_get(&script->vm, "rpcd.ucode.signature");
+ uc_value_t *args, *func;
+
+ if (ucv_type(signature) != UC_OBJECT) {
+ fprintf(stderr, "Invalid object signature for ucode script %s"
+ " - expected dictionary, got %s\n",
+ script->path, ucv_typename(signature));
+
+ return false;
+ }
+
+ ucv_object_foreach(signature, ubus_object_name, ubus_object_methods) {
+ if (ucv_type(ubus_object_methods) != UC_OBJECT) {
+ fprintf(stderr, "Invalid method signature for ucode script %s, object %s"
+ " - expected dictionary, got %s\n",
+ script->path, ubus_object_name, ucv_typename(ubus_object_methods));
+
+ return false;
+ }
+
+ ucv_object_foreach(ubus_object_methods, ubus_method_name, ubus_method_definition) {
+ func = ucv_object_get(ubus_method_definition, "call", NULL);
+ args = ucv_object_get(ubus_method_definition, "args", NULL);
+
+ if (ucv_type(ubus_method_definition) != UC_OBJECT) {
+ fprintf(stderr, "Invalid method definition for ucode script %s, object %s, method %s"
+ " - expected dictionary, got %s\n",
+ script->path, ubus_object_name, ubus_method_name, ucv_typename(ubus_method_definition));
+
+ return false;
+ }
+
+ if (!ucv_is_callable(func)) {
+ fprintf(stderr, "Invalid method callback for ucode script %s, object %s, method %s"
+ " - expected callable, got %s\n",
+ script->path, ubus_object_name, ubus_method_name, ucv_typename(func));
+
+ return false;
+ }
+
+ if (args) {
+ if (ucv_type(args) != UC_OBJECT) {
+ fprintf(stderr, "Invalid method argument definition for ucode script %s, "
+ "object %s, method %s - expected dictionary, got %s\n",
+ script->path, ubus_object_name, ubus_method_name, ucv_typename(args));
+
+ return false;
+ }
+
+ ucv_object_foreach(args, ubus_argument_name, ubus_argument_typehint) {
+ switch (ucv_type(ubus_argument_typehint)) {
+ case UC_BOOLEAN:
+ case UC_INTEGER:
+ case UC_DOUBLE:
+ case UC_STRING:
+ case UC_ARRAY:
+ case UC_OBJECT:
+ continue;
+
+ default:
+ fprintf(stderr, "Unsupported argument type for ucode script %s, object %s, "
+ "method %s, argument %s - expected boolean, integer, string, "
+ "array or object, got %s\n",
+ script->path, ubus_object_name, ubus_method_name, ubus_argument_name,
+ ucv_typename(ubus_argument_typehint));
+
+ return false;
+ }
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+static bool
+rpc_ucode_method_register(struct ubus_method *method, const char *ubus_method_name, uc_value_t *ubus_method_arguments)
+{
+ struct blobmsg_policy *policy;
+ enum blobmsg_type type;
+
+ method->name = strdup(ubus_method_name);
+
+ if (!method->name) {
+ fprintf(stderr, "Unable to allocate ubus method name: %s\n",
+ strerror(errno));
+
+ return false;
+ }
+
+ method->policy = calloc(ucv_object_length(ubus_method_arguments), sizeof(*method->policy));
+
+ if (!method->policy) {
+ fprintf(stderr, "Unable to allocate ubus method argument policy: %s\n",
+ strerror(errno));
+
+ return false;
+ }
+
+ method->handler = rpc_ucode_script_call;
+
+ ucv_object_foreach(ubus_method_arguments, ubus_argument_name, ubus_argument_typehint) {
+ switch (ucv_type(ubus_argument_typehint)) {
+ case UC_BOOLEAN:
+ type = BLOBMSG_TYPE_INT8;
+ break;
+
+ case UC_INTEGER:
+ switch (ucv_int64_get(ubus_argument_typehint)) {
+ case 8:
+ type = BLOBMSG_TYPE_INT8;
+ break;
+
+ case 16:
+ type = BLOBMSG_TYPE_INT16;
+ break;
+
+ case 64:
+ type = BLOBMSG_TYPE_INT64;
+ break;
+
+ default:
+ type = BLOBMSG_TYPE_INT32;
+ break;
+ }
+
+ break;
+
+ case UC_DOUBLE:
+ type = BLOBMSG_TYPE_DOUBLE;
+ break;
+
+ case UC_ARRAY:
+ type = BLOBMSG_TYPE_ARRAY;
+ break;
+
+ case UC_OBJECT:
+ type = BLOBMSG_TYPE_TABLE;
+ break;
+
+ default:
+ type = BLOBMSG_TYPE_STRING;
+ break;
+ }
+
+ policy = (struct blobmsg_policy *)&method->policy[method->n_policy++];
+
+ policy->type = type;
+ policy->name = strdup(ubus_argument_name);
+
+ if (!policy->name) {
+ fprintf(stderr, "Unable to allocate ubus method argument name: %s\n",
+ strerror(errno));
+
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static bool
+rpc_ucode_script_register(struct ubus_context *ctx, rpc_ucode_script_t *script)
+{
+ uc_value_t *signature = uc_vm_registry_get(&script->vm, "rpcd.ucode.signature");
+ const struct blobmsg_policy *policy;
+ rpc_ucode_ubus_obj_t *uuobj = NULL;
+ char *tptr, *tnptr, *onptr, *mptr;
+ struct ubus_method *method;
+ struct ubus_object *obj;
+ size_t typelen, namelen;
+ uc_value_t *args;
+ int rv;
+
+ if (!rpc_ucode_script_validate(script))
+ return false;
+
+ ucv_object_foreach(signature, ubus_object_name, ubus_object_methods) {
+ namelen = strlen(ubus_object_name);
+ typelen = strlen("rpcd-plugin-ucode-") + namelen;
+
+ uuobj = calloc_a(sizeof(*uuobj),
+ &onptr, namelen + 1,
+ &mptr, ucv_object_length(ubus_object_methods) * sizeof(struct ubus_method),
+ &tptr, sizeof(struct ubus_object_type),
+ &tnptr, typelen + 1);
+
+ if (!uuobj) {
+ fprintf(stderr, "Unable to allocate ubus object signature: %s\n",
+ strerror(errno));
+
+ continue;
+ }
+
+ list_add(&uuobj->list, &uuobjs);
+
+ uuobj->script = script;
+ uuobj->signature = ubus_object_methods;
+
+ snprintf(tnptr, typelen, "rpcd-plugin-ucode-%s", ubus_object_name);
+
+ method = (struct ubus_method *)mptr;
+
+ obj = &uuobj->ubusobj;
+ obj->name = strncpy(onptr, ubus_object_name, namelen);
+ obj->methods = method;
+
+ obj->type = (struct ubus_object_type *)tptr;
+ obj->type->name = tnptr;
+ obj->type->methods = obj->methods;
+
+ ucv_object_foreach(ubus_object_methods, ubus_method_name, ubus_method_definition) {
+ args = ucv_object_get(ubus_method_definition, "args", NULL);
+
+ if (!rpc_ucode_method_register(&method[obj->n_methods++], ubus_method_name, args))
+ goto free;
+ }
+
+ obj->type = (struct ubus_object_type *)tptr;
+ obj->type->name = tnptr;
+ obj->type->methods = obj->methods;
+ obj->type->n_methods = obj->n_methods;
+
+ rv = ubus_add_object(ctx, obj);
+
+ if (rv != UBUS_STATUS_OK) {
+ fprintf(stderr, "Unable to register ubus object %s: %s\n",
+ obj->name, ubus_strerror(rv));
+
+ goto free;
+ }
+
+ continue;
+
+free:
+ for (; obj->n_methods > 0; method++, obj->n_methods--) {
+ for (policy = method->policy; method->n_policy > 0; policy++, method->n_policy--)
+ free((char *)policy->name);
+
+ free((char *)method->name);
+ free((char *)method->policy);
+ }
+
+ free(uuobj);
+ }
+
+ return true;
+}
+
+static uc_value_t *
+rpc_ucode_request_reply(uc_vm_t *vm, size_t nargs)
+{
+ rpc_ucode_call_ctx_t **callctx = uc_fn_this("rpcd.ucode.request");
+ uc_value_t *reply = uc_fn_arg(0);
+ uc_value_t *rcode = uc_fn_arg(1);
+ int64_t code = UBUS_STATUS_OK;
+
+ if (!callctx || !*callctx) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "Attempt to invoke reply() on invalid self");
+
+ return NULL;
+ }
+ else if (reply && ucv_type(reply) != UC_OBJECT) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "First argument to reply() must be null or an object");
+
+ return NULL;
+ }
+ else if (rcode && ucv_type(rcode) != UC_INTEGER) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "Second argument to reply() must be null or an integer");
+
+ return NULL;
+ }
+
+ if ((*callctx)->replied) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "Reply has already been sent");
+
+ return NULL;
+ }
+
+ if (rcode) {
+ code = ucv_int64_get(rcode);
+
+ if (errno == ERANGE || code < 0 || code > __UBUS_STATUS_LAST)
+ code = UBUS_STATUS_UNKNOWN_ERROR;
+ }
+
+ rpc_ucode_request_finish(*callctx, code, reply);
+
+ return NULL;
+}
+
+static uc_value_t *
+rpc_ucode_request_error(uc_vm_t *vm, size_t nargs)
+{
+ rpc_ucode_call_ctx_t **callctx = uc_fn_this("rpcd.ucode.request");
+ uc_value_t *rcode = uc_fn_arg(0);
+ int64_t code;
+
+ if (!callctx || !*callctx) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "Attempt to invoke error() on invalid self");
+
+ return NULL;
+ }
+ else if (ucv_type(rcode) != UC_INTEGER) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "First argument to error() must be an integer");
+
+ return NULL;
+ }
+
+ if ((*callctx)->replied) {
+ uc_vm_raise_exception(vm, EXCEPTION_RUNTIME,
+ "Reply has already been sent");
+
+ return NULL;
+ }
+
+
+ code = ucv_int64_get(rcode);
+
+ if (errno == ERANGE || code < 0 || code > __UBUS_STATUS_LAST)
+ code = UBUS_STATUS_UNKNOWN_ERROR;
+
+ rpc_ucode_request_finish(*callctx, code, NULL);
+
+ return NULL;
+}
+
+static const uc_function_list_t rpc_ucode_request_fns[] = {
+ { "reply", rpc_ucode_request_reply },
+ { "error", rpc_ucode_request_error },
+};
+
+static void
+rpc_ucode_request_gc(void *ud)
+{
+ rpc_ucode_call_ctx_t *callctx = ud;
+
+ uloop_timeout_cancel(&callctx->timeout);
+ free(callctx);
+}
+
+static void
+rpc_ucode_init_globals(rpc_ucode_script_t *script)
+{
+ uc_vm_t *vm = &script->vm;
+ uc_value_t *scope = uc_vm_scope_get(vm);
+
+#define status_const(name) \
+ ucv_object_add(scope, #name, ucv_uint64_new(name))
+
+ status_const(UBUS_STATUS_OK);
+ status_const(UBUS_STATUS_INVALID_COMMAND);
+ status_const(UBUS_STATUS_INVALID_ARGUMENT);
+ status_const(UBUS_STATUS_METHOD_NOT_FOUND);
+ status_const(UBUS_STATUS_NOT_FOUND);
+ status_const(UBUS_STATUS_NO_DATA);
+ status_const(UBUS_STATUS_PERMISSION_DENIED);
+ status_const(UBUS_STATUS_TIMEOUT);
+ status_const(UBUS_STATUS_NOT_SUPPORTED);
+ status_const(UBUS_STATUS_UNKNOWN_ERROR);
+ status_const(UBUS_STATUS_CONNECTION_FAILED);
+
+#undef status_const
+
+ uc_stdlib_load(scope);
+
+ script->requesttype = uc_type_declare(vm, "rpcd.ucode.request",
+ rpc_ucode_request_fns, rpc_ucode_request_gc);
+}
+
+static rpc_ucode_script_t *
+rpc_ucode_script_execute(struct ubus_context *ctx, const char *path, uc_function_t *func)
+{
+ rpc_ucode_script_t *script;
+ uc_value_t *signature;
+ uc_vm_status_t status;
+ size_t pathlen;
+ char *pptr;
+
+ pathlen = strlen(path);
+ script = calloc_a(sizeof(*script), &pptr, pathlen + 1);
+
+ if (!script) {
+ fprintf(stderr, "Unable to allocate context for ucode script %s: %s\n",
+ path, strerror(errno));
+
+ ucv_put(&func->header);
+
+ return NULL;
+ }
+
+ script->path = strncpy(pptr, path, pathlen);
+
+ uc_vm_init(&script->vm, &config);
+ rpc_ucode_init_globals(script);
+
+ status = uc_vm_execute(&script->vm, func, &signature);
+
+ script->pending_replies = ucv_array_new(&script->vm);
+
+ uc_vm_registry_set(&script->vm, "rpcd.ucode.signature", signature);
+ uc_vm_registry_set(&script->vm, "rpcd.ucode.deferreds", script->pending_replies);
+
+ ucv_gc(&script->vm);
+
+ switch (status) {
+ case STATUS_OK:
+ if (rpc_ucode_script_register(ctx, script))
+ return script;
+
+ fprintf(stderr, "Skipping registration of ucode script %s\n", path);
+ break;
+
+ case STATUS_EXIT:
+ fprintf(stderr, "The ucode script %s invoked exit(%" PRId64 ")\n",
+ path, ucv_int64_get(signature));
+ break;
+
+ case ERROR_COMPILE:
+ fprintf(stderr, "Compilation error while executing ucode script %s\n", path);
+ break;
+
+ case ERROR_RUNTIME:
+ fprintf(stderr, "Runtime error while executing ucode script %s\n", path);
+ break;
+ }
+
+ uc_vm_free(&script->vm);
+ free(script);
+
+ return NULL;
+}
+
+static int
+rpc_ucode_init_script(struct ubus_context *ctx, const char *path)
+{
+ rpc_ucode_script_t *script;
+ uc_function_t *progfunc;
+ uc_source_t *src;
+
+ src = uc_source_new_file(path);
+
+ if (!src) {
+ fprintf(stderr, "Unable to open ucode script %s: %s\n",
+ path, strerror(errno));
+
+ return UBUS_STATUS_UNKNOWN_ERROR;
+ }
+
+ progfunc = rpc_ucode_script_compile(path, src);
+
+ if (!progfunc)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ script = rpc_ucode_script_execute(ctx, path, progfunc);
+
+ if (!script)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ list_add(&script->list, &scripts);
+
+ return UBUS_STATUS_OK;
+}
+
+static int
+rpc_ucode_api_init(const struct rpc_daemon_ops *ops, struct ubus_context *ctx)
+{
+ char path[PATH_MAX];
+ struct dirent *e;
+ struct stat s;
+ int rv = 0;
+ DIR *d;
+
+ request_timeout = *ops->exec_timeout;
+
+ /* reopen ucode.so with RTLD_GLOBAL in order to export libucode runtime
+ * symbols for ucode extensions loaded later at runtime */
+ if (!dlopen(RPC_LIBRARY_DIRECTORY "/ucode.so", RTLD_LAZY|RTLD_GLOBAL)) {
+ fprintf(stderr, "Failed to dlopen() ucode.so: %s, dynamic ucode plugins may fail\n",
+ dlerror());
+ }
+ if ((d = opendir(RPC_UCSCRIPT_DIRECTORY)) != NULL) {
+ while ((e = readdir(d)) != NULL) {
+ snprintf(path, sizeof(path), RPC_UCSCRIPT_DIRECTORY "/%s", e->d_name);
+
+ if (stat(path, &s) || !S_ISREG(s.st_mode))
+ continue;
+
+ if (s.st_mode & S_IWOTH) {
+ fprintf(stderr, "Ignoring ucode script %s because it is world writable\n",
+ path);
+
+ continue;
+ }
+
+ rv |= rpc_ucode_init_script(ctx, path);
+ }
+
+ closedir(d);
+ }
+
+ return rv;
+}
+
+struct rpc_plugin rpc_plugin = {
+ .init = rpc_ucode_api_init
+};
projects / project / rpcd.git / commitdiff