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 > 0) {
 112                 event = argv[0];
 113         } else {
 114                 event = "*";
 115                 argc = 1;
 116         }
 117
 118         do {
 119                 ret = ubus_register_event_handler(ctx, &listener, event);
 120                 if (ret)
 121                         break;
 122
 123                 argv++;
 124                 argc--;
 125                 if (argc <= 0)
 126                         break;
 127
 128                 event = argv[0];
 129         } while (1);
 130
 131         if (ret) {
 132                 fprintf(stderr, "Error while registering for event '%s': %s\n",
 133                         event, ubus_strerror(ret));
 134                 return -1;
 135         }
 136
 137         uloop_init();
 138         ubus_add_uloop(ctx);
 139         uloop_run();
 140         uloop_done();
 141
 142         return 0;
 143 }
 144
 145 static int ubus_cli_send(struct ubus_context *ctx, int argc, char **argv)
 146 {
 147         if (argc < 1 || argc > 2)
 148                 return -2;
 149
 150         blob_buf_init(&b, 0);
 151
 152         if (argc == 2 && !blobmsg_add_json_from_string(&b, argv[1])) {
 153                 fprintf(stderr, "Failed to parse message data\n");
 154                 return -1;
 155         }
 156
 157         return ubus_send_event(ctx, argv[0], b.head);
 158 }
 159
 160 static int usage(const char *prog)
 161 {
 162         fprintf(stderr,
 163                 "Usage: %s [<options>] <command> [arguments...]\n"
 164                 "Options:\n"
 165                 " -s <socket>:          Set the unix domain socket to connect to\n"
 166                 "\n"
 167                 "Commands:\n"
 168                 " - list [<path>]                       List objects\n"
 169                 " - call <path> <method> [<message>]    Call an object method\n"
 170                 " - listen [<path>...]                  Listen for events\n"
 171                 " - send <type> [<message>]             Send an event\n"
 172                 "\n", prog);
 173         return 1;
 174 }
 175
 176
 177 struct {
 178         const char *name;
 179         int (*cb)(struct ubus_context *ctx, int argc, char **argv);
 180 } commands[] = {
 181         { "list", ubus_cli_list },
 182         { "call", ubus_cli_call },
 183         { "listen", ubus_cli_listen },
 184         { "send", ubus_cli_send },
 185 };
 186
 187 int main(int argc, char **argv)
 188 {
 189         const char *progname, *ubus_socket = NULL;
 190         static struct ubus_context *ctx;
 191         char *cmd;
 192         int ret = 0;
 193         int i, ch;
 194
 195         progname = argv[0];
 196
 197         while ((ch = getopt(argc, argv, "s:")) != -1) {
 198                 switch (ch) {
 199                 case 's':
 200                         ubus_socket = optarg;
 201                         break;
 202                 default:
 203                         return usage(progname);
 204                 }
 205         }
 206
 207         argc -= optind;
 208         argv += optind;
 209
 210         cmd = argv[0];
 211         if (argc < 1)
 212                 return usage(progname);
 213
 214         ctx = ubus_connect(ubus_socket);
 215         if (!ctx) {
 216                 fprintf(stderr, "Failed to connect to ubus\n");
 217                 return -1;
 218         }
 219
 220         argv++;
 221         argc--;
 222
 223         ret = -2;
 224         for (i = 0; i < ARRAY_SIZE(commands); i++) {
 225                 if (strcmp(commands[i].name, cmd) != 0)
 226                         continue;
 227
 228                 ret = commands[i].cb(ctx, argc, argv);
 229                 break;
 230         }
 231
 232         if (ret > 0)
 233                 fprintf(stderr, "Command failed: %s\n", ubus_strerror(ret));
 234         else if (ret == -2)
 235                 usage(progname);
 236
 237         ubus_free(ctx);
 238         return ret;
 239 }