X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fubus.git;a=blobdiff_plain;f=examples%2Fserver.c;h=e0cde0bf3a8660941d34d0dcc29253f7fa0ad91e;hp=97789d5b6b203321248cf7e859e1fc04376466e0;hb=619f3a160de4f417226b69039538882787b3811c;hpb=fc913a077d84ab0d23414a7124c7a127cb526122 diff --git a/examples/server.c b/examples/server.c index 97789d5..e0cde0b 100644 --- a/examples/server.c +++ b/examples/server.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 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 @@ -12,11 +12,14 @@ */ #include +#include +#include #include "libubus.h" +#include "count.h" static struct ubus_context *ctx; -static struct ubus_watch_object test_event; +static struct ubus_subscriber test_event; static struct blob_buf b; enum { @@ -33,18 +36,46 @@ static const struct blobmsg_policy hello_policy[] = { struct hello_request { struct ubus_request_data req; struct uloop_timeout timeout; + int fd; + int idx; char data[]; }; +static void test_hello_fd_reply(struct uloop_timeout *t) +{ + struct hello_request *req = container_of(t, struct hello_request, timeout); + char *data; + + data = alloca(strlen(req->data) + 32); + sprintf(data, "msg%d: %s\n", ++req->idx, req->data); + if (write(req->fd, data, strlen(data)) < 0) { + close(req->fd); + free(req); + return; + } + + uloop_timeout_set(&req->timeout, 1000); +} + static void test_hello_reply(struct uloop_timeout *t) { struct hello_request *req = container_of(t, struct hello_request, timeout); + int fds[2]; blob_buf_init(&b, 0); blobmsg_add_string(&b, "message", req->data); ubus_send_reply(ctx, &req->req, b.head); + + if (pipe(fds) == -1) { + fprintf(stderr, "Failed to create pipe\n"); + return; + } + ubus_request_set_fd(ctx, &req->req, fds[0]); ubus_complete_deferred_request(ctx, &req->req, 0); - free(req); + req->fd = fds[1]; + + req->timeout.cb = test_hello_fd_reply; + test_hello_fd_reply(t); } static int test_hello(struct ubus_context *ctx, struct ubus_object *obj, @@ -62,6 +93,9 @@ static int test_hello(struct ubus_context *ctx, struct ubus_object *obj, msgstr = blobmsg_data(tb[HELLO_MSG]); hreq = calloc(1, sizeof(*hreq) + strlen(format) + strlen(obj->name) + strlen(msgstr) + 1); + if (!hreq) + return UBUS_STATUS_UNKNOWN_ERROR; + sprintf(hreq->data, format, obj->name, msgstr); ubus_defer_request(ctx, req, &hreq->req); hreq->timeout.cb = test_hello_reply; @@ -72,19 +106,38 @@ static int test_hello(struct ubus_context *ctx, struct ubus_object *obj, enum { WATCH_ID, + WATCH_COUNTER, __WATCH_MAX }; static const struct blobmsg_policy watch_policy[__WATCH_MAX] = { [WATCH_ID] = { .name = "id", .type = BLOBMSG_TYPE_INT32 }, + [WATCH_COUNTER] = { .name = "counter", .type = BLOBMSG_TYPE_INT32 }, }; -static void test_handle_event(struct ubus_context *ctx, struct ubus_watch_object *w, - uint32_t id) +static void +test_handle_remove(struct ubus_context *ctx, struct ubus_subscriber *s, + uint32_t id) { fprintf(stderr, "Object %08x went away\n", id); } +static int +test_notify(struct ubus_context *ctx, struct ubus_object *obj, + struct ubus_request_data *req, const char *method, + struct blob_attr *msg) +{ +#if 0 + char *str; + + str = blobmsg_format_json(msg, true); + fprintf(stderr, "Received notification '%s': %s\n", method, str); + free(str); +#endif + + return 0; +} + static int test_watch(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) @@ -96,15 +149,55 @@ static int test_watch(struct ubus_context *ctx, struct ubus_object *obj, if (!tb[WATCH_ID]) return UBUS_STATUS_INVALID_ARGUMENT; - test_event.cb = test_handle_event; - ret = ubus_watch_object_add(ctx, &test_event, blobmsg_get_u32(tb[WATCH_ID])); + test_event.remove_cb = test_handle_remove; + test_event.cb = test_notify; + ret = ubus_subscribe(ctx, &test_event, blobmsg_get_u32(tb[WATCH_ID])); fprintf(stderr, "Watching object %08x: %s\n", blobmsg_get_u32(tb[WATCH_ID]), ubus_strerror(ret)); return ret; } +enum { + COUNT_TO, + COUNT_STRING, + __COUNT_MAX +}; + +static const struct blobmsg_policy count_policy[__COUNT_MAX] = { + [COUNT_TO] = { .name = "to", .type = BLOBMSG_TYPE_INT32 }, + [COUNT_STRING] = { .name = "string", .type = BLOBMSG_TYPE_STRING }, +}; + +static int test_count(struct ubus_context *ctx, struct ubus_object *obj, + struct ubus_request_data *req, const char *method, + struct blob_attr *msg) +{ + struct blob_attr *tb[__COUNT_MAX]; + char *s1, *s2; + uint32_t num; + + blobmsg_parse(count_policy, __COUNT_MAX, tb, blob_data(msg), blob_len(msg)); + if (!tb[COUNT_TO] || !tb[COUNT_STRING]) + return UBUS_STATUS_INVALID_ARGUMENT; + + num = blobmsg_get_u32(tb[COUNT_TO]); + s1 = blobmsg_get_string(tb[COUNT_STRING]); + s2 = count_to_number(num); + if (!s1 || !s2) { + free(s2); + return UBUS_STATUS_UNKNOWN_ERROR; + } + blob_buf_init(&b, 0); + blobmsg_add_u32(&b, "rc", strcmp(s1, s2)); + ubus_send_reply(ctx, req, b.head); + free(s2); + + return 0; +} + static const struct ubus_method test_methods[] = { UBUS_METHOD("hello", test_hello, hello_policy), UBUS_METHOD("watch", test_watch, watch_policy), + UBUS_METHOD("count", test_count, count_policy), }; static struct ubus_object_type test_object_type = @@ -125,7 +218,7 @@ static void server_main(void) if (ret) fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret)); - ret = ubus_register_watch_object(ctx, &test_event); + ret = ubus_register_subscriber(ctx, &test_event); if (ret) fprintf(stderr, "Failed to add watch handler: %s\n", ubus_strerror(ret)); @@ -151,6 +244,7 @@ int main(int argc, char **argv) argv += optind; uloop_init(); + signal(SIGPIPE, SIG_IGN); ctx = ubus_connect(ubus_socket); if (!ctx) {