libubus: increase stack depth for processing obj msgs

[project/ubus.git] / ubusd_main.c

diff --git a/ubusd_main.c b/ubusd_main.c
index 81868c1482bcc7e6029000e7437d7bb9dd9b7705..e102186b43ab9cc006c3f58c8245e877482049c7 100644 (file)
--- a/ubusd_main.c
+++ b/ubusd_main.c
@@ -15,28 +15,11 @@
 
 #include "ubusd.h"
 
-static struct ubus_msg_buf *ubus_msg_head(struct ubus_client *cl)
-{
-       return cl->tx_queue[cl->txq_cur];
-}
-
-static void ubus_msg_dequeue(struct ubus_client *cl)
-{
-       struct ubus_msg_buf *ub = ubus_msg_head(cl);
-
-       if (!ub)
-               return;
-
-       ubus_msg_free(ub);
-       cl->txq_ofs = 0;
-       cl->tx_queue[cl->txq_cur] = NULL;
-       cl->txq_cur = (cl->txq_cur + 1) % ARRAY_SIZE(cl->tx_queue);
-}
-
 static void handle_client_disconnect(struct ubus_client *cl)
 {
-       while (ubus_msg_head(cl))
-               ubus_msg_dequeue(cl);
+       struct ubus_msg_buf_list *ubl, *ubl2;
+       list_for_each_entry_safe(ubl, ubl2, &cl->tx_queue, list)
+               ubus_msg_list_free(ubl);
 
        ubusd_monitor_disconnect(cl);
        ubusd_proto_free_client(cl);
@@ -50,27 +33,32 @@ static void handle_client_disconnect(struct ubus_client *cl)
 static void client_cb(struct uloop_fd *sock, unsigned int events)
 {
        struct ubus_client *cl = container_of(sock, struct ubus_client, sock);
+       uint8_t fd_buf[CMSG_SPACE(sizeof(int))] = { 0 };
+       struct msghdr msghdr = { 0 };
        struct ubus_msg_buf *ub;
+       struct ubus_msg_buf_list *ubl, *ubl2;
        static struct iovec iov;
-       static struct {
-               int fd;
-               struct cmsghdr h;
-       } 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,
-       };
+       struct cmsghdr *cmsg;
+       int *pfd;
+
+       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);
+       msghdr.msg_controllen = cmsg->cmsg_len;
 
        /* first try to tx more pending data */
-       while ((ub = ubus_msg_head(cl))) {
+       list_for_each_entry_safe(ubl, ubl2, &cl->tx_queue, list) {
                ssize_t written;
 
+               ub = ubl->msg;
                written = ubus_msg_writev(sock->fd, ub, cl->txq_ofs);
                if (written < 0) {
                        switch(errno) {
@@ -84,15 +72,17 @@ static void client_cb(struct uloop_fd *sock, unsigned int events)
                }
 
                cl->txq_ofs += written;
+               cl->txq_len -= written;
                if (cl->txq_ofs < ub->len + sizeof(ub->hdr))
                        break;
 
-               ubus_msg_dequeue(cl);
+               cl->txq_ofs = 0;
+               ubus_msg_list_free(ubl);
        }
 
        /* prevent further ULOOP_WRITE events if we don't have data
         * to send anymore */
-       if (!ubus_msg_head(cl) && (events & ULOOP_WRITE))
+       if (list_empty(&cl->tx_queue) && (events & ULOOP_WRITE))
                uloop_fd_add(sock, ULOOP_READ | ULOOP_EDGE_TRIGGER);
 
 retry:
@@ -100,14 +90,14 @@ retry:
                int offset = cl->pending_msg_offset;
                int bytes;
 
-               fd_buf.fd = -1;
+               *pfd = -1;
 
                iov.iov_base = ((char *) &cl->hdrbuf) + offset;
                iov.iov_len = sizeof(cl->hdrbuf) - offset;
 
                if (cl->pending_msg_fd < 0) {
-                       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;
@@ -117,13 +107,15 @@ retry:
                if (bytes < 0)
                        goto out;
 
-               if (fd_buf.fd >= 0)
-                       cl->pending_msg_fd = fd_buf.fd;
+               if (*pfd >= 0)
+                       cl->pending_msg_fd = *pfd;
 
                cl->pending_msg_offset += bytes;
                if (cl->pending_msg_offset < (int) sizeof(cl->hdrbuf))
                        goto out;
 
+               if (blob_raw_len(&cl->hdrbuf.data) < sizeof(struct blob_attr))
+                       goto disconnect;
                if (blob_pad_len(&cl->hdrbuf.data) > UBUS_MAX_MSGLEN)
                        goto disconnect;
 
@@ -166,7 +158,7 @@ retry:
        }
 
 out:
-       if (!sock->eof || ubus_msg_head(cl))
+       if (!sock->eof || !list_empty(&cl->tx_queue))
                return;
 
 disconnect: