libubus: implement file descriptor passing support

Signed-off-by: Felix Fietkau <nbd@openwrt.org>

diff --git a/libubus-internal.h b/libubus-internal.h
index 84ca770a8705305e797debc4fac1f9ecdcc995d7..3da057ee74ee05a64490e2b679c04109a0cfec1c 100644 (file)
--- a/libubus-internal.h
+++ b/libubus-internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (C) 2011-2014 Felix Fietkau <nbd@openwrt.org>
  *
  * 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
@@ -22,12 +22,12 @@ extern const struct ubus_method watch_method;
 struct blob_attr **ubus_parse_msg(struct blob_attr *msg);
 void ubus_handle_data(struct uloop_fd *u, unsigned int events);
 int ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
-                 struct blob_attr *msg, int cmd, uint32_t peer);
-void ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr);
+                 struct blob_attr *msg, int cmd, uint32_t peer, int fd);
+void ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr, int fd);
 int __hidden ubus_start_request(struct ubus_context *ctx, struct ubus_request *req,
                                struct blob_attr *msg, int cmd, uint32_t peer);
 void ubus_process_obj_msg(struct ubus_context*ctx, struct ubus_msghdr *hdr);
-void ubus_process_req_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr);
+void ubus_process_req_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr, int fd);
 void ubus_process_pending_msg(struct ubus_context *ctx);
 
 #endif

diff --git a/libubus-io.c b/libubus-io.c
index 19e3c2fd29d2e27dba06e4b97dcdab25c0ec8e66..bc054b8d0ff263a807482b48c093a6309ddcee72 100644 (file)
--- a/libubus-io.c
+++ b/libubus-io.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (C) 2011-2014 Felix Fietkau <nbd@openwrt.org>
  *
  * 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
@@ -54,12 +54,37 @@ static void wait_data(int fd, bool write)
        poll(&pfd, 1, 0);
 }
 
-static int writev_retry(int fd, struct iovec *iov, int iov_len)
+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),
+       };
        int len = 0;
 
        do {
-               int cur_len = writev(fd, iov, iov_len);
+               int cur_len;
+
+               if (sock_fd < 0) {
+                       msghdr.msg_control = NULL;
+                       msghdr.msg_controllen = 0;
+               } else {
+                       fd_buf.fd = sock_fd;
+               }
+
+               cur_len = sendmsg(fd, &msghdr, 0);
                if (cur_len < 0) {
                        switch(errno) {
                        case EAGAIN:
@@ -72,6 +97,10 @@ static int writev_retry(int fd, struct iovec *iov, int iov_len)
                        }
                        continue;
                }
+
+               if (len > 0)
+                       sock_fd = -1;
+
                len += cur_len;
                while (cur_len >= iov->iov_len) {
                        cur_len -= iov->iov_len;
@@ -88,7 +117,7 @@ static int writev_retry(int fd, struct iovec *iov, int iov_len)
 }
 
 int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
-                          struct blob_attr *msg, int cmd, uint32_t peer)
+                          struct blob_attr *msg, int cmd, uint32_t peer, int fd)
 {
        struct ubus_msghdr hdr;
        struct iovec iov[2] = {
@@ -109,22 +138,45 @@ int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
        iov[1].iov_base = (char *) msg;
        iov[1].iov_len = blob_raw_len(msg);
 
-       ret = writev_retry(ctx->sock.fd, iov, ARRAY_SIZE(iov));
+       ret = writev_retry(ctx->sock.fd, iov, ARRAY_SIZE(iov), fd);
        if (ret < 0)
                ctx->sock.eof = true;
 
        return ret;
 }
 
-static int recv_retry(int fd, struct iovec *iov, bool wait)
+static int recv_retry(int fd, struct iovec *iov, bool wait, int *recv_fd)
 {
        int bytes, total = 0;
+       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,
+       };
 
        while (iov->iov_len > 0) {
                if (wait)
                        wait_data(fd, false);
 
-               bytes = read(fd, iov->iov_base, iov->iov_len);
+               if (recv_fd) {
+                       msghdr.msg_control = &fd_buf;
+                       msghdr.msg_controllen = sizeof(fd_buf);
+               } else {
+                       msghdr.msg_control = NULL;
+                       msghdr.msg_controllen = 0;
+               }
+
+               fd_buf.fd = -1;
+               bytes = recvmsg(fd, &msghdr, 0);
                if (!bytes)
                        return -1;
 
@@ -141,6 +193,11 @@ static int recv_retry(int fd, struct iovec *iov, bool wait)
                if (!wait && !bytes)
                        return 0;
 
+               if (recv_fd)
+                       *recv_fd = fd_buf.fd;
+
+               recv_fd = NULL;
+
                wait = true;
                iov->iov_len -= bytes;
                iov->iov_base += bytes;
@@ -166,14 +223,14 @@ static bool ubus_validate_hdr(struct ubus_msghdr *hdr)
        return true;
 }
 
-static bool get_next_msg(struct ubus_context *ctx)
+static bool get_next_msg(struct ubus_context *ctx, int *recv_fd)
 {
        struct iovec iov = STATIC_IOV(ctx->msgbuf.hdr);
        int r;
 
        /* receive header + start attribute */
        iov.iov_len += sizeof(struct blob_attr);
-       r = recv_retry(ctx->sock.fd, &iov, false);
+       r = recv_retry(ctx->sock.fd, &iov, false, recv_fd);
        if (r <= 0) {
                if (r < 0)
                        ctx->sock.eof = true;
@@ -182,7 +239,7 @@ static bool get_next_msg(struct ubus_context *ctx)
        }
 
        iov.iov_len = blob_len(ubus_msghdr_data(&ctx->msgbuf.hdr));
-       if (iov.iov_len > 0 && !recv_retry(ctx->sock.fd, &iov, true))
+       if (iov.iov_len > 0 && !recv_retry(ctx->sock.fd, &iov, true, NULL))
                return false;
 
        return ubus_validate_hdr(&ctx->msgbuf.hdr);
@@ -192,9 +249,10 @@ void __hidden ubus_handle_data(struct uloop_fd *u, unsigned int events)
 {
        struct ubus_context *ctx = container_of(u, struct ubus_context, sock);
        struct ubus_msghdr *hdr = &ctx->msgbuf.hdr;
+       int recv_fd = -1;
 
-       while (get_next_msg(ctx)) {
-               ubus_process_msg(ctx, hdr);
+       while (get_next_msg(ctx, &recv_fd)) {
+               ubus_process_msg(ctx, hdr, recv_fd);
                if (uloop_cancelled)
                        break;
        }

diff --git a/libubus-obj.c b/libubus-obj.c
index 212c13cbc9723a52c7bf438c5b67038412374bd1..a1062e0a5a8b247cb849b729867dd585c3d22761 100644 (file)
--- a/libubus-obj.c
+++ b/libubus-obj.c
@@ -46,7 +46,9 @@ static void
 ubus_process_invoke(struct ubus_context *ctx, struct ubus_msghdr *hdr,
                    struct ubus_object *obj, struct blob_attr **attrbuf)
 {
-       struct ubus_request_data req = {};
+       struct ubus_request_data req = {
+               .fd = -1,
+       };
        int method;
        int ret;
        bool no_reply = false;

diff --git a/libubus-req.c b/libubus-req.c
index f89e7a7b3aa7d052eaa372767249f96231b57afa..79e5643e2773c9efd885d611de30e435474034da 100644 (file)
--- a/libubus-req.c
+++ b/libubus-req.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (C) 2011-2014 Felix Fietkau <nbd@openwrt.org>
  *
  * 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
@@ -11,6 +11,7 @@
  * GNU General Public License for more details.
  */
 
+#include <unistd.h>
 #include "libubus.h"
 #include "libubus-internal.h"
 
@@ -61,7 +62,7 @@ int __hidden ubus_start_request(struct ubus_context *ctx, struct ubus_request *r
        req->ctx = ctx;
        req->peer = peer;
        req->seq = ++ctx->request_seq;
-       return ubus_send_msg(ctx, req->seq, msg, cmd, peer);
+       return ubus_send_msg(ctx, req->seq, msg, cmd, peer, -1);
 }
 
 void ubus_abort_request(struct ubus_context *ctx, struct ubus_request *req)
@@ -184,7 +185,7 @@ void ubus_complete_deferred_request(struct ubus_context *ctx, struct ubus_reques
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_STATUS, ret);
        blob_put_int32(&b, UBUS_ATTR_OBJID, req->object);
-       ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_STATUS, req->peer);
+       ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_STATUS, req->peer, req->fd);
 }
 
 int ubus_send_reply(struct ubus_context *ctx, struct ubus_request_data *req,
@@ -195,7 +196,7 @@ int ubus_send_reply(struct ubus_context *ctx, struct ubus_request_data *req,
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_OBJID, req->object);
        blob_put(&b, UBUS_ATTR_DATA, blob_data(msg), blob_len(msg));
-       ret = ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_DATA, req->peer);
+       ret = ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_DATA, req->peer, -1);
        if (ret < 0)
                return UBUS_STATUS_NO_DATA;
 
@@ -428,7 +429,7 @@ static void ubus_process_notify_status(struct ubus_request *req, int id, struct
                ubus_set_req_status(req, 0);
 }
 
-void __hidden ubus_process_req_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr)
+void __hidden ubus_process_req_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr, int fd)
 {
        struct ubus_request *req;
        int id = -1;
@@ -439,6 +440,13 @@ void __hidden ubus_process_req_msg(struct ubus_context *ctx, struct ubus_msghdr
                if (!req)
                        break;
 
+               if (fd >= 0) {
+                       if (req->fd_cb)
+                               req->fd_cb(req, fd);
+                       else
+                               close(fd);
+               }
+
                if (id >= 0)
                        ubus_process_notify_status(req, id, hdr);
                else

diff --git a/libubus.c b/libubus.c
index e435200150ef02c48be73c25fd693b366cd7a515..8683fcc30069c017377c5467006269046d43a504 100644 (file)
--- a/libubus.c
+++ b/libubus.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (C) 2011-2014 Felix Fietkau <nbd@openwrt.org>
  *
  * 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
@@ -84,13 +84,13 @@ ubus_queue_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr)
 }
 
 void __hidden
-ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr)
+ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr, int fd)
 {
 
        switch(hdr->type) {
        case UBUS_MSG_STATUS:
        case UBUS_MSG_DATA:
-               ubus_process_req_msg(ctx, hdr);
+               ubus_process_req_msg(ctx, hdr, fd);
                break;
 
        case UBUS_MSG_INVOKE:
@@ -113,7 +113,7 @@ void __hidden ubus_process_pending_msg(struct ubus_context *ctx)
        while (!list_empty(&ctx->pending)) {
                pending = list_first_entry(&ctx->pending, struct ubus_pending_msg, list);
                list_del(&pending->list);
-               ubus_process_msg(ctx, &pending->hdr);
+               ubus_process_msg(ctx, &pending->hdr, -1);
                free(pending);
                if (ctx->stack_depth > 2)
                        break;

diff --git a/libubus.h b/libubus.h
index 0c97436df6e9a3c514a0200d6aa85c63b208d9e8..60d9bb6cac67849b8a03698dacf53e66afc49122 100644 (file)
--- a/libubus.h
+++ b/libubus.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2012 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (C) 2011-2014 Felix Fietkau <nbd@openwrt.org>
  *
  * 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
@@ -53,6 +53,7 @@ typedef void (*ubus_event_handler_t)(struct ubus_context *ctx, struct ubus_event
                                     const char *type, struct blob_attr *msg);
 typedef void (*ubus_data_handler_t)(struct ubus_request *req,
                                    int type, struct blob_attr *msg);
+typedef void (*ubus_fd_handler_t)(struct ubus_request *req, int fd);
 typedef void (*ubus_complete_handler_t)(struct ubus_request *req, int ret);
 typedef void (*ubus_notify_complete_handler_t)(struct ubus_notify_request *req,
                                               int idx, int ret);
@@ -155,7 +156,10 @@ struct ubus_request_data {
        uint32_t object;
        uint32_t peer;
        uint16_t seq;
+
+       /* internal use */
        bool deferred;
+       int fd;
 };
 
 struct ubus_request {
@@ -173,6 +177,7 @@ struct ubus_request {
 
        ubus_data_handler_t raw_data_cb;
        ubus_data_handler_t data_cb;
+       ubus_fd_handler_t fd_cb;
        ubus_complete_handler_t complete_cb;
 
        struct ubus_context *ctx;
@@ -275,6 +280,12 @@ static inline void ubus_defer_request(struct ubus_context *ctx,
     req->deferred = true;
 }
 
+static inline void ubus_request_set_fd(struct ubus_context *ctx,
+                                      struct ubus_request_data *req, int fd)
+{
+    req->fd = fd;
+}
+
 void ubus_complete_deferred_request(struct ubus_context *ctx,
                                    struct ubus_request_data *req, int ret);