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