X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fubus.git;a=blobdiff_plain;f=libubus.c;h=260e40f2f44b216947cf278ca4d0ad4bbec30a61;hp=67363ad57f42b1acc386c710cdd3541e564b02ff;hb=9c13096b169759eabf4c528df22d605e2d6093f4;hpb=7c140855d965598f2907454740c7a051dbee0176 diff --git a/libubus.c b/libubus.c index 67363ad..260e40f 100644 --- a/libubus.c +++ b/libubus.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011-2012 Felix Fietkau + * 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 @@ -40,7 +40,7 @@ struct blob_buf b __hidden = {}; struct ubus_pending_msg { struct list_head list; - struct ubus_msghdr hdr; + struct ubus_msghdr_buf hdr; }; static int ubus_cmp_id(const void *k1, const void *k2, void *ptr) @@ -71,52 +71,57 @@ 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(1, sizeof(*pending) + blob_raw_len(hdr->data)); - if (!pending) - return; + pending = calloc_a(sizeof(*pending), &data, blob_raw_len(buf->data)); - memcpy(&pending->hdr, hdr, sizeof(*hdr) + blob_raw_len(hdr->data)); - list_add(&pending->list, &ctx->pending); + pending->hdr.data = data; + 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) +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); + ubus_process_req_msg(ctx, buf, fd); break; case UBUS_MSG_INVOKE: case UBUS_MSG_UNSUBSCRIBE: case UBUS_MSG_NOTIFY: - if (ctx->stack_depth > 2) { - ubus_queue_msg(ctx, hdr); + if (ctx->stack_depth) { + ubus_queue_msg(ctx, buf); break; } - ubus_process_obj_msg(ctx, hdr); + ubus_process_obj_msg(ctx, buf, fd); + break; + case UBUS_MSG_MONITOR: + if (ctx->monitor_cb) + ctx->monitor_cb(ctx, buf->hdr.seq, buf->data); break; } } -void __hidden ubus_process_pending_msg(struct ubus_context *ctx) +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 (!list_empty(&ctx->pending)) { + while (!ctx->stack_depth && !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; } } @@ -128,7 +133,7 @@ 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); @@ -138,7 +143,6 @@ static void ubus_lookup_cb(struct ubus_request *ureq, int type, struct blob_attr !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]); @@ -215,7 +219,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) { @@ -231,14 +235,16 @@ 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) blobmsg_add_string(&b2, "pattern", pattern); - return ubus_invoke(ctx, UBUS_SYSTEM_OBJECT_EVENT, "register", b2.head, + ret = ubus_invoke(ctx, UBUS_SYSTEM_OBJECT_EVENT, "register", b2.head, NULL, NULL, 0); + blob_buf_free(&b2); + + return ret; } int ubus_send_event(struct ubus_context *ctx, const char *id, @@ -267,22 +273,81 @@ static void ubus_default_connection_lost(struct ubus_context *ctx) uloop_end(); } -struct ubus_context *ubus_connect(const char *path) +int ubus_connect_ctx(struct ubus_context *ctx, const char *path) { - struct ubus_context *ctx; - - ctx = calloc(1, sizeof(*ctx)); - if (!ctx) - return NULL; + 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)); + if (!ctx->msgbuf.data) + return -1; + ctx->msgbuf_data_len = UBUS_MSG_CHUNK_SIZE; INIT_LIST_HEAD(&ctx->requests); INIT_LIST_HEAD(&ctx->pending); avl_init(&ctx->objects, ubus_cmp_id, false, NULL); if (ubus_reconnect(ctx, path)) { + free(ctx->msgbuf.data); + ctx->msgbuf.data = NULL; + return -1; + } + + return 0; +} + +static void ubus_auto_reconnect_cb(struct uloop_timeout *timeout) +{ + struct ubus_auto_conn *conn = container_of(timeout, struct ubus_auto_conn, timer); + + if (!ubus_reconnect(&conn->ctx, conn->path)) + ubus_add_uloop(&conn->ctx); + else + uloop_timeout_set(timeout, 1000); +} + +static void ubus_auto_disconnect_cb(struct ubus_context *ctx) +{ + struct ubus_auto_conn *conn = container_of(ctx, struct ubus_auto_conn, ctx); + + conn->timer.cb = ubus_auto_reconnect_cb; + uloop_timeout_set(&conn->timer, 1000); +} + +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_ctx(&conn->ctx, conn->path)) { + uloop_timeout_set(timeout, 1000); + fprintf(stderr, "failed to connect to ubus\n"); + return; + } + conn->ctx.connection_lost = ubus_auto_disconnect_cb; + if (conn->cb) + conn->cb(&conn->ctx); + ubus_add_uloop(&conn->ctx); +} + +void ubus_auto_connect(struct ubus_auto_conn *conn) +{ + conn->timer.cb = ubus_auto_connect_cb; + ubus_auto_connect_cb(&conn->timer); +} + +struct ubus_context *ubus_connect(const char *path) +{ + struct ubus_context *ctx; + + ctx = calloc(1, sizeof(*ctx)); + if (!ctx) + return NULL; + + if (ubus_connect_ctx(ctx, path)) { free(ctx); ctx = NULL; } @@ -290,9 +355,18 @@ 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; 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); }