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