X-Git-Url: http://git.openwrt.org/?p=project%2Fubus.git;a=blobdiff_plain;f=libubus.c;h=9463522488c11782dc9c15c79f1932b37e1149c1;hp=35c61ef991263e497a638b36f1484649f0417994;hb=HEAD;hpb=7c25c119a58e66a6dded43262b73df71df4da505 diff --git a/libubus.c b/libubus.c index 35c61ef..c9c3c6e 100644 --- a/libubus.c +++ b/libubus.c @@ -34,6 +34,9 @@ const char *__ubus_strerror[__UBUS_STATUS_LAST] = { [UBUS_STATUS_NOT_SUPPORTED] = "Operation not supported", [UBUS_STATUS_UNKNOWN_ERROR] = "Unknown error", [UBUS_STATUS_CONNECTION_FAILED] = "Connection failed", + [UBUS_STATUS_NO_MEMORY] = "Out of memory", + [UBUS_STATUS_PARSE_ERROR] = "Parsing message data failed", + [UBUS_STATUS_SYSTEM_ERROR] = "System error", }; struct blob_buf b __hidden = {}; @@ -71,41 +74,45 @@ out: } static void -ubus_queue_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr) +ubus_queue_msg(struct ubus_context *ctx, struct ubus_msghdr_buf *buf) { struct ubus_pending_msg *pending; void *data; - pending = calloc_a(sizeof(*pending), - &data, blob_raw_len(ubus_msghdr_data(hdr))); + pending = calloc_a(sizeof(*pending), &data, blob_raw_len(buf->data)); pending->hdr.data = data; - memcpy(&pending->hdr.hdr, hdr, sizeof(*hdr)); - memcpy(data, ubus_msghdr_data(hdr), blob_raw_len(ubus_msghdr_data(hdr))); - list_add(&pending->list, &ctx->pending); + memcpy(&pending->hdr.hdr, &buf->hdr, sizeof(buf->hdr)); + memcpy(data, buf->data, blob_raw_len(buf->data)); + list_add_tail(&pending->list, &ctx->pending); if (ctx->sock.registered) uloop_timeout_set(&ctx->pending_timer, 1); } void __hidden -ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr, int fd) +ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr_buf *buf, int fd) { - - switch(hdr->type) { + switch(buf->hdr.type) { case UBUS_MSG_STATUS: case UBUS_MSG_DATA: - ubus_process_req_msg(ctx, hdr, fd); + ubus_process_req_msg(ctx, buf, fd); break; case UBUS_MSG_INVOKE: case UBUS_MSG_UNSUBSCRIBE: case UBUS_MSG_NOTIFY: if (ctx->stack_depth) { - ubus_queue_msg(ctx, hdr); + ubus_queue_msg(ctx, buf); break; } - ubus_process_obj_msg(ctx, hdr); + ctx->stack_depth++; + ubus_process_obj_msg(ctx, buf, fd); + ctx->stack_depth--; + break; + case UBUS_MSG_MONITOR: + if (ctx->monitor_cb) + ctx->monitor_cb(ctx, buf->hdr.seq, buf->data); break; } } @@ -115,10 +122,13 @@ static void ubus_process_pending_msg(struct uloop_timeout *timeout) struct ubus_context *ctx = container_of(timeout, struct ubus_context, pending_timer); struct ubus_pending_msg *pending; - while (!ctx->stack_depth && !list_empty(&ctx->pending)) { + while (!list_empty(&ctx->pending)) { + if (ctx->stack_depth) + break; + pending = list_first_entry(&ctx->pending, struct ubus_pending_msg, list); list_del(&pending->list); - ubus_process_msg(ctx, &pending->hdr.hdr, -1); + ubus_process_msg(ctx, &pending->hdr, -1); free(pending); } } @@ -131,17 +141,16 @@ struct ubus_lookup_request { static void ubus_lookup_cb(struct ubus_request *ureq, int type, struct blob_attr *msg) { struct ubus_lookup_request *req; - struct ubus_object_data obj; + struct ubus_object_data obj = {}; struct blob_attr **attr; req = container_of(ureq, struct ubus_lookup_request, req); - attr = ubus_parse_msg(msg); + attr = ubus_parse_msg(msg, blob_raw_len(msg)); if (!attr[UBUS_ATTR_OBJID] || !attr[UBUS_ATTR_OBJPATH] || !attr[UBUS_ATTR_OBJTYPE]) return; - memset(&obj, 0, sizeof(obj)); obj.id = blob_get_u32(attr[UBUS_ATTR_OBJID]); obj.path = blob_data(attr[UBUS_ATTR_OBJPATH]); obj.type_id = blob_get_u32(attr[UBUS_ATTR_OBJTYPE]); @@ -172,7 +181,7 @@ static void ubus_lookup_id_cb(struct ubus_request *req, int type, struct blob_at struct blob_attr **attr; uint32_t *id = req->priv; - attr = ubus_parse_msg(msg); + attr = ubus_parse_msg(msg, blob_raw_len(msg)); if (!attr[UBUS_ATTR_OBJID]) return; @@ -218,7 +227,7 @@ int ubus_register_event_handler(struct ubus_context *ctx, const char *pattern) { struct ubus_object *obj = &ev->obj; - struct blob_buf b2; + struct blob_buf b2 = {}; int ret; if (!obj->id) { @@ -234,7 +243,6 @@ int ubus_register_event_handler(struct ubus_context *ctx, } /* use a second buffer, ubus_invoke() overwrites the primary one */ - memset(&b2, 0, sizeof(b2)); blob_buf_init(&b2, 0); blobmsg_add_u32(&b2, "object", obj->id); if (pattern) @@ -273,23 +281,28 @@ static void ubus_default_connection_lost(struct ubus_context *ctx) uloop_end(); } -static int _ubus_connect(struct ubus_context *ctx, const char *path) +int ubus_connect_ctx(struct ubus_context *ctx, const char *path) { + uloop_init(); + memset(ctx, 0, sizeof(*ctx)); + ctx->sock.fd = -1; ctx->sock.cb = ubus_handle_data; ctx->connection_lost = ubus_default_connection_lost; ctx->pending_timer.cb = ubus_process_pending_msg; - ctx->msgbuf.data = calloc(UBUS_MSG_CHUNK_SIZE, sizeof(char)); + ctx->msgbuf.data = calloc(1, UBUS_MSG_CHUNK_SIZE); if (!ctx->msgbuf.data) return -1; ctx->msgbuf_data_len = UBUS_MSG_CHUNK_SIZE; INIT_LIST_HEAD(&ctx->requests); INIT_LIST_HEAD(&ctx->pending); + INIT_LIST_HEAD(&ctx->auto_subscribers); avl_init(&ctx->objects, ubus_cmp_id, false, NULL); if (ubus_reconnect(ctx, path)) { free(ctx->msgbuf.data); + ctx->msgbuf.data = NULL; return -1; } @@ -318,7 +331,7 @@ static void ubus_auto_connect_cb(struct uloop_timeout *timeout) { struct ubus_auto_conn *conn = container_of(timeout, struct ubus_auto_conn, timer); - if (_ubus_connect(&conn->ctx, conn->path)) { + if (ubus_connect_ctx(&conn->ctx, conn->path)) { uloop_timeout_set(timeout, 1000); fprintf(stderr, "failed to connect to ubus\n"); return; @@ -343,7 +356,7 @@ struct ubus_context *ubus_connect(const char *path) if (!ctx) return NULL; - if (_ubus_connect(ctx, path)) { + if (ubus_connect_ctx(ctx, path)) { free(ctx); ctx = NULL; } @@ -351,10 +364,19 @@ struct ubus_context *ubus_connect(const char *path) return ctx; } -void ubus_free(struct ubus_context *ctx) +void ubus_shutdown(struct ubus_context *ctx) { blob_buf_free(&b); + if (!ctx) + return; + uloop_fd_delete(&ctx->sock); close(ctx->sock.fd); + uloop_timeout_cancel(&ctx->pending_timer); free(ctx->msgbuf.data); +} + +void ubus_free(struct ubus_context *ctx) +{ + ubus_shutdown(ctx); free(ctx); }