remove some duplication
[project/ubus.git] / 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 }