libubus: fix data type of request sequence counter. fixes hang after ~64K requests
[project/ubus.git] / examples / server.c
1 /*
2  * Copyright (C) 2011 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
16 #include <libubox/blobmsg_json.h>
17 #include "libubus.h"
18
19 static struct ubus_context *ctx;
20 static struct ubus_subscriber test_event;
21 static struct blob_buf b;
22
23 enum {
24         HELLO_ID,
25         HELLO_MSG,
26         __HELLO_MAX
27 };
28
29 static const struct blobmsg_policy hello_policy[] = {
30         [HELLO_ID] = { .name = "id", .type = BLOBMSG_TYPE_INT32 },
31         [HELLO_MSG] = { .name = "msg", .type = BLOBMSG_TYPE_STRING },
32 };
33
34 struct hello_request {
35         struct ubus_request_data req;
36         struct uloop_timeout timeout;
37         char data[];
38 };
39
40 static void test_hello_reply(struct uloop_timeout *t)
41 {
42         struct hello_request *req = container_of(t, struct hello_request, timeout);
43
44         blob_buf_init(&b, 0);
45         blobmsg_add_string(&b, "message", req->data);
46         ubus_send_reply(ctx, &req->req, b.head);
47         ubus_complete_deferred_request(ctx, &req->req, 0);
48         free(req);
49 }
50
51 static int test_hello(struct ubus_context *ctx, struct ubus_object *obj,
52                       struct ubus_request_data *req, const char *method,
53                       struct blob_attr *msg)
54 {
55         struct hello_request *hreq;
56         struct blob_attr *tb[__HELLO_MAX];
57         const char *format = "%s received a message: %s";
58         const char *msgstr = "(unknown)";
59
60         blobmsg_parse(hello_policy, ARRAY_SIZE(hello_policy), tb, blob_data(msg), blob_len(msg));
61
62         if (tb[HELLO_MSG])
63                 msgstr = blobmsg_data(tb[HELLO_MSG]);
64
65         hreq = calloc(1, sizeof(*hreq) + strlen(format) + strlen(obj->name) + strlen(msgstr) + 1);
66         sprintf(hreq->data, format, obj->name, msgstr);
67         ubus_defer_request(ctx, req, &hreq->req);
68         hreq->timeout.cb = test_hello_reply;
69         uloop_timeout_set(&hreq->timeout, 1000);
70
71         return 0;
72 }
73
74 enum {
75         WATCH_ID,
76         WATCH_COUNTER,
77         __WATCH_MAX
78 };
79
80 static const struct blobmsg_policy watch_policy[__WATCH_MAX] = {
81         [WATCH_ID] = { .name = "id", .type = BLOBMSG_TYPE_INT32 },
82         [WATCH_COUNTER] = { .name = "counter", .type = BLOBMSG_TYPE_INT32 },
83 };
84
85 static void
86 test_handle_remove(struct ubus_context *ctx, struct ubus_subscriber *s,
87                    uint32_t id)
88 {
89         fprintf(stderr, "Object %08x went away\n", id);
90 }
91
92 static int
93 test_notify(struct ubus_context *ctx, struct ubus_object *obj,
94             struct ubus_request_data *req, const char *method,
95             struct blob_attr *msg)
96 {
97         char *str;
98
99         str = blobmsg_format_json(msg, true);
100         fprintf(stderr, "Received notification '%s': %s\n", method, str);
101         free(str);
102
103         return 0;
104 }
105
106 static int test_watch(struct ubus_context *ctx, struct ubus_object *obj,
107                       struct ubus_request_data *req, const char *method,
108                       struct blob_attr *msg)
109 {
110         struct blob_attr *tb[__WATCH_MAX];
111         int ret;
112
113         blobmsg_parse(watch_policy, __WATCH_MAX, tb, blob_data(msg), blob_len(msg));
114         if (!tb[WATCH_ID])
115                 return UBUS_STATUS_INVALID_ARGUMENT;
116
117         test_event.remove_cb = test_handle_remove;
118         test_event.cb = test_notify;
119         ret = ubus_subscribe(ctx, &test_event, blobmsg_get_u32(tb[WATCH_ID]));
120         fprintf(stderr, "Watching object %08x: %s\n", blobmsg_get_u32(tb[WATCH_ID]), ubus_strerror(ret));
121         return ret;
122 }
123
124 static const struct ubus_method test_methods[] = {
125         UBUS_METHOD("hello", test_hello, hello_policy),
126         UBUS_METHOD("watch", test_watch, watch_policy),
127 };
128
129 static struct ubus_object_type test_object_type =
130         UBUS_OBJECT_TYPE("test", test_methods);
131
132 static struct ubus_object test_object = {
133         .name = "test",
134         .type = &test_object_type,
135         .methods = test_methods,
136         .n_methods = ARRAY_SIZE(test_methods),
137 };
138
139 static void server_main(void)
140 {
141         int ret;
142
143         ret = ubus_add_object(ctx, &test_object);
144         if (ret)
145                 fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
146
147         ret = ubus_register_subscriber(ctx, &test_event);
148         if (ret)
149                 fprintf(stderr, "Failed to add watch handler: %s\n", ubus_strerror(ret));
150
151         uloop_run();
152 }
153
154 int main(int argc, char **argv)
155 {
156         const char *ubus_socket = NULL;
157         int ch;
158
159         while ((ch = getopt(argc, argv, "cs:")) != -1) {
160                 switch (ch) {
161                 case 's':
162                         ubus_socket = optarg;
163                         break;
164                 default:
165                         break;
166                 }
167         }
168
169         argc -= optind;
170         argv += optind;
171
172         uloop_init();
173
174         ctx = ubus_connect(ubus_socket);
175         if (!ctx) {
176                 fprintf(stderr, "Failed to connect to ubus\n");
177                 return -1;
178         }
179
180         ubus_add_uloop(ctx);
181
182         server_main();
183
184         ubus_free(ctx);
185         uloop_done();
186
187         return 0;
188 }