1 /* 2 * Copyright (C) 2012 Jo-Philipp Wich <jow@openwrt.org> 3 * Copyright (C) 2012 John Crispin <blogic@openwrt.org> 4 * Copyright (C) 2016 Iain Fraser <iainf@netduma.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU Lesser General Public License version 2.1 8 * as published by the Free Software Foundation 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 16 #include <unistd.h> 17 #include <libubus.h> 18 #include <libubox/blobmsg.h> 19 #include <libubox/blobmsg_json.h> 20 #include <lauxlib.h> 21 #include <lua.h> 22 23 #define MODNAME "ubus" 24 #define METANAME MODNAME ".meta" 25 26 static lua_State *state; 27 28 struct ubus_lua_connection { 29 int timeout; 30 struct blob_buf buf; 31 struct ubus_context *ctx; 32 }; 33 34 struct ubus_lua_object { 35 struct ubus_object o; 36 int r; 37 int rsubscriber; 38 }; 39 40 struct ubus_lua_event { 41 struct ubus_event_handler e; 42 int r; 43 }; 44 45 struct ubus_lua_subscriber { 46 struct ubus_subscriber s; 47 int rnotify; 48 int rremove; 49 }; 50 51 static int 52 ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table); 53 54 static int 55 ubus_lua_parse_blob_array(lua_State *L, struct blob_attr *attr, size_t len, bool table) 56 { 57 int rv; 58 int idx = 1; 59 size_t rem = len; 60 struct blob_attr *pos; 61 62 lua_newtable(L); 63 64 __blob_for_each_attr(pos, attr, rem) 65 { 66 rv = ubus_lua_parse_blob(L, pos, table); 67 68 if (rv > 1) 69 lua_rawset(L, -3); 70 else if (rv > 0) 71 lua_rawseti(L, -2, idx++); 72 } 73 74 return 1; 75 } 76 77 static int 78 ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table) 79 { 80 int len; 81 int off = 0; 82 void *data; 83 84 if (!blobmsg_check_attr(attr, false)) 85 return 0; 86 87 if (table && blobmsg_name(attr)[0]) 88 { 89 lua_pushstring(L, blobmsg_name(attr)); 90 off++; 91 } 92 93 data = blobmsg_data(attr); 94 len = blobmsg_data_len(attr); 95 96 switch (blob_id(attr)) 97 { 98 case BLOBMSG_TYPE_BOOL: 99 lua_pushboolean(L, *(uint8_t *)data); 100 break; 101 102 case BLOBMSG_TYPE_INT16: 103 lua_pushinteger(L, be16_to_cpu(*(uint16_t *)data)); 104 break; 105 106 case BLOBMSG_TYPE_INT32: 107 lua_pushinteger(L, be32_to_cpu(*(uint32_t *)data)); 108 break; 109 110 case BLOBMSG_TYPE_INT64: 111 lua_pushnumber(L, (double) be64_to_cpu(*(uint64_t *)data)); 112 break; 113 114 case BLOBMSG_TYPE_DOUBLE: 115 { 116 union { 117 double d; 118 uint64_t u64; 119 } v; 120 v.u64 = be64_to_cpu(*(uint64_t *)data); 121 lua_pushnumber(L, v.d); 122 } 123 break; 124 125 case BLOBMSG_TYPE_STRING: 126 lua_pushstring(L, data); 127 break; 128 129 case BLOBMSG_TYPE_ARRAY: 130 ubus_lua_parse_blob_array(L, data, len, false); 131 break; 132 133 case BLOBMSG_TYPE_TABLE: 134 ubus_lua_parse_blob_array(L, data, len, true); 135 break; 136 137 default: 138 lua_pushnil(L); 139 break; 140 } 141 142 return off + 1; 143 } 144 145 146 static bool 147 ubus_lua_format_blob_is_array(lua_State *L) 148 { 149 lua_Integer prv = 0; 150 lua_Integer cur = 0; 151 152 /* Find out whether table is array-like */ 153 for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) 154 { 155 #ifdef LUA_TINT 156 if (lua_type(L, -2) != LUA_TNUMBER && lua_type(L, -2) != LUA_TINT) 157 #else 158 if (lua_type(L, -2) != LUA_TNUMBER) 159 #endif 160 { 161 lua_pop(L, 2); 162 return false; 163 } 164 165 cur = lua_tointeger(L, -2); 166 167 if ((cur - 1) != prv) 168 { 169 lua_pop(L, 2); 170 return false; 171 } 172 173 prv = cur; 174 } 175 176 return true; 177 } 178 179 static int 180 ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table); 181 182 static int 183 ubus_lua_format_blob(lua_State *L, struct blob_buf *b, bool table) 184 { 185 void *c; 186 bool rv = true; 187 const char *key = table ? lua_tostring(L, -2) : NULL; 188 189 switch (lua_type(L, -1)) 190 { 191 case LUA_TBOOLEAN: 192 blobmsg_add_u8(b, key, (uint8_t)lua_toboolean(L, -1)); 193 break; 194 195 #ifdef LUA_TINT 196 case LUA_TINT: 197 #endif 198 case LUA_TNUMBER: 199 blobmsg_add_u32(b, key, (uint32_t)lua_tointeger(L, -1)); 200 break; 201 202 case LUA_TSTRING: 203 case LUA_TUSERDATA: 204 case LUA_TLIGHTUSERDATA: 205 blobmsg_add_string(b, key, lua_tostring(L, -1)); 206 break; 207 208 case LUA_TTABLE: 209 if (ubus_lua_format_blob_is_array(L)) 210 { 211 c = blobmsg_open_array(b, key); 212 rv = ubus_lua_format_blob_array(L, b, false); 213 blobmsg_close_array(b, c); 214 } 215 else 216 { 217 c = blobmsg_open_table(b, key); 218 rv = ubus_lua_format_blob_array(L, b, true); 219 blobmsg_close_table(b, c); 220 } 221 break; 222 223 default: 224 rv = false; 225 break; 226 } 227 228 return rv; 229 } 230 231 static int 232 ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table) 233 { 234 for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) 235 { 236 if (!ubus_lua_format_blob(L, b, table)) 237 { 238 lua_pop(L, 1); 239 return false; 240 } 241 } 242 243 return true; 244 } 245 246 247 static int 248 ubus_lua_connect(lua_State *L) 249 { 250 struct ubus_lua_connection *c; 251 const char *sockpath = luaL_optstring(L, 1, NULL); 252 int timeout = luaL_optint(L, 2, 30); 253 254 if ((c = lua_newuserdata(L, sizeof(*c))) != NULL && 255 (c->ctx = ubus_connect(sockpath)) != NULL) 256 { 257 ubus_add_uloop(c->ctx); 258 c->timeout = timeout; 259 memset(&c->buf, 0, sizeof(c->buf)); 260 luaL_getmetatable(L, METANAME); 261 lua_setmetatable(L, -2); 262 return 1; 263 } 264 265 /* NB: no errors from ubus_connect() yet */ 266 lua_pushnil(L); 267 lua_pushinteger(L, UBUS_STATUS_UNKNOWN_ERROR); 268 return 2; 269 } 270 271 272 static void 273 ubus_lua_objects_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) 274 { 275 lua_State *L = (lua_State *)p; 276 277 lua_pushstring(L, o->path); 278 lua_rawseti(L, -2, lua_objlen(L, -2) + 1); 279 } 280 281 static int 282 ubus_lua_objects(lua_State *L) 283 { 284 int rv; 285 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 286 287 lua_newtable(L); 288 rv = ubus_lookup(c->ctx, NULL, ubus_lua_objects_cb, L); 289 290 if (rv != UBUS_STATUS_OK) 291 { 292 lua_pop(L, 1); 293 lua_pushnil(L); 294 lua_pushinteger(L, rv); 295 return 2; 296 } 297 298 return 1; 299 } 300 301 static int 302 ubus_method_handler(struct ubus_context *ctx, struct ubus_object *obj, 303 struct ubus_request_data *req, const char *method, 304 struct blob_attr *msg) 305 { 306 struct ubus_lua_object *o = container_of(obj, struct ubus_lua_object, o); 307 int rv = 0; 308 309 lua_getglobal(state, "__ubus_cb"); 310 lua_rawgeti(state, -1, o->r); 311 lua_getfield(state, -1, method); 312 lua_remove(state, -2); 313 lua_remove(state, -2); 314 315 if (lua_isfunction(state, -1)) { 316 lua_pushlightuserdata(state, req); 317 if (!msg) 318 lua_pushnil(state); 319 else 320 ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true); 321 lua_call(state, 2, 1); 322 if (lua_isnumber(state, -1)) 323 rv = lua_tonumber(state, -1); 324 } 325 326 lua_pop(state, 1); 327 328 return rv; 329 } 330 331 static int lua_gettablelen(lua_State *L, int index) 332 { 333 int cnt = 0; 334 335 lua_pushnil(L); 336 index -= 1; 337 while (lua_next(L, index) != 0) { 338 cnt++; 339 lua_pop(L, 1); 340 } 341 342 return cnt; 343 } 344 345 static int ubus_lua_reply(lua_State *L) 346 { 347 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 348 struct ubus_request_data *req; 349 350 luaL_checktype(L, 3, LUA_TTABLE); 351 blob_buf_init(&c->buf, 0); 352 353 if (!ubus_lua_format_blob_array(L, &c->buf, true)) 354 { 355 lua_pushnil(L); 356 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT); 357 return 2; 358 } 359 360 req = lua_touserdata(L, 2); 361 ubus_send_reply(c->ctx, req, c->buf.head); 362 363 return 0; 364 } 365 366 static int ubus_lua_defer_request(lua_State *L) 367 { 368 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 369 struct ubus_request_data *req = lua_touserdata(L, 2); 370 struct ubus_request_data *new_req = lua_newuserdata(L, sizeof(struct ubus_request_data)); 371 ubus_defer_request(c->ctx, req, new_req); 372 373 return 1; 374 } 375 376 static int ubus_lua_complete_deferred_request(lua_State *L) 377 { 378 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 379 struct ubus_request_data *req = lua_touserdata(L, 2); 380 int ret = luaL_checkinteger(L, 3); 381 ubus_complete_deferred_request(c->ctx, req, ret); 382 383 return 0; 384 } 385 386 static int ubus_lua_load_methods(lua_State *L, struct ubus_method *m) 387 { 388 struct blobmsg_policy *p; 389 int plen; 390 int pidx = 0; 391 392 /* get the function pointer */ 393 lua_pushinteger(L, 1); 394 lua_gettable(L, -2); 395 396 /* get the policy table */ 397 lua_pushinteger(L, 2); 398 lua_gettable(L, -3); 399 400 /* check if the method table is valid */ 401 if ((lua_type(L, -2) != LUA_TFUNCTION) || 402 (lua_type(L, -1) != LUA_TTABLE) || 403 lua_objlen(L, -1)) { 404 lua_pop(L, 2); 405 return 1; 406 } 407 408 /* store function pointer */ 409 lua_pushvalue(L, -2); 410 lua_setfield(L, -6, lua_tostring(L, -5)); 411 412 m->name = lua_tostring(L, -4); 413 m->handler = ubus_method_handler; 414 415 plen = lua_gettablelen(L, -1); 416 417 /* exit if policy table is empty */ 418 if (!plen) { 419 lua_pop(L, 2); 420 return 0; 421 } 422 423 /* setup the policy pointers */ 424 p = calloc(plen, sizeof(struct blobmsg_policy)); 425 if (!p) 426 return 1; 427 428 m->policy = p; 429 lua_pushnil(L); 430 while (lua_next(L, -2) != 0) { 431 int val = lua_tointeger(L, -1); 432 433 /* check if the policy is valid */ 434 if ((lua_type(L, -2) != LUA_TSTRING) || 435 (lua_type(L, -1) != LUA_TNUMBER) || 436 (val < 0) || 437 (val > BLOBMSG_TYPE_LAST)) { 438 lua_pop(L, 1); 439 continue; 440 } 441 p[pidx].name = lua_tostring(L, -2); 442 p[pidx].type = val; 443 lua_pop(L, 1); 444 pidx++; 445 } 446 447 m->n_policy = pidx; 448 lua_pop(L, 2); 449 450 return 0; 451 } 452 453 static void 454 ubus_new_sub_cb(struct ubus_context *ctx, struct ubus_object *obj) 455 { 456 struct ubus_lua_object *luobj; 457 458 luobj = container_of(obj, struct ubus_lua_object, o); 459 460 lua_getglobal(state, "__ubus_cb_publisher"); 461 lua_rawgeti(state, -1, luobj->rsubscriber); 462 lua_remove(state, -2); 463 464 if (lua_isfunction(state, -1)) { 465 lua_pushnumber(state, luobj->o.has_subscribers ); 466 lua_call(state, 1, 0); 467 } else { 468 lua_pop(state, 1); 469 } 470 } 471 472 static void 473 ubus_lua_load_newsub_cb( lua_State *L, struct ubus_lua_object *obj ) 474 { 475 /* keep ref to func */ 476 lua_getglobal(L, "__ubus_cb_publisher"); 477 lua_pushvalue(L, -2); 478 obj->rsubscriber = luaL_ref(L, -2); 479 lua_pop(L, 1); 480 481 /* real callback */ 482 obj->o.subscribe_cb = ubus_new_sub_cb; 483 return; 484 } 485 486 static struct ubus_object* ubus_lua_load_object(lua_State *L) 487 { 488 struct ubus_lua_object *obj = NULL; 489 int mlen = lua_gettablelen(L, -1); 490 struct ubus_method *m; 491 int midx = 0; 492 493 /* setup object pointers */ 494 obj = calloc(1, sizeof(struct ubus_lua_object)); 495 if (!obj) 496 return NULL; 497 498 obj->o.name = lua_tostring(L, -2); 499 500 /* setup method pointers */ 501 m = calloc(mlen, sizeof(struct ubus_method)); 502 obj->o.methods = m; 503 504 /* setup type pointers */ 505 obj->o.type = calloc(1, sizeof(struct ubus_object_type)); 506 if (!obj->o.type) { 507 free(obj); 508 return NULL; 509 } 510 511 obj->o.type->name = lua_tostring(L, -2); 512 obj->o.type->id = 0; 513 obj->o.type->methods = obj->o.methods; 514 515 /* create the callback lookup table */ 516 lua_createtable(L, 1, 0); 517 lua_getglobal(L, "__ubus_cb"); 518 lua_pushvalue(L, -2); 519 obj->r = luaL_ref(L, -2); 520 lua_pop(L, 1); 521 522 /* scan each method */ 523 lua_pushnil(L); 524 while (lua_next(L, -3) != 0) { 525 /* check if its the subscriber notification callback */ 526 if( lua_type( L, -2 ) == LUA_TSTRING && 527 lua_type( L, -1 ) == LUA_TFUNCTION ){ 528 if( !strcmp( lua_tostring( L, -2 ), "__subscriber_cb" ) ) 529 ubus_lua_load_newsub_cb( L, obj ); 530 } 531 532 /* check if it looks like a method */ 533 if ((lua_type(L, -2) != LUA_TSTRING) || 534 (lua_type(L, -1) != LUA_TTABLE) || 535 !lua_objlen(L, -1)) { 536 lua_pop(L, 1); 537 continue; 538 } 539 540 if (!ubus_lua_load_methods(L, &m[midx])) 541 midx++; 542 lua_pop(L, 1); 543 } 544 545 obj->o.type->n_methods = obj->o.n_methods = midx; 546 547 /* pop the callback table */ 548 lua_pop(L, 1); 549 550 return &obj->o; 551 } 552 553 static int ubus_lua_add(lua_State *L) 554 { 555 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 556 557 /* verify top level object */ 558 if (lua_istable(L, 1)) { 559 lua_pushstring(L, "you need to pass a table"); 560 return lua_error(L); 561 } 562 563 /* scan each object */ 564 lua_pushnil(L); 565 while (lua_next(L, -2) != 0) { 566 struct ubus_object *obj = NULL; 567 568 /* check if the object has a table of methods */ 569 if ((lua_type(L, -2) == LUA_TSTRING) && (lua_type(L, -1) == LUA_TTABLE)) { 570 obj = ubus_lua_load_object(L); 571 572 if (obj){ 573 ubus_add_object(c->ctx, obj); 574 575 /* allow future reference of ubus obj */ 576 lua_pushstring(state,"__ubusobj"); 577 lua_pushlightuserdata(state, obj); 578 lua_settable(state,-3); 579 } 580 } 581 lua_pop(L, 1); 582 } 583 584 return 0; 585 } 586 587 static int 588 ubus_lua_notify( lua_State *L ) 589 { 590 struct ubus_lua_connection *c; 591 struct ubus_object *obj; 592 const char* method; 593 594 c = luaL_checkudata(L, 1, METANAME); 595 method = luaL_checkstring(L, 3); 596 luaL_checktype(L, 4, LUA_TTABLE); 597 598 if( !lua_islightuserdata( L, 2 ) ){ 599 lua_pushfstring( L, "Invald 2nd parameter, expected ubus obj ref" ); 600 return lua_error( L ); 601 } 602 obj = lua_touserdata( L, 2 ); 603 604 /* create parameters from table */ 605 blob_buf_init(&c->buf, 0); 606 if( !ubus_lua_format_blob_array( L, &c->buf, true ) ){ 607 lua_pushfstring( L, "Invalid 4th parameter, expected table of arguments" ); 608 return lua_error( L ); 609 } 610 611 ubus_notify( c->ctx, obj, method, c->buf.head, -1 ); 612 return 0; 613 } 614 615 static void 616 ubus_lua_signatures_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) 617 { 618 lua_State *L = (lua_State *)p; 619 620 if (!o->signature) 621 return; 622 623 ubus_lua_parse_blob_array(L, blob_data(o->signature), blob_len(o->signature), true); 624 } 625 626 static int 627 ubus_lua_signatures(lua_State *L) 628 { 629 int rv; 630 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 631 const char *path = luaL_checkstring(L, 2); 632 633 rv = ubus_lookup(c->ctx, path, ubus_lua_signatures_cb, L); 634 635 if (rv != UBUS_STATUS_OK) 636 { 637 lua_pop(L, 1); 638 lua_pushnil(L); 639 lua_pushinteger(L, rv); 640 return 2; 641 } 642 643 return 1; 644 } 645 646 647 static void 648 ubus_lua_call_cb(struct ubus_request *req, int type, struct blob_attr *msg) 649 { 650 lua_State *L = (lua_State *)req->priv; 651 652 if (!msg && L) 653 lua_pushnil(L); 654 655 if (msg && L) 656 ubus_lua_parse_blob_array(L, blob_data(msg), blob_len(msg), true); 657 } 658 659 static int 660 ubus_lua_call(lua_State *L) 661 { 662 int rv, top; 663 uint32_t id; 664 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 665 const char *path = luaL_checkstring(L, 2); 666 const char *func = luaL_checkstring(L, 3); 667 668 luaL_checktype(L, 4, LUA_TTABLE); 669 blob_buf_init(&c->buf, 0); 670 671 if (!ubus_lua_format_blob_array(L, &c->buf, true)) 672 { 673 lua_pushnil(L); 674 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT); 675 return 2; 676 } 677 678 rv = ubus_lookup_id(c->ctx, path, &id); 679 680 if (rv) 681 { 682 lua_pushnil(L); 683 lua_pushinteger(L, rv); 684 return 2; 685 } 686 687 top = lua_gettop(L); 688 rv = ubus_invoke(c->ctx, id, func, c->buf.head, ubus_lua_call_cb, L, c->timeout * 1000); 689 690 if (rv != UBUS_STATUS_OK) 691 { 692 lua_pop(L, 1); 693 lua_pushnil(L); 694 lua_pushinteger(L, rv); 695 return 2; 696 } 697 698 return lua_gettop(L) - top; 699 } 700 701 static void 702 ubus_event_handler(struct ubus_context *ctx, struct ubus_event_handler *ev, 703 const char *type, struct blob_attr *msg) 704 { 705 struct ubus_lua_event *listener = container_of(ev, struct ubus_lua_event, e); 706 707 lua_getglobal(state, "__ubus_cb_event"); 708 lua_rawgeti(state, -1, listener->r); 709 lua_remove(state, -2); 710 711 if (lua_isfunction(state, -1)) { 712 ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true); 713 lua_call(state, 1, 0); 714 } else { 715 lua_pop(state, 1); 716 } 717 } 718 719 static struct ubus_event_handler* 720 ubus_lua_load_event(lua_State *L) 721 { 722 struct ubus_lua_event* event = NULL; 723 724 event = calloc(1, sizeof(struct ubus_lua_event)); 725 if (!event) 726 return NULL; 727 728 event->e.cb = ubus_event_handler; 729 730 /* update the he callback lookup table */ 731 lua_getglobal(L, "__ubus_cb_event"); 732 lua_pushvalue(L, -2); 733 event->r = luaL_ref(L, -2); 734 lua_setfield(L, -1, lua_tostring(L, -3)); 735 736 return &event->e; 737 } 738 739 static int 740 ubus_lua_listen(lua_State *L) { 741 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 742 743 /* verify top level object */ 744 luaL_checktype(L, 2, LUA_TTABLE); 745 746 /* scan each object */ 747 lua_pushnil(L); 748 while (lua_next(L, -2) != 0) { 749 struct ubus_event_handler *listener; 750 751 /* check if the key is a string and the value is a method */ 752 if ((lua_type(L, -2) == LUA_TSTRING) && (lua_type(L, -1) == LUA_TFUNCTION)) { 753 listener = ubus_lua_load_event(L); 754 if(listener != NULL) { 755 ubus_register_event_handler(c->ctx, listener, lua_tostring(L, -2)); 756 } 757 } 758 lua_pop(L, 1); 759 } 760 return 0; 761 } 762 763 static void 764 ubus_sub_remove_handler(struct ubus_context *ctx, struct ubus_subscriber *s, 765 uint32_t id) 766 { 767 struct ubus_lua_subscriber *sub; 768 769 sub = container_of(s, struct ubus_lua_subscriber, s); 770 771 lua_getglobal(state, "__ubus_cb_subscribe"); 772 lua_rawgeti(state, -1, sub->rremove); 773 lua_remove(state, -2); 774 775 if (lua_isfunction(state, -1)) { 776 lua_call(state, 0, 0); 777 } else { 778 lua_pop(state, 1); 779 } 780 } 781 782 static int 783 ubus_sub_notify_handler(struct ubus_context *ctx, struct ubus_object *obj, 784 struct ubus_request_data *req, const char *method, 785 struct blob_attr *msg) 786 { 787 struct ubus_subscriber *s; 788 struct ubus_lua_subscriber *sub; 789 790 s = container_of(obj, struct ubus_subscriber, obj); 791 sub = container_of(s, struct ubus_lua_subscriber, s); 792 793 lua_getglobal(state, "__ubus_cb_subscribe"); 794 lua_rawgeti(state, -1, sub->rnotify); 795 lua_remove(state, -2); 796 797 if (lua_isfunction(state, -1)) { 798 if( msg ){ 799 ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true); 800 } else { 801 lua_pushnil(state); 802 } 803 lua_pushstring(state, method); 804 lua_call(state, 2, 0); 805 } else { 806 lua_pop(state, 1); 807 } 808 809 return 0; 810 } 811 812 813 814 static int 815 ubus_lua_do_subscribe( struct ubus_context *ctx, lua_State *L, const char* target, 816 int idxnotify, int idxremove ) 817 { 818 uint32_t id; 819 int status; 820 struct ubus_lua_subscriber *sub; 821 822 if( ( status = ubus_lookup_id( ctx, target, &id ) ) ){ 823 lua_pushfstring( L, "Unable find target, status=%d", status ); 824 return lua_error( L ); 825 } 826 827 sub = calloc( 1, sizeof( struct ubus_lua_subscriber ) ); 828 if( !sub ){ 829 lua_pushstring( L, "Out of memory" ); 830 return lua_error( L ); 831 } 832 833 if( idxnotify ){ 834 lua_getglobal(L, "__ubus_cb_subscribe"); 835 lua_pushvalue(L, idxnotify); 836 sub->rnotify = luaL_ref(L, -2); 837 lua_pop(L, 1); 838 sub->s.cb = ubus_sub_notify_handler; 839 } 840 841 if( idxremove ){ 842 lua_getglobal(L, "__ubus_cb_subscribe"); 843 lua_pushvalue(L, idxremove); 844 sub->rremove = luaL_ref(L, -2); 845 lua_pop(L, 1); 846 sub->s.remove_cb = ubus_sub_remove_handler; 847 } 848 849 if( ( status = ubus_register_subscriber( ctx, &sub->s ) ) ){ 850 lua_pushfstring( L, "Failed to register subscriber, status=%d", status ); 851 return lua_error( L ); 852 } 853 854 if( ( status = ubus_subscribe( ctx, &sub->s, id) ) ){ 855 lua_pushfstring( L, "Failed to register subscriber, status=%d", status ); 856 return lua_error( L ); 857 } 858 859 return 0; 860 } 861 862 static int 863 ubus_lua_subscribe(lua_State *L) { 864 int idxnotify, idxremove, stackstart; 865 struct ubus_lua_connection *c; 866 const char* target; 867 868 idxnotify = idxremove = 0; 869 stackstart = lua_gettop( L ); 870 871 872 c = luaL_checkudata(L, 1, METANAME); 873 target = luaL_checkstring(L, 2); 874 luaL_checktype(L, 3, LUA_TTABLE); 875 876 877 lua_pushstring( L, "notify"); 878 lua_gettable( L, 3 ); 879 if( lua_type( L, -1 ) == LUA_TFUNCTION ){ 880 idxnotify = lua_gettop( L ); 881 } else { 882 lua_pop( L, 1 ); 883 } 884 885 lua_pushstring( L, "remove"); 886 lua_gettable( L, 3 ); 887 if( lua_type( L, -1 ) == LUA_TFUNCTION ){ 888 idxremove = lua_gettop( L ); 889 } else { 890 lua_pop( L, 1 ); 891 } 892 893 if( idxnotify ) 894 ubus_lua_do_subscribe( c->ctx, L, target, idxnotify, idxremove ); 895 896 if( lua_gettop( L ) > stackstart ) 897 lua_pop( L, lua_gettop( L ) - stackstart ); 898 899 return 0; 900 } 901 902 static int 903 ubus_lua_send(lua_State *L) 904 { 905 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 906 const char *event = luaL_checkstring(L, 2); 907 908 if (*event == 0) 909 return luaL_argerror(L, 2, "no event name"); 910 911 // Event content convert to ubus form 912 luaL_checktype(L, 3, LUA_TTABLE); 913 blob_buf_init(&c->buf, 0); 914 915 if (!ubus_lua_format_blob_array(L, &c->buf, true)) { 916 lua_pushnil(L); 917 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT); 918 return 2; 919 } 920 921 // Send the event 922 ubus_send_event(c->ctx, event, c->buf.head); 923 924 return 0; 925 } 926 927 928 929 static int 930 ubus_lua__gc(lua_State *L) 931 { 932 struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); 933 934 blob_buf_free(&c->buf); 935 if (c->ctx != NULL) 936 { 937 ubus_free(c->ctx); 938 memset(c, 0, sizeof(*c)); 939 } 940 941 return 0; 942 } 943 944 static const luaL_Reg ubus[] = { 945 { "connect", ubus_lua_connect }, 946 { "objects", ubus_lua_objects }, 947 { "add", ubus_lua_add }, 948 { "notify", ubus_lua_notify }, 949 { "reply", ubus_lua_reply }, 950 { "defer_request", ubus_lua_defer_request }, 951 { "complete_deferred_request", ubus_lua_complete_deferred_request }, 952 { "signatures", ubus_lua_signatures }, 953 { "call", ubus_lua_call }, 954 { "close", ubus_lua__gc }, 955 { "listen", ubus_lua_listen }, 956 { "send", ubus_lua_send }, 957 { "subscribe", ubus_lua_subscribe }, 958 { "__gc", ubus_lua__gc }, 959 { NULL, NULL }, 960 }; 961 962 /* avoid missing prototype warning */ 963 int luaopen_ubus(lua_State *L); 964 965 int 966 luaopen_ubus(lua_State *L) 967 { 968 /* create metatable */ 969 luaL_newmetatable(L, METANAME); 970 971 /* metatable.__index = metatable */ 972 lua_pushvalue(L, -1); 973 lua_setfield(L, -2, "__index"); 974 975 /* fill metatable */ 976 luaL_register(L, NULL, ubus); 977 lua_pop(L, 1); 978 979 /* create module */ 980 luaL_register(L, MODNAME, ubus); 981 982 /* set some enum defines */ 983 lua_pushinteger(L, BLOBMSG_TYPE_ARRAY); 984 lua_setfield(L, -2, "ARRAY"); 985 lua_pushinteger(L, BLOBMSG_TYPE_TABLE); 986 lua_setfield(L, -2, "TABLE"); 987 lua_pushinteger(L, BLOBMSG_TYPE_STRING); 988 lua_setfield(L, -2, "STRING"); 989 lua_pushinteger(L, BLOBMSG_TYPE_INT64); 990 lua_setfield(L, -2, "INT64"); 991 lua_pushinteger(L, BLOBMSG_TYPE_INT32); 992 lua_setfield(L, -2, "INT32"); 993 lua_pushinteger(L, BLOBMSG_TYPE_INT16); 994 lua_setfield(L, -2, "INT16"); 995 lua_pushinteger(L, BLOBMSG_TYPE_INT8); 996 lua_setfield(L, -2, "INT8"); 997 lua_pushinteger(L, BLOBMSG_TYPE_DOUBLE); 998 lua_setfield(L, -2, "DOUBLE"); 999 lua_pushinteger(L, BLOBMSG_TYPE_BOOL); 1000 lua_setfield(L, -2, "BOOLEAN"); 1001 1002 /* used in our callbacks */ 1003 state = L; 1004 1005 /* create the callback table */ 1006 lua_createtable(L, 1, 0); 1007 lua_setglobal(L, "__ubus_cb"); 1008 1009 /* create the event table */ 1010 lua_createtable(L, 1, 0); 1011 lua_setglobal(L, "__ubus_cb_event"); 1012 1013 /* create the subscriber table */ 1014 lua_createtable(L, 1, 0); 1015 lua_setglobal(L, "__ubus_cb_subscribe"); 1016 1017 /* create the publisher table - notifications of new subs */ 1018 lua_createtable(L, 1, 0); 1019 lua_setglobal(L, "__ubus_cb_publisher"); 1020 return 0; 1021 } 1022
This page was automatically generated by LXR 0.3.1. • OpenWrt