make libubus a dynamic library
[project/ubus.git] / libubus.c
1 #include <sys/types.h>
2 #include <sys/uio.h>
3 #include <sys/socket.h>
4 #include <unistd.h>
5
6 #include <libubox/blob.h>
7 #include <libubox/blobmsg.h>
8 #include <libubox/usock.h>
9
10 #include "libubus.h"
11 #include "ubusmsg.h"
12
13 #define DEBUG 1
14
15 #ifdef DEBUG
16 #define DPRINTF(_format, ...) fprintf(stderr, "ubus: " _format, ## __VA_ARGS__)
17 #else
18 #define DPRINTF(...) do {} while(0)
19 #endif
20
21 #define STATIC_IOV(_var) { .iov_base = (char *) &(_var), .iov_len = sizeof(_var) }
22
23 const char *__ubus_strerror[__UBUS_STATUS_LAST] = {
24         [UBUS_STATUS_OK] = "Success",
25         [UBUS_STATUS_INVALID_COMMAND] = "Invalid command",
26         [UBUS_STATUS_INVALID_ARGUMENT] = "Invalid argument",
27         [UBUS_STATUS_METHOD_NOT_FOUND] = "Method not found",
28         [UBUS_STATUS_NOT_FOUND] = "Not found",
29         [UBUS_STATUS_NO_DATA] = "No response",
30 };
31
32 static struct blob_buf b;
33
34 static const struct blob_attr_info ubus_policy[UBUS_ATTR_MAX] = {
35         [UBUS_ATTR_STATUS] = { .type = BLOB_ATTR_INT32 },
36         [UBUS_ATTR_OBJID] = { .type = BLOB_ATTR_INT32 },
37         [UBUS_ATTR_OBJPATH] = { .type = BLOB_ATTR_STRING },
38         [UBUS_ATTR_METHOD] = { .type = BLOB_ATTR_STRING },
39 };
40 static struct blob_attr *attrbuf[UBUS_ATTR_MAX];
41
42 struct ubus_pending_data {
43         struct list_head list;
44         int type;
45         struct blob_attr data[];
46 };
47
48 static int ubus_cmp_id(const void *k1, const void *k2, void *ptr)
49 {
50         const uint32_t *id1 = k1, *id2 = k2;
51
52         if (*id1 < *id2)
53                 return -1;
54         else
55                 return *id1 > *id2;
56 }
57
58 static struct blob_attr **ubus_parse_msg(struct blob_attr *msg)
59 {
60         blob_parse(msg, attrbuf, ubus_policy, UBUS_ATTR_MAX);
61         return attrbuf;
62 }
63
64 const char *ubus_strerror(int error)
65 {
66         static char err[32];
67
68         if (error < 0 || error >= __UBUS_STATUS_LAST)
69                 goto out;
70
71         if (!__ubus_strerror[error])
72                 goto out;
73
74         return __ubus_strerror[error];
75
76 out:
77         sprintf(err, "Unknown error: %d", error);
78         return err;
79 }
80
81 static int ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
82                          struct blob_attr *msg, int cmd, uint32_t peer)
83 {
84         struct ubus_msghdr hdr;
85         struct iovec iov[2] = {
86                 STATIC_IOV(hdr)
87         };
88
89         hdr.version = 0;
90         hdr.type = cmd;
91         hdr.seq = seq;
92         hdr.peer = peer;
93
94         if (!msg) {
95                 blob_buf_init(&b, 0);
96                 msg = b.head;
97         }
98
99         iov[1].iov_base = (char *) msg;
100         iov[1].iov_len = blob_raw_len(msg);
101
102         return writev(ctx->sock.fd, iov, 2);
103 }
104
105 static int ubus_start_request(struct ubus_context *ctx, struct ubus_request *req,
106                               struct blob_attr *msg, int cmd, uint32_t peer)
107 {
108         memset(req, 0, sizeof(*req));
109
110         INIT_LIST_HEAD(&req->list);
111         INIT_LIST_HEAD(&req->pending);
112         req->ctx = ctx;
113         req->peer = peer;
114         req->seq = ++ctx->request_seq;
115         return ubus_send_msg(ctx, req->seq, msg, cmd, peer);
116 }
117
118 static bool recv_retry(int fd, struct iovec *iov, bool wait)
119 {
120         int bytes;
121
122         while (iov->iov_len > 0) {
123                 bytes = read(fd, iov->iov_base, iov->iov_len);
124                 if (bytes < 0) {
125                         bytes = 0;
126                         if (errno == EINTR)
127                                 continue;
128
129                         if (errno != EAGAIN) {
130                                 perror("read");
131                                 return false;
132                         }
133                 }
134                 if (!wait && !bytes)
135                         return false;
136
137                 wait = true;
138                 iov->iov_len -= bytes;
139                 iov->iov_base += bytes;
140         }
141
142         return true;
143 }
144
145 static bool ubus_validate_hdr(struct ubus_msghdr *hdr)
146 {
147         if (hdr->version != 0)
148                 return false;
149
150         if (blob_raw_len(hdr->data) < sizeof(*hdr->data))
151                 return false;
152
153         if (blob_raw_len(hdr->data) + sizeof(*hdr) > UBUS_MAX_MSGLEN)
154                 return false;
155
156         return true;
157 }
158
159 static bool get_next_msg(struct ubus_context *ctx, bool wait)
160 {
161         struct iovec iov = STATIC_IOV(ctx->msgbuf.hdr);
162
163         /* receive header + start attribute */
164         iov.iov_len += sizeof(struct blob_attr);
165         if (!recv_retry(ctx->sock.fd, &iov, wait))
166                 return false;
167
168         iov.iov_len = blob_len(ctx->msgbuf.hdr.data);
169         if (iov.iov_len > 0 && !recv_retry(ctx->sock.fd, &iov, true))
170                 return false;
171
172         return ubus_validate_hdr(&ctx->msgbuf.hdr);
173 }
174
175 static bool ubus_get_status(struct ubus_msghdr *hdr, int *ret)
176 {
177         ubus_parse_msg(hdr->data);
178
179         if (!attrbuf[UBUS_ATTR_STATUS])
180                 return false;
181
182         *ret = blob_get_int32(attrbuf[UBUS_ATTR_STATUS]);
183         return true;
184 }
185
186 static void req_data_cb(struct ubus_request *req, int type, struct blob_attr *data)
187 {
188         struct blob_attr **attr;
189
190         if (req->raw_data_cb)
191                 req->raw_data_cb(req, type, data);
192
193         if (!req->data_cb)
194                 return;
195
196         attr = ubus_parse_msg(data);
197         req->data_cb(req, type, attr[UBUS_ATTR_DATA]);
198 }
199
200 static void ubus_process_req_data(struct ubus_request *req)
201 {
202         struct ubus_pending_data *data;
203
204         while (!list_empty(&req->pending)) {
205                 data = list_first_entry(&req->pending,
206                         struct ubus_pending_data, list);
207                 list_del(&data->list);
208                 if (!req->cancelled)
209                         req_data_cb(req, data->type, data->data);
210                 free(data);
211         }
212 }
213
214 static void ubus_req_complete_cb(struct ubus_request *req)
215 {
216         ubus_complete_handler_t cb = req->complete_cb;
217
218         if (!cb)
219                 return;
220
221         req->complete_cb = NULL;
222         cb(req, req->status_code);
223 }
224
225 static int ubus_process_req_status(struct ubus_request *req, struct ubus_msghdr *hdr)
226 {
227         int ret = UBUS_STATUS_INVALID_ARGUMENT;
228
229         if (!list_empty(&req->list))
230                 list_del(&req->list);
231
232         ubus_get_status(hdr, &ret);
233         req->peer = hdr->peer;
234         req->status_msg = true;
235         req->status_code = ret;
236         if (!req->blocked)
237                 ubus_req_complete_cb(req);
238
239         return ret;
240 }
241
242 static void ubus_req_data(struct ubus_request *req, struct ubus_msghdr *hdr)
243 {
244         struct ubus_pending_data *data;
245         int len;
246
247         if (!req->blocked) {
248                 req->blocked = true;
249                 req_data_cb(req, hdr->type, hdr->data);
250                 ubus_process_req_data(req);
251                 req->blocked = false;
252
253                 if (req->status_msg)
254                         ubus_req_complete_cb(req);
255
256                 return;
257         }
258
259         len = blob_raw_len(hdr->data);
260         data = calloc(1, sizeof(*data) + len);
261         if (!data)
262                 return;
263
264         data->type = hdr->type;
265         memcpy(data->data, hdr->data, len);
266         list_add(&data->list, &req->pending);
267 }
268
269 static struct ubus_request *ubus_find_request(struct ubus_context *ctx, uint32_t seq, uint32_t peer)
270 {
271         struct ubus_request *req;
272
273         list_for_each_entry(req, &ctx->requests, list) {
274                 if (seq != req->seq || peer != req->peer)
275                         continue;
276
277                 return req;
278         }
279         return NULL;
280 }
281
282 static void ubus_process_invoke(struct ubus_context *ctx, struct ubus_msghdr *hdr)
283 {
284         struct ubus_request_data req;
285         struct ubus_object *obj;
286         uint32_t objid = 0;
287         int method;
288         int ret = 0;
289
290         ubus_parse_msg(hdr->data);
291
292         if (!attrbuf[UBUS_ATTR_OBJID])
293                 return;
294
295         objid = blob_get_int32(attrbuf[UBUS_ATTR_OBJID]);
296
297         if (!attrbuf[UBUS_ATTR_METHOD]) {
298                 ret = UBUS_STATUS_INVALID_ARGUMENT;
299                 goto send;
300         }
301
302         obj = avl_find_element(&ctx->objects, &objid, obj, avl);
303         if (!obj) {
304                 ret = UBUS_STATUS_NOT_FOUND;
305                 goto send;
306         }
307
308         for (method = 0; method < obj->n_methods; method++)
309                 if (!strcmp(obj->methods[method].name,
310                             blob_data(attrbuf[UBUS_ATTR_METHOD])))
311                         goto found;
312
313         /* not found */
314         ret = UBUS_STATUS_METHOD_NOT_FOUND;
315         goto send;
316
317 found:
318         req.object = objid;
319         req.peer = hdr->peer;
320         req.seq = hdr->seq;
321         ret = obj->methods[method].handler(ctx, obj, &req,
322                                            obj->methods[method].name,
323                                            attrbuf[UBUS_ATTR_DATA]);
324
325 send:
326         blob_buf_init(&b, 0);
327         blob_put_int32(&b, UBUS_ATTR_STATUS, ret);
328         blob_put_int32(&b, UBUS_ATTR_OBJID, objid);
329         ubus_send_msg(ctx, hdr->seq, b.head, UBUS_MSG_STATUS, hdr->peer);
330 }
331
332 static void ubus_process_msg(struct ubus_context *ctx, struct ubus_msghdr *hdr)
333 {
334         struct ubus_request *req;
335
336         switch(hdr->type) {
337         case UBUS_MSG_STATUS:
338                 req = ubus_find_request(ctx, hdr->seq, hdr->peer);
339                 if (!req)
340                         break;
341
342                 ubus_process_req_status(req, hdr);
343                 break;
344
345         case UBUS_MSG_DATA:
346                 req = ubus_find_request(ctx, hdr->seq, hdr->peer);
347                 if (req && (req->data_cb || req->raw_data_cb))
348                         ubus_req_data(req, hdr);
349                 break;
350
351         case UBUS_MSG_INVOKE:
352                 ubus_process_invoke(ctx, hdr);
353                 break;
354         default:
355                 DPRINTF("unknown message type: %d\n", hdr->type);
356                 break;
357         }
358 }
359
360 void ubus_abort_request(struct ubus_context *ctx, struct ubus_request *req)
361 {
362         if (!list_empty(&req->list))
363                 return;
364
365         req->cancelled = true;
366         ubus_process_req_data(req);
367         list_del(&req->list);
368 }
369
370 void ubus_complete_request_async(struct ubus_context *ctx, struct ubus_request *req)
371 {
372         if (!list_empty(&req->list))
373                 return;
374
375         list_add(&req->list, &ctx->requests);
376 }
377
378 static void ubus_handle_data(struct uloop_fd *u, unsigned int events)
379 {
380         struct ubus_context *ctx = container_of(u, struct ubus_context, sock);
381         struct ubus_msghdr *hdr = &ctx->msgbuf.hdr;
382
383         while (get_next_msg(ctx, false))
384                 ubus_process_msg(ctx, hdr);
385
386         if (u->eof)
387                 ctx->connection_lost(ctx);
388 }
389
390 int ubus_complete_request(struct ubus_context *ctx, struct ubus_request *req)
391 {
392         struct ubus_msghdr *hdr = &ctx->msgbuf.hdr;
393
394         if (!list_empty(&req->list))
395                 list_del(&req->list);
396
397         while (1) {
398                 if (req->status_msg)
399                         return req->status_code;
400
401                 if (req->cancelled)
402                         return UBUS_STATUS_NO_DATA;
403
404                 if (!get_next_msg(ctx, true))
405                         return UBUS_STATUS_NO_DATA;
406
407                 if (hdr->seq != req->seq || hdr->peer != req->peer)
408                         goto skip;
409
410                 switch(hdr->type) {
411                 case UBUS_MSG_STATUS:
412                         return ubus_process_req_status(req, hdr);
413                 case UBUS_MSG_DATA:
414                         if (req->data_cb || req->raw_data_cb)
415                                 ubus_req_data(req, hdr);
416                         continue;
417                 default:
418                         goto skip;
419                 }
420
421 skip:
422                 ubus_process_msg(ctx, hdr);
423         }
424 }
425
426 struct ubus_lookup_request {
427         struct ubus_request req;
428         ubus_lookup_handler_t cb;
429 };
430
431 static void ubus_lookup_cb(struct ubus_request *ureq, int type, struct blob_attr *msg)
432 {
433         struct ubus_lookup_request *req;
434         struct ubus_object_data obj;
435         struct blob_attr **attr;
436
437         req = container_of(ureq, struct ubus_lookup_request, req);
438         attr = ubus_parse_msg(msg);
439
440         if (!attr[UBUS_ATTR_OBJID] || !attr[UBUS_ATTR_OBJPATH] ||
441             !attr[UBUS_ATTR_OBJTYPE])
442                 return;
443
444         memset(&obj, 0, sizeof(obj));
445         obj.id = blob_get_int32(attr[UBUS_ATTR_OBJID]);
446         obj.path = blob_data(attr[UBUS_ATTR_OBJPATH]);
447         obj.type_id = blob_get_int32(attr[UBUS_ATTR_OBJTYPE]);
448         obj.signature = attr[UBUS_ATTR_SIGNATURE];
449         req->cb(ureq->ctx, &obj, ureq->priv);
450 }
451
452 int ubus_lookup(struct ubus_context *ctx, const char *path,
453                 ubus_lookup_handler_t cb, void *priv)
454 {
455         struct ubus_lookup_request lookup;
456
457         blob_buf_init(&b, 0);
458         if (path)
459                 blob_put_string(&b, UBUS_ATTR_OBJPATH, path);
460         ubus_start_request(ctx, &lookup.req, b.head, UBUS_MSG_LOOKUP, 0);
461         lookup.req.raw_data_cb = ubus_lookup_cb;
462         lookup.req.priv = priv;
463         lookup.cb = cb;
464         return ubus_complete_request(ctx, &lookup.req);
465 }
466
467 static void ubus_lookup_id_cb(struct ubus_request *req, int type, struct blob_attr *msg)
468 {
469         struct blob_attr **attr;
470         uint32_t *id = req->priv;
471
472         attr = ubus_parse_msg(msg);
473
474         if (!attr[UBUS_ATTR_OBJID])
475                 return;
476
477         *id = blob_get_int32(attr[UBUS_ATTR_OBJID]);
478 }
479
480 int ubus_lookup_id(struct ubus_context *ctx, const char *path, uint32_t *id)
481 {
482         struct ubus_request req;
483
484         blob_buf_init(&b, 0);
485         if (path)
486                 blob_put_string(&b, UBUS_ATTR_OBJPATH, path);
487         ubus_start_request(ctx, &req, b.head, UBUS_MSG_LOOKUP, 0);
488         req.raw_data_cb = ubus_lookup_id_cb;
489         req.priv = id;
490
491         return ubus_complete_request(ctx, &req);
492 }
493
494 int ubus_send_reply(struct ubus_context *ctx, struct ubus_request_data *req,
495                     struct blob_attr *msg)
496 {
497         int ret;
498
499         blob_buf_init(&b, 0);
500         blob_put_int32(&b, UBUS_ATTR_OBJID, req->object);
501         blob_put(&b, UBUS_ATTR_DATA, blob_data(msg), blob_len(msg));
502         ret = ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_DATA, req->peer);
503         if (ret < 0)
504                 return UBUS_STATUS_NO_DATA;
505
506         return 0;
507 }
508
509 void ubus_invoke_async(struct ubus_context *ctx, uint32_t obj, const char *method,
510                        struct blob_attr *msg, struct ubus_request *req)
511 {
512         blob_buf_init(&b, 0);
513         blob_put_int32(&b, UBUS_ATTR_OBJID, obj);
514         blob_put_string(&b, UBUS_ATTR_METHOD, method);
515         if (msg)
516                 blob_put(&b, UBUS_ATTR_DATA, blob_data(msg), blob_len(msg));
517
518         ubus_start_request(ctx, req, b.head, UBUS_MSG_INVOKE, obj);
519 }
520
521 int ubus_invoke(struct ubus_context *ctx, uint32_t obj, const char *method,
522                 struct blob_attr *msg, ubus_data_handler_t cb, void *priv)
523 {
524         struct ubus_request req;
525
526         ubus_invoke_async(ctx, obj, method, msg, &req);
527         req.data_cb = cb;
528         req.priv = priv;
529         return ubus_complete_request(ctx, &req);
530 }
531
532 static void ubus_publish_cb(struct ubus_request *req, int type, struct blob_attr *msg)
533 {
534         struct ubus_object *obj = req->priv;
535
536         ubus_parse_msg(msg);
537
538         if (!attrbuf[UBUS_ATTR_OBJID])
539                 return;
540
541         obj->id = blob_get_int32(attrbuf[UBUS_ATTR_OBJID]);
542
543         if (attrbuf[UBUS_ATTR_OBJTYPE])
544                 obj->type->id = blob_get_int32(attrbuf[UBUS_ATTR_OBJTYPE]);
545
546         obj->avl.key = &obj->id;
547         avl_insert(&req->ctx->objects, &obj->avl);
548 }
549
550 static bool ubus_push_table_data(const struct ubus_signature **sig, int *rem, bool array)
551 {
552         const struct ubus_signature *cur;
553         bool nest_type;
554         void *nest;
555
556         while (rem) {
557                 cur = (*sig)++;
558                 (*rem)--;
559                 switch(cur->type) {
560                 case UBUS_SIGNATURE_END:
561                         return !array;
562                 case BLOBMSG_TYPE_INT32:
563                 case BLOBMSG_TYPE_STRING:
564                         blobmsg_add_u32(&b, cur->name, cur->type);
565                         break;
566                 case BLOBMSG_TYPE_TABLE:
567                 case BLOBMSG_TYPE_ARRAY:
568                         nest_type = cur->type == BLOBMSG_TYPE_ARRAY;
569                         nest = blobmsg_open_nested(&b, cur->name, nest_type);
570                         if (!ubus_push_table_data(sig, rem, nest_type))
571                                 return false;
572                         blobmsg_close_table(&b, nest);
573                         break;
574                 default:
575                         return false;
576                 }
577                 if (array)
578                         return true;
579         }
580         return false;
581 }
582
583 static bool ubus_push_object_type(struct ubus_object_type *type)
584 {
585         void *s, *m;
586         int rem = type->n_signature;
587         const struct ubus_signature *sig = type->signature;
588
589         s = blob_nest_start(&b, UBUS_ATTR_SIGNATURE);
590         while (rem) {
591                 if (sig->type != UBUS_SIGNATURE_METHOD)
592                         return false;
593
594                 m = blobmsg_open_table(&b, sig->name);
595
596                 sig++;
597                 rem--;
598                 if (!ubus_push_table_data(&sig, &rem, false))
599                         return false;
600
601                 blobmsg_close_table(&b, m);
602         }
603         blob_nest_end(&b, s);
604
605         return true;
606 }
607
608 int ubus_publish(struct ubus_context *ctx, struct ubus_object *obj)
609 {
610         struct ubus_request req;
611         int ret;
612
613         if (obj->id || !obj->name || !obj->type)
614                 return UBUS_STATUS_INVALID_ARGUMENT;
615
616         blob_buf_init(&b, 0);
617         blob_put_string(&b, UBUS_ATTR_OBJPATH, obj->name);
618
619         if (obj->type->id)
620                 blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id);
621         else if (!ubus_push_object_type(obj->type))
622                 return UBUS_STATUS_INVALID_ARGUMENT;
623
624         ubus_start_request(ctx, &req, b.head, UBUS_MSG_PUBLISH, 0);
625         req.raw_data_cb = ubus_publish_cb;
626         req.priv = obj;
627         ret = ubus_complete_request(ctx, &req);
628         if (ret)
629                 return ret;
630
631         if (!obj->id)
632                 return UBUS_STATUS_NO_DATA;
633
634         return 0;
635 }
636
637 void ubus_default_connection_lost(struct ubus_context *ctx)
638 {
639         if (ctx->sock.registered)
640                 uloop_end();
641 }
642
643 struct ubus_context *ubus_connect(const char *path)
644 {
645         struct ubus_context *ctx;
646         struct {
647                 struct ubus_msghdr hdr;
648                 struct blob_attr data;
649         } hdr;
650         struct blob_attr *buf;
651
652         if (!path)
653                 path = UBUS_UNIX_SOCKET;
654
655         ctx = calloc(1, sizeof(*ctx));
656         if (!ctx)
657                 goto error;
658
659         ctx->sock.fd = usock(USOCK_UNIX, path, NULL);
660         if (ctx->sock.fd < 0) {
661                 DPRINTF("Failed to connect to server\n");
662                 goto error_free;
663         }
664         ctx->sock.cb = ubus_handle_data;
665
666         if (read(ctx->sock.fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
667                 DPRINTF("Failed to read initial message data\n");
668                 goto error_close;
669         }
670
671         if (!ubus_validate_hdr(&hdr.hdr)) {
672                 DPRINTF("Failed to validate initial message header\n");
673                 goto error_close;
674         }
675
676         if (hdr.hdr.type != UBUS_MSG_HELLO) {
677                 DPRINTF("Unexpected initial message\n");
678                 goto error_close;
679         }
680
681         buf = calloc(1, blob_raw_len(&hdr.data));
682         if (!buf)
683                 goto error_close;
684
685         memcpy(buf, &hdr.data, sizeof(hdr.data));
686         if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != blob_len(buf)) {
687                 DPRINTF("Failed to retrieve initial message data\n");
688                 goto error_free_buf;
689         }
690
691         ctx->local_id = hdr.hdr.peer;
692         free(buf);
693
694         ctx->connection_lost = ubus_default_connection_lost;
695
696         INIT_LIST_HEAD(&ctx->requests);
697         avl_init(&ctx->objects, ubus_cmp_id, false, NULL);
698
699         if (!ctx->local_id) {
700                 DPRINTF("Failed to get local peer id\n");
701                 goto error_close;
702         }
703
704         return ctx;
705
706 error_free_buf:
707         free(buf);
708 error_close:
709         close(ctx->sock.fd);
710 error_free:
711         free(ctx);
712 error:
713         return NULL;
714 }
715
716 void ubus_free(struct ubus_context *ctx)
717 {
718         close(ctx->sock.fd);
719         free(ctx);
720 }