cli.c

   1 #include "libubus.h"
   2
   3 static struct blob_buf b;
   4 static struct ubus_context *ctx;
   5 static uint32_t objid;
   6
   7 static void receive_lookup(struct ubus_request *req, int type, struct blob_attr *msg)
   8 {
   9         struct blob_attr **attr, *cur;
  10         char *s;
  11         int rem;
  12
  13         attr = ubus_parse_msg(msg);
  14         if (!attr[UBUS_ATTR_OBJID] || !attr[UBUS_ATTR_OBJPATH])
  15                 return;
  16
  17         fprintf(stderr, "'%s' @%08x\n",
  18                 (char *) blob_data(attr[UBUS_ATTR_OBJPATH]),
  19                 blob_get_int32(attr[UBUS_ATTR_OBJID]));
  20
  21         if (!attr[UBUS_ATTR_SIGNATURE])
  22                 return;
  23
  24         blob_for_each_attr(cur, attr[UBUS_ATTR_SIGNATURE], rem) {
  25                 s = blobmsg_format_json(cur, false);
  26                 fprintf(stderr, "\t%s\n", s);
  27                 free(s);
  28         }
  29 }
  30
  31 static void receive_data(struct ubus_request *req, int type, struct blob_attr *msg)
  32 {
  33         if (!msg)
  34                 return;
  35
  36         fprintf(stderr, "%s\n", blobmsg_format_json(msg, true));
  37 }
  38
  39 static void store_objid(struct ubus_request *req, int type, struct blob_attr *msg)
  40 {
  41         struct blob_attr **attr;
  42
  43         attr = ubus_parse_msg(msg);
  44         if (!attr[UBUS_ATTR_OBJID])
  45                 return;
  46
  47         objid = blob_get_int32(attr[UBUS_ATTR_OBJID]);
  48 }
  49
  50 static uint32_t get_object(const char *name)
  51 {
  52         struct ubus_request req;
  53
  54         blob_buf_init(&b, 0);
  55         blob_put_string(&b, UBUS_ATTR_OBJPATH, name);
  56         ubus_start_request(ctx, &req, b.head, UBUS_MSG_LOOKUP, 0);
  57         req.raw_data_cb = store_objid;
  58         if (ubus_complete_request(ctx, &req))
  59                 return 0;
  60
  61         return objid;
  62 }
  63
  64 static int usage(char *prog)
  65 {
  66         fprintf(stderr,
  67                 "Usage: %s <command> [arguments...]\n"
  68                 "Commands:\n"
  69                 " - list [<path>]                       List objects\n"
  70                 " - call <path> <method> [<message>]    Call an object method\n"
  71                 "\n", prog);
  72         return 1;
  73 }
  74
  75 int main(int argc, char **argv)
  76 {
  77         struct ubus_request req;
  78         char *cmd;
  79         int ret;
  80
  81         ctx = ubus_connect(NULL);
  82         if (!ctx) {
  83                 fprintf(stderr, "Failed to connect to ubus\n");
  84                 return -1;
  85         }
  86
  87         cmd = argv[1];
  88         if (argc < 2)
  89                 return usage(argv[0]);
  90
  91         if (!strcmp(cmd, "list")) {
  92                 blob_buf_init(&b, 0);
  93
  94                 if (argc == 3)
  95                         blob_put_string(&b, UBUS_ATTR_OBJPATH, argv[2]);
  96
  97                 ubus_start_request(ctx, &req, b.head, UBUS_MSG_LOOKUP, 0);
  98                 req.raw_data_cb = receive_lookup;
  99         } else if (!strcmp(cmd, "call")) {
 100                 if (argc < 4 || argc > 5)
 101                         return usage(argv[0]);
 102
 103                 if (get_object(argv[2]) == 0) {
 104                         fprintf(stderr, "Object not found\n");
 105                         return 1;
 106                 }
 107
 108                 blob_buf_init(&b, 0);
 109                 blob_put_int32(&b, UBUS_ATTR_OBJID, objid);
 110                 blob_put_string(&b, UBUS_ATTR_METHOD, argv[3]);
 111                 ubus_start_request(ctx, &req, b.head, UBUS_MSG_INVOKE, objid);
 112                 req.data_cb = receive_data;
 113         } else {
 114                 return usage(argv[0]);
 115         }
 116
 117         ret = ubus_complete_request(ctx, &req);
 118         if (ret)
 119                 fprintf(stderr, "Failed: %s\n", ubus_strerror(ret));
 120
 121         ubus_free(ctx);
 122         return 0;
 123 }