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;
+ struct blob_buf *buf;
+};
+
enum rpc_error {
ERROR_PARSE,
ERROR_REQUEST,
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)
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, json_object *obj, 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_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));
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;
- 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);
+ o = blobmsg_open_table(data->buf, obj->path);
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);
+ blobmsg_close_table(data->buf, o);
}
static void uh_ubus_send_list(struct client *cl, json_object *obj, struct blob_attr *params)
{
struct blob_attr *cur, *dup;
+ struct list_data data = { .buf = &cl->dispatch.ubus.buf, .verbose = false };
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_client_unref(cl);
+
+ uh_ubus_init_response(cl);
+ blobmsg_add_blob(&buf, blob_data(data.buf->head));
uh_ubus_send_response(cl);
}
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[3];
+ struct blob_attr *tb2[4];
struct blob_attr *cur;
blobmsg_parse(rpc_policy, __RPC_MAX, tb, blob_data(data), blob_len(data));
blobmsg_data(d->params), blobmsg_data_len(d->params));
if (tb2[0])
- d->object = blobmsg_data(tb2[0]);
+ d->sid = blobmsg_data(tb2[0]);
+
+ if (conf.ubus_noauth && (!d->sid || !*d->sid))
+ d->sid = UH_UBUS_DEFAULT_SID;
if (tb2[1])
- d->function = blobmsg_data(tb2[1]);
+ d->object = blobmsg_data(tb2[1]);
+
+ if (tb2[2])
+ d->function = blobmsg_data(tb2[2]);
- d->data = tb2[2];
+ d->data = tb2[3];
return true;
}
du->array = true;
uh_ubus_send_header(cl);
- ops->chunk_printf(cl, "[\n\t");
+ 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);
}
return false;
blob_buf_init(&req, 0);
- blobmsg_add_string(&req, "sid", sid);
+ blobmsg_add_string(&req, "ubus_rpc_session", sid);
blobmsg_add_string(&req, "object", obj);
blobmsg_add_string(&req, "function", fun);
struct rpc_data data = {};
enum rpc_error err = ERROR_PARSE;
+ uh_client_ref(cl);
+
if (json_object_get_type(obj) != json_type_object)
goto error;
goto error;
if (!strcmp(data.method, "call")) {
- if (!data.object || !data.function || !data.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, obj, data.sid, data.data);
goto out;
}
else if (!strcmp(data.method, "list")) {
out:
if (data.params)
free(data.params);
+
+ uh_client_unref(cl);
}
static void __uh_ubus_next_batched_request(struct uloop_timeout *timeout)
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);
- if (conf.ubus_noauth) {
- sid = UH_UBUS_DEFAULT_SID;
- }
- else {
- url += strlen(conf.ubus_prefix);
- while (*url == '/')
- url++;
-
- sep = strchr(url, '/');
- if (sep)
- *sep = 0;
-
- sid = url;
- }
-
- if (strlen(sid) != 32 ||
- cl->request.method != UH_HTTP_MSG_POST)
+ if (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->data_send = uh_ubus_data_send;
d->data_done = uh_ubus_data_done;
d->ubus.jstok = json_tokener_new();
- d->ubus.sid = sid;
}
static bool
projects / project / uhttpd.git / blobdiff