[PATCH V2 uhttpd] ubus: add new RESTful API
Nicolas Pace
nico at libre.ws
Fri Jul 31 08:31:46 EDT 2020
On 7/31/20 1:49 AM, Rafał Miłecki wrote:
> From: Rafał Miłecki <rafal at milecki.pl>
>
> 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
I did a quick and dirty implementation of it some time ago, that works
with everything as it is.
You might want to check it out.
https://bugs.openwrt.org/index.php?do=details&task_id=2248
Still, eager to see this work done!
> 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 <prefix>/list
> 2. Listing object methods using GET <prefix>/list/<path>
> 3. Listening to object notifications with GET <prefix>/subscribe/<path>
> 4. Calling ubus methods using POST <prefix>/call/<path>
>
> 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 <rafal at milecki.pl>
> ---
> 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"}})
> ---
> main.c | 8 +-
> ubus.c | 326 +++++++++++++++++++++++++++++++++++++++++++++++++++----
> uhttpd.h | 5 +
> 3 files changed, 318 insertions(+), 21 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 c22e07a..fd907db 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");
> @@ -217,12 +218,165 @@ static void uh_ubus_json_rpc_error(struct client *cl, enum rpc_error type)
> uh_ubus_send_response(cl);
> }
>
> +static void uh_ubus_error(struct client *cl, int code, const char *message)
> +{
> + blobmsg_add_u32(&buf, "code", code);
> + blobmsg_add_string(&buf, "message", message);
> + uh_ubus_send_response(cl);
> +}
> +
> +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;
> + }
> +
> + uh_ubus_send_header(cl, 200, "OK", "application/json");
> + blob_for_each_attr(cur, tmp.head, rem)
> + blobmsg_add_blob(&buf, cur);
> + uh_ubus_send_response(cl);
> +}
> +
> +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;
> +
> + 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
> @@ -235,13 +389,46 @@ uh_ubus_request_cb(struct ubus_request *req, int ret)
> int rem;
>
> uloop_timeout_cancel(&du->timeout);
> - uh_ubus_init_json_rpc_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);
> +
> + /* Legacy format always uses "result" array - even for errors and empty
> + * results. */
> + if (du->legacy) {
> + void *c;
> +
> + uh_ubus_init_json_rpc_response(cl);
> + 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);
> + return;
> + }
> +
> + if (ret) {
> + void *c;
> +
> + uh_ubus_init_json_rpc_response(cl);
> + 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);
> + } else {
> + uh_ubus_init_json_rpc_response(cl);
> + 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);
> + }
> +
> }
>
> static void
> @@ -282,7 +469,7 @@ static void uh_ubus_request_free(struct client *cl)
>
> 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);
> }
> @@ -335,7 +522,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);
> @@ -366,13 +554,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;
>
> @@ -471,7 +660,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, "[");
> }
>
> @@ -594,7 +783,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);
> @@ -604,6 +793,96 @@ 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;
> + const char *auth;
> +
> + if (!strcmp(url, conf.ubus_prefix)) {
> + 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;
> @@ -626,21 +905,28 @@ 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;
>
> blob_buf_init(&buf, 0);
>
> + du->url = url;
> + 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();
> + du->jstok = json_tokener_new();
> break;
>
> case UH_HTTP_MSG_OPTIONS:
> - uh_ubus_send_header(cl);
> + uh_ubus_send_header(cl, 200, "OK", "application/json");
> ops->request_done(cl);
> break;
>
> diff --git a/uhttpd.h b/uhttpd.h
> index f77718e..75dd747 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;
> + const char *url;
> 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
>
>
More information about the openwrt-devel
mailing list