libubus: do not register/unregister with uloop during sync requests
[project/ubus.git] / examples / server.c
1 /*
2  * Copyright (C) 2011-2014 Felix Fietkau <nbd@openwrt.org>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License version 2.1
6  * as published by the Free Software Foundation
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  */
13
14 #include <unistd.h>
15 #include <signal.h>
16
17 #include <libubox/blobmsg_json.h>
18 #include "libubus.h"
19 #include "count.h"
20
21 static struct ubus_context *ctx;
22 static struct ubus_subscriber test_event;
23 static struct blob_buf b;
24
25 enum {
26         HELLO_ID,
27         HELLO_MSG,
28         __HELLO_MAX
29 };
30
31 static const struct blobmsg_policy hello_policy[] = {
32         [HELLO_ID] = { .name = "id", .type = BLOBMSG_TYPE_INT32 },
33         [HELLO_MSG] = { .name = "msg", .type = BLOBMSG_TYPE_STRING },
34 };
35
36 struct hello_request {
37         struct ubus_request_data req;
38         struct uloop_timeout timeout;
39         int fd;
40         int idx;
41         char data[];
42 };
43
44 static void test_hello_fd_reply(struct uloop_timeout *t)
45 {
46         struct hello_request *req = container_of(t, struct hello_request, timeout);
47         char *data;
48
49         data = alloca(strlen(req->data) + 32);
50         sprintf(data, "msg%d: %s\n", ++req->idx, req->data);
51         if (write(req->fd, data, strlen(data)) < 0) {
52                 close(req->fd);
53                 free(req);
54                 return;
55         }
56
57         uloop_timeout_set(&req->timeout, 1000);
58 }
59
60 static void test_hello_reply(struct uloop_timeout *t)
61 {
62         struct hello_request *req = container_of(t, struct hello_request, timeout);
63         int fds[2];
64
65         blob_buf_init(&b, 0);
66         blobmsg_add_string(&b, "message", req->data);
67         ubus_send_reply(ctx, &req->req, b.head);
68
69         if (pipe(fds) == -1) {
70                 fprintf(stderr, "Failed to create pipe\n");
71                 return;
72         }
73         ubus_request_set_fd(ctx, &req->req, fds[0]);
74         ubus_complete_deferred_request(ctx, &req->req, 0);
75         req->fd = fds[1];
76
77         req->timeout.cb = test_hello_fd_reply;
78         test_hello_fd_reply(t);
79 }
80
81 static int test_hello(struct ubus_context *ctx, struct ubus_object *obj,
82                       struct ubus_request_data *req, const char *method,
83                       struct blob_attr *msg)
84 {
85         struct hello_request *hreq;
86         struct blob_attr *tb[__HELLO_MAX];
87         const char *format = "%s received a message: %s";
88         const char *msgstr = "(unknown)";
89
90         blobmsg_parse(hello_policy, ARRAY_SIZE(hello_policy), tb, blob_data(msg), blob_len(msg));
91
92         if (tb[HELLO_MSG])
93                 msgstr = blobmsg_data(tb[HELLO_MSG]);
94
95         hreq = calloc(1, sizeof(*hreq) + strlen(format) + strlen(obj->name) + strlen(msgstr) + 1);
96         if (!hreq)
97                 return UBUS_STATUS_UNKNOWN_ERROR;
98
99         sprintf(hreq->data, format, obj->name, msgstr);
100         ubus_defer_request(ctx, req, &hreq->req);
101         hreq->timeout.cb = test_hello_reply;
102         uloop_timeout_set(&hreq->timeout, 1000);
103
104         return 0;
105 }
106
107 enum {
108         WATCH_ID,
109         WATCH_COUNTER,
110         __WATCH_MAX
111 };
112
113 static const struct blobmsg_policy watch_policy[__WATCH_MAX] = {
114         [WATCH_ID] = { .name = "id", .type = BLOBMSG_TYPE_INT32 },
115         [WATCH_COUNTER] = { .name = "counter", .type = BLOBMSG_TYPE_INT32 },
116 };
117
118 static void
119 test_handle_remove(struct ubus_context *ctx, struct ubus_subscriber *s,
120                    uint32_t id)
121 {
122         fprintf(stderr, "Object %08x went away\n", id);
123 }
124
125 static int
126 test_notify(struct ubus_context *ctx, struct ubus_object *obj,
127             struct ubus_request_data *req, const char *method,
128             struct blob_attr *msg)
129 {
130 #if 0
131         char *str;
132
133         str = blobmsg_format_json(msg, true);
134         fprintf(stderr, "Received notification '%s': %s\n", method, str);
135         free(str);
136 #endif
137
138         return 0;
139 }
140
141 static int test_watch(struct ubus_context *ctx, struct ubus_object *obj,
142                       struct ubus_request_data *req, const char *method,
143                       struct blob_attr *msg)
144 {
145         struct blob_attr *tb[__WATCH_MAX];
146         int ret;
147
148         blobmsg_parse(watch_policy, __WATCH_MAX, tb, blob_data(msg), blob_len(msg));
149         if (!tb[WATCH_ID])
150                 return UBUS_STATUS_INVALID_ARGUMENT;
151
152         test_event.remove_cb = test_handle_remove;
153         test_event.cb = test_notify;
154         ret = ubus_subscribe(ctx, &test_event, blobmsg_get_u32(tb[WATCH_ID]));
155         fprintf(stderr, "Watching object %08x: %s\n", blobmsg_get_u32(tb[WATCH_ID]), ubus_strerror(ret));
156         return ret;
157 }
158
159 enum {
160     COUNT_TO,
161     COUNT_STRING,
162     __COUNT_MAX
163 };
164
165 static const struct blobmsg_policy count_policy[__COUNT_MAX] = {
166     [COUNT_TO] = { .name = "to", .type = BLOBMSG_TYPE_INT32 },
167     [COUNT_STRING] = { .name = "string", .type = BLOBMSG_TYPE_STRING },
168 };
169
170 static int test_count(struct ubus_context *ctx, struct ubus_object *obj,
171                       struct ubus_request_data *req, const char *method,
172                       struct blob_attr *msg)
173 {
174         struct blob_attr *tb[__COUNT_MAX];
175         char *s1, *s2;
176         uint32_t num;
177
178         blobmsg_parse(count_policy, __COUNT_MAX, tb, blob_data(msg), blob_len(msg));
179         if (!tb[COUNT_TO] || !tb[COUNT_STRING])
180                 return UBUS_STATUS_INVALID_ARGUMENT;
181
182         num = blobmsg_get_u32(tb[COUNT_TO]);
183         s1 = blobmsg_get_string(tb[COUNT_STRING]);
184         s2 = count_to_number(num);
185         if (!s1 || !s2) {
186                 free(s2);
187                 return UBUS_STATUS_UNKNOWN_ERROR;
188         }
189         blob_buf_init(&b, 0);
190         blobmsg_add_u32(&b, "rc", strcmp(s1, s2));
191         ubus_send_reply(ctx, req, b.head);
192         free(s2);
193
194         return 0;
195 }
196
197 static const struct ubus_method test_methods[] = {
198         UBUS_METHOD("hello", test_hello, hello_policy),
199         UBUS_METHOD("watch", test_watch, watch_policy),
200         UBUS_METHOD("count", test_count, count_policy),
201 };
202
203 static struct ubus_object_type test_object_type =
204         UBUS_OBJECT_TYPE("test", test_methods);
205
206 static struct ubus_object test_object = {
207         .name = "test",
208         .type = &test_object_type,
209         .methods = test_methods,
210         .n_methods = ARRAY_SIZE(test_methods),
211 };
212
213 static void server_main(void)
214 {
215         int ret;
216
217         ret = ubus_add_object(ctx, &test_object);
218         if (ret)
219                 fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
220
221         ret = ubus_register_subscriber(ctx, &test_event);
222         if (ret)
223                 fprintf(stderr, "Failed to add watch handler: %s\n", ubus_strerror(ret));
224
225         uloop_run();
226 }
227
228 int main(int argc, char **argv)
229 {
230         const char *ubus_socket = NULL;
231         int ch;
232
233         while ((ch = getopt(argc, argv, "cs:")) != -1) {
234                 switch (ch) {
235                 case 's':
236                         ubus_socket = optarg;
237                         break;
238                 default:
239                         break;
240                 }
241         }
242
243         argc -= optind;
244         argv += optind;
245
246         uloop_init();
247         signal(SIGPIPE, SIG_IGN);
248
249         ctx = ubus_connect(ubus_socket);
250         if (!ctx) {
251                 fprintf(stderr, "Failed to connect to ubus\n");
252                 return -1;
253         }
254
255         ubus_add_uloop(ctx);
256
257         server_main();
258
259         ubus_free(ctx);
260         uloop_done();
261
262         return 0;
263 }