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                 return;
 112         }
 113
 114         fprintf(stderr, "Sending count up to '%u'; string has length '%u'\n",
 115                 count_to, (uint32_t)strlen(s));
 116         blob_buf_init(&b, 0);
 117         blobmsg_add_u32(&b, "to", count_to);
 118         blobmsg_add_string(&b, "string", s);
 119
 120         if (ubus_lookup_id(ctx, "test", &id)) {
 121                 fprintf(stderr, "Failed to look up test object\n");
 122                 return;
 123         }
 124
 125         ubus_invoke(ctx, id, "count", b.head, test_count_data_cb, &count_to, 5000);
 126
 127         free(s);
 128
 129         uloop_timeout_set(timeout, 2000);
 130 }
 131
 132 static struct uloop_timeout notify_timer = {
 133         .cb = test_client_notify_cb,
 134 };
 135
 136 static struct uloop_timeout count_timer = {
 137         .cb = test_count,
 138 };
 139
 140 static void test_client_fd_data_cb(struct ustream *s, int bytes)
 141 {
 142         char *data, *sep;
 143         int len;
 144
 145         data = ustream_get_read_buf(s, &len);
 146         if (len < 1)
 147                 return;
 148
 149         sep = strchr(data, '\n');
 150         if (!sep)
 151                 return;
 152
 153         *sep = 0;
 154         fprintf(stderr, "Got line: %s\n", data);
 155         ustream_consume(s, sep + 1 - data);
 156 }
 157
 158 static void test_client_fd_cb(struct ubus_request *req, int fd)
 159 {
 160         static struct ustream_fd test_fd;
 161
 162         fprintf(stderr, "Got fd from the server, watching...\n");
 163
 164         test_fd.stream.notify_read = test_client_fd_data_cb;
 165         ustream_fd_init(&test_fd, fd);
 166 }
 167
 168 static void test_client_complete_cb(struct ubus_request *req, int ret)
 169 {
 170         fprintf(stderr, "completed request, ret: %d\n", ret);
 171 }
 172
 173 static void client_main(void)
 174 {
 175         static struct ubus_request req;
 176         uint32_t id;
 177         int ret;
 178
 179         ret = ubus_add_object(ctx, &test_client_object);
 180         if (ret) {
 181                 fprintf(stderr, "Failed to add_object object: %s\n", ubus_strerror(ret));
 182                 return;
 183         }
 184
 185         if (ubus_lookup_id(ctx, "test", &id)) {
 186                 fprintf(stderr, "Failed to look up test object\n");
 187                 return;
 188         }
 189
 190         blob_buf_init(&b, 0);
 191         blobmsg_add_u32(&b, "id", test_client_object.id);
 192         ubus_invoke(ctx, id, "watch", b.head, NULL, 0, 3000);
 193         test_client_notify_cb(&notify_timer);
 194
 195         blob_buf_init(&b, 0);
 196         blobmsg_add_string(&b, "msg", "blah");
 197         ubus_invoke_async(ctx, id, "hello", b.head, &req);
 198         req.fd_cb = test_client_fd_cb;
 199         req.complete_cb = test_client_complete_cb;
 200         ubus_complete_request_async(ctx, &req);
 201
 202         uloop_timeout_set(&count_timer, 2000);
 203
 204         uloop_run();
 205 }
 206
 207 int main(int argc, char **argv)
 208 {
 209         const char *ubus_socket = NULL;
 210         int ch;
 211
 212         while ((ch = getopt(argc, argv, "cs:")) != -1) {
 213                 switch (ch) {
 214                 case 's':
 215                         ubus_socket = optarg;
 216                         break;
 217                 default:
 218                         break;
 219                 }
 220         }
 221
 222         argc -= optind;
 223         argv += optind;
 224
 225         uloop_init();
 226
 227         ctx = ubus_connect(ubus_socket);
 228         if (!ctx) {
 229                 fprintf(stderr, "Failed to connect to ubus\n");
 230                 return -1;
 231         }
 232
 233         ubus_add_uloop(ctx);
 234
 235         client_main();
 236
 237         ubus_free(ctx);
 238         uloop_done();
 239
 240         return 0;
 241 }