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 }