CMakeLists.txt: bump minimum cmake version

[project/ubus.git] / libubus-io.c

diff --git a/libubus-io.c b/libubus-io.c
index 228af5ca279c6d5f3d428c7ee4fe0b2670a68c1d..d190b67795eef5ebf96dc58df5366cb2e88f5352 100644 (file)
--- a/libubus-io.c
+++ b/libubus-io.c
@@ -43,9 +43,9 @@ static const struct blob_attr_info ubus_policy[UBUS_ATTR_MAX] = {
 
 static struct blob_attr *attrbuf[UBUS_ATTR_MAX];
 
-__hidden struct blob_attr **ubus_parse_msg(struct blob_attr *msg)
+__hidden struct blob_attr **ubus_parse_msg(struct blob_attr *msg, size_t len)
 {
-       blob_parse(msg, attrbuf, ubus_policy, UBUS_ATTR_MAX);
+       blob_parse_untrusted(msg, len, attrbuf, ubus_policy, UBUS_ATTR_MAX);
        return attrbuf;
 }
 
@@ -59,32 +59,33 @@ static void wait_data(int fd, bool write)
 
 static int writev_retry(int fd, struct iovec *iov, int iov_len, int sock_fd)
 {
-       static struct {
-               struct cmsghdr h;
-               int fd;
-       } fd_buf = {
-               .h = {
-                       .cmsg_len = sizeof(fd_buf),
-                       .cmsg_level = SOL_SOCKET,
-                       .cmsg_type = SCM_RIGHTS,
-               }
-       };
-       struct msghdr msghdr = {
-               .msg_iov = iov,
-               .msg_iovlen = iov_len,
-               .msg_control = &fd_buf,
-               .msg_controllen = sizeof(fd_buf),
-       };
+       uint8_t fd_buf[CMSG_SPACE(sizeof(int))] = { 0 };
+       struct msghdr msghdr = { 0 };
+       struct cmsghdr *cmsg;
        int len = 0;
+       int *pfd;
+
+       msghdr.msg_iov = iov,
+       msghdr.msg_iovlen = iov_len,
+       msghdr.msg_control = fd_buf;
+       msghdr.msg_controllen = sizeof(fd_buf);
+
+       cmsg = CMSG_FIRSTHDR(&msghdr);
+       cmsg->cmsg_type = SCM_RIGHTS;
+       cmsg->cmsg_level = SOL_SOCKET;
+       cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+
+       pfd = (int *) CMSG_DATA(cmsg);
+       msghdr.msg_controllen = cmsg->cmsg_len;
 
        do {
-               int cur_len;
+               ssize_t cur_len;
 
                if (sock_fd < 0) {
                        msghdr.msg_control = NULL;
                        msghdr.msg_controllen = 0;
                } else {
-                       fd_buf.fd = sock_fd;
+                       *pfd = sock_fd;
                }
 
                cur_len = sendmsg(fd, &msghdr, 0);
@@ -105,7 +106,7 @@ static int writev_retry(int fd, struct iovec *iov, int iov_len, int sock_fd)
                        sock_fd = -1;
 
                len += cur_len;
-               while (cur_len >= iov->iov_len) {
+               while (cur_len >= (ssize_t) iov->iov_len) {
                        cur_len -= iov->iov_len;
                        iov_len--;
                        iov++;
@@ -156,33 +157,38 @@ int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
 
 static int recv_retry(struct ubus_context *ctx, struct iovec *iov, bool wait, int *recv_fd)
 {
-       int bytes, total = 0;
-       int fd = ctx->sock.fd;
-       static struct {
-               struct cmsghdr h;
-               int fd;
-       } fd_buf = {
-               .h = {
-                       .cmsg_type = SCM_RIGHTS,
-                       .cmsg_level = SOL_SOCKET,
-                       .cmsg_len = sizeof(fd_buf),
-               },
-       };
-       struct msghdr msghdr = {
-               .msg_iov = iov,
-               .msg_iovlen = 1,
-       };
+       uint8_t fd_buf[CMSG_SPACE(sizeof(int))] = { 0 };
+       struct msghdr msghdr = { 0 };
+       struct cmsghdr *cmsg;
+       int total = 0;
+       int bytes;
+       int *pfd;
+       int fd;
+
+       fd = ctx->sock.fd;
+
+       msghdr.msg_iov = iov,
+       msghdr.msg_iovlen = 1,
+       msghdr.msg_control = fd_buf;
+       msghdr.msg_controllen = sizeof(fd_buf);
+
+       cmsg = CMSG_FIRSTHDR(&msghdr);
+       cmsg->cmsg_type = SCM_RIGHTS;
+       cmsg->cmsg_level = SOL_SOCKET;
+       cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+
+       pfd = (int *) CMSG_DATA(cmsg);
 
        while (iov->iov_len > 0) {
                if (recv_fd) {
-                       msghdr.msg_control = &fd_buf;
-                       msghdr.msg_controllen = sizeof(fd_buf);
+                       msghdr.msg_control = fd_buf;
+                       msghdr.msg_controllen = cmsg->cmsg_len;
                } else {
                        msghdr.msg_control = NULL;
                        msghdr.msg_controllen = 0;
                }
 
-               fd_buf.fd = -1;
+               *pfd = -1;
                bytes = recvmsg(fd, &msghdr, 0);
                if (!bytes)
                        return -1;
@@ -199,7 +205,7 @@ static int recv_retry(struct ubus_context *ctx, struct iovec *iov, bool wait, in
                        return 0;
 
                if (recv_fd)
-                       *recv_fd = fd_buf.fd;
+                       *recv_fd = *pfd;
 
                recv_fd = NULL;
 
@@ -215,7 +221,7 @@ static int recv_retry(struct ubus_context *ctx, struct iovec *iov, bool wait, in
        return total;
 }
 
-static bool ubus_validate_hdr(struct ubus_msghdr *hdr)
+bool ubus_validate_hdr(struct ubus_msghdr *hdr)
 {
        struct blob_attr *data = (struct blob_attr *) (hdr + 1);
 
@@ -308,12 +314,20 @@ void __hidden ubus_handle_data(struct uloop_fd *u, unsigned int events)
        struct ubus_context *ctx = container_of(u, struct ubus_context, sock);
        int recv_fd = -1;
 
-       while (get_next_msg(ctx, &recv_fd)) {
+       while (1) {
+               if (!ctx->stack_depth)
+                       ctx->pending_timer.cb(&ctx->pending_timer);
+
+               if (!get_next_msg(ctx, &recv_fd))
+                       break;
                ubus_process_msg(ctx, &ctx->msgbuf, recv_fd);
                if (uloop_cancelling() || ctx->cancel_poll)
                        break;
        }
 
+       if (!ctx->stack_depth)
+               ctx->pending_timer.cb(&ctx->pending_timer);
+
        if (u->eof)
                ctx->connection_lost(ctx);
 }
@@ -330,6 +344,29 @@ void __hidden ubus_poll_data(struct ubus_context *ctx, int timeout)
        ubus_handle_data(&ctx->sock, ULOOP_READ);
 }
 
+static void
+ubus_auto_sub_lookup(struct ubus_context *ctx, struct ubus_object_data *obj,
+                    void *priv)
+{
+       struct ubus_subscriber *s;
+
+       list_for_each_entry(s, &ctx->auto_subscribers, list)
+               if (s->new_obj_cb(ctx, s, obj->path))
+                       ubus_subscribe(ctx, s, obj->id);
+}
+
+static void
+ubus_refresh_auto_subscribe(struct ubus_context *ctx)
+{
+       struct ubus_event_handler *ev = &ctx->auto_subscribe_event_handler;
+
+       if (list_empty(&ctx->auto_subscribers))
+               return;
+
+       ubus_register_event_handler(ctx, ev, "ubus.object.add");
+       ubus_lookup(ctx, NULL, ubus_auto_sub_lookup, NULL);
+}
+
 static void
 ubus_refresh_state(struct ubus_context *ctx)
 {
@@ -351,6 +388,8 @@ ubus_refresh_state(struct ubus_context *ctx)
 
        for (n = i, i = 0; i < n; i++)
                ubus_add_object(ctx, objs[i]);
+
+       ubus_refresh_auto_subscribe(ctx);
 }
 
 int ubus_reconnect(struct ubus_context *ctx, const char *path)
@@ -392,7 +431,7 @@ int ubus_reconnect(struct ubus_context *ctx, const char *path)
                goto out_close;
 
        memcpy(buf, &hdr.data, sizeof(hdr.data));
-       if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != blob_len(buf))
+       if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != (ssize_t) blob_len(buf))
                goto out_free;
 
        ctx->local_id = hdr.hdr.peer;