ubus: Remove unnecessary memset calls.

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

diff --git a/libubus-io.c b/libubus-io.c
index 55ddff5..daa7106 100644 (file)
--- a/libubus-io.c
+++ b/libubus-io.c
@@ -11,6 +11,7 @@
  * GNU General Public License for more details.
  */
 
+#define _GNU_SOURCE
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/socket.h>
@@ -53,7 +54,7 @@ static void wait_data(int fd, bool write)
        struct pollfd pfd = { .fd = fd };
 
        pfd.events = write ? POLLOUT : POLLIN;
-       poll(&pfd, 1, 0);
+       poll(&pfd, 1, -1);
 }
 
 static int writev_retry(int fd, struct iovec *iov, int iov_len, int sock_fd)
@@ -132,8 +133,8 @@ int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
 
        hdr.version = 0;
        hdr.type = cmd;
-       hdr.seq = seq;
-       hdr.peer = peer;
+       hdr.seq = cpu_to_be16(seq);
+       hdr.peer = cpu_to_be32(peer);
 
        if (!msg) {
                blob_buf_init(&b, 0);
@@ -153,9 +154,10 @@ int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
        return ret;
 }
 
-static int recv_retry(int fd, struct iovec *iov, bool wait, int *recv_fd)
+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;
@@ -190,7 +192,7 @@ static int recv_retry(int fd, struct iovec *iov, bool wait, int *recv_fd)
 
                if (bytes < 0) {
                        bytes = 0;
-                       if (uloop_cancelled)
+                       if (uloop_cancelling() || ctx->cancel_poll)
                                return 0;
                        if (errno == EINTR)
                                continue;
@@ -231,6 +233,37 @@ static bool ubus_validate_hdr(struct ubus_msghdr *hdr)
        return true;
 }
 
+static bool alloc_msg_buf(struct ubus_context *ctx, int len)
+{
+       void *ptr;
+       int buf_len = ctx->msgbuf_data_len;
+       int rem;
+
+       if (!ctx->msgbuf.data)
+               buf_len = 0;
+
+       rem = (len % UBUS_MSG_CHUNK_SIZE);
+       if (rem > 0)
+               len += UBUS_MSG_CHUNK_SIZE - rem;
+
+       if (len < buf_len &&
+           ++ctx->msgbuf_reduction_counter > UBUS_MSGBUF_REDUCTION_INTERVAL) {
+               ctx->msgbuf_reduction_counter = 0;
+               buf_len = 0;
+       }
+
+       if (len <= buf_len)
+               return true;
+
+       ptr = realloc(ctx->msgbuf.data, len);
+       if (!ptr)
+               return false;
+
+       ctx->msgbuf.data = ptr;
+       ctx->msgbuf_data_len = len;
+       return true;
+}
+
 static bool get_next_msg(struct ubus_context *ctx, int *recv_fd)
 {
        struct {
@@ -242,7 +275,7 @@ static bool get_next_msg(struct ubus_context *ctx, int *recv_fd)
        int r;
 
        /* receive header + start attribute */
-       r = recv_retry(ctx->sock.fd, &iov, false, recv_fd);
+       r = recv_retry(ctx, &iov, false, recv_fd);
        if (r <= 0) {
                if (r < 0)
                        ctx->sock.eof = true;
@@ -250,23 +283,14 @@ static bool get_next_msg(struct ubus_context *ctx, int *recv_fd)
                return false;
        }
 
+       hdrbuf.hdr.seq = be16_to_cpu(hdrbuf.hdr.seq);
+       hdrbuf.hdr.peer = be32_to_cpu(hdrbuf.hdr.peer);
+
        if (!ubus_validate_hdr(&hdrbuf.hdr))
                return false;
 
        len = blob_raw_len(&hdrbuf.data);
-       if (len > ctx->msgbuf_data_len)
-               ctx->msgbuf_reduction_counter = UBUS_MSGBUF_REDUCTION_INTERVAL;
-       else if (ctx->msgbuf_reduction_counter > 0 && len < UBUS_MSG_CHUNK_SIZE)
-               len = !--ctx->msgbuf_reduction_counter ? UBUS_MSG_CHUNK_SIZE : -1;
-       else
-               len = -1;
-
-       if (len > -1) {
-               ctx->msgbuf.data = realloc(ctx->msgbuf.data, len * sizeof(char));
-               if (ctx->msgbuf.data)
-                       ctx->msgbuf_data_len = len;
-       }
-       if (!ctx->msgbuf.data)
+       if (!alloc_msg_buf(ctx, len))
                return false;
 
        memcpy(&ctx->msgbuf.hdr, &hdrbuf.hdr, sizeof(hdrbuf.hdr));
@@ -274,7 +298,8 @@ static bool get_next_msg(struct ubus_context *ctx, int *recv_fd)
 
        iov.iov_base = (char *)ctx->msgbuf.data + sizeof(hdrbuf.data);
        iov.iov_len = blob_len(ctx->msgbuf.data);
-       if (iov.iov_len > 0 && !recv_retry(ctx->sock.fd, &iov, true, NULL))
+       if (iov.iov_len > 0 &&
+           recv_retry(ctx, &iov, true, NULL) <= 0)
                return false;
 
        return true;
@@ -287,7 +312,7 @@ void __hidden ubus_handle_data(struct uloop_fd *u, unsigned int events)
 
        while (get_next_msg(ctx, &recv_fd)) {
                ubus_process_msg(ctx, &ctx->msgbuf, recv_fd);
-               if (uloop_cancelled)
+               if (uloop_cancelling() || ctx->cancel_poll)
                        break;
        }
 
@@ -302,7 +327,8 @@ void __hidden ubus_poll_data(struct ubus_context *ctx, int timeout)
                .events = POLLIN | POLLERR,
        };
 
-       poll(&pfd, 1, timeout);
+       ctx->cancel_poll = false;
+       poll(&pfd, 1, timeout ? timeout : -1);
        ubus_handle_data(&ctx->sock, ULOOP_READ);
 }
 
@@ -348,6 +374,8 @@ int ubus_reconnect(struct ubus_context *ctx, const char *path)
                close(ctx->sock.fd);
        }
 
+       ctx->sock.eof = false;
+       ctx->sock.error = false;
        ctx->sock.fd = usock(USOCK_UNIX, path, NULL);
        if (ctx->sock.fd < 0)
                return UBUS_STATUS_CONNECTION_FAILED;