• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/ubus/lua/ubus.c

  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