cli.c

   1 #include <unistd.h>
   2
   3 #include <libubox/blobmsg_json.h>
   4 #include "libubus.h"
   5
   6 static struct blob_buf b;
   7
   8 static const char *format_type(void *priv, struct blob_attr *attr)
   9 {
  10         static const char * const attr_types[] = {
  11                 [BLOBMSG_TYPE_INT32] = "\"Integer\"",
  12                 [BLOBMSG_TYPE_STRING] = "\"String\"",
  13         };
  14         const char *type = NULL;
  15         int typeid;
  16
  17         if (blob_id(attr) != BLOBMSG_TYPE_INT32)
  18                 return NULL;
  19
  20         typeid = blobmsg_get_u32(attr);
  21         if (typeid < ARRAY_SIZE(attr_types))
  22                 type = attr_types[typeid];
  23         if (!type)
  24                 type = "\"(unknown)\"";
  25
  26         return type;
  27 }
  28
  29 static void receive_list_result(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
  30 {
  31         struct blob_attr *cur;
  32         char *s;
  33         int rem;
  34
  35         printf("'%s' @%08x\n", obj->path, obj->id);
  36
  37         if (!obj->signature)
  38                 return;
  39
  40         blob_for_each_attr(cur, obj->signature, rem) {
  41                 s = blobmsg_format_json_with_cb(cur, false, format_type, NULL);
  42                 printf("\t%s\n", s);
  43                 free(s);
  44         }
  45 }
  46
  47 static void receive_call_result_data(struct ubus_request *req, int type, struct blob_attr *msg)
  48 {
  49         char *str;
  50         if (!msg)
  51                 return;
  52
  53         str = blobmsg_format_json(msg, true);
  54         printf("%s\n", str);
  55         free(str);
  56 }
  57
  58 static void receive_event(struct ubus_context *ctx, struct ubus_event_handler *ev,
  59                           const char *type, struct blob_attr *msg)
  60 {
  61         char *str;
  62
  63         str = blobmsg_format_json(msg, true);
  64         printf("\"%s\": %s\n", type, str);
  65         free(str);
  66 }
  67
  68 static int ubus_cli_list(struct ubus_context *ctx, int argc, char **argv)
  69 {
  70         const char *path = NULL;
  71
  72         if (argc > 1)
  73                 return -2;
  74
  75         if (argc == 1)
  76                 path = argv[0];
  77
  78         return ubus_lookup(ctx, path, receive_list_result, NULL);
  79 }
  80
  81 static int ubus_cli_call(struct ubus_context *ctx, int argc, char **argv)
  82 {
  83         uint32_t id;
  84         int ret;
  85
  86         if (argc < 2 || argc > 3)
  87                 return -2;
  88
  89         blob_buf_init(&b, 0);
  90         if (argc == 3 && !blobmsg_add_json_from_string(&b, argv[2])) {
  91                 fprintf(stderr, "Failed to parse message data\n");
  92                 return -1;
  93         }
  94
  95         ret = ubus_lookup_id(ctx, argv[0], &id);
  96         if (ret)
  97                 return ret;
  98
  99         return ubus_invoke(ctx, id, argv[1], b.head, receive_call_result_data, NULL);
 100 }
 101
 102 static int ubus_cli_listen(struct ubus_context *ctx, int argc, char **argv)
 103 {
 104         static struct ubus_event_handler listener;
 105         const char *event;
 106         int ret = 0;
 107
 108         memset(&listener, 0, sizeof(listener));
 109         listener.cb = receive_event;
 110
 111         if (!argc) {
 112                 event = "*";
 113                 ret = ubus_register_event_handler(ctx, &listener, NULL);
 114         }
 115
 116         for (;argc;argv++, argc--) {
 117                 event = argv[0];
 118                 ret = ubus_register_event_handler(ctx, &listener, argv[0]);
 119                 if (ret)
 120                         break;
 121         }
 122
 123         if (ret) {
 124                 fprintf(stderr, "Error while registering for event '%s': %s\n",
 125                         event, ubus_strerror(ret));
 126                 return -1;
 127         }
 128
 129         uloop_init();
 130         ubus_add_uloop(ctx);
 131         uloop_run();
 132         uloop_done();
 133
 134         return 0;
 135 }
 136
 137 static int ubus_cli_send(struct ubus_context *ctx, int argc, char **argv)
 138 {
 139         if (argc < 1 || argc > 2)
 140                 return -2;
 141
 142         blob_buf_init(&b, 0);
 143
 144         if (argc == 2 && !blobmsg_add_json_from_string(&b, argv[1])) {
 145                 fprintf(stderr, "Failed to parse message data\n");
 146                 return -1;
 147         }
 148
 149         return ubus_send_event(ctx, argv[0], b.head);
 150 }
 151
 152 static int usage(const char *prog)
 153 {
 154         fprintf(stderr,
 155                 "Usage: %s [<options>] <command> [arguments...]\n"
 156                 "Options:\n"
 157                 " -s <socket>:          Set the unix domain socket to connect to\n"
 158                 "\n"
 159                 "Commands:\n"
 160                 " - list [<path>]                       List objects\n"
 161                 " - call <path> <method> [<message>]    Call an object method\n"
 162                 " - listen [<path>...]                  Listen for events\n"
 163                 " - send <type> [<message>]             Send an event\n"
 164                 "\n", prog);
 165         return 1;
 166 }
 167
 168
 169 struct {
 170         const char *name;
 171         int (*cb)(struct ubus_context *ctx, int argc, char **argv);
 172 } commands[] = {
 173         { "list", ubus_cli_list },
 174         { "call", ubus_cli_call },
 175         { "listen", ubus_cli_listen },
 176         { "send", ubus_cli_send },
 177 };
 178
 179 int main(int argc, char **argv)
 180 {
 181         const char *progname, *ubus_socket = NULL;
 182         static struct ubus_context *ctx;
 183         char *cmd;
 184         int ret = 0;
 185         int i, ch;
 186
 187         progname = argv[0];
 188
 189         while ((ch = getopt(argc, argv, "s:")) != -1) {
 190                 switch (ch) {
 191                 case 's':
 192                         ubus_socket = optarg;
 193                         break;
 194                 default:
 195                         return usage(progname);
 196                 }
 197         }
 198
 199         argc -= optind;
 200         argv += optind;
 201
 202         cmd = argv[0];
 203         if (argc < 1)
 204                 return usage(progname);
 205
 206         ctx = ubus_connect(ubus_socket);
 207         if (!ctx) {
 208                 fprintf(stderr, "Failed to connect to ubus\n");
 209                 return -1;
 210         }
 211
 212         argv++;
 213         argc--;
 214
 215         ret = -2;
 216         for (i = 0; i < ARRAY_SIZE(commands); i++) {
 217                 if (strcmp(commands[i].name, cmd) != 0)
 218                         continue;
 219
 220                 ret = commands[i].cb(ctx, argc, argv);
 221                 break;
 222         }
 223
 224         if (ret > 0)
 225                 fprintf(stderr, "Command failed: %s\n", ubus_strerror(ret));
 226         else if (ret == -2)
 227                 usage(progname);
 228
 229         ubus_free(ctx);
 230         return ret;
 231 }