From patchwork Mon Sep 14 15:15:23 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?UmFmYcWCIE1pxYJlY2tp?= X-Patchwork-Id: 1363721 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=lists.openwrt.org (client-ip=2001:8b0:10b:1231::1; helo=merlin.infradead.org; envelope-from=openwrt-devel-bounces+incoming=patchwork.ozlabs.org@lists.openwrt.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; secure) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=merlin.20170209 header.b=19vqnh6l; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=RL2qX5/8; dkim-atps=neutral Received: from merlin.infradead.org (merlin.infradead.org [IPv6:2001:8b0:10b:1231::1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4Bqqws35tyz9sTK for ; Tue, 15 Sep 2020 01:27:24 +1000 (AEST) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:Message-Id:Date:Subject:To:From: Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender :Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References:List-Owner; bh=qM7mFno5Pm47o/HNlZOosuQLx2QphB5dsKmec/UKD2U=; b=19vqnh6lKIxfH7+csgXUTLlX1c VABS/v3ID6MDsWCbh1fyPAEDt+eVyRTaHa5yB3FXrG0dInc6IlyxLNtLvXsTURNJWUGEdzbIiODWI iPptVUc80b4EGwas+YiNvEJAHCqajlZ0E1v/v1knYBLFQUvpR0BVDGdTLe2RWWBZHGsI8A2U1G/ES yxClDx3EBKXi7nmNJF7BETnsiC7OP/AAVRw0fJ7JfGtp+AoOVfUZ8QAKa0T3TX1FruT1Xoo3AoKWn i2F+axNevwr+iNdjzmqrc60isLJ/L/frJ0p/E8zCPNKcZOnJJS7qRN6dUHBPLr3zmVr8U53R1CzRV pJbg4IBg==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kHqLU-0007Fg-Jf; Mon, 14 Sep 2020 15:24:44 +0000 Received: from mail-lf1-x129.google.com ([2a00:1450:4864:20::129]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1kHqKf-0006n8-FG for openwrt-devel@lists.openwrt.org; Mon, 14 Sep 2020 15:23:55 +0000 Received: by mail-lf1-x129.google.com with SMTP id b12so13865785lfp.9 for ; Mon, 14 Sep 2020 08:23:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=RnPCBS3x7CF3Fe921pF9VFav3mWvUWfo8qIfhzt1llg=; b=RL2qX5/8nX5EvponPkaDuX8SY70z8ir6M4xQoKUuaC09Jic80mvHzg1RTGOJMd65SD HsAawQGjDRQA3DcTHlCzTVSHO9bKGTpO94bqC2QXguP/RbNETJR3V7qOE40V6t2wuaNs ZIQ5wgCYh18Qq75gjoJH2nNrc8eJdlzJIbPhSjDtQaHQtwry2YxzzP9LJhkOxvO+akvg lNBOpP4jecqT0GOIsjGI91TaouDtH6zAkjjlhYCNVfg6sivdoWbF5ZSAMIuBrZSXyiXc OYZM7LskswH8iMqczNs60+BCRx/68bVCQOdEzFLogUcQNvOSsi6MuRomaJr+fSxXclwm j6SA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=RnPCBS3x7CF3Fe921pF9VFav3mWvUWfo8qIfhzt1llg=; b=fwRDmDG/OSQGaqoRZnMvtZBpQ4cgSR7kbJakVQMHmq+9KwMNpZ+skZL9jz8J7R5nZY U8GpskTJtZFx2uMgJESYBtX56GqCj9l8BVdFhek8mESbeSzX5Lu9eAuSJdsHBpD47q3C d6q03oW2MZ4jCBOUPjy4/AZehC5z8lJpkvVToFa/OjfUtweEJWX9bHcE6JfnsDEvDsRm Gkl3H+lgMAtQLaZG9BKB7EP/2tWNA198LyW0FFcVIYIed/8B7X1NWil6hbl/Kb/+ojrt xMFw+a8J3GwqjSu1mfw2D/6XEXfRcu8IpKM5GfXeF28SK0FNPlHujZpUlD1gjRCt3zy2 bkkA== X-Gm-Message-State: AOAM530pUMWY6j7nSCcLv4C1P/w+1Ig7CKo90/tcOPYtaBYTYc47LdOA AJQIn0895do0qcT2uVkRvhX3GvGvGF8= X-Google-Smtp-Source: ABdhPJyRGpSjDGjgTnMB6S+ELE0AiWw8uSsaq6CRuCBb58uG6MunXxipVqn2mRzdW3UmrRSmIDoJtw== X-Received: by 2002:ac2:51a8:: with SMTP id f8mr4957422lfk.472.1600097030992; Mon, 14 Sep 2020 08:23:50 -0700 (PDT) Received: from localhost.localdomain (ip-194-187-74-233.konfederacka.maverick.com.pl. [194.187.74.233]) by smtp.gmail.com with ESMTPSA id d1sm3423892lfq.225.2020.09.14.08.23.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 14 Sep 2020 08:23:50 -0700 (PDT) From: =?utf-8?b?UmFmYcWCIE1pxYJlY2tp?= To: openwrt-devel@lists.openwrt.org Subject: [PATCH V3 uhttpd] ubus: add new RESTful API Date: Mon, 14 Sep 2020 17:15:23 +0200 Message-Id: <20200914151523.4757-1-zajec5@gmail.com> X-Mailer: git-send-email 2.27.0 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200914_112353_592322_C1A63BEF X-CRM114-Status: GOOD ( 22.45 ) X-Spam-Score: 0.1 (/) X-Spam-Report: SpamAssassin version 3.4.4 on merlin.infradead.org summary: Content analysis details: (0.1 points) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at https://www.dnswl.org/, no trust [2a00:1450:4864:20:0:0:0:129 listed in] [list.dnswl.org] 0.2 FREEMAIL_ENVFROM_END_DIGIT Envelope-from freemail username ends in digit [zajec5[at]gmail.com] 0.0 FREEMAIL_FROM Sender email is commonly abused enduser mail provider [zajec5[at]gmail.com] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record 0.0 NUMERIC_HTTP_ADDR URI: Uses a numeric IP address in URL -0.1 DKIM_VALID_EF Message has a valid DKIM or DK signature from envelope-from domain 0.1 DKIM_SIGNED Message has a DKIM or DK signature, not necessarily valid -0.1 DKIM_VALID_AU Message has a valid DKIM or DK signature from author's domain -0.1 DKIM_VALID Message has at least one valid DKIM or DK signature X-BeenThere: openwrt-devel@lists.openwrt.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: OpenWrt Development List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?utf-8?b?UmFmYcWCIE1pxYJlY2tp?= , Jo-Philipp Wich Sender: "openwrt-devel" Errors-To: openwrt-devel-bounces+incoming=patchwork.ozlabs.org@lists.openwrt.org From: Rafał Miłecki Initial uhttpd ubus API was fully based on JSON-RPC. That restricted it from supporting ubus notifications that don't fit its model. Notifications require protocol that allows server to send data without being polled. There are two candidates for that: 1. Server-sent events 2. WebSocket The later one is overcomplex for this simple task so ideally uhttps ubus should support text-based server-sent events. It's not possible with JSON-RPC without violating it. Specification requires server to reply with Response object. Replying with text/event-stream is not allowed. All above led to designing new API that: 1. Uses GET and POST requests 2. Makes use of RESTful URLs 3. Uses JSON-RPC in cleaner form and only for calling ubus methods This new API allows: 1. Listing all ubus objects and their methods using GET /list 2. Listing object methods using GET /list/ 3. Listening to object notifications with GET /subscribe/ 4. Calling ubus methods using POST /call/ JSON-RPC custom protocol was also simplified to: 1. Use "method" member for ubus object method name It was possible thanks to using RESTful URLs. Previously "method" had to be "list" or "call". 2. Reply with Error object on ubus method call error This simplified "result" member format as it doesn't need to contain ubus result code anymore. This patch doesn't break or change the old API. The biggest downside of the new API is no support for batch requests. It's cost of using RESTful URLs. It should not matter much as uhttpd supports keep alive. Example usages: 1. Getting all objects and their methods: $ curl http://192.168.1.1/ubus/list { "dhcp": { "ipv4leases": { }, "ipv6leases": { } }, "log": { "read": { "lines": "number", "stream": "boolean", "oneshot": "boolean" }, "write": { "event": "string" } } } 2. Getting object methods: $ curl http://192.168.1.1/ubus/list/log { "read": { "lines": "number", "stream": "boolean", "oneshot": "boolean" }, "write": { "event": "string" } } 3. Subscribing to notifications: $ curl http://192.168.1.1/ubus/subscribe/foo event: status data: {"count":5} 4. Calling ubus object method: $ curl -d '{ "jsonrpc": "2.0", "id": 1, "method": "login", "params": {"username": "root", "password": "password" } }' http://192.168.1.1/ubus/call/session { "jsonrpc": "2.0", "id": 1, "result": { "ubus_rpc_session": "01234567890123456789012345678901", (...) } } $ curl -H 'Authorization: Bearer 01234567890123456789012345678901' -d '{ "jsonrpc": "2.0", "id": 1, "method": "write", "params": {"event": "Hello world" } }' http://192.168.1.1/ubus/call/log { "jsonrpc": "2.0", "id": 1, "result": null } Signed-off-by: Rafał Miłecki --- V2: Use "Authorization" with Bearer for rpcd session id / token Treat missing session id as UH_UBUS_DEFAULT_SID Fix "result" format (was: "result":{{"foo":"bar"}}) V3: Treat /ubus/ requests as legacy ones for backward compatibility. Previously there were causing 404 (only /ubus was accepted). Support requests with search path (e.g. ?foo=bar) by ignoring it. This may be used by some clients to avoid caching responses. Rebase on the [PATCH uhttpd] ubus: fix blob_buf initialization --- main.c | 8 +- ubus.c | 348 +++++++++++++++++++++++++++++++++++++++++++++++++++---- uhttpd.h | 5 + 3 files changed, 339 insertions(+), 22 deletions(-) diff --git a/main.c b/main.c index 26e74ec..73e3d42 100644 --- a/main.c +++ b/main.c @@ -159,6 +159,7 @@ static int usage(const char *name) " -U file Override ubus socket path\n" " -a Do not authenticate JSON-RPC requests against UBUS session api\n" " -X Enable CORS HTTP headers on JSON-RPC api\n" + " -e Events subscription reconnection time (retry value)\n" #endif " -x string URL prefix for CGI handler, default is '/cgi-bin'\n" " -y alias[=path] URL alias handle\n" @@ -262,7 +263,7 @@ int main(int argc, char **argv) init_defaults_pre(); signal(SIGPIPE, SIG_IGN); - while ((ch = getopt(argc, argv, "A:aC:c:Dd:E:fh:H:I:i:K:k:L:l:m:N:n:P:p:qRr:Ss:T:t:U:u:Xx:y:")) != -1) { + while ((ch = getopt(argc, argv, "A:aC:c:Dd:E:e:fh:H:I:i:K:k:L:l:m:N:n:P:p:qRr:Ss:T:t:U:u:Xx:y:")) != -1) { switch(ch) { #ifdef HAVE_TLS case 'C': @@ -490,11 +491,16 @@ int main(int argc, char **argv) case 'X': conf.ubus_cors = 1; break; + + case 'e': + conf.events_retry = atoi(optarg); + break; #else case 'a': case 'u': case 'U': case 'X': + case 'e': fprintf(stderr, "uhttpd: UBUS support not compiled, " "ignoring -%c\n", ch); break; diff --git a/ubus.c b/ubus.c index a458f4c..d7d7678 100644 --- a/ubus.c +++ b/ubus.c @@ -73,6 +73,7 @@ struct rpc_data { struct list_data { bool verbose; + bool add_object; struct blob_buf *buf; }; @@ -154,14 +155,14 @@ static void uh_ubus_add_cors_headers(struct client *cl) ustream_printf(cl->us, "Access-Control-Allow-Credentials: true\r\n"); } -static void uh_ubus_send_header(struct client *cl) +static void uh_ubus_send_header(struct client *cl, int code, const char *summary, const char *content_type) { - ops->http_header(cl, 200, "OK"); + ops->http_header(cl, code, summary); if (conf.ubus_cors) uh_ubus_add_cors_headers(cl); - ustream_printf(cl->us, "Content-Type: application/json\r\n"); + ustream_printf(cl->us, "Content-Type: %s\r\n", content_type); if (cl->request.method == UH_HTTP_MSG_OPTIONS) ustream_printf(cl->us, "Content-Length: 0\r\n"); @@ -219,12 +220,169 @@ static void uh_ubus_json_rpc_error(struct client *cl, enum rpc_error type) uh_ubus_send_response(cl, &buf); } +static void uh_ubus_error(struct client *cl, int code, const char *message) +{ + blob_buf_init(&buf, 0); + + blobmsg_add_u32(&buf, "code", code); + blobmsg_add_string(&buf, "message", message); + uh_ubus_send_response(cl, &buf); +} + +static void uh_ubus_posix_error(struct client *cl, int err) +{ + uh_ubus_error(cl, -err, strerror(err)); +} + +static void uh_ubus_ubus_error(struct client *cl, int err) +{ + uh_ubus_error(cl, err, ubus_strerror(err)); +} + +/* GET requests handling */ + +static void uh_ubus_list_cb(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv); + +static void uh_ubus_handle_get_list(struct client *cl, const char *path) +{ + static struct blob_buf tmp; + struct list_data data = { .verbose = true, .add_object = !path, .buf = &tmp}; + struct blob_attr *cur; + int rem; + int err; + + blob_buf_init(&tmp, 0); + + err = ubus_lookup(ctx, path, uh_ubus_list_cb, &data); + if (err) { + uh_ubus_send_header(cl, 500, "Ubus Protocol Error", "application/json"); + uh_ubus_ubus_error(cl, err); + return; + } + + blob_buf_init(&buf, 0); + blob_for_each_attr(cur, tmp.head, rem) + blobmsg_add_blob(&buf, cur); + + uh_ubus_send_header(cl, 200, "OK", "application/json"); + uh_ubus_send_response(cl, &buf); +} + +static int uh_ubus_subscription_notification_cb(struct ubus_context *ctx, + struct ubus_object *obj, + struct ubus_request_data *req, + const char *method, + struct blob_attr *msg) +{ + struct ubus_subscriber *s; + struct dispatch_ubus *du; + struct client *cl; + char *json; + + s = container_of(obj, struct ubus_subscriber, obj); + du = container_of(s, struct dispatch_ubus, sub); + cl = container_of(du, struct client, dispatch.ubus); + + json = blobmsg_format_json(msg, true); + if (json) { + ops->chunk_printf(cl, "event: %s\ndata: %s\n\n", method, json); + free(json); + } + + return 0; +} + +static void uh_ubus_subscription_notification_remove_cb(struct ubus_context *ctx, struct ubus_subscriber *s, uint32_t id) +{ + struct dispatch_ubus *du; + struct client *cl; + + du = container_of(s, struct dispatch_ubus, sub); + cl = container_of(du, struct client, dispatch.ubus); + + ops->request_done(cl); +} + +static void uh_ubus_handle_get_subscribe(struct client *cl, const char *sid, const char *path) +{ + struct dispatch_ubus *du = &cl->dispatch.ubus; + uint32_t id; + int err; + + /* TODO: add ACL support */ + if (!conf.ubus_noauth) { + uh_ubus_send_header(cl, 200, "OK", "application/json"); + uh_ubus_posix_error(cl, EACCES); + return; + } + + du->sub.cb = uh_ubus_subscription_notification_cb; + du->sub.remove_cb = uh_ubus_subscription_notification_remove_cb; + + uh_client_ref(cl); + + err = ubus_register_subscriber(ctx, &du->sub); + if (err) + goto err_unref; + + err = ubus_lookup_id(ctx, path, &id); + if (err) + goto err_unregister; + + err = ubus_subscribe(ctx, &du->sub, id); + if (err) + goto err_unregister; + + uh_ubus_send_header(cl, 200, "OK", "text/event-stream"); + + if (conf.events_retry) + ops->chunk_printf(cl, "retry: %d\n", conf.events_retry); + + return; + +err_unregister: + ubus_unregister_subscriber(ctx, &du->sub); +err_unref: + uh_client_unref(cl); + if (err) { + uh_ubus_send_header(cl, 200, "OK", "application/json"); + uh_ubus_ubus_error(cl, err); + } +} + +static void uh_ubus_handle_get(struct client *cl) +{ + struct dispatch_ubus *du = &cl->dispatch.ubus; + const char *url = du->url_path; + + url += strlen(conf.ubus_prefix); + + if (!strcmp(url, "/list") || !strncmp(url, "/list/", strlen("/list/"))) { + url += strlen("/list"); + + uh_ubus_handle_get_list(cl, *url ? url + 1 : NULL); + } else if (!strncmp(url, "/subscribe/", strlen("/subscribe/"))) { + url += strlen("/subscribe"); + + uh_ubus_handle_get_subscribe(cl, NULL, url + 1); + } else { + ops->http_header(cl, 404, "Not Found"); + ustream_printf(cl->us, "\r\n"); + ops->request_done(cl); + } +} + +/* POST requests handling */ + 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 blob_attr *cur; + int len; - blobmsg_add_field(&du->buf, BLOBMSG_TYPE_TABLE, "", blob_data(msg), blob_len(msg)); + blob_for_each_attr(cur, msg, len) + blobmsg_add_blob(&du->buf, cur); } static void @@ -239,13 +397,46 @@ uh_ubus_request_cb(struct ubus_request *req, int ret) blob_buf_init(&buf, 0); uloop_timeout_cancel(&du->timeout); - uh_ubus_init_json_rpc_response(cl, &buf); - 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, &buf); + + /* Legacy format always uses "result" array - even for errors and empty + * results. */ + if (du->legacy) { + void *c; + + uh_ubus_init_json_rpc_response(cl, &buf); + r = blobmsg_open_array(&buf, "result"); + blobmsg_add_u32(&buf, "", ret); + c = blobmsg_open_table(&buf, NULL); + blob_for_each_attr(cur, du->buf.head, rem) + blobmsg_add_blob(&buf, cur); + blobmsg_close_table(&buf, c); + blobmsg_close_array(&buf, r); + uh_ubus_send_response(cl, &buf); + return; + } + + if (ret) { + void *c; + + uh_ubus_init_json_rpc_response(cl, &buf); + c = blobmsg_open_table(&buf, "error"); + blobmsg_add_u32(&buf, "code", ret); + blobmsg_add_string(&buf, "message", ubus_strerror(ret)); + blobmsg_close_table(&buf, c); + uh_ubus_send_response(cl, &buf); + } else { + uh_ubus_init_json_rpc_response(cl, &buf); + if (blob_len(du->buf.head)) { + r = blobmsg_open_table(&buf, "result"); + blob_for_each_attr(cur, du->buf.head, rem) + blobmsg_add_blob(&buf, cur); + blobmsg_close_table(&buf, r); + } else { + blobmsg_add_field(&buf, BLOBMSG_TYPE_UNSPEC, "result", NULL, 0); + } + uh_ubus_send_response(cl, &buf); + } + } static void @@ -282,11 +473,14 @@ static void uh_ubus_request_free(struct client *cl) if (du->req_pending) ubus_abort_request(ctx, &du->req); + + free(du->url_path); + du->url_path = NULL; } static void uh_ubus_single_error(struct client *cl, enum rpc_error type) { - uh_ubus_send_header(cl); + uh_ubus_send_header(cl, 200, "OK", "application/json"); uh_ubus_json_rpc_error(cl, type); ops->request_done(cl); } @@ -339,7 +533,8 @@ static void uh_ubus_list_cb(struct ubus_context *ctx, struct ubus_object_data *o if (!obj->signature) return; - o = blobmsg_open_table(data->buf, obj->path); + if (data->add_object) + 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); @@ -370,13 +565,14 @@ static void uh_ubus_list_cb(struct ubus_context *ctx, struct ubus_object_data *o } blobmsg_close_table(data->buf, t); } - blobmsg_close_table(data->buf, o); + if (data->add_object) + blobmsg_close_table(data->buf, o); } static void uh_ubus_send_list(struct client *cl, struct blob_attr *params) { struct blob_attr *cur, *dup; - struct list_data data = { .buf = &cl->dispatch.ubus.buf, .verbose = false }; + struct list_data data = { .buf = &cl->dispatch.ubus.buf, .verbose = false, .add_object = true }; void *r; int rem; @@ -476,7 +672,7 @@ static void uh_ubus_init_batch(struct client *cl) struct dispatch_ubus *du = &cl->dispatch.ubus; du->array = true; - uh_ubus_send_header(cl); + uh_ubus_send_header(cl, 200, "OK", "application/json"); ops->chunk_printf(cl, "["); } @@ -599,7 +795,7 @@ static void uh_ubus_data_done(struct client *cl) switch (obj ? json_object_get_type(obj) : json_type_null) { case json_type_object: - uh_ubus_send_header(cl); + uh_ubus_send_header(cl, 200, "OK", "application/json"); return uh_ubus_handle_request_object(cl, obj); case json_type_array: uh_ubus_init_batch(cl); @@ -609,6 +805,97 @@ static void uh_ubus_data_done(struct client *cl) } } +static void uh_ubus_call(struct client *cl, const char *path, const char *sid) +{ + struct dispatch_ubus *du = &cl->dispatch.ubus; + struct json_object *obj = du->jsobj; + struct rpc_data data = {}; + enum rpc_error err = ERROR_PARSE; + static struct blob_buf req; + + uh_client_ref(cl); + + if (!obj || json_object_get_type(obj) != json_type_object) + goto error; + + uh_ubus_send_header(cl, 200, "OK", "application/json"); + + du->jsobj_cur = obj; + blob_buf_init(&req, 0); + if (!blobmsg_add_object(&req, obj)) + goto error; + + if (!parse_json_rpc(&data, req.head)) + goto error; + + du->func = data.method; + if (ubus_lookup_id(ctx, path, &du->obj)) { + err = ERROR_OBJECT; + goto error; + } + + if (!conf.ubus_noauth && !uh_ubus_allowed(sid, path, data.method)) { + err = ERROR_ACCESS; + goto error; + } + + uh_ubus_send_request(cl, sid, data.params); + goto out; + +error: + uh_ubus_json_rpc_error(cl, err); +out: + if (data.params) + free(data.params); + + uh_client_unref(cl); +} + +enum ubus_hdr { + HDR_AUTHORIZATION, + __HDR_UBUS_MAX +}; + +static void uh_ubus_handle_post(struct client *cl) +{ + static const struct blobmsg_policy hdr_policy[__HDR_UBUS_MAX] = { + [HDR_AUTHORIZATION] = { "authorization", BLOBMSG_TYPE_STRING }, + }; + struct dispatch_ubus *du = &cl->dispatch.ubus; + struct blob_attr *tb[__HDR_UBUS_MAX]; + const char *url = du->url_path; + const char *auth; + + if (!strcmp(url, conf.ubus_prefix) || + (url[strlen(url) - 1] == '/' && !strncmp(url, conf.ubus_prefix, strlen(url) - 1))) { + du->legacy = true; + uh_ubus_data_done(cl); + return; + } + + blobmsg_parse(hdr_policy, __HDR_UBUS_MAX, tb, blob_data(cl->hdr.head), blob_len(cl->hdr.head)); + + auth = UH_UBUS_DEFAULT_SID; + if (tb[HDR_AUTHORIZATION]) { + const char *tmp = blobmsg_get_string(tb[HDR_AUTHORIZATION]); + + if (!strncasecmp(tmp, "Bearer ", 7)) + auth = tmp + 7; + } + + url += strlen(conf.ubus_prefix); + + if (!strncmp(url, "/call/", strlen("/call/"))) { + url += strlen("/call/"); + + uh_ubus_call(cl, url, auth); + } else { + ops->http_header(cl, 404, "Not Found"); + ustream_printf(cl->us, "\r\n"); + ops->request_done(cl); + } +} + static int uh_ubus_data_send(struct client *cl, const char *data, int len) { struct dispatch_ubus *du = &cl->dispatch.ubus; @@ -631,25 +918,44 @@ error: static void uh_ubus_handle_request(struct client *cl, char *url, struct path_info *pi) { struct dispatch *d = &cl->dispatch; + struct dispatch_ubus *du = &d->ubus; + char *chr; + + du->url_path = strdup(url); + if (!du->url_path) { + ops->client_error(cl, 500, "Internal Server Error", "Failed to allocate resources"); + return; + } + chr = strchr(du->url_path, '?'); + if (chr) + chr[0] = '\0'; + + du->legacy = false; switch (cl->request.method) { + case UH_HTTP_MSG_GET: + uh_ubus_handle_get(cl); + break; case UH_HTTP_MSG_POST: d->data_send = uh_ubus_data_send; - d->data_done = uh_ubus_data_done; + d->data_done = uh_ubus_handle_post; d->close_fds = uh_ubus_close_fds; d->free = uh_ubus_request_free; - d->ubus.jstok = json_tokener_new(); - break; + du->jstok = json_tokener_new(); + return; case UH_HTTP_MSG_OPTIONS: - uh_ubus_send_header(cl); + uh_ubus_send_header(cl, 200, "OK", "application/json"); ops->request_done(cl); break; default: ops->client_error(cl, 400, "Bad Request", "Invalid Request"); } + + free(du->url_path); + du->url_path = NULL; } static bool diff --git a/uhttpd.h b/uhttpd.h index f77718e..e61e176 100644 --- a/uhttpd.h +++ b/uhttpd.h @@ -82,6 +82,7 @@ struct config { int ubus_noauth; int ubus_cors; int cgi_prefix_len; + int events_retry; struct list_head cgi_alias; struct list_head lua_prefix; }; @@ -209,6 +210,7 @@ struct dispatch_ubus { struct json_tokener *jstok; struct json_object *jsobj; struct json_object *jsobj_cur; + char *url_path; int post_len; uint32_t obj; @@ -218,6 +220,9 @@ struct dispatch_ubus { bool req_pending; bool array; int array_idx; + bool legacy; /* Got legacy request => use legacy reply */ + + struct ubus_subscriber sub; }; #endif