X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fubus.git;a=blobdiff_plain;f=libubus.h;h=07239d6664d4ade26de378df46d4e44d9876b413;hp=48ee056975882096cb294cbe6e7186dd85e7ecb6;hb=d009a084735c7e0bca28ca05919fa9c60007f314;hpb=f6a6b0d492900b7a087a8a89d11fa5b94f4c5cb5 diff --git a/libubus.h b/libubus.h index 48ee056..07239d6 100644 --- a/libubus.h +++ b/libubus.h @@ -1,3 +1,19 @@ +/* + * Copyright (C) 2011-2014 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_H +#define __LIBUBUS_H + #include #include #include @@ -6,12 +22,22 @@ #include "ubusmsg.h" #include "ubus_common.h" +#define UBUS_MAX_NOTIFY_PEERS 16 + struct ubus_context; struct ubus_msg_src; struct ubus_object; struct ubus_request; struct ubus_request_data; struct ubus_object_data; +struct ubus_event_handler; +struct ubus_subscriber; +struct ubus_notify_request; + +struct ubus_msghdr_buf { + struct ubus_msghdr hdr; + struct blob_attr *data; +}; typedef void (*ubus_lookup_handler_t)(struct ubus_context *ctx, struct ubus_object_data *obj, @@ -19,47 +45,75 @@ typedef void (*ubus_lookup_handler_t)(struct ubus_context *ctx, typedef int (*ubus_handler_t)(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg); +typedef void (*ubus_state_handler_t)(struct ubus_context *ctx, struct ubus_object *obj); +typedef void (*ubus_remove_handler_t)(struct ubus_context *ctx, + struct ubus_subscriber *obj, uint32_t id); +typedef void (*ubus_event_handler_t)(struct ubus_context *ctx, struct ubus_event_handler *ev, + 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); +typedef void (*ubus_connect_handler_t)(struct ubus_context *ctx); +#define UBUS_OBJECT_TYPE(_name, _methods) \ + { \ + .name = _name, \ + .id = 0, \ + .n_methods = ARRAY_SIZE(_methods), \ + .methods = _methods \ + } -#define UBUS_SIGNATURE(_type, _name) { .type = _type, .name = _name } - -#define UBUS_METHOD_START(_name) UBUS_SIGNATURE(UBUS_SIGNATURE_METHOD, _name) -#define UBUS_METHOD_END() UBUS_SIGNATURE(UBUS_SIGNATURE_END, NULL) +#define __UBUS_METHOD_NOARG(_name, _handler, _tags) \ + .name = _name, \ + .handler = _handler, \ + .tags = _tags -#define UBUS_FIELD(_type, _name) UBUS_SIGNATURE(BLOBMSG_TYPE_ ## _type, _name) +#define __UBUS_METHOD(_name, _handler, _policy, _tags) \ + __UBUS_METHOD_NOARG(_name, _handler, _tags), \ + .policy = _policy, \ + .n_policy = ARRAY_SIZE(_policy) -#define UBUS_ARRAY(_name) UBUS_FIELD(ARRAY, _name) -#define UBUS_ARRAY_END() UBUS_SIGNATURE(UBUS_SIGNATURE_END, NULL) +#define UBUS_METHOD(_name, _handler, _policy) \ + { __UBUS_METHOD(_name, _handler, _policy, 0) } -#define UBUS_TABLE_START(_name) UBUS_FIELD(TABLE, _name) -#define UBUS_TABLE_END() UBUS_SIGNATURE(UBUS_SIGNATURE_END, NULL) +#define UBUS_METHOD_TAG(_name, _handler, _policy, _tags)\ + { __UBUS_METHOD(_name, _handler, _policy, _tags) } -#define UBUS_OBJECT_TYPE(_name, _signature) \ +#define UBUS_METHOD_MASK(_name, _handler, _policy, _mask) \ { \ - .name = _name, \ - .id = 0, \ - .n_signature = ARRAY_SIZE(_signature), \ - .signature = _signature \ + __UBUS_METHOD(_name, _handler, _policy, 0),\ + .mask = _mask \ } -struct ubus_signature { - enum blobmsg_type type; +#define UBUS_METHOD_NOARG(_name, _handler) \ + { __UBUS_METHOD_NOARG(_name, _handler, 0) } + +#define UBUS_METHOD_TAG_NOARG(_name, _handler, _tags) \ + { __UBUS_METHOD_NOARG(_name, _handler, _tags) } + +#define UBUS_TAG_STATUS BIT(0) +#define UBUS_TAG_ADMIN BIT(1) +#define UBUS_TAG_PRIVATE BIT(2) + +struct ubus_method { const char *name; + ubus_handler_t handler; + + unsigned long mask; + unsigned long tags; + const struct blobmsg_policy *policy; + int n_policy; }; struct ubus_object_type { const char *name; uint32_t id; - int n_signature; - const struct ubus_signature *signature; -}; -struct ubus_method { - const char *name; - ubus_handler_t handler; + const struct ubus_method *methods; + int n_methods; }; struct ubus_object { @@ -71,25 +125,44 @@ struct ubus_object { const char *path; struct ubus_object_type *type; + ubus_state_handler_t subscribe_cb; + bool has_subscribers; + const struct ubus_method *methods; int n_methods; }; +struct ubus_subscriber { + struct ubus_object obj; + + ubus_handler_t cb; + ubus_remove_handler_t remove_cb; +}; + +struct ubus_event_handler { + struct ubus_object obj; + + ubus_event_handler_t cb; +}; + struct ubus_context { struct list_head requests; struct avl_tree objects; + struct list_head pending; struct uloop_fd sock; + struct uloop_timeout pending_timer; uint32_t local_id; - uint32_t request_seq; + uint16_t request_seq; + int stack_depth; void (*connection_lost)(struct ubus_context *ctx); + void (*monitor_cb)(struct ubus_context *ctx, uint32_t seq, struct blob_attr *data); - struct { - struct ubus_msghdr hdr; - char data[UBUS_MAX_MSGLEN - sizeof(struct ubus_msghdr)]; - } msgbuf; + struct ubus_msghdr_buf msgbuf; + uint32_t msgbuf_data_len; + int msgbuf_reduction_counter; }; struct ubus_object_data { @@ -99,47 +172,98 @@ struct ubus_object_data { struct blob_attr *signature; }; +struct ubus_acl_key { + const char *user; + const char *group; + const char *object; +}; + struct ubus_request_data { uint32_t object; uint32_t peer; - uint32_t seq; + uint16_t seq; + + struct ubus_acl_key acl; + + /* internal use */ + bool deferred; + int fd; }; struct ubus_request { struct list_head list; struct list_head pending; - bool status_msg; int status_code; + bool status_msg; bool blocked; bool cancelled; + bool notify; uint32_t peer; - uint32_t seq; + uint16_t seq; 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; void *priv; }; +struct ubus_notify_request { + struct ubus_request req; + + ubus_notify_complete_handler_t status_cb; + ubus_notify_complete_handler_t complete_cb; + + uint32_t pending; + uint32_t id[UBUS_MAX_NOTIFY_PEERS + 1]; +}; + +struct ubus_auto_conn { + struct ubus_context ctx; + struct uloop_timeout timer; + const char *path; + ubus_connect_handler_t cb; +}; struct ubus_context *ubus_connect(const char *path); +int ubus_connect_ctx(struct ubus_context *ctx, const char *path); +void ubus_auto_connect(struct ubus_auto_conn *conn); +int ubus_reconnect(struct ubus_context *ctx, const char *path); + +/* call this only for struct ubus_context pointers returned by ubus_connect() */ void ubus_free(struct ubus_context *ctx); +/* call this only for struct ubus_context pointers initialised by ubus_connect_ctx() */ +void ubus_shutdown(struct ubus_context *ctx); + +static inline void ubus_auto_shutdown(struct ubus_auto_conn *conn) +{ + uloop_timeout_cancel(&conn->timer); + ubus_shutdown(&conn->ctx); +} + const char *ubus_strerror(int error); static inline void ubus_add_uloop(struct ubus_context *ctx) { - uloop_fd_add(&ctx->sock, ULOOP_EDGE_TRIGGER | ULOOP_BLOCKING | ULOOP_READ); + uloop_fd_add(&ctx->sock, ULOOP_BLOCKING | ULOOP_READ); +} + +/* call this for read events on ctx->sock.fd when not using uloop */ +static inline void ubus_handle_event(struct ubus_context *ctx) +{ + ctx->sock.cb(&ctx->sock, ULOOP_READ); } /* ----------- raw request handling ----------- */ /* wait for a request to complete and return its status */ -int ubus_complete_request(struct ubus_context *ctx, struct ubus_request *req); +int ubus_complete_request(struct ubus_context *ctx, struct ubus_request *req, + int timeout); /* complete a request asynchronously */ void ubus_complete_request_async(struct ubus_context *ctx, @@ -155,23 +279,111 @@ int ubus_lookup(struct ubus_context *ctx, const char *path, int ubus_lookup_id(struct ubus_context *ctx, const char *path, uint32_t *id); +/* make an object visible to remote connections */ +int ubus_add_object(struct ubus_context *ctx, struct ubus_object *obj); + +/* remove the object from the ubus connection */ +int ubus_remove_object(struct ubus_context *ctx, struct ubus_object *obj); + +/* add a subscriber notifications from another object */ +int ubus_register_subscriber(struct ubus_context *ctx, struct ubus_subscriber *obj); + +static inline int +ubus_unregister_subscriber(struct ubus_context *ctx, struct ubus_subscriber *obj) +{ + return ubus_remove_object(ctx, &obj->obj); +} + +int ubus_subscribe(struct ubus_context *ctx, struct ubus_subscriber *obj, uint32_t id); +int ubus_unsubscribe(struct ubus_context *ctx, struct ubus_subscriber *obj, uint32_t id); + +int __ubus_monitor(struct ubus_context *ctx, const char *type); + +static inline int ubus_monitor_start(struct ubus_context *ctx) +{ + return __ubus_monitor(ctx, "add"); +} + +static inline int ubus_monitor_stop(struct ubus_context *ctx) +{ + return __ubus_monitor(ctx, "remove"); +} + + +/* ----------- acl ----------- */ + +struct acl_object { + struct ubus_acl_key key; + struct avl_node avl; + struct blob_attr *acl; +}; + +extern struct avl_tree acl_objects; +int ubus_register_acl(struct ubus_context *ctx); + +#define acl_for_each(o, m) \ + if ((m)->object && (m)->user && (m)->group) \ + avl_for_element_range(avl_find_ge_element(&acl_objects, m, o, avl), avl_find_le_element(&acl_objects, m, o, avl), o, avl) + /* ----------- rpc ----------- */ /* invoke a method on a specific object */ int ubus_invoke(struct ubus_context *ctx, uint32_t obj, const char *method, - struct blob_attr *msg, ubus_data_handler_t cb, void *priv); + struct blob_attr *msg, ubus_data_handler_t cb, void *priv, + int timeout); /* asynchronous version of ubus_invoke() */ -void ubus_invoke_async(struct ubus_context *ctx, uint32_t obj, const char *method, - struct blob_attr *msg, struct ubus_request *req); - -/* make an object visible to remote connections */ -int ubus_publish(struct ubus_context *ctx, struct ubus_object *obj); +int ubus_invoke_async(struct ubus_context *ctx, uint32_t obj, const char *method, + struct blob_attr *msg, struct ubus_request *req); /* send a reply to an incoming object method call */ int ubus_send_reply(struct ubus_context *ctx, struct ubus_request_data *req, struct blob_attr *msg); +static inline void ubus_defer_request(struct ubus_context *ctx, + struct ubus_request_data *req, + struct ubus_request_data *new_req) +{ + (void) ctx; + memcpy(new_req, req, sizeof(*req)); + req->deferred = true; +} + +static inline void ubus_request_set_fd(struct ubus_context *ctx, + struct ubus_request_data *req, int fd) +{ + (void) ctx; + req->fd = fd; +} + +void ubus_complete_deferred_request(struct ubus_context *ctx, + struct ubus_request_data *req, int ret); + +/* + * send a notification to all subscribers of an object + * if timeout < 0, no reply is expected from subscribers + */ +int ubus_notify(struct ubus_context *ctx, struct ubus_object *obj, + const char *type, struct blob_attr *msg, int timeout); + +int ubus_notify_async(struct ubus_context *ctx, struct ubus_object *obj, + const char *type, struct blob_attr *msg, + struct ubus_notify_request *req); + + /* ----------- events ----------- */ -int ubus_register_event_handler(struct ubus_context *ctx, struct ubus_object *obj, + +int ubus_send_event(struct ubus_context *ctx, const char *id, + struct blob_attr *data); + +int ubus_register_event_handler(struct ubus_context *ctx, + struct ubus_event_handler *ev, const char *pattern); + +static inline int ubus_unregister_event_handler(struct ubus_context *ctx, + struct ubus_event_handler *ev) +{ + return ubus_remove_object(ctx, &ev->obj); +} + +#endif