From a6f52f058e52c7720afb05e5e4e51648e636b940 Mon Sep 17 00:00:00 2001 From: Felix Fietkau Date: Wed, 24 Oct 2012 14:37:44 +0200 Subject: [PATCH] libubus: split out some code into separate source files --- CMakeLists.txt | 2 +- libubus-internal.h | 30 ++++ libubus-io.c | 256 ++++++++++++++++++++++++++ libubus-obj.c | 179 +++++++++++++++++++ libubus-obj.h | 4 + libubus.c | 436 +++------------------------------------------ 6 files changed, 491 insertions(+), 416 deletions(-) create mode 100644 libubus-internal.h create mode 100644 libubus-io.c create mode 100644 libubus-obj.c create mode 100644 libubus-obj.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 30f184d..a2c4101 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ IF(APPLE) LINK_DIRECTORIES(/opt/local/lib) ENDIF() -ADD_LIBRARY(ubus SHARED libubus.c) +ADD_LIBRARY(ubus SHARED libubus.c libubus-io.c libubus-obj.c) TARGET_LINK_LIBRARIES(ubus ubox) ADD_EXECUTABLE(ubusd ubusd.c ubusd_id.c ubusd_obj.c ubusd_proto.c ubusd_event.c) diff --git a/libubus-internal.h b/libubus-internal.h new file mode 100644 index 0000000..b58fb1d --- /dev/null +++ b/libubus-internal.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2011-2012 Felix Fietkau + * + * 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 + * as published by the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __LIBUBUS_IO_H +#define __LIBUBUS_IO_H + +#define __hidden __attribute__((visibility ("hidden"))) + +extern struct blob_buf b; + +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); +void ubus_process_invoke(struct ubus_context *ctx, struct ubus_msghdr *hdr); +int __hidden ubus_start_request(struct ubus_context *ctx, struct ubus_request *req, + struct blob_attr *msg, int cmd, uint32_t peer); + +#endif diff --git a/libubus-io.c b/libubus-io.c new file mode 100644 index 0000000..4ebb8fb --- /dev/null +++ b/libubus-io.c @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2011-2012 Felix Fietkau + * + * 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 + * as published by the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include "libubus.h" +#include "libubus-internal.h" + +#define STATIC_IOV(_var) { .iov_base = (char *) &(_var), .iov_len = sizeof(_var) } + +static const struct blob_attr_info ubus_policy[UBUS_ATTR_MAX] = { + [UBUS_ATTR_STATUS] = { .type = BLOB_ATTR_INT32 }, + [UBUS_ATTR_OBJID] = { .type = BLOB_ATTR_INT32 }, + [UBUS_ATTR_OBJPATH] = { .type = BLOB_ATTR_STRING }, + [UBUS_ATTR_METHOD] = { .type = BLOB_ATTR_STRING }, +}; + +static struct blob_attr *attrbuf[UBUS_ATTR_MAX]; + +__hidden struct blob_attr **ubus_parse_msg(struct blob_attr *msg) +{ + blob_parse(msg, attrbuf, ubus_policy, UBUS_ATTR_MAX); + return attrbuf; +} + +static void wait_data(int fd, bool write) +{ + struct pollfd pfd = { .fd = fd }; + + pfd.events = write ? POLLOUT : POLLIN; + poll(&pfd, 1, 0); +} + +static int writev_retry(int fd, struct iovec *iov, int iov_len) +{ + int len = 0; + + do { + int cur_len = writev(fd, iov, iov_len); + if (cur_len < 0) { + switch(errno) { + case EAGAIN: + wait_data(fd, true); + break; + case EINTR: + break; + default: + return -1; + } + continue; + } + len += cur_len; + while (cur_len >= iov->iov_len) { + cur_len -= iov->iov_len; + iov_len--; + iov++; + if (!cur_len || !iov_len) + return len; + } + iov->iov_len -= cur_len; + } while (1); +} + +int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq, + struct blob_attr *msg, int cmd, uint32_t peer) +{ + struct ubus_msghdr hdr; + struct iovec iov[2] = { + STATIC_IOV(hdr) + }; + + hdr.version = 0; + hdr.type = cmd; + hdr.seq = seq; + hdr.peer = peer; + + if (!msg) { + blob_buf_init(&b, 0); + msg = b.head; + } + + iov[1].iov_base = (char *) msg; + iov[1].iov_len = blob_raw_len(msg); + + return writev_retry(ctx->sock.fd, iov, ARRAY_SIZE(iov)); +} + +static bool recv_retry(int fd, struct iovec *iov, bool wait) +{ + int bytes; + + while (iov->iov_len > 0) { + if (wait) + wait_data(fd, false); + + bytes = read(fd, iov->iov_base, iov->iov_len); + if (bytes < 0) { + bytes = 0; + if (uloop_cancelled) + return false; + if (errno == EINTR) + continue; + + if (errno != EAGAIN) + return false; + } + if (!wait && !bytes) + return false; + + wait = true; + iov->iov_len -= bytes; + iov->iov_base += bytes; + } + + return true; +} + +static bool ubus_validate_hdr(struct ubus_msghdr *hdr) +{ + if (hdr->version != 0) + return false; + + if (blob_raw_len(hdr->data) < sizeof(*hdr->data)) + return false; + + if (blob_pad_len(hdr->data) > UBUS_MAX_MSGLEN) + return false; + + return true; +} + +static bool get_next_msg(struct ubus_context *ctx) +{ + struct iovec iov = STATIC_IOV(ctx->msgbuf.hdr); + + /* receive header + start attribute */ + iov.iov_len += sizeof(struct blob_attr); + if (!recv_retry(ctx->sock.fd, &iov, false)) + return false; + + iov.iov_len = blob_len(ctx->msgbuf.hdr.data); + if (iov.iov_len > 0 && !recv_retry(ctx->sock.fd, &iov, true)) + return false; + + return ubus_validate_hdr(&ctx->msgbuf.hdr); +} + +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; + + while (get_next_msg(ctx)) { + ubus_process_msg(ctx, hdr); + if (uloop_cancelled) + break; + } + + if (u->eof) + ctx->connection_lost(ctx); +} + +static void +ubus_refresh_state(struct ubus_context *ctx) +{ + struct ubus_object *obj, *tmp; + + /* clear all type IDs, they need to be registered again */ + avl_for_each_element(&ctx->objects, obj, avl) + obj->type->id = 0; + + /* push out all objects again */ + avl_for_each_element_safe(&ctx->objects, obj, avl, tmp) { + obj->id = 0; + avl_delete(&ctx->objects, &obj->avl); + ubus_add_object(ctx, obj); + } +} + +int ubus_reconnect(struct ubus_context *ctx, const char *path) +{ + struct { + struct ubus_msghdr hdr; + struct blob_attr data; + } hdr; + struct blob_attr *buf; + int ret = UBUS_STATUS_UNKNOWN_ERROR; + + if (!path) + path = UBUS_UNIX_SOCKET; + + if (ctx->sock.fd >= 0) { + if (ctx->sock.registered) + uloop_fd_delete(&ctx->sock); + + close(ctx->sock.fd); + } + + ctx->sock.fd = usock(USOCK_UNIX, path, NULL); + if (ctx->sock.fd < 0) + return UBUS_STATUS_CONNECTION_FAILED; + + if (read(ctx->sock.fd, &hdr, sizeof(hdr)) != sizeof(hdr)) + goto out_close; + + if (!ubus_validate_hdr(&hdr.hdr)) + goto out_close; + + if (hdr.hdr.type != UBUS_MSG_HELLO) + goto out_close; + + buf = calloc(1, blob_raw_len(&hdr.data)); + if (!buf) + goto out_close; + + memcpy(buf, &hdr.data, sizeof(hdr.data)); + if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != blob_len(buf)) + goto out_free; + + ctx->local_id = hdr.hdr.peer; + if (!ctx->local_id) + goto out_free; + + ret = UBUS_STATUS_OK; + fcntl(ctx->sock.fd, F_SETFL, fcntl(ctx->sock.fd, F_GETFL) | O_NONBLOCK); + + ubus_refresh_state(ctx); + +out_free: + free(buf); +out_close: + if (ret) + close(ctx->sock.fd); + + return ret; +} diff --git a/libubus-obj.c b/libubus-obj.c new file mode 100644 index 0000000..532a7fa --- /dev/null +++ b/libubus-obj.c @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2011-2012 Felix Fietkau + * + * 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 + * as published by the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include "libubus.h" +#include "libubus-internal.h" + +void __hidden ubus_process_invoke(struct ubus_context *ctx, struct ubus_msghdr *hdr) +{ + struct blob_attr **attrbuf; + struct ubus_request_data req; + struct ubus_object *obj; + int method; + int ret = 0; + + req.peer = hdr->peer; + req.seq = hdr->seq; + attrbuf = ubus_parse_msg(hdr->data); + + if (!attrbuf[UBUS_ATTR_OBJID]) + return; + + req.object = blob_get_u32(attrbuf[UBUS_ATTR_OBJID]); + + if (!attrbuf[UBUS_ATTR_METHOD]) { + ret = UBUS_STATUS_INVALID_ARGUMENT; + goto send; + } + + obj = avl_find_element(&ctx->objects, &req.object, obj, avl); + if (!obj) { + ret = UBUS_STATUS_NOT_FOUND; + goto send; + } + + for (method = 0; method < obj->n_methods; method++) + if (!obj->methods[method].name || + !strcmp(obj->methods[method].name, + blob_data(attrbuf[UBUS_ATTR_METHOD]))) + goto found; + + /* not found */ + ret = UBUS_STATUS_METHOD_NOT_FOUND; + goto send; + +found: + ret = obj->methods[method].handler(ctx, obj, &req, + blob_data(attrbuf[UBUS_ATTR_METHOD]), + attrbuf[UBUS_ATTR_DATA]); + if (req.deferred) + return; + +send: + ubus_complete_deferred_request(ctx, &req, ret); +} + +static void ubus_add_object_cb(struct ubus_request *req, int type, struct blob_attr *msg) +{ + struct ubus_object *obj = req->priv; + struct blob_attr **attrbuf = ubus_parse_msg(msg); + + if (!attrbuf[UBUS_ATTR_OBJID]) + return; + + obj->id = blob_get_u32(attrbuf[UBUS_ATTR_OBJID]); + + if (attrbuf[UBUS_ATTR_OBJTYPE]) + obj->type->id = blob_get_u32(attrbuf[UBUS_ATTR_OBJTYPE]); + + obj->avl.key = &obj->id; + avl_insert(&req->ctx->objects, &obj->avl); +} + +static void ubus_push_method_data(const struct ubus_method *m) +{ + void *mtbl; + int i; + + mtbl = blobmsg_open_table(&b, m->name); + + for (i = 0; i < m->n_policy; i++) + blobmsg_add_u32(&b, m->policy[i].name, m->policy[i].type); + + blobmsg_close_table(&b, mtbl); +} + +static bool ubus_push_object_type(const struct ubus_object_type *type) +{ + void *s; + int i; + + s = blob_nest_start(&b, UBUS_ATTR_SIGNATURE); + + for (i = 0; i < type->n_methods; i++) + ubus_push_method_data(&type->methods[i]); + + blob_nest_end(&b, s); + + return true; +} + +int ubus_add_object(struct ubus_context *ctx, struct ubus_object *obj) +{ + struct ubus_request req; + int ret; + + blob_buf_init(&b, 0); + + if (obj->name && obj->type) { + blob_put_string(&b, UBUS_ATTR_OBJPATH, obj->name); + + if (obj->type->id) + blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id); + else if (!ubus_push_object_type(obj->type)) + return UBUS_STATUS_INVALID_ARGUMENT; + } + + if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_ADD_OBJECT, 0) < 0) + return UBUS_STATUS_INVALID_ARGUMENT; + + req.raw_data_cb = ubus_add_object_cb; + req.priv = obj; + ret = ubus_complete_request(ctx, &req, 0); + if (ret) + return ret; + + if (!obj->id) + return UBUS_STATUS_NO_DATA; + + return 0; +} + +static void ubus_remove_object_cb(struct ubus_request *req, int type, struct blob_attr *msg) +{ + struct ubus_object *obj = req->priv; + struct blob_attr **attrbuf = ubus_parse_msg(msg); + + if (!attrbuf[UBUS_ATTR_OBJID]) + return; + + obj->id = 0; + + if (attrbuf[UBUS_ATTR_OBJTYPE] && obj->type) + obj->type->id = 0; + + avl_delete(&req->ctx->objects, &obj->avl); +} + +int ubus_remove_object(struct ubus_context *ctx, struct ubus_object *obj) +{ + struct ubus_request req; + int ret; + + blob_buf_init(&b, 0); + blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id); + + if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_REMOVE_OBJECT, 0) < 0) + return UBUS_STATUS_INVALID_ARGUMENT; + + req.raw_data_cb = ubus_remove_object_cb; + req.priv = obj; + ret = ubus_complete_request(ctx, &req, 0); + if (ret) + return ret; + + if (obj->id) + return UBUS_STATUS_NO_DATA; + + return 0; +} diff --git a/libubus-obj.h b/libubus-obj.h new file mode 100644 index 0000000..3168484 --- /dev/null +++ b/libubus-obj.h @@ -0,0 +1,4 @@ +#ifndef __LIBUBUS_OBJ_H + + +#endif diff --git a/libubus.c b/libubus.c index 6291e75..bcaf63d 100644 --- a/libubus.c +++ b/libubus.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Felix Fietkau + * Copyright (C) 2011-2012 Felix Fietkau * * 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 @@ -12,21 +12,16 @@ */ #include -#include #include -#include #include -#include #include #include -#include #include "libubus.h" +#include "libubus-internal.h" #include "ubusmsg.h" -#define STATIC_IOV(_var) { .iov_base = (char *) &(_var), .iov_len = sizeof(_var) } - const char *__ubus_strerror[__UBUS_STATUS_LAST] = { [UBUS_STATUS_OK] = "Success", [UBUS_STATUS_INVALID_COMMAND] = "Invalid command", @@ -41,15 +36,7 @@ const char *__ubus_strerror[__UBUS_STATUS_LAST] = { [UBUS_STATUS_CONNECTION_FAILED] = "Connection failed", }; -static struct blob_buf b; - -static const struct blob_attr_info ubus_policy[UBUS_ATTR_MAX] = { - [UBUS_ATTR_STATUS] = { .type = BLOB_ATTR_INT32 }, - [UBUS_ATTR_OBJID] = { .type = BLOB_ATTR_INT32 }, - [UBUS_ATTR_OBJPATH] = { .type = BLOB_ATTR_STRING }, - [UBUS_ATTR_METHOD] = { .type = BLOB_ATTR_STRING }, -}; -static struct blob_attr *attrbuf[UBUS_ATTR_MAX]; +struct blob_buf b __hidden = {}; struct ubus_pending_data { struct list_head list; @@ -74,12 +61,6 @@ static int ubus_cmp_id(const void *k1, const void *k2, void *ptr) return *id1 > *id2; } -static struct blob_attr **ubus_parse_msg(struct blob_attr *msg) -{ - blob_parse(msg, attrbuf, ubus_policy, UBUS_ATTR_MAX); - return attrbuf; -} - const char *ubus_strerror(int error) { static char err[32]; @@ -97,147 +78,9 @@ out: return err; } -static void wait_data(int fd, bool write) -{ - struct pollfd pfd = { .fd = fd }; - - pfd.events = write ? POLLOUT : POLLIN; - poll(&pfd, 1, 0); -} - -static int writev_retry(int fd, struct iovec *iov, int iov_len) -{ - int len = 0; - - do { - int cur_len = writev(fd, iov, iov_len); - if (cur_len < 0) { - switch(errno) { - case EAGAIN: - wait_data(fd, true); - break; - case EINTR: - break; - default: - return -1; - } - continue; - } - len += cur_len; - while (cur_len >= iov->iov_len) { - cur_len -= iov->iov_len; - iov_len--; - iov++; - if (!cur_len || !iov_len) - return len; - } - iov->iov_len -= cur_len; - } while (1); -} - -static int ubus_send_msg(struct ubus_context *ctx, uint32_t seq, - struct blob_attr *msg, int cmd, uint32_t peer) -{ - struct ubus_msghdr hdr; - struct iovec iov[2] = { - STATIC_IOV(hdr) - }; - - hdr.version = 0; - hdr.type = cmd; - hdr.seq = seq; - hdr.peer = peer; - - if (!msg) { - blob_buf_init(&b, 0); - msg = b.head; - } - - iov[1].iov_base = (char *) msg; - iov[1].iov_len = blob_raw_len(msg); - - return writev_retry(ctx->sock.fd, iov, ARRAY_SIZE(iov)); -} - -static int ubus_start_request(struct ubus_context *ctx, struct ubus_request *req, - struct blob_attr *msg, int cmd, uint32_t peer) -{ - memset(req, 0, sizeof(*req)); - - if (msg && blob_pad_len(msg) > UBUS_MAX_MSGLEN) - return -1; - - INIT_LIST_HEAD(&req->list); - INIT_LIST_HEAD(&req->pending); - req->ctx = ctx; - req->peer = peer; - req->seq = ++ctx->request_seq; - return ubus_send_msg(ctx, req->seq, msg, cmd, peer); -} - -static bool recv_retry(int fd, struct iovec *iov, bool wait) -{ - int bytes; - - while (iov->iov_len > 0) { - if (wait) - wait_data(fd, false); - - bytes = read(fd, iov->iov_base, iov->iov_len); - if (bytes < 0) { - bytes = 0; - if (uloop_cancelled) - return false; - if (errno == EINTR) - continue; - - if (errno != EAGAIN) - return false; - } - if (!wait && !bytes) - return false; - - wait = true; - iov->iov_len -= bytes; - iov->iov_base += bytes; - } - - return true; -} - -static bool ubus_validate_hdr(struct ubus_msghdr *hdr) -{ - if (hdr->version != 0) - return false; - - if (blob_raw_len(hdr->data) < sizeof(*hdr->data)) - return false; - - if (blob_pad_len(hdr->data) > UBUS_MAX_MSGLEN) - return false; - - return true; -} - -static bool get_next_msg(struct ubus_context *ctx) -{ - struct iovec iov = STATIC_IOV(ctx->msgbuf.hdr); - - /* receive header + start attribute */ - iov.iov_len += sizeof(struct blob_attr); - if (!recv_retry(ctx->sock.fd, &iov, false)) - return false; - - iov.iov_len = blob_len(ctx->msgbuf.hdr.data); - if (iov.iov_len > 0 && !recv_retry(ctx->sock.fd, &iov, true)) - return false; - - return ubus_validate_hdr(&ctx->msgbuf.hdr); -} - static bool ubus_get_status(struct ubus_msghdr *hdr, int *ret) { - ubus_parse_msg(hdr->data); + struct blob_attr **attrbuf = ubus_parse_msg(hdr->data); if (!attrbuf[UBUS_ATTR_STATUS]) return false; @@ -350,55 +193,7 @@ void ubus_complete_deferred_request(struct ubus_context *ctx, struct ubus_reques ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_STATUS, req->peer); } -static void ubus_process_invoke(struct ubus_context *ctx, struct ubus_msghdr *hdr) -{ - struct ubus_request_data req; - struct ubus_object *obj; - int method; - int ret = 0; - - req.peer = hdr->peer; - req.seq = hdr->seq; - ubus_parse_msg(hdr->data); - - if (!attrbuf[UBUS_ATTR_OBJID]) - return; - - req.object = blob_get_u32(attrbuf[UBUS_ATTR_OBJID]); - - if (!attrbuf[UBUS_ATTR_METHOD]) { - ret = UBUS_STATUS_INVALID_ARGUMENT; - goto send; - } - - obj = avl_find_element(&ctx->objects, &req.object, obj, avl); - if (!obj) { - ret = UBUS_STATUS_NOT_FOUND; - goto send; - } - - for (method = 0; method < obj->n_methods; method++) - if (!obj->methods[method].name || - !strcmp(obj->methods[method].name, - blob_data(attrbuf[UBUS_ATTR_METHOD]))) - goto found; - - /* not found */ - ret = UBUS_STATUS_METHOD_NOT_FOUND; - goto send; - -found: - ret = obj->methods[method].handler(ctx, obj, &req, - blob_data(attrbuf[UBUS_ATTR_METHOD]), - attrbuf[UBUS_ATTR_DATA]); - if (req.deferred) - return; - -send: - ubus_complete_deferred_request(ctx, &req, ret); -} - -static void ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr) +void __hidden ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr) { struct ubus_pending_invoke *pending; struct ubus_request *req; @@ -467,21 +262,6 @@ void ubus_complete_request_async(struct ubus_context *ctx, struct ubus_request * list_add(&req->list, &ctx->requests); } -static void 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; - - while (get_next_msg(ctx)) { - ubus_process_msg(ctx, hdr); - if (uloop_cancelled) - break; - } - - if (u->eof) - ctx->connection_lost(ctx); -} - static void ubus_sync_req_cb(struct ubus_request *req, int ret) { req->status_msg = true; @@ -579,6 +359,22 @@ static void ubus_lookup_cb(struct ubus_request *ureq, int type, struct blob_attr req->cb(ureq->ctx, &obj, ureq->priv); } +int __hidden ubus_start_request(struct ubus_context *ctx, struct ubus_request *req, + struct blob_attr *msg, int cmd, uint32_t peer) +{ + memset(req, 0, sizeof(*req)); + + if (msg && blob_pad_len(msg) > UBUS_MAX_MSGLEN) + return -1; + + INIT_LIST_HEAD(&req->list); + INIT_LIST_HEAD(&req->pending); + req->ctx = ctx; + req->peer = peer; + req->seq = ++ctx->request_seq; + return ubus_send_msg(ctx, req->seq, msg, cmd, peer); +} + int ubus_lookup(struct ubus_context *ctx, const char *path, ubus_lookup_handler_t cb, void *priv) { @@ -669,122 +465,7 @@ int ubus_invoke(struct ubus_context *ctx, uint32_t obj, const char *method, return ubus_complete_request(ctx, &req, timeout); } -static void ubus_add_object_cb(struct ubus_request *req, int type, struct blob_attr *msg) -{ - struct ubus_object *obj = req->priv; - - ubus_parse_msg(msg); - - if (!attrbuf[UBUS_ATTR_OBJID]) - return; - - obj->id = blob_get_u32(attrbuf[UBUS_ATTR_OBJID]); - - if (attrbuf[UBUS_ATTR_OBJTYPE]) - obj->type->id = blob_get_u32(attrbuf[UBUS_ATTR_OBJTYPE]); - - obj->avl.key = &obj->id; - avl_insert(&req->ctx->objects, &obj->avl); -} - -static void ubus_push_method_data(const struct ubus_method *m) -{ - void *mtbl; - int i; - - mtbl = blobmsg_open_table(&b, m->name); - - for (i = 0; i < m->n_policy; i++) - blobmsg_add_u32(&b, m->policy[i].name, m->policy[i].type); - - blobmsg_close_table(&b, mtbl); -} - -static bool ubus_push_object_type(const struct ubus_object_type *type) -{ - void *s; - int i; - - s = blob_nest_start(&b, UBUS_ATTR_SIGNATURE); - - for (i = 0; i < type->n_methods; i++) - ubus_push_method_data(&type->methods[i]); - - blob_nest_end(&b, s); - - return true; -} - -int ubus_add_object(struct ubus_context *ctx, struct ubus_object *obj) -{ - struct ubus_request req; - int ret; - - blob_buf_init(&b, 0); - - if (obj->name && obj->type) { - blob_put_string(&b, UBUS_ATTR_OBJPATH, obj->name); - - if (obj->type->id) - blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id); - else if (!ubus_push_object_type(obj->type)) - return UBUS_STATUS_INVALID_ARGUMENT; - } - - if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_ADD_OBJECT, 0) < 0) - return UBUS_STATUS_INVALID_ARGUMENT; - - req.raw_data_cb = ubus_add_object_cb; - req.priv = obj; - ret = ubus_complete_request(ctx, &req, 0); - if (ret) - return ret; - - if (!obj->id) - return UBUS_STATUS_NO_DATA; - - return 0; -} - -static void ubus_remove_object_cb(struct ubus_request *req, int type, struct blob_attr *msg) -{ - struct ubus_object *obj = req->priv; - - ubus_parse_msg(msg); - - if (!attrbuf[UBUS_ATTR_OBJID]) - return; - - obj->id = 0; - - if (attrbuf[UBUS_ATTR_OBJTYPE] && obj->type) - obj->type->id = 0; - - avl_delete(&req->ctx->objects, &obj->avl); -} - -int ubus_remove_object(struct ubus_context *ctx, struct ubus_object *obj) -{ - struct ubus_request req; - int ret; - blob_buf_init(&b, 0); - blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id); - - if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_REMOVE_OBJECT, 0) < 0) - return UBUS_STATUS_INVALID_ARGUMENT; - - req.raw_data_cb = ubus_remove_object_cb; - req.priv = obj; - ret = ubus_complete_request(ctx, &req, 0); - if (ret) - return ret; - - if (obj->id) - return UBUS_STATUS_NO_DATA; - - return 0; -} static int ubus_event_cb(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, @@ -928,81 +609,6 @@ int ubus_send_event(struct ubus_context *ctx, const char *id, return ubus_complete_request(ctx, &req, 0); } -static void -ubus_refresh_state(struct ubus_context *ctx) -{ - struct ubus_object *obj, *tmp; - - /* clear all type IDs, they need to be registered again */ - avl_for_each_element(&ctx->objects, obj, avl) - obj->type->id = 0; - - /* push out all objects again */ - avl_for_each_element_safe(&ctx->objects, obj, avl, tmp) { - obj->id = 0; - avl_delete(&ctx->objects, &obj->avl); - ubus_add_object(ctx, obj); - } -} - -int ubus_reconnect(struct ubus_context *ctx, const char *path) -{ - struct { - struct ubus_msghdr hdr; - struct blob_attr data; - } hdr; - struct blob_attr *buf; - int ret = UBUS_STATUS_UNKNOWN_ERROR; - - if (!path) - path = UBUS_UNIX_SOCKET; - - if (ctx->sock.fd >= 0) { - if (ctx->sock.registered) - uloop_fd_delete(&ctx->sock); - - close(ctx->sock.fd); - } - - ctx->sock.fd = usock(USOCK_UNIX, path, NULL); - if (ctx->sock.fd < 0) - return UBUS_STATUS_CONNECTION_FAILED; - - if (read(ctx->sock.fd, &hdr, sizeof(hdr)) != sizeof(hdr)) - goto out_close; - - if (!ubus_validate_hdr(&hdr.hdr)) - goto out_close; - - if (hdr.hdr.type != UBUS_MSG_HELLO) - goto out_close; - - buf = calloc(1, blob_raw_len(&hdr.data)); - if (!buf) - goto out_close; - - memcpy(buf, &hdr.data, sizeof(hdr.data)); - if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != blob_len(buf)) - goto out_free; - - ctx->local_id = hdr.hdr.peer; - if (!ctx->local_id) - goto out_free; - - ret = UBUS_STATUS_OK; - fcntl(ctx->sock.fd, F_SETFL, fcntl(ctx->sock.fd, F_GETFL) | O_NONBLOCK); - - ubus_refresh_state(ctx); - -out_free: - free(buf); -out_close: - if (ret) - close(ctx->sock.fd); - - return ret; -} - static void ubus_default_connection_lost(struct ubus_context *ctx) { if (ctx->sock.registered) -- 2.30.2