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 }