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 }