X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fuhttpd.git;a=blobdiff_plain;f=ubus.c;h=0d41c2dd6b7f3b712f9dd3e725e7b6f2f0a6f2cc;hp=2b4ac5b036bab0d85f687591295b026a3b2627b8;hb=c171d9c5a1c1320e53183f425fa9b82682eeaa51;hpb=f8573c7b4c3a9e1a67cae787690f27a976aee11c diff --git a/ubus.c b/ubus.c index 2b4ac5b..0d41c2d 100644 --- a/ubus.c +++ b/ubus.c @@ -1,690 +1,526 @@ /* * uhttpd - Tiny single-threaded httpd * - * Copyright (C) 2010-2012 Jo-Philipp Wich - * Copyright (C) 2012 Felix Fietkau + * Copyright (C) 2010-2013 Jo-Philipp Wich + * Copyright (C) 2013 Felix Fietkau * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at + * 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. * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * 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 #include #include #include -#include #include #include #include "uhttpd.h" #include "plugin.h" -#include "ubus.h" static const struct uhttpd_ops *ops; static struct config *_conf; #define conf (*_conf) static struct ubus_context *ctx; -static struct avl_tree sessions; static struct blob_buf buf; -static const struct blobmsg_policy new_policy = { - .name = "timeout", .type = BLOBMSG_TYPE_INT32 +#define UH_UBUS_MAX_POST_SIZE 4096 +#define UH_UBUS_DEFAULT_SID "00000000000000000000000000000000" + +enum { + RPC_JSONRPC, + RPC_METHOD, + RPC_PARAMS, + RPC_ID, + __RPC_MAX, }; -static const struct blobmsg_policy sid_policy = { - .name = "sid", .type = BLOBMSG_TYPE_STRING +static const struct blobmsg_policy rpc_policy[__RPC_MAX] = { + [RPC_JSONRPC] = { .name = "jsonrpc", .type = BLOBMSG_TYPE_STRING }, + [RPC_METHOD] = { .name = "method", .type = BLOBMSG_TYPE_STRING }, + [RPC_PARAMS] = { .name = "params", .type = BLOBMSG_TYPE_ARRAY }, + [RPC_ID] = { .name = "id", .type = BLOBMSG_TYPE_UNSPEC }, }; enum { - UH_UBUS_SS_SID, - UH_UBUS_SS_VALUES, - __UH_UBUS_SS_MAX, -}; -static const struct blobmsg_policy set_policy[__UH_UBUS_SS_MAX] = { - [UH_UBUS_SS_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING }, - [UH_UBUS_SS_VALUES] = { .name = "values", .type = BLOBMSG_TYPE_TABLE }, + SES_ACCESS, + __SES_MAX, }; -enum { - UH_UBUS_SG_SID, - UH_UBUS_SG_KEYS, - __UH_UBUS_SG_MAX, +static const struct blobmsg_policy ses_policy[__SES_MAX] = { + [SES_ACCESS] = { .name = "access", .type = BLOBMSG_TYPE_BOOL }, }; -static const struct blobmsg_policy get_policy[__UH_UBUS_SG_MAX] = { - [UH_UBUS_SG_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING }, - [UH_UBUS_SG_KEYS] = { .name = "keys", .type = BLOBMSG_TYPE_ARRAY }, + +struct rpc_data { + struct blob_attr *id; + const char *sid; + const char *method; + const char *object; + const char *function; + struct blob_attr *data; + struct blob_attr *params; }; -enum { - UH_UBUS_SA_SID, - UH_UBUS_SA_OBJECTS, - __UH_UBUS_SA_MAX, +struct list_data { + bool verbose; + struct blob_buf *buf; }; -static const struct blobmsg_policy acl_policy[__UH_UBUS_SA_MAX] = { - [UH_UBUS_SA_SID] = { .name = "sid", .type = BLOBMSG_TYPE_STRING }, - [UH_UBUS_SA_OBJECTS] = { .name = "objects", .type = BLOBMSG_TYPE_ARRAY }, + +enum rpc_error { + ERROR_PARSE, + ERROR_REQUEST, + ERROR_METHOD, + ERROR_PARAMS, + ERROR_INTERNAL, + ERROR_OBJECT, + ERROR_SESSION, + ERROR_ACCESS, + ERROR_TIMEOUT, + __ERROR_MAX }; -/* - * Keys in the AVL tree contain all pattern characters up to the first wildcard. - * To look up entries, start with the last entry that has a key less than or - * equal to the method name, then work backwards as long as the AVL key still - * matches its counterpart in the object name - */ -#define uh_foreach_matching_acl_prefix(_acl, _ses, _obj, _func) \ - for (_acl = avl_find_le_element(&(_ses)->acls, _obj, _acl, avl); \ - _acl && !strncmp((_acl)->object, _obj, (_acl)->sort_len); \ - _acl = avl_is_first(&(ses)->acls, &(_acl)->avl) ? NULL : \ - avl_prev_element((_acl), avl)) +static const struct { + int code; + const char *msg; +} json_errors[__ERROR_MAX] = { + [ERROR_PARSE] = { -32700, "Parse error" }, + [ERROR_REQUEST] = { -32600, "Invalid request" }, + [ERROR_METHOD] = { -32601, "Method not found" }, + [ERROR_PARAMS] = { -32602, "Invalid parameters" }, + [ERROR_INTERNAL] = { -32603, "Internal error" }, + [ERROR_OBJECT] = { -32000, "Object not found" }, + [ERROR_SESSION] = { -32001, "Session not found" }, + [ERROR_ACCESS] = { -32002, "Access denied" }, + [ERROR_TIMEOUT] = { -32003, "ubus request timed out" }, +}; -#define uh_foreach_matching_acl(_acl, _ses, _obj, _func) \ - uh_foreach_matching_acl_prefix(_acl, _ses, _obj, _func) \ - if (!fnmatch((_acl)->object, (_obj), FNM_NOESCAPE) && \ - !fnmatch((_acl)->function, (_func), FNM_NOESCAPE)) +static void __uh_ubus_next_batched_request(struct uloop_timeout *timeout); -static void -uh_ubus_random(char *dest) +static void uh_ubus_next_batched_request(struct client *cl) { - unsigned char buf[16] = { 0 }; - FILE *f; - int i; - - f = fopen("/dev/urandom", "r"); - if (!f) - return; - - fread(buf, 1, sizeof(buf), f); - fclose(f); + struct dispatch_ubus *du = &cl->dispatch.ubus; - for (i = 0; i < sizeof(buf); i++) - sprintf(dest + (i<<1), "%02x", buf[i]); + du->timeout.cb = __uh_ubus_next_batched_request; + uloop_timeout_set(&du->timeout, 1); } -static void -uh_ubus_session_dump_data(struct uh_ubus_session *ses, struct blob_buf *b) +static void uh_ubus_send_header(struct client *cl) { - struct uh_ubus_session_data *d; - - avl_for_each_element(&ses->data, d, avl) { - blobmsg_add_field(b, blobmsg_type(d->attr), blobmsg_name(d->attr), - blobmsg_data(d->attr), blobmsg_data_len(d->attr)); - } + ops->http_header(cl, 200, "OK"); + ustream_printf(cl->us, "Content-Type: application/json\r\n\r\n"); } -static void -uh_ubus_session_dump_acls(struct uh_ubus_session *ses, struct blob_buf *b) +static void uh_ubus_send_response(struct client *cl) { - struct uh_ubus_session_acl *acl; - const char *lastobj = NULL; - void *c = NULL; + struct dispatch_ubus *du = &cl->dispatch.ubus; + const char *sep = ""; + char *str; - avl_for_each_element(&ses->acls, acl, avl) { - if (!lastobj || strcmp(acl->object, lastobj)) - { - if (c) blobmsg_close_array(b, c); - c = blobmsg_open_array(b, acl->object); - } + if (du->array && du->array_idx > 1) + sep = ", "; - blobmsg_add_string(b, NULL, acl->function); - lastobj = acl->object; - } + str = blobmsg_format_json_indent(buf.head, true, du->array); + ops->chunk_printf(cl, "%s%s", sep, str); + free(str); - if (c) blobmsg_close_array(b, c); + du->jsobj_cur = NULL; + if (du->array) + uh_ubus_next_batched_request(cl); + else { + ops->chunk_printf(cl, "\n"); + return ops->request_done(cl); + } } -static void -uh_ubus_session_dump(struct uh_ubus_session *ses, - struct ubus_context *ctx, - struct ubus_request_data *req) +static void uh_ubus_init_response(struct client *cl) { - void *c; - struct blob_buf b; - - memset(&b, 0, sizeof(b)); - blob_buf_init(&b, 0); - - blobmsg_add_string(&b, "sid", ses->id); - blobmsg_add_u32(&b, "timeout", ses->timeout); - - c = blobmsg_open_table(&b, "acls"); - uh_ubus_session_dump_acls(ses, &b); - blobmsg_close_table(&b, c); + struct dispatch_ubus *du = &cl->dispatch.ubus; + struct json_object *obj = du->jsobj_cur; - c = blobmsg_open_table(&b, "data"); - uh_ubus_session_dump_data(ses, &b); - blobmsg_close_table(&b, c); + blob_buf_init(&buf, 0); + blobmsg_add_string(&buf, "jsonrpc", "2.0"); - ubus_send_reply(ctx, req, b.head); - blob_buf_free(&b); -} + if (obj) + obj = json_object_object_get(obj, "id"); -static void -uh_ubus_touch_session(struct uh_ubus_session *ses) -{ - uloop_timeout_set(&ses->t, ses->timeout * 1000); + if (obj) + blobmsg_add_json_element(&buf, "id", obj); + else + blobmsg_add_field(&buf, BLOBMSG_TYPE_UNSPEC, "id", NULL, 0); } -static void -uh_ubus_session_destroy(struct uh_ubus_session *ses) +static void uh_ubus_json_error(struct client *cl, enum rpc_error type) { - struct uh_ubus_session_acl *acl, *nacl; - struct uh_ubus_session_data *data, *ndata; - - uloop_timeout_cancel(&ses->t); - avl_remove_all_elements(&ses->acls, acl, avl, nacl) - free(acl); - - avl_remove_all_elements(&ses->data, data, avl, ndata) - free(data); + void *c; - avl_delete(&sessions, &ses->avl); - free(ses); + uh_ubus_init_response(cl); + c = blobmsg_open_table(&buf, "error"); + blobmsg_add_u32(&buf, "code", json_errors[type].code); + blobmsg_add_string(&buf, "message", json_errors[type].msg); + blobmsg_close_table(&buf, c); + uh_ubus_send_response(cl); } -static void uh_ubus_session_timeout(struct uloop_timeout *t) +static void +uh_ubus_request_data_cb(struct ubus_request *req, int type, struct blob_attr *msg) { - struct uh_ubus_session *ses; + struct dispatch_ubus *du = container_of(req, struct dispatch_ubus, req); - ses = container_of(t, struct uh_ubus_session, t); - uh_ubus_session_destroy(ses); + blobmsg_add_field(&du->buf, BLOBMSG_TYPE_TABLE, "", blob_data(msg), blob_len(msg)); } -static struct uh_ubus_session * -uh_ubus_session_create(int timeout) +static void +uh_ubus_request_cb(struct ubus_request *req, int ret) { - struct uh_ubus_session *ses; - - ses = calloc(1, sizeof(*ses)); - if (!ses) - return NULL; - - ses->timeout = timeout; - ses->avl.key = ses->id; - uh_ubus_random(ses->id); - - avl_insert(&sessions, &ses->avl); - avl_init(&ses->acls, avl_strcmp, true, NULL); - avl_init(&ses->data, avl_strcmp, false, NULL); - - ses->t.cb = uh_ubus_session_timeout; - uh_ubus_touch_session(ses); + struct dispatch_ubus *du = container_of(req, struct dispatch_ubus, req); + struct client *cl = container_of(du, struct client, dispatch.ubus); + struct blob_attr *cur; + void *r; + int rem; - return ses; + uloop_timeout_cancel(&du->timeout); + uh_ubus_init_response(cl); + r = blobmsg_open_array(&buf, "result"); + blobmsg_add_u32(&buf, "", ret); + blob_for_each_attr(cur, du->buf.head, rem) + blobmsg_add_blob(&buf, cur); + blobmsg_close_array(&buf, r); + uh_ubus_send_response(cl); } -static struct uh_ubus_session * -uh_ubus_session_get(const char *id) +static void +uh_ubus_timeout_cb(struct uloop_timeout *timeout) { - struct uh_ubus_session *ses; - - ses = avl_find_element(&sessions, id, ses, avl); - if (!ses) - return NULL; + struct dispatch_ubus *du = container_of(timeout, struct dispatch_ubus, timeout); + struct client *cl = container_of(du, struct client, dispatch.ubus); - uh_ubus_touch_session(ses); - return ses; + ubus_abort_request(ctx, &du->req); + uh_ubus_json_error(cl, ERROR_TIMEOUT); } -static int -uh_ubus_handle_create(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) +static void uh_ubus_close_fds(struct client *cl) { - struct uh_ubus_session *ses; - struct blob_attr *tb; - int timeout = conf.script_timeout; - - blobmsg_parse(&new_policy, 1, &tb, blob_data(msg), blob_len(msg)); - if (tb) - timeout = blobmsg_get_u32(tb); - - ses = uh_ubus_session_create(timeout); - if (ses) - uh_ubus_session_dump(ses, ctx, req); + if (ctx->sock.fd < 0) + return; - return 0; + close(ctx->sock.fd); + ctx->sock.fd = -1; } -static int -uh_ubus_handle_list(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) +static void uh_ubus_request_free(struct client *cl) { - struct uh_ubus_session *ses; - struct blob_attr *tb; - - blobmsg_parse(&sid_policy, 1, &tb, blob_data(msg), blob_len(msg)); + struct dispatch_ubus *du = &cl->dispatch.ubus; - if (!tb) { - avl_for_each_element(&sessions, ses, avl) - uh_ubus_session_dump(ses, ctx, req); - return 0; - } + blob_buf_free(&du->buf); + uloop_timeout_cancel(&du->timeout); - ses = uh_ubus_session_get(blobmsg_data(tb)); - if (!ses) - return UBUS_STATUS_NOT_FOUND; + if (du->jsobj) + json_object_put(du->jsobj); - uh_ubus_session_dump(ses, ctx, req); + if (du->jstok) + json_tokener_free(du->jstok); - return 0; + if (du->req_pending) + ubus_abort_request(ctx, &du->req); } -static int -uh_id_len(const char *str) +static void uh_ubus_single_error(struct client *cl, enum rpc_error type) { - return strcspn(str, "*?["); + uh_ubus_send_header(cl); + uh_ubus_json_error(cl, type); + ops->request_done(cl); } -static int -uh_ubus_session_grant(struct uh_ubus_session *ses, struct ubus_context *ctx, - const char *object, const char *function) +static void uh_ubus_send_request(struct client *cl, json_object *obj, const char *sid, struct blob_attr *args) { - struct uh_ubus_session_acl *acl; - char *new_obj, *new_func, *new_id; - int id_len; - - if (!object || !function) - return UBUS_STATUS_INVALID_ARGUMENT; - - uh_foreach_matching_acl_prefix(acl, ses, object, function) { - if (!strcmp(acl->object, object) && - !strcmp(acl->function, function)) - return 0; + struct dispatch *d = &cl->dispatch; + struct dispatch_ubus *du = &d->ubus; + struct blob_attr *cur; + static struct blob_buf req; + int ret, rem; + + blob_buf_init(&req, 0); + blobmsg_for_each_attr(cur, args, rem) { + if (!strcmp(blobmsg_name(cur), "ubus_rpc_session")) + return uh_ubus_json_error(cl, ERROR_PARAMS); + blobmsg_add_blob(&req, cur); } - id_len = uh_id_len(object); - acl = calloc_a(sizeof(*acl), - &new_obj, strlen(object) + 1, - &new_func, strlen(function) + 1, - &new_id, id_len + 1); - - if (!acl) - return UBUS_STATUS_UNKNOWN_ERROR; + blobmsg_add_string(&req, "ubus_rpc_session", sid); - acl->object = strcpy(new_obj, object); - acl->function = strcpy(new_func, function); - acl->avl.key = strncpy(new_id, object, id_len); - avl_insert(&ses->acls, &acl->avl); - - return 0; -} + blob_buf_init(&du->buf, 0); + memset(&du->req, 0, sizeof(du->req)); + ret = ubus_invoke_async(ctx, du->obj, du->func, req.head, &du->req); + if (ret) + return uh_ubus_json_error(cl, ERROR_INTERNAL); -static int -uh_ubus_session_revoke(struct uh_ubus_session *ses, struct ubus_context *ctx, - const char *object, const char *function) -{ - struct uh_ubus_session_acl *acl, *next; - int id_len; - char *id; - - if (!object && !function) { - avl_remove_all_elements(&ses->acls, acl, avl, next) - free(acl); - return 0; - } + du->req.data_cb = uh_ubus_request_data_cb; + du->req.complete_cb = uh_ubus_request_cb; + ubus_complete_request_async(ctx, &du->req); - id_len = uh_id_len(object); - id = alloca(id_len + 1); - strncpy(id, object, id_len); - id[id_len] = 0; - - acl = avl_find_element(&ses->acls, id, acl, avl); - while (acl) { - if (!avl_is_last(&ses->acls, &acl->avl)) - next = avl_next_element(acl, avl); - else - next = NULL; - - if (strcmp(id, acl->avl.key) != 0) - break; - - if (!strcmp(acl->object, object) && - !strcmp(acl->function, function)) { - avl_delete(&ses->acls, &acl->avl); - free(acl); - } - acl = next; - } + du->timeout.cb = uh_ubus_timeout_cb; + uloop_timeout_set(&du->timeout, conf.script_timeout * 1000); - return 0; + du->req_pending = true; } - -static int -uh_ubus_handle_acl(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) +static void uh_ubus_list_cb(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv) { - struct uh_ubus_session *ses; - struct blob_attr *tb[__UH_UBUS_SA_MAX]; - struct blob_attr *attr, *sattr; - const char *object, *function; - int rem1, rem2; - - int (*cb)(struct uh_ubus_session *ses, struct ubus_context *ctx, - const char *object, const char *function); - - blobmsg_parse(acl_policy, __UH_UBUS_SA_MAX, tb, blob_data(msg), blob_len(msg)); - - if (!tb[UH_UBUS_SA_SID]) - return UBUS_STATUS_INVALID_ARGUMENT; - - ses = uh_ubus_session_get(blobmsg_data(tb[UH_UBUS_SA_SID])); - if (!ses) - return UBUS_STATUS_NOT_FOUND; - - if (!strcmp(method, "grant")) - cb = uh_ubus_session_grant; - else - cb = uh_ubus_session_revoke; - - if (!tb[UH_UBUS_SA_OBJECTS]) - return cb(ses, ctx, NULL, NULL); + struct blob_attr *sig, *attr; + struct list_data *data = priv; + int rem, rem2; + void *t, *o; - blobmsg_for_each_attr(attr, tb[UH_UBUS_SA_OBJECTS], rem1) { - if (blob_id(attr) != BLOBMSG_TYPE_ARRAY) - continue; + if (!data->verbose) { + blobmsg_add_string(data->buf, NULL, obj->path); + return; + } - object = NULL; - function = NULL; + if (!obj->signature) + return; - blobmsg_for_each_attr(sattr, attr, rem2) { - if (blob_id(sattr) != BLOBMSG_TYPE_STRING) + o = blobmsg_open_table(data->buf, obj->path); + blob_for_each_attr(sig, obj->signature, rem) { + t = blobmsg_open_table(data->buf, blobmsg_name(sig)); + rem2 = blobmsg_data_len(sig); + __blob_for_each_attr(attr, blobmsg_data(sig), rem2) { + if (blob_id(attr) != BLOBMSG_TYPE_INT32) continue; - if (!object) - object = blobmsg_data(sattr); - else if (!function) - function = blobmsg_data(sattr); - else + switch (blobmsg_get_u32(attr)) { + case BLOBMSG_TYPE_INT8: + blobmsg_add_string(data->buf, blobmsg_name(attr), "boolean"); + break; + case BLOBMSG_TYPE_INT32: + blobmsg_add_string(data->buf, blobmsg_name(attr), "number"); + break; + case BLOBMSG_TYPE_STRING: + blobmsg_add_string(data->buf, blobmsg_name(attr), "string"); + break; + case BLOBMSG_TYPE_ARRAY: + blobmsg_add_string(data->buf, blobmsg_name(attr), "array"); + break; + case BLOBMSG_TYPE_TABLE: + blobmsg_add_string(data->buf, blobmsg_name(attr), "object"); + break; + default: + blobmsg_add_string(data->buf, blobmsg_name(attr), "unknown"); break; + } } - - if (object && function) - cb(ses, ctx, object, function); + blobmsg_close_table(data->buf, t); } - - return 0; + blobmsg_close_table(data->buf, o); } -static int -uh_ubus_handle_set(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) +static void uh_ubus_send_list(struct client *cl, json_object *obj, struct blob_attr *params) { - struct uh_ubus_session *ses; - struct uh_ubus_session_data *data; - struct blob_attr *tb[__UH_UBUS_SA_MAX]; - struct blob_attr *attr; + struct blob_attr *cur, *dup; + struct list_data data = { .buf = &cl->dispatch.ubus.buf, .verbose = false }; + void *r; int rem; - blobmsg_parse(set_policy, __UH_UBUS_SS_MAX, tb, blob_data(msg), blob_len(msg)); - - if (!tb[UH_UBUS_SS_SID] || !tb[UH_UBUS_SS_VALUES]) - return UBUS_STATUS_INVALID_ARGUMENT; - - ses = uh_ubus_session_get(blobmsg_data(tb[UH_UBUS_SS_SID])); - if (!ses) - return UBUS_STATUS_NOT_FOUND; - - blobmsg_for_each_attr(attr, tb[UH_UBUS_SS_VALUES], rem) { - if (!blobmsg_name(attr)[0]) - continue; + blob_buf_init(data.buf, 0); - data = avl_find_element(&ses->data, blobmsg_name(attr), data, avl); - if (data) { - avl_delete(&ses->data, &data->avl); - free(data); + if (!params || blob_id(params) != BLOBMSG_TYPE_ARRAY) { + r = blobmsg_open_array(data.buf, "result"); + ubus_lookup(ctx, NULL, uh_ubus_list_cb, &data); + blobmsg_close_array(data.buf, r); + } + else { + r = blobmsg_open_table(data.buf, "result"); + dup = blob_memdup(params); + if (dup) + { + rem = blobmsg_data_len(dup); + data.verbose = true; + __blob_for_each_attr(cur, blobmsg_data(dup), rem) + ubus_lookup(ctx, blobmsg_data(cur), uh_ubus_list_cb, &data); + free(dup); } - - data = calloc(1, sizeof(*data) + blob_pad_len(attr)); - if (!data) - break; - - memcpy(data->attr, attr, blob_pad_len(attr)); - data->avl.key = blobmsg_name(data->attr); - avl_insert(&ses->data, &data->avl); + blobmsg_close_table(data.buf, r); } - return 0; + uh_ubus_init_response(cl); + blobmsg_add_blob(&buf, blob_data(data.buf->head)); + uh_ubus_send_response(cl); } -static int -uh_ubus_handle_get(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) +static bool parse_json_rpc(struct rpc_data *d, struct blob_attr *data) { - struct uh_ubus_session *ses; - struct uh_ubus_session_data *data; - struct blob_attr *tb[__UH_UBUS_SA_MAX]; - struct blob_attr *attr; - struct blob_buf b; - void *c; - int rem; + const struct blobmsg_policy data_policy[] = { + { .type = BLOBMSG_TYPE_STRING }, + { .type = BLOBMSG_TYPE_STRING }, + { .type = BLOBMSG_TYPE_STRING }, + { .type = BLOBMSG_TYPE_TABLE }, + }; + struct blob_attr *tb[__RPC_MAX]; + struct blob_attr *tb2[4]; + struct blob_attr *cur; - blobmsg_parse(get_policy, __UH_UBUS_SG_MAX, tb, blob_data(msg), blob_len(msg)); + blobmsg_parse(rpc_policy, __RPC_MAX, tb, blob_data(data), blob_len(data)); - if (!tb[UH_UBUS_SG_SID]) - return UBUS_STATUS_INVALID_ARGUMENT; + cur = tb[RPC_JSONRPC]; + if (!cur || strcmp(blobmsg_data(cur), "2.0") != 0) + return false; - ses = uh_ubus_session_get(blobmsg_data(tb[UH_UBUS_SG_SID])); - if (!ses) - return UBUS_STATUS_NOT_FOUND; + cur = tb[RPC_METHOD]; + if (!cur) + return false; - memset(&b, 0, sizeof(b)); - blob_buf_init(&b, 0); - c = blobmsg_open_table(&b, "values"); + d->id = tb[RPC_ID]; + d->method = blobmsg_data(cur); - if (!tb[UH_UBUS_SG_KEYS]) { - uh_ubus_session_dump_data(ses, &b); - return 0; - } + cur = tb[RPC_PARAMS]; + if (!cur) + return true; - blobmsg_for_each_attr(attr, tb[UH_UBUS_SG_KEYS], rem) { - if (blob_id(attr) != BLOBMSG_TYPE_STRING) - continue; + d->params = blob_memdup(cur); + if (!d->params) + return false; - data = avl_find_element(&ses->data, blobmsg_data(attr), data, avl); - if (!data) - continue; + blobmsg_parse_array(data_policy, ARRAY_SIZE(data_policy), tb2, + blobmsg_data(d->params), blobmsg_data_len(d->params)); - blobmsg_add_field(&b, blobmsg_type(data->attr), - blobmsg_name(data->attr), - blobmsg_data(data->attr), - blobmsg_data_len(data->attr)); - } + if (tb2[0]) + d->sid = blobmsg_data(tb2[0]); - blobmsg_close_table(&b, c); - ubus_send_reply(ctx, req, b.head); - blob_buf_free(&b); + if (conf.ubus_noauth && (!d->sid || !*d->sid)) + d->sid = UH_UBUS_DEFAULT_SID; - return 0; -} + if (tb2[1]) + d->object = blobmsg_data(tb2[1]); -static int -uh_ubus_handle_unset(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) -{ - struct uh_ubus_session *ses; - struct uh_ubus_session_data *data, *ndata; - struct blob_attr *tb[__UH_UBUS_SA_MAX]; - struct blob_attr *attr; - int rem; + if (tb2[2]) + d->function = blobmsg_data(tb2[2]); - blobmsg_parse(get_policy, __UH_UBUS_SG_MAX, tb, blob_data(msg), blob_len(msg)); + d->data = tb2[3]; - if (!tb[UH_UBUS_SG_SID]) - return UBUS_STATUS_INVALID_ARGUMENT; - - ses = uh_ubus_session_get(blobmsg_data(tb[UH_UBUS_SG_SID])); - if (!ses) - return UBUS_STATUS_NOT_FOUND; - - if (!tb[UH_UBUS_SG_KEYS]) { - avl_remove_all_elements(&ses->data, data, avl, ndata) - free(data); - return 0; - } - - blobmsg_for_each_attr(attr, tb[UH_UBUS_SG_KEYS], rem) { - if (blob_id(attr) != BLOBMSG_TYPE_STRING) - continue; - - data = avl_find_element(&ses->data, blobmsg_data(attr), data, avl); - if (!data) - continue; - - avl_delete(&ses->data, &data->avl); - free(data); - } - - return 0; + return true; } -static int -uh_ubus_handle_destroy(struct ubus_context *ctx, struct ubus_object *obj, - struct ubus_request_data *req, const char *method, - struct blob_attr *msg) +static void uh_ubus_init_batch(struct client *cl) { - struct uh_ubus_session *ses; - struct blob_attr *tb; - - blobmsg_parse(&sid_policy, 1, &tb, blob_data(msg), blob_len(msg)); - - if (!tb) - return UBUS_STATUS_INVALID_ARGUMENT; - - ses = uh_ubus_session_get(blobmsg_data(tb)); - if (!ses) - return UBUS_STATUS_NOT_FOUND; - - uh_ubus_session_destroy(ses); + struct dispatch_ubus *du = &cl->dispatch.ubus; - return 0; + du->array = true; + uh_ubus_send_header(cl); + ops->chunk_printf(cl, "[\n\t"); } -static char *split_str(char *str) +static void uh_ubus_complete_batch(struct client *cl) { - if (str) - str = strchr(str, '/'); - - while (str && *str == '/') { - *str = 0; - str++; - } - return str; + ops->chunk_printf(cl, "\n]\n"); + ops->request_done(cl); } -static bool -uh_ubus_request_parse_url(struct client *cl, char *url, char **sid, char **obj, char **fun) +static void uh_ubus_allowed_cb(struct ubus_request *req, int type, struct blob_attr *msg) { - url += strlen(conf.ubus_prefix); - while (url && *url == '/') - url++; - - *sid = url; - - url = split_str(url); - *obj = url; - - url = split_str(url); - *fun = url; + struct blob_attr *tb[__SES_MAX]; + bool *allow = (bool *)req->priv; - return *sid && *obj && *fun; -} - -static void -uh_ubus_request_data_cb(struct ubus_request *req, int type, struct blob_attr *msg) -{ - struct dispatch_ubus *du = container_of(req, struct dispatch_ubus, req); - struct client *cl = container_of(du, struct client, dispatch.ubus); - char *str; + if (!msg) + return; - if (!du->header_sent) { - ops->http_header(cl, 200, "OK"); - ustream_printf(cl->us, "Content-Type: application/json\r\n\r\n"); - du->header_sent = true; - } + blobmsg_parse(ses_policy, __SES_MAX, tb, blob_data(msg), blob_len(msg)); - str = blobmsg_format_json_indent(msg, true, 0); - ops->chunk_write(cl, str, strlen(str)); - free(str); + if (tb[SES_ACCESS]) + *allow = blobmsg_get_bool(tb[SES_ACCESS]); } -static void -uh_ubus_request_cb(struct ubus_request *req, int ret) +static bool uh_ubus_allowed(const char *sid, const char *obj, const char *fun) { - struct dispatch_ubus *du = container_of(req, struct dispatch_ubus, req); - struct client *cl = container_of(du, struct client, dispatch.ubus); + uint32_t id; + bool allow = false; + static struct blob_buf req; - if (!du->header_sent) - return ops->client_error(cl, 204, "No content", "Function did not return data"); + if (ubus_lookup_id(ctx, "session", &id)) + return false; - ops->request_done(cl); -} + blob_buf_init(&req, 0); + blobmsg_add_string(&req, "sid", sid); + blobmsg_add_string(&req, "object", obj); + blobmsg_add_string(&req, "function", fun); -static void uh_ubus_close_fds(struct client *cl) -{ - if (ctx->sock.fd < 0) - return; + ubus_invoke(ctx, id, "access", req.head, uh_ubus_allowed_cb, &allow, conf.script_timeout * 500); - close(ctx->sock.fd); - ctx->sock.fd = -1; + return allow; } -static void uh_ubus_request_free(struct client *cl) +static void uh_ubus_handle_request_object(struct client *cl, struct json_object *obj) { struct dispatch_ubus *du = &cl->dispatch.ubus; + struct rpc_data data = {}; + enum rpc_error err = ERROR_PARSE; - if (du->jsobj) - json_object_put(du->jsobj); + if (json_object_get_type(obj) != json_type_object) + goto error; - if (du->jstok) - json_tokener_free(du->jstok); + du->jsobj_cur = obj; + blob_buf_init(&buf, 0); + if (!blobmsg_add_object(&buf, obj)) + goto error; - if (du->req_pending) - ubus_abort_request(ctx, &du->req); -} + if (!parse_json_rpc(&data, buf.head)) + goto error; -static void uh_ubus_json_error(struct client *cl) -{ - ops->client_error(cl, 400, "Bad Request", "Invalid JSON data"); -} + if (!strcmp(data.method, "call")) { + if (!data.sid || !data.object || !data.function || !data.data) + goto error; -static void uh_ubus_send_request(struct client *cl, json_object *obj) -{ - struct dispatch *d = &cl->dispatch; - struct dispatch_ubus *du = &d->ubus; - int ret; + du->func = data.function; + if (ubus_lookup_id(ctx, data.object, &du->obj)) { + err = ERROR_OBJECT; + goto error; + } - blob_buf_init(&buf, 0); + if (!conf.ubus_noauth && !uh_ubus_allowed(data.sid, data.object, data.function)) { + err = ERROR_ACCESS; + goto error; + } - if (obj && !blobmsg_add_object(&buf, obj)) - return uh_ubus_json_error(cl); + uh_ubus_send_request(cl, obj, data.sid, data.data); + goto out; + } + else if (!strcmp(data.method, "list")) { + uh_ubus_send_list(cl, obj, data.params); + goto out; + } + else { + err = ERROR_METHOD; + goto error; + } - ret = ubus_invoke_async(ctx, du->obj, du->func, buf.head, &du->req); - if (ret) - return ops->client_error(cl, 500, "Internal Error", - "Error sending ubus request: %s", ubus_strerror(ret)); +error: + uh_ubus_json_error(cl, err); +out: + if (data.params) + free(data.params); +} - du->req.data_cb = uh_ubus_request_data_cb; - du->req.complete_cb = uh_ubus_request_cb; - ubus_complete_request_async(ctx, &du->req); +static void __uh_ubus_next_batched_request(struct uloop_timeout *timeout) +{ + struct dispatch_ubus *du = container_of(timeout, struct dispatch_ubus, timeout); + struct client *cl = container_of(du, struct client, dispatch.ubus); + struct json_object *obj = du->jsobj; + int len; - du->req_pending = true; + len = json_object_array_length(obj); + if (du->array_idx >= len) + return uh_ubus_complete_batch(cl); + + obj = json_object_array_get_idx(obj, du->array_idx++); + uh_ubus_handle_request_object(cl, obj); } static void uh_ubus_data_done(struct client *cl) @@ -692,79 +528,51 @@ static void uh_ubus_data_done(struct client *cl) struct dispatch_ubus *du = &cl->dispatch.ubus; struct json_object *obj = du->jsobj; - if (!obj || json_object_get_type(obj) != json_type_object) - return uh_ubus_json_error(cl); - - uh_ubus_send_request(cl, obj); + switch (obj ? json_object_get_type(obj) : json_type_null) { + case json_type_object: + uh_ubus_send_header(cl); + return uh_ubus_handle_request_object(cl, obj); + case json_type_array: + uh_ubus_init_batch(cl); + return uh_ubus_next_batched_request(cl); + default: + return uh_ubus_single_error(cl, ERROR_PARSE); + } } static int uh_ubus_data_send(struct client *cl, const char *data, int len) { struct dispatch_ubus *du = &cl->dispatch.ubus; - if (du->jsobj) { - uh_ubus_json_error(cl); - return 0; - } + if (du->jsobj || !du->jstok) + goto error; du->post_len += len; - if (du->post_len > UH_UBUS_MAX_POST_SIZE) { - ops->client_error(cl, 413, "Too Large", "Message too big"); - return 0; - } + if (du->post_len > UH_UBUS_MAX_POST_SIZE) + goto error; du->jsobj = json_tokener_parse_ex(du->jstok, data, len); return len; -} - -static void uh_ubus_defer_post(struct client *cl) -{ - struct dispatch *d = &cl->dispatch; - - d->ubus.jstok = json_tokener_new(); - if (d->ubus.jstok) - return ops->client_error(cl, 500, "Internal Error", "Internal Error"); - d->data_send = uh_ubus_data_send; - d->data_done = uh_ubus_data_done; +error: + uh_ubus_single_error(cl, ERROR_PARSE); + return 0; } static void uh_ubus_handle_request(struct client *cl, char *url, struct path_info *pi) { - struct uh_ubus_session_acl *acl; - struct uh_ubus_session *ses; struct dispatch *d = &cl->dispatch; - char *sid, *obj, *fun; - bool access = false; blob_buf_init(&buf, 0); - if (!uh_ubus_request_parse_url(cl, url, &sid, &obj, &fun)) + if (cl->request.method != UH_HTTP_MSG_POST) return ops->client_error(cl, 400, "Bad Request", "Invalid Request"); - ses = uh_ubus_session_get(sid); - if (!ses) - return ops->client_error(cl, 404, "Not Found", "No such session %s", sid); - - uh_foreach_matching_acl(acl, ses, obj, fun) { - access = true; - break; - } - - if (!access) - return ops->client_error(cl, 403, "Denied", "Access to object denied"); - - if (ubus_lookup_id(ctx, obj, &d->ubus.obj)) - return ops->client_error(cl, 500, "Not Found", "No such object"); - d->close_fds = uh_ubus_close_fds; d->free = uh_ubus_request_free; - d->ubus.func = fun; - - if (cl->request.method == UH_HTTP_MSG_POST) - uh_ubus_defer_post(cl); - else - uh_ubus_send_request(cl, NULL); + d->data_send = uh_ubus_data_send; + d->data_done = uh_ubus_data_done; + d->ubus.jstok = json_tokener_new(); } static bool @@ -781,43 +589,12 @@ uh_ubus_init(void) .handle_request = uh_ubus_handle_request, }; - static const struct ubus_method session_methods[] = { - UBUS_METHOD("create", uh_ubus_handle_create, &new_policy), - UBUS_METHOD("list", uh_ubus_handle_list, &sid_policy), - UBUS_METHOD("grant", uh_ubus_handle_acl, acl_policy), - UBUS_METHOD("revoke", uh_ubus_handle_acl, acl_policy), - UBUS_METHOD("set", uh_ubus_handle_set, set_policy), - UBUS_METHOD("get", uh_ubus_handle_get, get_policy), - UBUS_METHOD("unset", uh_ubus_handle_unset, get_policy), - UBUS_METHOD("destroy", uh_ubus_handle_destroy, &sid_policy), - }; - - static struct ubus_object_type session_type = - UBUS_OBJECT_TYPE("uhttpd", session_methods); - - static struct ubus_object obj = { - .name = "session", - .type = &session_type, - .methods = session_methods, - .n_methods = ARRAY_SIZE(session_methods), - }; - - int ret; - ctx = ubus_connect(conf.ubus_socket); if (!ctx) { fprintf(stderr, "Unable to connect to ubus socket\n"); exit(1); } - ret = ubus_add_object(ctx, &obj); - if (ret) { - fprintf(stderr, "Unable to publish ubus object: %s\n", - ubus_strerror(ret)); - exit(1); - } - - avl_init(&sessions, avl_strcmp, false, NULL); ops->dispatch_add(&ubus_dispatch); uloop_done();