libubus: expose ubus_connect_ctx() in public API
[project/ubus.git] / lua / ubus.c
1 /*
2  * Copyright (C) 2012 Jo-Philipp Wich <jow@openwrt.org>
3  * Copyright (C) 2012 John Crispin <blogic@openwrt.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU Lesser General Public License version 2.1
7  * as published by the Free Software Foundation
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <unistd.h>
16 #include <libubus.h>
17 #include <libubox/blobmsg.h>
18 #include <libubox/blobmsg_json.h>
19 #include <lauxlib.h>
20 #include <lua.h>
21
22 #define MODNAME         "ubus"
23 #define METANAME        MODNAME ".meta"
24
25 static lua_State *state;
26
27 struct ubus_lua_connection {
28         int timeout;
29         struct blob_buf buf;
30         struct ubus_context *ctx;
31 };
32
33 struct ubus_lua_object {
34         struct ubus_object o;
35         int r;
36 };
37
38 struct ubus_lua_event {
39         struct ubus_event_handler e;
40         int r;
41 };
42
43 static int
44 ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table);
45
46 static int
47 ubus_lua_parse_blob_array(lua_State *L, struct blob_attr *attr, int len, bool table)
48 {
49         int rv;
50         int idx = 1;
51         int rem = len;
52         struct blob_attr *pos;
53
54         lua_newtable(L);
55
56         __blob_for_each_attr(pos, attr, rem)
57         {
58                 rv = ubus_lua_parse_blob(L, pos, table);
59
60                 if (rv > 1)
61                         lua_rawset(L, -3);
62                 else if (rv > 0)
63                         lua_rawseti(L, -2, idx++);
64         }
65
66         return 1;
67 }
68
69 static int
70 ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table)
71 {
72         int len;
73         int off = 0;
74         void *data;
75
76         if (!blobmsg_check_attr(attr, false))
77                 return 0;
78
79         if (table && blobmsg_name(attr)[0])
80         {
81                 lua_pushstring(L, blobmsg_name(attr));
82                 off++;
83         }
84
85         data = blobmsg_data(attr);
86         len = blobmsg_data_len(attr);
87
88         switch (blob_id(attr))
89         {
90         case BLOBMSG_TYPE_BOOL:
91                 lua_pushboolean(L, *(uint8_t *)data);
92                 break;
93
94         case BLOBMSG_TYPE_INT16:
95                 lua_pushinteger(L, be16_to_cpu(*(uint16_t *)data));
96                 break;
97
98         case BLOBMSG_TYPE_INT32:
99                 lua_pushinteger(L, be32_to_cpu(*(uint32_t *)data));
100                 break;
101
102         case BLOBMSG_TYPE_INT64:
103                 lua_pushnumber(L, (double) be64_to_cpu(*(uint64_t *)data));
104                 break;
105
106         case BLOBMSG_TYPE_STRING:
107                 lua_pushstring(L, data);
108                 break;
109
110         case BLOBMSG_TYPE_ARRAY:
111                 ubus_lua_parse_blob_array(L, data, len, false);
112                 break;
113
114         case BLOBMSG_TYPE_TABLE:
115                 ubus_lua_parse_blob_array(L, data, len, true);
116                 break;
117
118         default:
119                 lua_pushnil(L);
120                 break;
121         }
122
123         return off + 1;
124 }
125
126
127 static bool
128 ubus_lua_format_blob_is_array(lua_State *L)
129 {
130         lua_Integer prv = 0;
131         lua_Integer cur = 0;
132
133         /* Find out whether table is array-like */
134         for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1))
135         {
136 #ifdef LUA_TINT
137                 if (lua_type(L, -2) != LUA_TNUMBER && lua_type(L, -2) != LUA_TINT)
138 #else
139                 if (lua_type(L, -2) != LUA_TNUMBER)
140 #endif
141                 {
142                         lua_pop(L, 2);
143                         return false;
144                 }
145
146                 cur = lua_tointeger(L, -2);
147
148                 if ((cur - 1) != prv)
149                 {
150                         lua_pop(L, 2);
151                         return false;
152                 }
153
154                 prv = cur;
155         }
156
157         return true;
158 }
159
160 static int
161 ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table);
162
163 static int
164 ubus_lua_format_blob(lua_State *L, struct blob_buf *b, bool table)
165 {
166         void *c;
167         bool rv = true;
168         const char *key = table ? lua_tostring(L, -2) : NULL;
169
170         switch (lua_type(L, -1))
171         {
172         case LUA_TBOOLEAN:
173                 blobmsg_add_u8(b, key, (uint8_t)lua_toboolean(L, -1));
174                 break;
175
176 #ifdef LUA_TINT
177         case LUA_TINT:
178 #endif
179         case LUA_TNUMBER:
180                 blobmsg_add_u32(b, key, (uint32_t)lua_tointeger(L, -1));
181                 break;
182
183         case LUA_TSTRING:
184         case LUA_TUSERDATA:
185         case LUA_TLIGHTUSERDATA:
186                 blobmsg_add_string(b, key, lua_tostring(L, -1));
187                 break;
188
189         case LUA_TTABLE:
190                 if (ubus_lua_format_blob_is_array(L))
191                 {
192                         c = blobmsg_open_array(b, key);
193                         rv = ubus_lua_format_blob_array(L, b, false);
194                         blobmsg_close_array(b, c);
195                 }
196                 else
197                 {
198                         c = blobmsg_open_table(b, key);
199                         rv = ubus_lua_format_blob_array(L, b, true);
200                         blobmsg_close_table(b, c);
201                 }
202                 break;
203
204         default:
205                 rv = false;
206                 break;
207         }
208
209         return rv;
210 }
211
212 static int
213 ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table)
214 {
215         for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1))
216         {
217                 if (!ubus_lua_format_blob(L, b, table))
218                 {
219                         lua_pop(L, 1);
220                         return false;
221                 }
222         }
223
224         return true;
225 }
226
227
228 static int
229 ubus_lua_connect(lua_State *L)
230 {
231         struct ubus_lua_connection *c;
232         const char *sockpath = luaL_optstring(L, 1, NULL);
233         int timeout = luaL_optint(L, 2, 30);
234
235         if ((c = lua_newuserdata(L, sizeof(*c))) != NULL &&
236                 (c->ctx = ubus_connect(sockpath)) != NULL)
237         {
238                 ubus_add_uloop(c->ctx);
239                 c->timeout = timeout;
240                 memset(&c->buf, 0, sizeof(c->buf));
241                 luaL_getmetatable(L, METANAME);
242                 lua_setmetatable(L, -2);
243                 return 1;
244         }
245
246         /* NB: no errors from ubus_connect() yet */
247         lua_pushnil(L);
248         lua_pushinteger(L, UBUS_STATUS_UNKNOWN_ERROR);
249         return 2;
250 }
251
252
253 static void
254 ubus_lua_objects_cb(struct ubus_context *c, struct ubus_object_data *o, void *p)
255 {
256         lua_State *L = (lua_State *)p;
257
258         lua_pushstring(L, o->path);
259         lua_rawseti(L, -2, lua_objlen(L, -2) + 1);
260 }
261
262 static int
263 ubus_lua_objects(lua_State *L)
264 {
265         int rv;
266         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
267
268         lua_newtable(L);
269         rv = ubus_lookup(c->ctx, NULL, ubus_lua_objects_cb, L);
270
271         if (rv != UBUS_STATUS_OK)
272         {
273                 lua_pop(L, 1);
274                 lua_pushnil(L);
275                 lua_pushinteger(L, rv);
276                 return 2;
277         }
278
279         return 1;
280 }
281
282 static int
283 ubus_method_handler(struct ubus_context *ctx, struct ubus_object *obj,
284                 struct ubus_request_data *req, const char *method,
285                 struct blob_attr *msg)
286 {
287         struct ubus_lua_object *o = container_of(obj, struct ubus_lua_object, o);
288         int rv = 0;
289
290         lua_getglobal(state, "__ubus_cb");
291         lua_rawgeti(state, -1, o->r);
292         lua_getfield(state, -1, method);
293         lua_remove(state, -2);
294         lua_remove(state, -2);
295
296         if (lua_isfunction(state, -1)) {
297                 lua_pushlightuserdata(state, req);
298                 if (!msg)
299                         lua_pushnil(state);
300                 else
301                         ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true);
302                 lua_call(state, 2, 1);
303                 if (lua_isnumber(state, -1))
304                         rv = lua_tonumber(state, -1);
305         } else
306                 lua_pop(state, 1);
307
308         return rv;
309 }
310
311 static int lua_gettablelen(lua_State *L, int index)
312 {
313         int cnt = 0;
314
315         lua_pushnil(L);
316         index -= 1;
317         while (lua_next(L, index) != 0) {
318                 cnt++;
319                 lua_pop(L, 1);
320         }
321
322         return cnt;
323 }
324
325 static int ubus_lua_reply(lua_State *L)
326 {
327         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
328         struct ubus_request_data *req;
329
330         luaL_checktype(L, 3, LUA_TTABLE);
331         blob_buf_init(&c->buf, 0);
332
333         if (!ubus_lua_format_blob_array(L, &c->buf, true))
334         {
335                 lua_pushnil(L);
336                 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT);
337                 return 2;
338         }
339
340         req = lua_touserdata(L, 2);
341         ubus_send_reply(c->ctx, req, c->buf.head);
342
343         return 0;
344 }
345
346 static int ubus_lua_load_methods(lua_State *L, struct ubus_method *m)
347 {
348         struct blobmsg_policy *p;
349         int plen;
350         int pidx = 0;
351
352         /* get the function pointer */
353         lua_pushinteger(L, 1);
354         lua_gettable(L, -2);
355
356         /* get the policy table */
357         lua_pushinteger(L, 2);
358         lua_gettable(L, -3);
359
360         /* check if the method table is valid */
361         if ((lua_type(L, -2) != LUA_TFUNCTION) ||
362                         (lua_type(L, -1) != LUA_TTABLE) ||
363                         lua_objlen(L, -1)) {
364                 lua_pop(L, 2);
365                 return 1;
366         }
367
368         /* store function pointer */
369         lua_pushvalue(L, -2);
370         lua_setfield(L, -6, lua_tostring(L, -5));
371
372         m->name = lua_tostring(L, -4);
373         m->handler = ubus_method_handler;
374
375         plen = lua_gettablelen(L, -1);
376
377         /* exit if policy table is empty */
378         if (!plen) {
379                 lua_pop(L, 2);
380                 return 0;
381         }
382
383         /* setup the policy pointers */
384         p = malloc(sizeof(struct blobmsg_policy) * plen);
385         memset(p, 0, sizeof(struct blobmsg_policy) * plen);
386         m->policy = p;
387         lua_pushnil(L);
388         while (lua_next(L, -2) != 0) {
389                 int val = lua_tointeger(L, -1);
390
391                 /* check if the policy is valid */
392                 if ((lua_type(L, -2) != LUA_TSTRING) ||
393                                 (lua_type(L, -1) != LUA_TNUMBER) ||
394                                 (val < 0) ||
395                                 (val > BLOBMSG_TYPE_LAST)) {
396                         lua_pop(L, 1);
397                         continue;
398                 }
399                 p[pidx].name = lua_tostring(L, -2);
400                 p[pidx].type = val;
401                 lua_pop(L, 1);
402                 pidx++;
403         }
404
405         m->n_policy = pidx;
406         lua_pop(L, 2);
407
408         return 0;
409 }
410
411 static struct ubus_object* ubus_lua_load_object(lua_State *L)
412 {
413         struct ubus_lua_object *obj = NULL;
414         int mlen = lua_gettablelen(L, -1);
415         struct ubus_method *m;
416         int midx = 0;
417
418         /* setup object pointers */
419         obj = malloc(sizeof(struct ubus_lua_object));
420         memset(obj, 0, sizeof(struct ubus_lua_object));
421         obj->o.name = lua_tostring(L, -2);
422
423         /* setup method pointers */
424         m = malloc(sizeof(struct ubus_method) * mlen);
425         memset(m, 0, sizeof(struct ubus_method) * mlen);
426         obj->o.methods = m;
427
428         /* setup type pointers */
429         obj->o.type = malloc(sizeof(struct ubus_object_type));
430         memset(obj->o.type, 0, sizeof(struct ubus_object_type));
431         obj->o.type->name = lua_tostring(L, -2);
432         obj->o.type->id = 0;
433         obj->o.type->methods = obj->o.methods;
434
435         /* create the callback lookup table */
436         lua_createtable(L, 1, 0);
437         lua_getglobal(L, "__ubus_cb");
438         lua_pushvalue(L, -2);
439         obj->r = luaL_ref(L, -2);
440         lua_pop(L, 1);
441
442         /* scan each method */
443         lua_pushnil(L);
444         while (lua_next(L, -3) != 0) {
445                 /* check if it looks like a method */
446                 if ((lua_type(L, -2) != LUA_TSTRING) ||
447                                 (lua_type(L, -1) != LUA_TTABLE) ||
448                                 !lua_objlen(L, -1)) {
449                         lua_pop(L, 1);
450                         continue;
451                 }
452
453                 if (!ubus_lua_load_methods(L, &m[midx]))
454                         midx++;
455                 lua_pop(L, 1);
456         }
457
458         obj->o.type->n_methods = obj->o.n_methods = midx;
459
460         /* pop the callback table */
461         lua_pop(L, 1);
462
463         return &obj->o;
464 }
465
466 static int ubus_lua_add(lua_State *L)
467 {
468         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
469
470         /* verify top level object */
471         if (lua_istable(L, 1)) {
472                 lua_pushstring(L, "you need to pass a table");
473                 lua_error(L);
474                 return 0;
475         }
476
477         /* scan each object */
478         lua_pushnil(L);
479         while (lua_next(L, -2) != 0) {
480                 struct ubus_object *obj = NULL;
481
482                 /* check if the object has a table of methods */
483                 if ((lua_type(L, -2) == LUA_TSTRING) && (lua_type(L, -1) == LUA_TTABLE)) {
484                         obj = ubus_lua_load_object(L);
485
486                         if (obj)
487                                 ubus_add_object(c->ctx, obj);
488                 }
489                 lua_pop(L, 1);
490         }
491
492         return 0;
493 }
494
495 static void
496 ubus_lua_signatures_cb(struct ubus_context *c, struct ubus_object_data *o, void *p)
497 {
498         lua_State *L = (lua_State *)p;
499
500         if (!o->signature)
501                 return;
502
503         ubus_lua_parse_blob_array(L, blob_data(o->signature), blob_len(o->signature), true);
504 }
505
506 static int
507 ubus_lua_signatures(lua_State *L)
508 {
509         int rv;
510         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
511         const char *path = luaL_checkstring(L, 2);
512
513         rv = ubus_lookup(c->ctx, path, ubus_lua_signatures_cb, L);
514
515         if (rv != UBUS_STATUS_OK)
516         {
517                 lua_pop(L, 1);
518                 lua_pushnil(L);
519                 lua_pushinteger(L, rv);
520                 return 2;
521         }
522
523         return 1;
524 }
525
526
527 static void
528 ubus_lua_call_cb(struct ubus_request *req, int type, struct blob_attr *msg)
529 {
530         lua_State *L = (lua_State *)req->priv;
531
532         if (!msg)
533                 lua_pushnil(L);
534
535         ubus_lua_parse_blob_array(L, blob_data(msg), blob_len(msg), true);
536 }
537
538 static int
539 ubus_lua_call(lua_State *L)
540 {
541         int rv, top;
542         uint32_t id;
543         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
544         const char *path = luaL_checkstring(L, 2);
545         const char *func = luaL_checkstring(L, 3);
546
547         luaL_checktype(L, 4, LUA_TTABLE);
548         blob_buf_init(&c->buf, 0);
549
550         if (!ubus_lua_format_blob_array(L, &c->buf, true))
551         {
552                 lua_pushnil(L);
553                 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT);
554                 return 2;
555         }
556
557         rv = ubus_lookup_id(c->ctx, path, &id);
558
559         if (rv)
560         {
561                 lua_pushnil(L);
562                 lua_pushinteger(L, rv);
563                 return 2;
564         }
565
566         top = lua_gettop(L);
567         rv = ubus_invoke(c->ctx, id, func, c->buf.head, ubus_lua_call_cb, L, c->timeout * 1000);
568
569         if (rv != UBUS_STATUS_OK)
570         {
571                 lua_pop(L, 1);
572                 lua_pushnil(L);
573                 lua_pushinteger(L, rv);
574                 return 2;
575         }
576
577         return lua_gettop(L) - top;
578 }
579
580 static void
581 ubus_event_handler(struct ubus_context *ctx, struct ubus_event_handler *ev,
582                         const char *type, struct blob_attr *msg)
583 {
584         struct ubus_lua_event *listener = container_of(ev, struct ubus_lua_event, e);
585
586         lua_getglobal(state, "__ubus_cb_event");
587         lua_rawgeti(state, -1, listener->r);
588
589         if (lua_isfunction(state, -1)) {
590                 ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true);
591                 lua_call(state, 1, 0);
592         }
593 }
594
595 static struct ubus_event_handler*
596 ubus_lua_load_event(lua_State *L)
597 {
598         struct ubus_lua_event* event = NULL;
599
600         event = malloc(sizeof(struct ubus_lua_event));
601         memset(event, 0, sizeof(struct ubus_lua_event));
602         event->e.cb = ubus_event_handler;
603
604         /* update the he callback lookup table */
605         lua_getglobal(L, "__ubus_cb_event");
606         lua_pushvalue(L, -2);
607         event->r = luaL_ref(L, -2);
608         lua_setfield(L, -1, lua_tostring(L, -3));
609
610         return &event->e;
611 }
612
613 static int
614 ubus_lua_listen(lua_State *L) {
615         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
616
617         /* verify top level object */
618         luaL_checktype(L, 2, LUA_TTABLE);
619
620         /* scan each object */
621         lua_pushnil(L);
622         while (lua_next(L, -2) != 0) {
623                 struct ubus_event_handler *listener;
624
625                 /* check if the key is a string and the value is a method */
626                 if ((lua_type(L, -2) == LUA_TSTRING) && (lua_type(L, -1) == LUA_TFUNCTION)) {
627                         listener = ubus_lua_load_event(L);
628                         if(listener != NULL) {
629                                 ubus_register_event_handler(c->ctx, listener, lua_tostring(L, -2));
630                         }
631                 }
632                 lua_pop(L, 1);
633         }
634         return 0;
635 }
636
637 static int
638 ubus_lua_send(lua_State *L)
639 {
640         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
641         const char *event = luaL_checkstring(L, 2);
642
643         if (*event == 0)
644                 return luaL_argerror(L, 2, "no event name");
645
646         // Event content convert to ubus form
647         luaL_checktype(L, 3, LUA_TTABLE);
648         blob_buf_init(&c->buf, 0);
649
650         if (!ubus_lua_format_blob_array(L, &c->buf, true)) {
651                 lua_pushnil(L);
652                 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT);
653                 return 2;
654         }
655
656         // Send the event
657         ubus_send_event(c->ctx, event, c->buf.head);
658
659         return 0;
660 }
661
662
663
664 static int
665 ubus_lua__gc(lua_State *L)
666 {
667         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
668
669         if (c->ctx != NULL)
670         {
671                 ubus_free(c->ctx);
672                 memset(c, 0, sizeof(*c));
673         }
674
675         return 0;
676 }
677
678 static const luaL_Reg ubus[] = {
679         { "connect", ubus_lua_connect },
680         { "objects", ubus_lua_objects },
681         { "add", ubus_lua_add },
682         { "reply", ubus_lua_reply },
683         { "signatures", ubus_lua_signatures },
684         { "call", ubus_lua_call },
685         { "close", ubus_lua__gc },
686         { "listen", ubus_lua_listen },
687         { "send", ubus_lua_send },
688         { "__gc", ubus_lua__gc },
689         { NULL, NULL },
690 };
691
692 /* avoid missing prototype warning */
693 int luaopen_ubus(lua_State *L);
694
695 int
696 luaopen_ubus(lua_State *L)
697 {
698         /* create metatable */
699         luaL_newmetatable(L, METANAME);
700
701         /* metatable.__index = metatable */
702         lua_pushvalue(L, -1);
703         lua_setfield(L, -2, "__index");
704
705         /* fill metatable */
706         luaL_register(L, NULL, ubus);
707         lua_pop(L, 1);
708
709         /* create module */
710         luaL_register(L, MODNAME, ubus);
711
712         /* set some enum defines */
713         lua_pushinteger(L, BLOBMSG_TYPE_ARRAY);
714         lua_setfield(L, -2, "ARRAY");
715         lua_pushinteger(L, BLOBMSG_TYPE_TABLE);
716         lua_setfield(L, -2, "TABLE");
717         lua_pushinteger(L, BLOBMSG_TYPE_STRING);
718         lua_setfield(L, -2, "STRING");
719         lua_pushinteger(L, BLOBMSG_TYPE_INT64);
720         lua_setfield(L, -2, "INT64");
721         lua_pushinteger(L, BLOBMSG_TYPE_INT32);
722         lua_setfield(L, -2, "INT32");
723         lua_pushinteger(L, BLOBMSG_TYPE_INT16);
724         lua_setfield(L, -2, "INT16");
725         lua_pushinteger(L, BLOBMSG_TYPE_INT8);
726         lua_setfield(L, -2, "INT8");
727         lua_pushinteger(L, BLOBMSG_TYPE_BOOL);
728         lua_setfield(L, -2, "BOOLEAN");
729
730         /* used in our callbacks */
731         state = L;
732
733         /* create the callback table */
734         lua_createtable(L, 1, 0);
735         lua_setglobal(L, "__ubus_cb");
736
737         /* create the event table */
738         lua_createtable(L, 1, 0);
739         lua_setglobal(L, "__ubus_cb_event");
740
741         return 0;
742 }