X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fubus.git;a=blobdiff_plain;f=ubusd_proto.c;h=caede10fefc9e3d7d09bad2e13673e785cd23a60;hp=d49ef48e61adb9dbb149e30913b4ade2c20b8395;hb=ba607d976b77c40162637d354fd8e1560384a66d;hpb=3706552c1c42182a8b656f95affc7e787a5b71dd diff --git a/ubusd_proto.c b/ubusd_proto.c index d49ef48..caede10 100644 --- a/ubusd_proto.c +++ b/ubusd_proto.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Felix Fietkau + * Copyright (C) 2011-2014 Felix Fietkau * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 2.1 @@ -12,6 +12,8 @@ */ #include +#include + #include "ubusd.h" struct blob_buf b; @@ -29,6 +31,7 @@ static const struct blob_attr_info ubus_policy[UBUS_ATTR_MAX] = { [UBUS_ATTR_OBJPATH] = { .type = BLOB_ATTR_STRING }, [UBUS_ATTR_OBJID] = { .type = BLOB_ATTR_INT32 }, [UBUS_ATTR_STATUS] = { .type = BLOB_ATTR_INT32 }, + [UBUS_ATTR_METHOD] = { .type = BLOB_ATTR_STRING }, }; static struct blob_attr **ubus_parse_msg(struct blob_attr *msg) @@ -37,6 +40,15 @@ static struct blob_attr **ubus_parse_msg(struct blob_attr *msg) return attrbuf; } +static void ubus_msg_close_fd(struct ubus_msg_buf *ub) +{ + if (ub->fd < 0) + return; + + close(ub->fd); + ub->fd = -1; +} + static void ubus_msg_init(struct ubus_msg_buf *ub, uint8_t type, uint16_t seq, uint32_t peer) { ub->hdr.version = 0; @@ -62,6 +74,18 @@ static struct ubus_msg_buf *ubus_reply_from_blob(struct ubus_msg_buf *ub, bool s return new; } +static void +ubus_send_msg_from_blob(struct ubus_client *cl, struct ubus_msg_buf *ub, + uint8_t type) +{ + ub = ubus_reply_from_blob(ub, true); + if (!ub) + return; + + ub->hdr.type = type; + ubus_msg_send(cl, ub, true); +} + static bool ubusd_send_hello(struct ubus_client *cl) { struct ubus_msg_buf *ub; @@ -105,12 +129,8 @@ static int ubusd_handle_remove_object(struct ubus_client *cl, struct ubus_msg_bu blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id.id); ubusd_free_object(obj); + ubus_send_msg_from_blob(cl, ub, UBUS_MSG_DATA); - ub = ubus_reply_from_blob(ub, true); - if (!ub) - return UBUS_STATUS_NO_DATA; - - ubus_msg_send(cl, ub, true); return 0; } @@ -127,11 +147,7 @@ static int ubusd_handle_add_object(struct ubus_client *cl, struct ubus_msg_buf * if (attr[UBUS_ATTR_SIGNATURE]) blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id.id); - ub = ubus_reply_from_blob(ub, true); - if (!ub) - return UBUS_STATUS_NO_DATA; - - ubus_msg_send(cl, ub, true); + ubus_send_msg_from_blob(cl, ub, UBUS_MSG_DATA); return 0; } @@ -142,21 +158,16 @@ static void ubusd_send_obj(struct ubus_client *cl, struct ubus_msg_buf *ub, stru blob_buf_init(&b, 0); - if (obj->path.key) - blob_put_string(&b, UBUS_ATTR_OBJPATH, obj->path.key); + blob_put_string(&b, UBUS_ATTR_OBJPATH, obj->path.key); blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id.id); blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id.id); s = blob_nest_start(&b, UBUS_ATTR_SIGNATURE); list_for_each_entry(m, &obj->type->methods, list) - blob_put(&b, blob_id(m->data), blob_data(m->data), blob_len(m->data)); + blobmsg_add_blob(&b, m->data); blob_nest_end(&b, s); - ub = ubus_reply_from_blob(ub, true); - if (!ub) - return; - - ubus_msg_send(cl, ub, true); + ubus_send_msg_from_blob(cl, ub, UBUS_MSG_DATA); } static int ubusd_handle_lookup(struct ubus_client *cl, struct ubus_msg_buf *ub, struct blob_attr **attr) @@ -203,9 +214,20 @@ static int ubusd_handle_lookup(struct ubus_client *cl, struct ubus_msg_buf *ub, return 0; } +static void +ubusd_forward_invoke(struct ubus_object *obj, const char *method, + struct ubus_msg_buf *ub, struct blob_attr *data) +{ + blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id.id); + blob_put_string(&b, UBUS_ATTR_METHOD, method); + if (data) + blob_put(&b, UBUS_ATTR_DATA, blob_data(data), blob_len(data)); + + ubus_send_msg_from_blob(obj->client, ub, UBUS_MSG_INVOKE); +} + static int ubusd_handle_invoke(struct ubus_client *cl, struct ubus_msg_buf *ub, struct blob_attr **attr) { - struct ubus_msg_buf *ub_new; struct ubus_object *obj = NULL; struct ubus_id *id; const char *method; @@ -222,25 +244,60 @@ static int ubusd_handle_invoke(struct ubus_client *cl, struct ubus_msg_buf *ub, method = blob_data(attr[UBUS_ATTR_METHOD]); if (!obj->client) - return obj->recv_msg(cl, method, attr[UBUS_ATTR_DATA]); + return obj->recv_msg(cl, ub, method, attr[UBUS_ATTR_DATA]); + ub->hdr.peer = cl->id.id; blob_buf_init(&b, 0); - blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id.id); - blob_put_string(&b, UBUS_ATTR_METHOD, method); - if (attr[UBUS_ATTR_DATA]) - blob_put(&b, UBUS_ATTR_DATA, blob_data(attr[UBUS_ATTR_DATA]), - blob_len(attr[UBUS_ATTR_DATA])); - - ub_new = ubus_reply_from_blob(ub, true); + ubusd_forward_invoke(obj, method, ub, attr[UBUS_ATTR_DATA]); ubus_msg_free(ub); - ub = ub_new; - if (!ub) - return UBUS_STATUS_NO_DATA; + return -1; +} + +static int ubusd_handle_notify(struct ubus_client *cl, struct ubus_msg_buf *ub, struct blob_attr **attr) +{ + struct ubus_object *obj = NULL; + struct ubus_subscription *s; + struct ubus_id *id; + const char *method; + bool no_reply = false; + void *c; + + if (!attr[UBUS_ATTR_METHOD] || !attr[UBUS_ATTR_OBJID]) + return UBUS_STATUS_INVALID_ARGUMENT; + + if (attr[UBUS_ATTR_NO_REPLY]) + no_reply = blob_get_int8(attr[UBUS_ATTR_NO_REPLY]); + + id = ubus_find_id(&objects, blob_get_u32(attr[UBUS_ATTR_OBJID])); + if (!id) + return UBUS_STATUS_NOT_FOUND; + + obj = container_of(id, struct ubus_object, id); + if (obj->client != cl) + return UBUS_STATUS_PERMISSION_DENIED; + + if (!no_reply) { + blob_buf_init(&b, 0); + blob_put_int32(&b, UBUS_ATTR_OBJID, id->id); + c = blob_nest_start(&b, UBUS_ATTR_SUBSCRIBERS); + list_for_each_entry(s, &obj->subscribers, list) { + blob_put_int32(&b, 0, s->subscriber->id.id); + } + blob_nest_end(&b, c); + blob_put_int32(&b, UBUS_ATTR_STATUS, 0); + ubus_send_msg_from_blob(cl, ub, UBUS_MSG_STATUS); + } - ub->hdr.type = UBUS_MSG_INVOKE; ub->hdr.peer = cl->id.id; - ubus_msg_send(obj->client, ub, true); + method = blob_data(attr[UBUS_ATTR_METHOD]); + list_for_each_entry(s, &obj->subscribers, list) { + blob_buf_init(&b, 0); + if (no_reply) + blob_put_int8(&b, UBUS_ATTR_NO_REPLY, 1); + ubusd_forward_invoke(s->subscriber, method, ub, attr[UBUS_ATTR_DATA]); + } + ubus_msg_free(ub); return -1; } @@ -285,6 +342,59 @@ error: return -1; } +static int ubusd_handle_add_watch(struct ubus_client *cl, struct ubus_msg_buf *ub, struct blob_attr **attr) +{ + struct ubus_object *obj, *target; + + if (!attr[UBUS_ATTR_OBJID] || !attr[UBUS_ATTR_TARGET]) + return UBUS_STATUS_INVALID_ARGUMENT; + + obj = ubusd_find_object(blob_get_u32(attr[UBUS_ATTR_OBJID])); + if (!obj) + return UBUS_STATUS_NOT_FOUND; + + if (cl != obj->client) + return UBUS_STATUS_INVALID_ARGUMENT; + + target = ubusd_find_object(blob_get_u32(attr[UBUS_ATTR_TARGET])); + if (!target) + return UBUS_STATUS_NOT_FOUND; + + if (cl == target->client) + return UBUS_STATUS_INVALID_ARGUMENT; + + ubus_subscribe(obj, target); + return 0; +} + +static int ubusd_handle_remove_watch(struct ubus_client *cl, struct ubus_msg_buf *ub, struct blob_attr **attr) +{ + struct ubus_object *obj; + struct ubus_subscription *s; + uint32_t id; + + if (!attr[UBUS_ATTR_OBJID] || !attr[UBUS_ATTR_TARGET]) + return UBUS_STATUS_INVALID_ARGUMENT; + + obj = ubusd_find_object(blob_get_u32(attr[UBUS_ATTR_OBJID])); + if (!obj) + return UBUS_STATUS_NOT_FOUND; + + if (cl != obj->client) + return UBUS_STATUS_INVALID_ARGUMENT; + + id = blob_get_u32(attr[UBUS_ATTR_TARGET]); + list_for_each_entry(s, &obj->target_list, target_list) { + if (s->target->id.id != id) + continue; + + ubus_unsubscribe(s); + return 0; + } + + return UBUS_STATUS_NOT_FOUND; +} + static const ubus_cmd_cb handlers[__UBUS_MSG_LAST] = { [UBUS_MSG_PING] = ubusd_send_pong, [UBUS_MSG_ADD_OBJECT] = ubusd_handle_add_object, @@ -293,6 +403,9 @@ static const ubus_cmd_cb handlers[__UBUS_MSG_LAST] = { [UBUS_MSG_INVOKE] = ubusd_handle_invoke, [UBUS_MSG_STATUS] = ubusd_handle_response, [UBUS_MSG_DATA] = ubusd_handle_response, + [UBUS_MSG_SUBSCRIBE] = ubusd_handle_add_watch, + [UBUS_MSG_UNSUBSCRIBE] = ubusd_handle_remove_watch, + [UBUS_MSG_NOTIFY] = ubusd_handle_notify, }; void ubusd_proto_receive_message(struct ubus_client *cl, struct ubus_msg_buf *ub) @@ -306,6 +419,9 @@ void ubusd_proto_receive_message(struct ubus_client *cl, struct ubus_msg_buf *ub if (ub->hdr.type < __UBUS_MSG_LAST) cb = handlers[ub->hdr.type]; + if (ub->hdr.type != UBUS_MSG_STATUS) + ubus_msg_close_fd(ub); + if (cb) ret = cb(cl, ub, ubus_parse_msg(ub->data)); else @@ -331,6 +447,7 @@ struct ubus_client *ubusd_proto_new_client(int fd, uloop_fd_handler cb) INIT_LIST_HEAD(&cl->objects); cl->sock.fd = fd; cl->sock.cb = cb; + cl->pending_msg_fd = -1; if (!ubus_alloc_id(&clients, &cl->id, 0)) goto free; @@ -359,7 +476,41 @@ void ubusd_proto_free_client(struct ubus_client *cl) ubus_free_id(&clients, &cl->id); } -static void __init ubusd_proto_init(void) +void ubus_notify_subscription(struct ubus_object *obj) +{ + bool active = !list_empty(&obj->subscribers); + struct ubus_msg_buf *ub; + + blob_buf_init(&b, 0); + blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id.id); + blob_put_int8(&b, UBUS_ATTR_ACTIVE, active); + + ub = ubus_msg_from_blob(false); + if (!ub) + return; + + ubus_msg_init(ub, UBUS_MSG_NOTIFY, ++obj->invoke_seq, 0); + ubus_msg_send(obj->client, ub, true); +} + +void ubus_notify_unsubscribe(struct ubus_subscription *s) +{ + struct ubus_msg_buf *ub; + + blob_buf_init(&b, 0); + blob_put_int32(&b, UBUS_ATTR_OBJID, s->subscriber->id.id); + blob_put_int32(&b, UBUS_ATTR_TARGET, s->target->id.id); + + ub = ubus_msg_from_blob(false); + if (ub != NULL) { + ubus_msg_init(ub, UBUS_MSG_UNSUBSCRIBE, ++s->subscriber->invoke_seq, 0); + ubus_msg_send(s->subscriber->client, ub, true); + } + + ubus_unsubscribe(s); +} + +static void __constructor ubusd_proto_init(void) { ubus_init_id_tree(&clients);