ubus/lua: pass notification name to callback

[project/ubus.git] / ubusd_proto.c

diff --git a/ubusd_proto.c b/ubusd_proto.c
index 53e507a..2d04b5a 100644 (file)
--- a/ubusd_proto.c
+++ b/ubusd_proto.c
@@ -17,8 +17,6 @@
 #include "ubusd.h"
 
 struct blob_buf b;
-static struct ubus_msg_buf *retmsg;
-static int *retmsg_data;
 static struct avl_tree clients;
 
 static struct blob_attr *attrbuf[UBUS_ATTR_MAX];
@@ -80,12 +78,17 @@ void
 ubus_proto_send_msg_from_blob(struct ubus_client *cl, struct ubus_msg_buf *ub,
                        uint8_t type)
 {
+       /* keep the fd to be passed if it is UBUS_MSG_INVOKE */
+       int fd = ub->fd;
        ub = ubus_reply_from_blob(ub, true);
        if (!ub)
                return;
 
        ub->hdr.type = type;
-       ubus_msg_send(cl, ub, true);
+       ub->fd = fd;
+
+       ubus_msg_send(cl, ub);
+       ubus_msg_free(ub);
 }
 
 static bool ubusd_send_hello(struct ubus_client *cl)
@@ -98,14 +101,15 @@ static bool ubusd_send_hello(struct ubus_client *cl)
                return false;
 
        ubus_msg_init(ub, UBUS_MSG_HELLO, 0, cl->id.id);
-       ubus_msg_send(cl, ub, true);
+       ubus_msg_send(cl, ub);
+       ubus_msg_free(ub);
        return true;
 }
 
 static int ubusd_send_pong(struct ubus_client *cl, struct ubus_msg_buf *ub, struct blob_attr **attr)
 {
        ub->hdr.type = UBUS_MSG_DATA;
-       ubus_msg_send(cl, ub, false);
+       ubus_msg_send(cl, ub);
        return 0;
 }
 
@@ -156,7 +160,7 @@ static int ubusd_handle_add_object(struct ubus_client *cl, struct ubus_msg_buf *
 static void ubusd_send_obj(struct ubus_client *cl, struct ubus_msg_buf *ub, struct ubus_object *obj)
 {
        struct ubus_method *m;
-       int cnt = 0;
+       int all_cnt = 0, cnt = 0;
        void *s;
 
        if (!obj->type)
@@ -170,6 +174,7 @@ static void ubusd_send_obj(struct ubus_client *cl, struct ubus_msg_buf *ub, stru
 
        s = blob_nest_start(&b, UBUS_ATTR_SIGNATURE);
        list_for_each_entry(m, &obj->type->methods, list) {
+               all_cnt++;
                if (!ubusd_acl_check(cl, obj->path.key, blobmsg_name(m->data), UBUS_ACL_ACCESS)) {
                        blobmsg_add_blob(&b, m->data);
                        cnt++;
@@ -177,7 +182,7 @@ static void ubusd_send_obj(struct ubus_client *cl, struct ubus_msg_buf *ub, stru
        }
        blob_nest_end(&b, s);
 
-       if (cnt)
+       if (cnt || !all_cnt)
                ubus_proto_send_msg_from_blob(cl, ub, UBUS_MSG_DATA);
 }
 
@@ -269,7 +274,6 @@ static int ubusd_handle_invoke(struct ubus_client *cl, struct ubus_msg_buf *ub,
        blob_buf_init(&b, 0);
 
        ubusd_forward_invoke(cl, obj, method, ub, attr[UBUS_ATTR_DATA]);
-       ubus_msg_free(ub);
 
        return -1;
 }
@@ -317,7 +321,6 @@ static int ubusd_handle_notify(struct ubus_client *cl, struct ubus_msg_buf *ub,
                        blob_put_int8(&b, UBUS_ATTR_NO_REPLY, 1);
                ubusd_forward_invoke(cl, s->subscriber, method, ub, attr[UBUS_ATTR_DATA]);
        }
-       ubus_msg_free(ub);
 
        return -1;
 }
@@ -340,25 +343,22 @@ static int ubusd_handle_response(struct ubus_client *cl, struct ubus_msg_buf *ub
        if (!attr[UBUS_ATTR_OBJID] ||
            (ub->hdr.type == UBUS_MSG_STATUS && !attr[UBUS_ATTR_STATUS]) ||
            (ub->hdr.type == UBUS_MSG_DATA && !attr[UBUS_ATTR_DATA]))
-               goto error;
+               goto out;
 
        obj = ubusd_find_object(blob_get_u32(attr[UBUS_ATTR_OBJID]));
        if (!obj)
-               goto error;
+               goto out;
 
        if (cl != obj->client)
-               goto error;
+               goto out;
 
        cl = ubusd_get_client_by_id(ub->hdr.peer);
        if (!cl)
-               goto error;
+               goto out;
 
        ub->hdr.peer = blob_get_u32(attr[UBUS_ATTR_OBJID]);
-       ubus_msg_send(cl, ub, true);
-       return -1;
-
-error:
-       ubus_msg_free(ub);
+       ubus_msg_send(cl, ub);
+out:
        return -1;
 }
 
@@ -377,7 +377,7 @@ static int ubusd_handle_add_watch(struct ubus_client *cl, struct ubus_msg_buf *u
                return UBUS_STATUS_INVALID_ARGUMENT;
 
        target = ubusd_find_object(blob_get_u32(attr[UBUS_ATTR_TARGET]));
-       if (!target)
+       if (!target || !target->client)
                return UBUS_STATUS_NOT_FOUND;
 
        if (cl == target->client)
@@ -439,6 +439,8 @@ void ubusd_proto_receive_message(struct ubus_client *cl, struct ubus_msg_buf *ub
 {
        ubus_cmd_cb cb = NULL;
        int ret;
+       struct ubus_msg_buf *retmsg = cl->retmsg;
+       int *retmsg_data = blob_data(blob_data(retmsg->data));
 
        retmsg->hdr.seq = ub->hdr.seq;
        retmsg->hdr.peer = ub->hdr.peer;
@@ -446,21 +448,39 @@ 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)
+       if (ub->hdr.type != UBUS_MSG_STATUS && ub->hdr.type != UBUS_MSG_INVOKE)
                ubus_msg_close_fd(ub);
 
+       /* Note: no callback should free the `ub` buffer
+                that's always done right after the callback finishes */
        if (cb)
                ret = cb(cl, ub, ubus_parse_msg(ub->data));
        else
                ret = UBUS_STATUS_INVALID_COMMAND;
 
+       ubus_msg_free(ub);
+
        if (ret == -1)
                return;
 
-       ubus_msg_free(ub);
-
        *retmsg_data = htonl(ret);
-       ubus_msg_send(cl, retmsg, false);
+       ubus_msg_send(cl, retmsg);
+}
+
+static int ubusd_proto_init_retmsg(struct ubus_client *cl)
+{
+       struct blob_buf *b = &cl->b;
+
+       blob_buf_init(&cl->b, 0);
+       blob_put_int32(&cl->b, UBUS_ATTR_STATUS, 0);
+
+       /* we make the 'retmsg' buffer shared with the blob_buf b, to reduce mem duplication */
+       cl->retmsg = ubus_msg_new(b->head, blob_raw_len(b->head), true);
+       if (!cl->retmsg)
+               return -1;
+
+       cl->retmsg->hdr.type = UBUS_MSG_STATUS;
+       return 0;
 }
 
 struct ubus_client *ubusd_proto_new_client(int fd, uloop_fd_handler cb)
@@ -482,6 +502,9 @@ struct ubus_client *ubusd_proto_new_client(int fd, uloop_fd_handler cb)
        if (!ubus_alloc_id(&clients, &cl->id, 0))
                goto free;
 
+       if (ubusd_proto_init_retmsg(cl))
+               goto free;
+
        if (!ubusd_send_hello(cl))
                goto delete;
 
@@ -502,6 +525,8 @@ void ubusd_proto_free_client(struct ubus_client *cl)
                obj = list_first_entry(&cl->objects, struct ubus_object, list);
                ubusd_free_object(obj);
        }
+       ubus_msg_free(cl->retmsg);
+       blob_buf_free(&cl->b);
 
        ubusd_acl_free_client(cl);
        ubus_free_id(&clients, &cl->id);
@@ -521,7 +546,8 @@ void ubus_notify_subscription(struct ubus_object *obj)
                return;
 
        ubus_msg_init(ub, UBUS_MSG_NOTIFY, ++obj->invoke_seq, 0);
-       ubus_msg_send(obj->client, ub, true);
+       ubus_msg_send(obj->client, ub);
+       ubus_msg_free(ub);
 }
 
 void ubus_notify_unsubscribe(struct ubus_subscription *s)
@@ -535,7 +561,8 @@ void ubus_notify_unsubscribe(struct ubus_subscription *s)
        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_msg_send(s->subscriber->client, ub);
+               ubus_msg_free(ub);
        }
 
        ubus_unsubscribe(s);
@@ -544,14 +571,4 @@ void ubus_notify_unsubscribe(struct ubus_subscription *s)
 static void __constructor ubusd_proto_init(void)
 {
        ubus_init_id_tree(&clients);
-
-       blob_buf_init(&b, 0);
-       blob_put_int32(&b, UBUS_ATTR_STATUS, 0);
-
-       retmsg = ubus_msg_from_blob(false);
-       if (!retmsg)
-               exit(1);
-
-       retmsg->hdr.type = UBUS_MSG_STATUS;
-       retmsg_data = blob_data(blob_data(retmsg->data));
 }