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 store_objid(struct ubus_request *req, int type, struct blob_attr *msg)
  32 {
  33         struct blob_attr **attr;
  34
  35         attr = ubus_parse_msg(msg);
  36         if (!attr[UBUS_ATTR_OBJID])
  37                 return;
  38
  39         objid = blob_get_int32(attr[UBUS_ATTR_OBJID]);
  40 }
  41
  42 static uint32_t get_object(const char *name)
  43 {
  44         struct ubus_request req;
  45
  46         blob_buf_init(&b, 0);
  47         blob_put_string(&b, UBUS_ATTR_OBJPATH, name);
  48         ubus_start_request(ctx, &req, b.head, UBUS_MSG_LOOKUP, 0);
  49         req.data_cb = store_objid;
  50         if (ubus_complete_request(ctx, &req))
  51                 return 0;
  52
  53         return objid;
  54 }
  55
  56 static int usage(char *prog)
  57 {
  58         fprintf(stderr,
  59                 "Usage: %s <command> [arguments...]\n"
  60                 "Commands:\n"
  61                 " - list [<path>]                       List objects\n"
  62                 " - call <path> <method> [<message>]    Call an object method\n"
  63                 "\n", prog);
  64         return 1;
  65 }
  66
  67 int main(int argc, char **argv)
  68 {
  69         struct ubus_request req;
  70         char *cmd;
  71         int ret;
  72
  73         ctx = ubus_connect(NULL);
  74         if (!ctx) {
  75                 fprintf(stderr, "Failed to connect to ubus\n");
  76                 return -1;
  77         }
  78
  79         cmd = argv[1];
  80         if (argc < 2)
  81                 return usage(argv[0]);
  82
  83         if (!strcmp(cmd, "list")) {
  84                 blob_buf_init(&b, 0);
  85
  86                 if (argc == 3)
  87                         blob_put_string(&b, UBUS_ATTR_OBJPATH, argv[2]);
  88
  89                 ubus_start_request(ctx, &req, b.head, UBUS_MSG_LOOKUP, 0);
  90                 req.data_cb = receive_lookup;
  91         } else if (!strcmp(cmd, "call")) {
  92                 if (argc < 4 || argc > 5)
  93                         return usage(argv[0]);
  94
  95                 if (get_object(argv[2]) == 0) {
  96                         fprintf(stderr, "Object not found\n");
  97                         return 1;
  98                 }
  99
 100                 blob_buf_init(&b, 0);
 101                 blob_put_int32(&b, UBUS_ATTR_OBJID, objid);
 102                 blob_put_string(&b, UBUS_ATTR_METHOD, argv[3]);
 103                 ubus_start_request(ctx, &req, b.head, UBUS_MSG_INVOKE, objid);
 104         } else {
 105                 return usage(argv[0]);
 106         }
 107
 108         ret = ubus_complete_request(ctx, &req);
 109         if (ret)
 110                 fprintf(stderr, "Failed: %s\n", ubus_strerror(ret));
 111
 112         ubus_free(ctx);
 113         return 0;
 114 }