cli.c

   1 #include "libubus.h"
   2
   3 static void receive_lookup(struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
   4 {
   5         struct blob_attr *cur;
   6         char *s;
   7         int rem;
   8
   9         fprintf(stderr, "'%s' @%08x\n", obj->path, obj->id);
  10
  11         if (!obj->signature)
  12                 return;
  13
  14         blob_for_each_attr(cur, obj->signature, rem) {
  15                 s = blobmsg_format_json(cur, false);
  16                 fprintf(stderr, "\t%s\n", s);
  17                 free(s);
  18         }
  19 }
  20
  21 static void receive_data(struct ubus_request *req, int type, struct blob_attr *msg)
  22 {
  23         char *str;
  24         if (!msg)
  25                 return;
  26
  27         str = blobmsg_format_json(msg, true);
  28         fprintf(stderr, "%s\n", str);
  29         free(str);
  30 }
  31
  32
  33 static int usage(char *prog)
  34 {
  35         fprintf(stderr,
  36                 "Usage: %s <command> [arguments...]\n"
  37                 "Commands:\n"
  38                 " - list [<path>]                       List objects\n"
  39                 " - call <path> <method> [<message>]    Call an object method\n"
  40                 " - listen [<path>...]                  Listen for events\n"
  41                 "\n", prog);
  42         return 1;
  43 }
  44
  45 static void receive_event(struct ubus_context *ctx, struct ubus_event_handler *ev,
  46                           const char *type, struct blob_attr *msg)
  47 {
  48         char *str;
  49
  50         if (msg)
  51                 str = blobmsg_format_json(msg, true);
  52         else
  53                 str = "";
  54
  55         fprintf(stderr, "\"%s\":{ %s }\n", type, str);
  56         free(str);
  57 }
  58
  59 static int ubus_cli_listen(struct ubus_context *ctx, int argc, char **argv)
  60 {
  61         static struct ubus_event_handler listener;
  62         const char *event;
  63         int ret = 0;
  64
  65         memset(&listener, 0, sizeof(listener));
  66         listener.cb = receive_event;
  67
  68         if (!argc) {
  69                 event = "*";
  70                 ret = ubus_register_event_handler(ctx, &listener, NULL);
  71         }
  72
  73         for (;argc;argv++, argc--) {
  74                 event = argv[0];
  75                 ret = ubus_register_event_handler(ctx, &listener, argv[0]);
  76                 if (ret)
  77                         break;
  78         }
  79
  80         if (ret) {
  81                 fprintf(stderr, "Error while registering for event '%s': %s\n",
  82                         event, ubus_strerror(ret));
  83         }
  84
  85         uloop_init();
  86         ubus_add_uloop(ctx);
  87         uloop_run();
  88         uloop_done();
  89
  90         return 0;
  91 }
  92
  93 int main(int argc, char **argv)
  94 {
  95         static struct ubus_context *ctx;
  96         char *cmd;
  97         int ret;
  98
  99         ctx = ubus_connect(NULL);
 100         if (!ctx) {
 101                 fprintf(stderr, "Failed to connect to ubus\n");
 102                 return -1;
 103         }
 104
 105         cmd = argv[1];
 106         if (argc < 2)
 107                 return usage(argv[0]);
 108
 109         if (!strcmp(cmd, "list")) {
 110                 const char *path = NULL;
 111
 112                 if (argc == 3)
 113                         path = argv[2];
 114
 115                 ret = ubus_lookup(ctx, path, receive_lookup, NULL);
 116         } else if (!strcmp(cmd, "call")) {
 117                 uint32_t id;
 118
 119                 if (argc < 4 || argc > 5)
 120                         return usage(argv[0]);
 121
 122                 ret = ubus_lookup_id(ctx, argv[2], &id);
 123                 if (!ret)
 124                         ret = ubus_invoke(ctx, id, argv[3], NULL, receive_data, NULL);
 125         } else if (!strcmp(cmd, "listen")) {
 126                 ret = ubus_cli_listen(ctx, argc - 2, argv + 2);
 127         } else {
 128                 return usage(argv[0]);
 129         }
 130
 131         if (ret)
 132                 fprintf(stderr, "Failed: %s\n", ubus_strerror(ret));
 133
 134         ubus_free(ctx);
 135         return ret;
 136 }