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