libubus: restore uloop_cancelled on timeout
[project/ubus.git] / examples / client.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 <sys/time.h>
15 #include <unistd.h>
16
17 #include <libubox/ustream.h>
18
19 #include "libubus.h"
20 #include "count.h"
21
22 static struct ubus_context *ctx;
23 static struct blob_buf b;
24
25 static void test_client_subscribe_cb(struct ubus_context *ctx, struct ubus_object *obj)
26 {
27         fprintf(stderr, "Subscribers active: %d\n", obj->has_subscribers);
28 }
29
30 static struct ubus_object test_client_object = {
31         .subscribe_cb = test_client_subscribe_cb,
32 };
33
34 static void test_client_notify_cb(struct uloop_timeout *timeout)
35 {
36         static int counter = 0;
37         int err;
38         struct timeval tv1, tv2;
39         int max = 1000;
40         long delta;
41         int i = 0;
42
43         blob_buf_init(&b, 0);
44         blobmsg_add_u32(&b, "counter", counter++);
45
46         gettimeofday(&tv1, NULL);
47         for (i = 0; i < max; i++)
48                 err = ubus_notify(ctx, &test_client_object, "ping", b.head, 1000);
49         gettimeofday(&tv2, NULL);
50         if (err)
51                 fprintf(stderr, "Notify failed: %s\n", ubus_strerror(err));
52
53         delta = (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
54         fprintf(stderr, "Avg time per iteration: %ld usec\n", delta / max);
55
56         uloop_timeout_set(timeout, 1000);
57 }
58
59 enum {
60         RETURN_CODE,
61         __RETURN_MAX,
62 };
63
64 static const struct blobmsg_policy return_policy[__RETURN_MAX] = {
65         [RETURN_CODE] = { .name = "rc", .type = BLOBMSG_TYPE_INT32 },
66 };
67
68 static void test_count_data_cb(struct ubus_request *req,
69                                     int type, struct blob_attr *msg)
70 {
71         struct blob_attr *tb[__RETURN_MAX];
72         int rc;
73         uint32_t count_to = *(uint32_t *)req->priv;
74
75         blobmsg_parse(return_policy, __RETURN_MAX, tb, blob_data(msg), blob_len(msg));
76
77         if (!tb[RETURN_CODE]) {
78                 fprintf(stderr, "No return code received from server\n");
79                 return;
80         }
81         rc = blobmsg_get_u32(tb[RETURN_CODE]);
82         if (rc)
83                 fprintf(stderr, "Corruption of data with count up to '%u'\n", count_to);
84         else
85                 fprintf(stderr, "Server validated our count up to '%u'\n", count_to);
86 }
87
88 static void test_count(struct uloop_timeout *timeout)
89 {
90         enum {
91                 COUNT_TO_MIN = 10000,
92                 COUNT_TO_MAX = 1000000,
93                 PROGRESSION  = 100,
94         };
95
96         uint32_t id;
97         static uint32_t count_to = 100000;
98         static int count_progression = PROGRESSION;
99         char *s;
100
101         if (count_to <= COUNT_TO_MIN)
102                 count_progression = PROGRESSION;
103         else if (count_to >= COUNT_TO_MAX)
104                 count_progression = -PROGRESSION;
105
106         count_to += count_progression;
107
108         s = count_to_number(count_to);
109         if (!s)
110                 fprintf(stderr, "Could not allocate memory to count up to '%u'\n", count_to);
111
112         fprintf(stderr, "Sending count up to '%u'; string has length '%u'\n",
113                 count_to, (uint32_t)strlen(s));
114         blob_buf_init(&b, 0);
115         blobmsg_add_u32(&b, "to", count_to);
116         blobmsg_add_string(&b, "string", s);
117
118         if (ubus_lookup_id(ctx, "test", &id)) {
119                 fprintf(stderr, "Failed to look up test object\n");
120                 return;
121         }
122
123         ubus_invoke(ctx, id, "count", b.head, test_count_data_cb, &count_to, 5000);
124
125         free(s);
126
127         uloop_timeout_set(timeout, 2000);
128 }
129
130 static struct uloop_timeout notify_timer = {
131         .cb = test_client_notify_cb,
132 };
133
134 static struct uloop_timeout count_timer = {
135         .cb = test_count,
136 };
137
138 static void test_client_fd_data_cb(struct ustream *s, int bytes)
139 {
140         char *data, *sep;
141         int len;
142
143         data = ustream_get_read_buf(s, &len);
144         if (len < 1)
145                 return;
146
147         sep = strchr(data, '\n');
148         if (!sep)
149                 return;
150
151         *sep = 0;
152         fprintf(stderr, "Got line: %s\n", data);
153         ustream_consume(s, sep + 1 - data);
154 }
155
156 static void test_client_fd_cb(struct ubus_request *req, int fd)
157 {
158         static struct ustream_fd test_fd;
159
160         fprintf(stderr, "Got fd from the server, watching...\n");
161
162         test_fd.stream.notify_read = test_client_fd_data_cb;
163         ustream_fd_init(&test_fd, fd);
164 }
165
166 static void test_client_complete_cb(struct ubus_request *req, int ret)
167 {
168         fprintf(stderr, "completed request, ret: %d\n", ret);
169 }
170
171 static void client_main(void)
172 {
173         static struct ubus_request req;
174         uint32_t id;
175         int ret;
176
177         ret = ubus_add_object(ctx, &test_client_object);
178         if (ret) {
179                 fprintf(stderr, "Failed to add_object object: %s\n", ubus_strerror(ret));
180                 return;
181         }
182
183         if (ubus_lookup_id(ctx, "test", &id)) {
184                 fprintf(stderr, "Failed to look up test object\n");
185                 return;
186         }
187
188         blob_buf_init(&b, 0);
189         blobmsg_add_u32(&b, "id", test_client_object.id);
190         ubus_invoke(ctx, id, "watch", b.head, NULL, 0, 3000);
191         test_client_notify_cb(&notify_timer);
192
193         blob_buf_init(&b, 0);
194         blobmsg_add_string(&b, "msg", "blah");
195         ubus_invoke_async(ctx, id, "hello", b.head, &req);
196         req.fd_cb = test_client_fd_cb;
197         req.complete_cb = test_client_complete_cb;
198         ubus_complete_request_async(ctx, &req);
199
200         uloop_timeout_set(&count_timer, 2000);
201
202         uloop_run();
203 }
204
205 int main(int argc, char **argv)
206 {
207         const char *ubus_socket = NULL;
208         int ch;
209
210         while ((ch = getopt(argc, argv, "cs:")) != -1) {
211                 switch (ch) {
212                 case 's':
213                         ubus_socket = optarg;
214                         break;
215                 default:
216                         break;
217                 }
218         }
219
220         argc -= optind;
221         argv += optind;
222
223         uloop_init();
224
225         ctx = ubus_connect(ubus_socket);
226         if (!ctx) {
227                 fprintf(stderr, "Failed to connect to ubus\n");
228                 return -1;
229         }
230
231         ubus_add_uloop(ctx);
232
233         client_main();
234
235         ubus_free(ctx);
236         uloop_done();
237
238         return 0;
239 }