static struct ubus_context *ctx;
static struct blob_buf buf;
-#define UH_UBUS_MAX_POST_SIZE 4096
+#define UH_UBUS_MAX_POST_SIZE 65536
#define UH_UBUS_DEFAULT_SID "00000000000000000000000000000000"
enum {
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_PARAMS] = { .name = "params", .type = BLOBMSG_TYPE_UNSPEC },
[RPC_ID] = { .name = "id", .type = BLOBMSG_TYPE_UNSPEC },
};
struct rpc_data {
struct blob_attr *id;
+ const char *sid;
const char *method;
const char *object;
const char *function;
struct blob_attr *params;
};
+struct list_data {
+ bool verbose;
+ bool add_object;
+ struct blob_buf *buf;
+};
+
enum rpc_error {
ERROR_PARSE,
ERROR_REQUEST,
[ERROR_TIMEOUT] = { -32003, "ubus request timed out" },
};
+enum cors_hdr {
+ HDR_ORIGIN,
+ HDR_ACCESS_CONTROL_REQUEST_METHOD,
+ HDR_ACCESS_CONTROL_REQUEST_HEADERS,
+ __HDR_MAX
+};
+
+enum ubus_hdr {
+ HDR_AUTHORIZATION,
+ __HDR_UBUS_MAX
+};
+
+static const char *uh_ubus_get_auth(const struct blob_attr *attr)
+{
+ static const struct blobmsg_policy hdr_policy[__HDR_UBUS_MAX] = {
+ [HDR_AUTHORIZATION] = { "authorization", BLOBMSG_TYPE_STRING },
+ };
+ struct blob_attr *tb[__HDR_UBUS_MAX];
+
+ blobmsg_parse(hdr_policy, __HDR_UBUS_MAX, tb, blob_data(attr), blob_len(attr));
+
+ if (tb[HDR_AUTHORIZATION]) {
+ const char *tmp = blobmsg_get_string(tb[HDR_AUTHORIZATION]);
+
+ if (!strncasecmp(tmp, "Bearer ", 7))
+ return tmp + 7;
+ }
+
+ return UH_UBUS_DEFAULT_SID;
+}
+
static void __uh_ubus_next_batched_request(struct uloop_timeout *timeout);
static void uh_ubus_next_batched_request(struct client *cl)
uloop_timeout_set(&du->timeout, 1);
}
-static void uh_ubus_send_header(struct client *cl)
+static void uh_ubus_add_cors_headers(struct client *cl)
{
- ops->http_header(cl, 200, "OK");
- ustream_printf(cl->us, "Content-Type: application/json\r\n\r\n");
+ struct blob_attr *tb[__HDR_MAX];
+ static const struct blobmsg_policy hdr_policy[__HDR_MAX] = {
+ [HDR_ORIGIN] = { "origin", BLOBMSG_TYPE_STRING },
+ [HDR_ACCESS_CONTROL_REQUEST_METHOD] = { "access-control-request-method", BLOBMSG_TYPE_STRING },
+ [HDR_ACCESS_CONTROL_REQUEST_HEADERS] = { "access-control-request-headers", BLOBMSG_TYPE_STRING },
+ };
+
+ blobmsg_parse(hdr_policy, __HDR_MAX, tb, blob_data(cl->hdr.head), blob_len(cl->hdr.head));
+
+ if (!tb[HDR_ORIGIN])
+ return;
+
+ if (tb[HDR_ACCESS_CONTROL_REQUEST_METHOD])
+ {
+ char *hdr = (char *) blobmsg_data(tb[HDR_ACCESS_CONTROL_REQUEST_METHOD]);
+
+ if (strcmp(hdr, "GET") && strcmp(hdr, "POST") && strcmp(hdr, "OPTIONS"))
+ return;
+ }
+
+ ustream_printf(cl->us, "Access-Control-Allow-Origin: %s\r\n",
+ blobmsg_get_string(tb[HDR_ORIGIN]));
+
+ if (tb[HDR_ACCESS_CONTROL_REQUEST_HEADERS])
+ ustream_printf(cl->us, "Access-Control-Allow-Headers: %s\r\n",
+ blobmsg_get_string(tb[HDR_ACCESS_CONTROL_REQUEST_HEADERS]));
+
+ ustream_printf(cl->us, "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n");
+ ustream_printf(cl->us, "Access-Control-Allow-Credentials: true\r\n");
}
-static void uh_ubus_send_response(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, code, summary);
+
+ if (conf.ubus_cors)
+ uh_ubus_add_cors_headers(cl);
+
+ 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");
+
+ ustream_printf(cl->us, "\r\n");
+}
+
+static void uh_ubus_send_response(struct client *cl, struct blob_buf *buf)
{
struct dispatch_ubus *du = &cl->dispatch.ubus;
const char *sep = "";
char *str;
if (du->array && du->array_idx > 1)
- sep = ", ";
+ sep = ",";
- str = blobmsg_format_json_indent(buf.head, true, du->array);
+ str = blobmsg_format_json(buf->head, true);
ops->chunk_printf(cl, "%s%s", sep, str);
free(str);
du->jsobj_cur = NULL;
if (du->array)
uh_ubus_next_batched_request(cl);
- else {
- ops->chunk_printf(cl, "\n");
+ else
return ops->request_done(cl);
- }
}
-static void uh_ubus_init_response(struct client *cl)
+static void uh_ubus_init_json_rpc_response(struct client *cl, struct blob_buf *buf)
{
struct dispatch_ubus *du = &cl->dispatch.ubus;
- struct json_object *obj = du->jsobj_cur;
+ struct json_object *obj = du->jsobj_cur, *obj2 = NULL;
- blob_buf_init(&buf, 0);
- blobmsg_add_string(&buf, "jsonrpc", "2.0");
+ blobmsg_add_string(buf, "jsonrpc", "2.0");
if (obj)
- obj = json_object_object_get(obj, "id");
+ json_object_object_get_ex(obj, "id", &obj2);
- if (obj)
- blobmsg_add_json_element(&buf, "id", obj);
+ if (obj2)
+ blobmsg_add_json_element(buf, "id", obj2);
else
- blobmsg_add_field(&buf, BLOBMSG_TYPE_UNSPEC, "id", NULL, 0);
+ blobmsg_add_field(buf, BLOBMSG_TYPE_UNSPEC, "id", NULL, 0);
}
-static void uh_ubus_json_error(struct client *cl, enum rpc_error type)
+static void uh_ubus_json_rpc_error(struct client *cl, enum rpc_error type)
{
void *c;
- uh_ubus_init_response(cl);
+ blob_buf_init(&buf, 0);
+
+ uh_ubus_init_json_rpc_response(cl, &buf);
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);
+ 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));
+}
+
+static void uh_ubus_allowed_cb(struct ubus_request *req, int type, struct blob_attr *msg)
+{
+ struct blob_attr *tb[__SES_MAX];
+ bool *allow = (bool *)req->priv;
+
+ if (!msg)
+ return;
+
+ blobmsg_parse(ses_policy, __SES_MAX, tb, blob_data(msg), blob_len(msg));
+
+ if (tb[SES_ACCESS])
+ *allow = blobmsg_get_bool(tb[SES_ACCESS]);
+}
+
+static bool uh_ubus_allowed(const char *sid, const char *obj, const char *fun)
+{
+ uint32_t id;
+ bool allow = false;
+ static struct blob_buf req;
+
+ if (ubus_lookup_id(ctx, "session", &id))
+ return false;
+
+ blob_buf_init(&req, 0);
+ blobmsg_add_string(&req, "ubus_rpc_session", sid);
+ blobmsg_add_string(&req, "object", obj);
+ blobmsg_add_string(&req, "function", fun);
+
+ ubus_invoke(ctx, id, "access", req.head, uh_ubus_allowed_cb, &allow, conf.script_timeout * 500);
+
+ return allow;
+}
+
+/* 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);
+
+ ubus_unregister_subscriber(ctx, &du->sub);
+
+ ops->request_done(cl);
+}
+
+static void uh_ubus_handle_get_subscribe(struct client *cl, const char *path)
+{
+ struct dispatch_ubus *du = &cl->dispatch.ubus;
+ const char *sid;
+ uint32_t id;
+ int err;
+
+ sid = uh_ubus_get_auth(cl->hdr.head);
+
+ if (!conf.ubus_noauth && !uh_ubus_allowed(sid, path, ":subscribe")) {
+ 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, 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
void *r;
int rem;
+ blob_buf_init(&buf, 0);
+
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);
+
+ /* 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);
+
+ if (blob_len(du->buf.head)) {
+ 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
struct client *cl = container_of(du, struct client, dispatch.ubus);
ubus_abort_request(ctx, &du->req);
- uh_ubus_json_error(cl, ERROR_TIMEOUT);
+ uh_ubus_json_rpc_error(cl, ERROR_TIMEOUT);
}
static void uh_ubus_close_fds(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_json_error(cl, type);
+ uh_ubus_send_header(cl, 200, "OK", "application/json");
+ uh_ubus_json_rpc_error(cl, type);
ops->request_done(cl);
}
-static void uh_ubus_send_request(struct client *cl, json_object *obj, struct blob_attr *args)
+static void uh_ubus_send_request(struct client *cl, const char *sid, struct blob_attr *args)
{
struct dispatch *d = &cl->dispatch;
struct dispatch_ubus *du = &d->ubus;
int ret, rem;
blob_buf_init(&req, 0);
- blobmsg_for_each_attr(cur, args, rem)
+ blobmsg_for_each_attr(cur, args, rem) {
+ if (!strcmp(blobmsg_name(cur), "ubus_rpc_session"))
+ return uh_ubus_json_rpc_error(cl, ERROR_PARAMS);
blobmsg_add_blob(&req, cur);
+ }
+
+ blobmsg_add_string(&req, "ubus_rpc_session", sid);
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);
+ return uh_ubus_json_rpc_error(cl, ERROR_INTERNAL);
du->req.data_cb = uh_ubus_request_data_cb;
du->req.complete_cb = uh_ubus_request_cb;
static void uh_ubus_list_cb(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
{
struct blob_attr *sig, *attr;
+ struct list_data *data = priv;
int rem, rem2;
- void *t, *o;
+ void *t, *o=NULL;
- if (!priv) {
- blobmsg_add_string(&buf, NULL, obj->path);
+ if (!data->verbose) {
+ blobmsg_add_string(data->buf, NULL, obj->path);
return;
}
if (!obj->signature)
return;
- o = blobmsg_open_table(&buf, obj->path);
+ if (data->add_object) {
+ o = blobmsg_open_table(data->buf, obj->path);
+ if (!o)
+ return;
+ }
+
blob_for_each_attr(sig, obj->signature, rem) {
- t = blobmsg_open_table(&buf, blobmsg_name(sig));
+ 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)
switch (blobmsg_get_u32(attr)) {
case BLOBMSG_TYPE_INT8:
- blobmsg_add_string(&buf, blobmsg_name(attr), "boolean");
+ blobmsg_add_string(data->buf, blobmsg_name(attr), "boolean");
break;
case BLOBMSG_TYPE_INT32:
- blobmsg_add_string(&buf, blobmsg_name(attr), "number");
+ blobmsg_add_string(data->buf, blobmsg_name(attr), "number");
break;
case BLOBMSG_TYPE_STRING:
- blobmsg_add_string(&buf, blobmsg_name(attr), "string");
+ blobmsg_add_string(data->buf, blobmsg_name(attr), "string");
break;
case BLOBMSG_TYPE_ARRAY:
- blobmsg_add_string(&buf, blobmsg_name(attr), "array");
+ blobmsg_add_string(data->buf, blobmsg_name(attr), "array");
break;
case BLOBMSG_TYPE_TABLE:
- blobmsg_add_string(&buf, blobmsg_name(attr), "object");
+ blobmsg_add_string(data->buf, blobmsg_name(attr), "object");
break;
default:
- blobmsg_add_string(&buf, blobmsg_name(attr), "unknown");
+ blobmsg_add_string(data->buf, blobmsg_name(attr), "unknown");
break;
}
}
- blobmsg_close_table(&buf, t);
+ blobmsg_close_table(data->buf, t);
}
- blobmsg_close_table(&buf, o);
+
+ if (data->add_object)
+ blobmsg_close_table(data->buf, o);
}
-static void uh_ubus_send_list(struct client *cl, json_object *obj, struct blob_attr *params)
+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, .add_object = true };
void *r;
int rem;
- uh_ubus_init_response(cl);
+ blob_buf_init(data.buf, 0);
+
+ uh_client_ref(cl);
if (!params || blob_id(params) != BLOBMSG_TYPE_ARRAY) {
- r = blobmsg_open_array(&buf, "result");
- ubus_lookup(ctx, NULL, uh_ubus_list_cb, NULL);
- blobmsg_close_array(&buf, r);
+ 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(&buf, "result");
+ 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, blobmsg_data(cur));
+ ubus_lookup(ctx, blobmsg_data(cur), uh_ubus_list_cb, &data);
free(dup);
}
- blobmsg_close_table(&buf, r);
+ blobmsg_close_table(data.buf, r);
}
- uh_ubus_send_response(cl);
+ uh_client_unref(cl);
+
+ blob_buf_init(&buf, 0);
+ uh_ubus_init_json_rpc_response(cl, &buf);
+ blobmsg_add_blob(&buf, blob_data(data.buf->head));
+ uh_ubus_send_response(cl, &buf);
}
static bool parse_json_rpc(struct rpc_data *d, struct blob_attr *data)
{
- const struct blobmsg_policy data_policy[] = {
- { .type = BLOBMSG_TYPE_STRING },
- { .type = BLOBMSG_TYPE_STRING },
- { .type = BLOBMSG_TYPE_TABLE },
- };
struct blob_attr *tb[__RPC_MAX];
- struct blob_attr *tb2[3];
struct blob_attr *cur;
blobmsg_parse(rpc_policy, __RPC_MAX, tb, blob_data(data), blob_len(data));
if (!d->params)
return false;
- blobmsg_parse_array(data_policy, ARRAY_SIZE(data_policy), tb2,
+ return true;
+}
+
+static void parse_call_params(struct rpc_data *d)
+{
+ 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[4];
+
+ if (!d->params || blobmsg_type(d->params) != BLOBMSG_TYPE_ARRAY)
+ return;
+
+ blobmsg_parse_array(data_policy, ARRAY_SIZE(data_policy), tb,
blobmsg_data(d->params), blobmsg_data_len(d->params));
- if (tb2[0])
- d->object = blobmsg_data(tb2[0]);
+ if (tb[0])
+ d->sid = blobmsg_data(tb[0]);
- if (tb2[1])
- d->function = blobmsg_data(tb2[1]);
+ if (conf.ubus_noauth && (!d->sid || !*d->sid))
+ d->sid = UH_UBUS_DEFAULT_SID;
- d->data = tb2[2];
+ if (tb[1])
+ d->object = blobmsg_data(tb[1]);
- return true;
+ if (tb[2])
+ d->function = blobmsg_data(tb[2]);
+
+ d->data = tb[3];
}
static void uh_ubus_init_batch(struct client *cl)
struct dispatch_ubus *du = &cl->dispatch.ubus;
du->array = true;
- uh_ubus_send_header(cl);
- ops->chunk_printf(cl, "[\n\t");
+ uh_ubus_send_header(cl, 200, "OK", "application/json");
+ ops->chunk_printf(cl, "[");
}
static void uh_ubus_complete_batch(struct client *cl)
{
- ops->chunk_printf(cl, "\n]\n");
+ ops->chunk_printf(cl, "]");
ops->request_done(cl);
}
-static void uh_ubus_allowed_cb(struct ubus_request *req, int type, struct blob_attr *msg)
-{
- struct blob_attr *tb[__SES_MAX];
- bool *allow = (bool *)req->priv;
-
- if (!msg)
- return;
-
- blobmsg_parse(ses_policy, __SES_MAX, tb, blob_data(msg), blob_len(msg));
-
- if (tb[SES_ACCESS])
- *allow = blobmsg_get_bool(tb[SES_ACCESS]);
-}
-
-static bool uh_ubus_allowed(const char *sid, const char *obj, const char *fun)
-{
- uint32_t id;
- bool allow = false;
- static struct blob_buf req;
-
- if (ubus_lookup_id(ctx, "session", &id))
- return false;
-
- blob_buf_init(&req, 0);
- blobmsg_add_string(&req, "sid", sid);
- blobmsg_add_string(&req, "object", obj);
- blobmsg_add_string(&req, "function", fun);
-
- ubus_invoke(ctx, id, "access", req.head, uh_ubus_allowed_cb, &allow, conf.script_timeout * 500);
-
- return allow;
-}
-
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;
+ static struct blob_buf req;
+
+ uh_client_ref(cl);
if (json_object_get_type(obj) != json_type_object)
goto error;
du->jsobj_cur = obj;
- blob_buf_init(&buf, 0);
- if (!blobmsg_add_object(&buf, obj))
+ blob_buf_init(&req, 0);
+ if (!blobmsg_add_object(&req, obj))
goto error;
- if (!parse_json_rpc(&data, buf.head))
+ if (!parse_json_rpc(&data, req.head))
goto error;
if (!strcmp(data.method, "call")) {
- if (!data.object || !data.function || !data.data)
+ parse_call_params(&data);
+
+ if (!data.sid || !data.object || !data.function || !data.data)
goto error;
du->func = data.function;
goto error;
}
- if (!conf.ubus_noauth && !uh_ubus_allowed(du->sid, data.object, data.function)) {
+ if (!conf.ubus_noauth && !uh_ubus_allowed(data.sid, data.object, data.function)) {
err = ERROR_ACCESS;
goto error;
}
- uh_ubus_send_request(cl, obj, data.data);
+ uh_ubus_send_request(cl, data.sid, data.data);
goto out;
}
else if (!strcmp(data.method, "list")) {
- uh_ubus_send_list(cl, obj, data.params);
+ uh_ubus_send_list(cl, data.params);
goto out;
}
else {
}
error:
- uh_ubus_json_error(cl, err);
+ uh_ubus_json_rpc_error(cl, err);
out:
if (data.params)
free(data.params);
+
+ uh_client_unref(cl);
}
static void __uh_ubus_next_batched_request(struct uloop_timeout *timeout)
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);
- if (json_object_array_length(obj) > 0)
- return uh_ubus_next_batched_request(cl);
- /* fall through */
+ return uh_ubus_next_batched_request(cl);
default:
return uh_ubus_single_error(cl, ERROR_PARSE);
}
}
+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);
+}
+
+static void uh_ubus_handle_post(struct client *cl)
+{
+ struct dispatch_ubus *du = &cl->dispatch.ubus;
+ const char *url = du->url_path;
+ const char *auth;
+
+ /* Treat both: /foo AND /foo/ as legacy requests. */
+ if (ops->path_match(conf.ubus_prefix, url) && strlen(url) - strlen(conf.ubus_prefix) <= 1) {
+ du->legacy = true;
+ uh_ubus_data_done(cl);
+ return;
+ }
+
+ auth = uh_ubus_get_auth(cl->hdr.head);
+
+ 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;
static void uh_ubus_handle_request(struct client *cl, char *url, struct path_info *pi)
{
struct dispatch *d = &cl->dispatch;
- char *sid, *sep;
-
- blob_buf_init(&buf, 0);
+ struct dispatch_ubus *du = &d->ubus;
+ char *chr;
- if (conf.ubus_noauth) {
- sid = UH_UBUS_DEFAULT_SID;
+ du->url_path = strdup(url);
+ if (!du->url_path) {
+ ops->client_error(cl, 500, "Internal Server Error", "Failed to allocate resources");
+ return;
}
- else {
- url += strlen(conf.ubus_prefix);
- while (*url == '/')
- url++;
+ 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_handle_post;
+ d->close_fds = uh_ubus_close_fds;
+ d->free = uh_ubus_request_free;
+ du->jstok = json_tokener_new();
+ return;
- sep = strchr(url, '/');
- if (sep)
- *sep = 0;
+ case UH_HTTP_MSG_OPTIONS:
+ uh_ubus_send_header(cl, 200, "OK", "application/json");
+ ops->request_done(cl);
+ break;
- sid = url;
+ default:
+ ops->client_error(cl, 400, "Bad Request", "Invalid Request");
}
- if (strlen(sid) != 32 ||
- cl->request.method != UH_HTTP_MSG_POST)
- return ops->client_error(cl, 400, "Bad Request", "Invalid Request");
-
- d->close_fds = uh_ubus_close_fds;
- d->free = uh_ubus_request_free;
- d->data_send = uh_ubus_data_send;
- d->data_done = uh_ubus_data_done;
- d->ubus.jstok = json_tokener_new();
- d->ubus.sid = sid;
+ free(du->url_path);
+ du->url_path = NULL;
}
static bool
ubus_add_uloop(ctx);
}
-const struct uhttpd_plugin uhttpd_plugin = {
+struct uhttpd_plugin uhttpd_plugin = {
.init = uh_ubus_plugin_init,
.post_init = uh_ubus_post_init,
};
projects / project / uhttpd.git / blobdiff