libubus.c

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