/* * Copyright (C) 2012 Jo-Philipp Wich * Copyright (C) 2012 John Crispin * Copyright (C) 2016 Iain Fraser * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 2.1 * as published by the Free Software Foundation * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #include #include #include #include #include #include #define MODNAME "ubus" #define METANAME MODNAME ".meta" static lua_State *state; struct ubus_lua_connection { int timeout; struct blob_buf buf; struct ubus_context *ctx; }; struct ubus_lua_object { struct ubus_object o; int r; int rsubscriber; }; struct ubus_lua_event { struct ubus_event_handler e; int r; }; struct ubus_lua_subscriber { struct ubus_subscriber s; int rnotify; int rremove; }; static int ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table); static int ubus_lua_parse_blob_array(lua_State *L, struct blob_attr *attr, int len, bool table) { int rv; int idx = 1; int rem = len; struct blob_attr *pos; lua_newtable(L); __blob_for_each_attr(pos, attr, rem) { rv = ubus_lua_parse_blob(L, pos, table); if (rv > 1) lua_rawset(L, -3); else if (rv > 0) lua_rawseti(L, -2, idx++); } return 1; } static int ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table) { int len; int off = 0; void *data; if (!blobmsg_check_attr(attr, false)) return 0; if (table && blobmsg_name(attr)[0]) { lua_pushstring(L, blobmsg_name(attr)); off++; } data = blobmsg_data(attr); len = blobmsg_data_len(attr); switch (blob_id(attr)) { case BLOBMSG_TYPE_BOOL: lua_pushboolean(L, *(uint8_t *)data); break; case BLOBMSG_TYPE_INT16: lua_pushinteger(L, be16_to_cpu(*(uint16_t *)data)); break; case BLOBMSG_TYPE_INT32: lua_pushinteger(L, be32_to_cpu(*(uint32_t *)data)); break; case BLOBMSG_TYPE_INT64: lua_pushnumber(L, (double) be64_to_cpu(*(uint64_t *)data)); break; case BLOBMSG_TYPE_STRING: lua_pushstring(L, data); break; case BLOBMSG_TYPE_ARRAY: ubus_lua_parse_blob_array(L, data, len, false); break; case BLOBMSG_TYPE_TABLE: ubus_lua_parse_blob_array(L, data, len, true); break; default: lua_pushnil(L); break; } return off + 1; } static bool ubus_lua_format_blob_is_array(lua_State *L) { lua_Integer prv = 0; lua_Integer cur = 0; /* Find out whether table is array-like */ for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) { #ifdef LUA_TINT if (lua_type(L, -2) != LUA_TNUMBER && lua_type(L, -2) != LUA_TINT) #else if (lua_type(L, -2) != LUA_TNUMBER) #endif { lua_pop(L, 2); return false; } cur = lua_tointeger(L, -2); if ((cur - 1) != prv) { lua_pop(L, 2); return false; } prv = cur; } return true; } static int ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table); static int ubus_lua_format_blob(lua_State *L, struct blob_buf *b, bool table) { void *c; bool rv = true; const char *key = table ? lua_tostring(L, -2) : NULL; switch (lua_type(L, -1)) { case LUA_TBOOLEAN: blobmsg_add_u8(b, key, (uint8_t)lua_toboolean(L, -1)); break; #ifdef LUA_TINT case LUA_TINT: #endif case LUA_TNUMBER: blobmsg_add_u32(b, key, (uint32_t)lua_tointeger(L, -1)); break; case LUA_TSTRING: case LUA_TUSERDATA: case LUA_TLIGHTUSERDATA: blobmsg_add_string(b, key, lua_tostring(L, -1)); break; case LUA_TTABLE: if (ubus_lua_format_blob_is_array(L)) { c = blobmsg_open_array(b, key); rv = ubus_lua_format_blob_array(L, b, false); blobmsg_close_array(b, c); } else { c = blobmsg_open_table(b, key); rv = ubus_lua_format_blob_array(L, b, true); blobmsg_close_table(b, c); } break; default: rv = false; break; } return rv; } static int ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table) { for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) { if (!ubus_lua_format_blob(L, b, table)) { lua_pop(L, 1); return false; } } return true; } static int ubus_lua_connect(lua_State *L) { struct ubus_lua_connection *c; const char *sockpath = luaL_optstring(L, 1, NULL); int timeout = luaL_optint(L, 2, 30); if ((c = lua_newuserdata(L, sizeof(*c))) != NULL && (c->ctx = ubus_connect(sockpath)) != NULL) { ubus_add_uloop(c->ctx); c->timeout = timeout; memset(&c->buf, 0, sizeof(c->buf)); luaL_getmetatable(L, METANAME); lua_setmetatable(L, -2); return 1; } /* NB: no errors from ubus_connect() yet */ lua_pushnil(L); lua_pushinteger(L, UBUS_STATUS_UNKNOWN_ERROR); return 2; } static void ubus_lua_objects_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) { lua_State *L = (lua_State *)p; lua_pushstring(L, o->path); lua_rawseti(L, -2, lua_objlen(L, -2) + 1); } static int ubus_lua_objects(lua_State *L) { int rv; struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); lua_newtable(L); rv = ubus_lookup(c->ctx, NULL, ubus_lua_objects_cb, L); if (rv != UBUS_STATUS_OK) { lua_pop(L, 1); lua_pushnil(L); lua_pushinteger(L, rv); return 2; } return 1; } static int ubus_method_handler(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct ubus_lua_object *o = container_of(obj, struct ubus_lua_object, o); int rv = 0; lua_getglobal(state, "__ubus_cb"); lua_rawgeti(state, -1, o->r); lua_getfield(state, -1, method); lua_remove(state, -2); lua_remove(state, -2); if (lua_isfunction(state, -1)) { lua_pushlightuserdata(state, req); if (!msg) lua_pushnil(state); else ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true); lua_call(state, 2, 1); if (lua_isnumber(state, -1)) rv = lua_tonumber(state, -1); } lua_pop(state, 1); return rv; } static int lua_gettablelen(lua_State *L, int index) { int cnt = 0; lua_pushnil(L); index -= 1; while (lua_next(L, index) != 0) { cnt++; lua_pop(L, 1); } return cnt; } static int ubus_lua_reply(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); struct ubus_request_data *req; luaL_checktype(L, 3, LUA_TTABLE); blob_buf_init(&c->buf, 0); if (!ubus_lua_format_blob_array(L, &c->buf, true)) { lua_pushnil(L); lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT); return 2; } req = lua_touserdata(L, 2); ubus_send_reply(c->ctx, req, c->buf.head); return 0; } static int ubus_lua_defer_request(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); struct ubus_request_data *req = lua_touserdata(L, 2); struct ubus_request_data *new_req = lua_newuserdata(L, sizeof(struct ubus_request_data)); ubus_defer_request(c->ctx, req, new_req); return 1; } static int ubus_lua_complete_deferred_request(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); struct ubus_request_data *req = lua_touserdata(L, 2); int ret = luaL_checkinteger(L, 3); ubus_complete_deferred_request(c->ctx, req, ret); return 0; } static int ubus_lua_load_methods(lua_State *L, struct ubus_method *m) { struct blobmsg_policy *p; int plen; int pidx = 0; /* get the function pointer */ lua_pushinteger(L, 1); lua_gettable(L, -2); /* get the policy table */ lua_pushinteger(L, 2); lua_gettable(L, -3); /* check if the method table is valid */ if ((lua_type(L, -2) != LUA_TFUNCTION) || (lua_type(L, -1) != LUA_TTABLE) || lua_objlen(L, -1)) { lua_pop(L, 2); return 1; } /* store function pointer */ lua_pushvalue(L, -2); lua_setfield(L, -6, lua_tostring(L, -5)); m->name = lua_tostring(L, -4); m->handler = ubus_method_handler; plen = lua_gettablelen(L, -1); /* exit if policy table is empty */ if (!plen) { lua_pop(L, 2); return 0; } /* setup the policy pointers */ p = malloc(sizeof(struct blobmsg_policy) * plen); if (!p) return 1; memset(p, 0, sizeof(struct blobmsg_policy) * plen); m->policy = p; lua_pushnil(L); while (lua_next(L, -2) != 0) { int val = lua_tointeger(L, -1); /* check if the policy is valid */ if ((lua_type(L, -2) != LUA_TSTRING) || (lua_type(L, -1) != LUA_TNUMBER) || (val < 0) || (val > BLOBMSG_TYPE_LAST)) { lua_pop(L, 1); continue; } p[pidx].name = lua_tostring(L, -2); p[pidx].type = val; lua_pop(L, 1); pidx++; } m->n_policy = pidx; lua_pop(L, 2); return 0; } static void ubus_new_sub_cb(struct ubus_context *ctx, struct ubus_object *obj) { struct ubus_lua_object *luobj; luobj = container_of(obj, struct ubus_lua_object, o); lua_getglobal(state, "__ubus_cb_publisher"); lua_rawgeti(state, -1, luobj->rsubscriber); lua_remove(state, -2); if (lua_isfunction(state, -1)) { lua_pushnumber(state, luobj->o.has_subscribers ); lua_call(state, 1, 0); } else { lua_pop(state, 1); } } static void ubus_lua_load_newsub_cb( lua_State *L, struct ubus_lua_object *obj ) { /* keep ref to func */ lua_getglobal(L, "__ubus_cb_publisher"); lua_pushvalue(L, -2); obj->rsubscriber = luaL_ref(L, -2); lua_pop(L, 1); /* real callback */ obj->o.subscribe_cb = ubus_new_sub_cb; return; } static struct ubus_object* ubus_lua_load_object(lua_State *L) { struct ubus_lua_object *obj = NULL; int mlen = lua_gettablelen(L, -1); struct ubus_method *m; int midx = 0; /* setup object pointers */ obj = malloc(sizeof(struct ubus_lua_object)); if (!obj) return NULL; memset(obj, 0, sizeof(struct ubus_lua_object)); obj->o.name = lua_tostring(L, -2); /* setup method pointers */ m = malloc(sizeof(struct ubus_method) * mlen); memset(m, 0, sizeof(struct ubus_method) * mlen); obj->o.methods = m; /* setup type pointers */ obj->o.type = malloc(sizeof(struct ubus_object_type)); if (!obj->o.type) { free(obj); return NULL; } memset(obj->o.type, 0, sizeof(struct ubus_object_type)); obj->o.type->name = lua_tostring(L, -2); obj->o.type->id = 0; obj->o.type->methods = obj->o.methods; /* create the callback lookup table */ lua_createtable(L, 1, 0); lua_getglobal(L, "__ubus_cb"); lua_pushvalue(L, -2); obj->r = luaL_ref(L, -2); lua_pop(L, 1); /* scan each method */ lua_pushnil(L); while (lua_next(L, -3) != 0) { /* check if its the subscriber notification callback */ if( lua_type( L, -2 ) == LUA_TSTRING && lua_type( L, -1 ) == LUA_TFUNCTION ){ if( !strcmp( lua_tostring( L, -2 ), "__subscriber_cb" ) ) ubus_lua_load_newsub_cb( L, obj ); } /* check if it looks like a method */ if ((lua_type(L, -2) != LUA_TSTRING) || (lua_type(L, -1) != LUA_TTABLE) || !lua_objlen(L, -1)) { lua_pop(L, 1); continue; } if (!ubus_lua_load_methods(L, &m[midx])) midx++; lua_pop(L, 1); } obj->o.type->n_methods = obj->o.n_methods = midx; /* pop the callback table */ lua_pop(L, 1); return &obj->o; } static int ubus_lua_add(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); /* verify top level object */ if (lua_istable(L, 1)) { lua_pushstring(L, "you need to pass a table"); lua_error(L); return 0; } /* scan each object */ lua_pushnil(L); while (lua_next(L, -2) != 0) { struct ubus_object *obj = NULL; /* check if the object has a table of methods */ if ((lua_type(L, -2) == LUA_TSTRING) && (lua_type(L, -1) == LUA_TTABLE)) { obj = ubus_lua_load_object(L); if (obj){ ubus_add_object(c->ctx, obj); /* allow future reference of ubus obj */ lua_pushstring(state,"__ubusobj"); lua_pushlightuserdata(state, obj); lua_settable(state,-3); } } lua_pop(L, 1); } return 0; } static int ubus_lua_notify( lua_State *L ) { struct ubus_lua_connection *c; struct ubus_object *obj; const char* method; c = luaL_checkudata(L, 1, METANAME); method = luaL_checkstring(L, 3); luaL_checktype(L, 4, LUA_TTABLE); if( !lua_islightuserdata( L, 2 ) ){ lua_pushfstring( L, "Invald 2nd parameter, expected ubus obj ref" ); lua_error( L ); } obj = lua_touserdata( L, 2 ); /* create parameters from table */ blob_buf_init(&c->buf, 0); if( !ubus_lua_format_blob_array( L, &c->buf, true ) ){ lua_pushfstring( L, "Invalid 4th parameter, expected table of arguments" ); lua_error( L ); } ubus_notify( c->ctx, obj, method, c->buf.head, -1 ); return 0; } static void ubus_lua_signatures_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) { lua_State *L = (lua_State *)p; if (!o->signature) return; ubus_lua_parse_blob_array(L, blob_data(o->signature), blob_len(o->signature), true); } static int ubus_lua_signatures(lua_State *L) { int rv; struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); const char *path = luaL_checkstring(L, 2); rv = ubus_lookup(c->ctx, path, ubus_lua_signatures_cb, L); if (rv != UBUS_STATUS_OK) { lua_pop(L, 1); lua_pushnil(L); lua_pushinteger(L, rv); return 2; } return 1; } static void ubus_lua_call_cb(struct ubus_request *req, int type, struct blob_attr *msg) { lua_State *L = (lua_State *)req->priv; if (!msg && L) lua_pushnil(L); if (msg && L) ubus_lua_parse_blob_array(L, blob_data(msg), blob_len(msg), true); } static int ubus_lua_call(lua_State *L) { int rv, top; uint32_t id; struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); const char *path = luaL_checkstring(L, 2); const char *func = luaL_checkstring(L, 3); luaL_checktype(L, 4, LUA_TTABLE); blob_buf_init(&c->buf, 0); if (!ubus_lua_format_blob_array(L, &c->buf, true)) { lua_pushnil(L); lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT); return 2; } rv = ubus_lookup_id(c->ctx, path, &id); if (rv) { lua_pushnil(L); lua_pushinteger(L, rv); return 2; } top = lua_gettop(L); rv = ubus_invoke(c->ctx, id, func, c->buf.head, ubus_lua_call_cb, L, c->timeout * 1000); if (rv != UBUS_STATUS_OK) { lua_pop(L, 1); lua_pushnil(L); lua_pushinteger(L, rv); return 2; } return lua_gettop(L) - top; } static void ubus_event_handler(struct ubus_context *ctx, struct ubus_event_handler *ev, const char *type, struct blob_attr *msg) { struct ubus_lua_event *listener = container_of(ev, struct ubus_lua_event, e); lua_getglobal(state, "__ubus_cb_event"); lua_rawgeti(state, -1, listener->r); lua_remove(state, -2); if (lua_isfunction(state, -1)) { ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true); lua_call(state, 1, 0); } else { lua_pop(state, 1); } } static struct ubus_event_handler* ubus_lua_load_event(lua_State *L) { struct ubus_lua_event* event = NULL; event = malloc(sizeof(struct ubus_lua_event)); if (!event) return NULL; memset(event, 0, sizeof(struct ubus_lua_event)); event->e.cb = ubus_event_handler; /* update the he callback lookup table */ lua_getglobal(L, "__ubus_cb_event"); lua_pushvalue(L, -2); event->r = luaL_ref(L, -2); lua_setfield(L, -1, lua_tostring(L, -3)); return &event->e; } static int ubus_lua_listen(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); /* verify top level object */ luaL_checktype(L, 2, LUA_TTABLE); /* scan each object */ lua_pushnil(L); while (lua_next(L, -2) != 0) { struct ubus_event_handler *listener; /* check if the key is a string and the value is a method */ if ((lua_type(L, -2) == LUA_TSTRING) && (lua_type(L, -1) == LUA_TFUNCTION)) { listener = ubus_lua_load_event(L); if(listener != NULL) { ubus_register_event_handler(c->ctx, listener, lua_tostring(L, -2)); } } lua_pop(L, 1); } return 0; } static void ubus_sub_remove_handler(struct ubus_context *ctx, struct ubus_subscriber *s, uint32_t id) { struct ubus_lua_subscriber *sub; sub = container_of(s, struct ubus_lua_subscriber, s); lua_getglobal(state, "__ubus_cb_subscribe"); lua_rawgeti(state, -1, sub->rremove); lua_remove(state, -2); if (lua_isfunction(state, -1)) { lua_call(state, 0, 0); } else { lua_pop(state, 1); } } static int ubus_sub_notify_handler(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct ubus_subscriber *s; struct ubus_lua_subscriber *sub; s = container_of(obj, struct ubus_subscriber, obj); sub = container_of(s, struct ubus_lua_subscriber, s); lua_getglobal(state, "__ubus_cb_subscribe"); lua_rawgeti(state, -1, sub->rnotify); lua_remove(state, -2); if (lua_isfunction(state, -1)) { if( msg ){ ubus_lua_parse_blob_array(state, blob_data(msg), blob_len(msg), true); lua_call(state, 1, 0); } else { lua_call(state, 0, 0); } } else { lua_pop(state, 1); } return 0; } static void ubus_lua_do_subscribe( struct ubus_context *ctx, lua_State *L, const char* target, int idxnotify, int idxremove ) { uint32_t id; int status; struct ubus_lua_subscriber *sub; if( ( status = ubus_lookup_id( ctx, target, &id ) ) ){ lua_pushfstring( L, "Unable find target, status=%d", status ); lua_error( L ); } sub = malloc( sizeof( struct ubus_lua_subscriber ) ); memset( sub, 0, sizeof( struct ubus_lua_subscriber ) ); if( !sub ){ lua_pushstring( L, "Out of memory" ); lua_error( L ); } if( idxnotify ){ lua_getglobal(L, "__ubus_cb_subscribe"); lua_pushvalue(L, idxnotify); sub->rnotify = luaL_ref(L, -2); lua_pop(L, 1); sub->s.cb = ubus_sub_notify_handler; } if( idxremove ){ lua_getglobal(L, "__ubus_cb_subscribe"); lua_pushvalue(L, idxnotify); sub->rnotify = luaL_ref(L, -2); lua_pop(L, 1); sub->s.remove_cb = ubus_sub_remove_handler; } if( ( status = ubus_register_subscriber( ctx, &sub->s ) ) ){ lua_pushfstring( L, "Failed to register subscriber, status=%d", status ); lua_error( L ); } if( ( status = ubus_subscribe( ctx, &sub->s, id) ) ){ lua_pushfstring( L, "Failed to register subscriber, status=%d", status ); lua_error( L ); } } static int ubus_lua_subscribe(lua_State *L) { int idxnotify, idxremove, stackstart; struct ubus_lua_connection *c; const char* target; idxnotify = idxremove = 0; stackstart = lua_gettop( L ); c = luaL_checkudata(L, 1, METANAME); target = luaL_checkstring(L, 2); luaL_checktype(L, 3, LUA_TTABLE); lua_pushstring( L, "notify"); lua_gettable( L, 3 ); if( lua_type( L, -1 ) == LUA_TFUNCTION ){ idxnotify = lua_gettop( L ); } else { lua_pop( L, 1 ); } lua_pushstring( L, "remove"); lua_gettable( L, 3 ); if( lua_type( L, -1 ) == LUA_TFUNCTION ){ idxremove = lua_gettop( L ); } else { lua_pop( L, 1 ); } if( idxnotify ) ubus_lua_do_subscribe( c->ctx, L, target, idxnotify, idxremove ); if( lua_gettop( L ) > stackstart ) lua_pop( L, lua_gettop( L ) - stackstart ); return 0; } static int ubus_lua_send(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); const char *event = luaL_checkstring(L, 2); if (*event == 0) return luaL_argerror(L, 2, "no event name"); // Event content convert to ubus form luaL_checktype(L, 3, LUA_TTABLE); blob_buf_init(&c->buf, 0); if (!ubus_lua_format_blob_array(L, &c->buf, true)) { lua_pushnil(L); lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT); return 2; } // Send the event ubus_send_event(c->ctx, event, c->buf.head); return 0; } static int ubus_lua__gc(lua_State *L) { struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME); blob_buf_free(&c->buf); if (c->ctx != NULL) { ubus_free(c->ctx); memset(c, 0, sizeof(*c)); } return 0; } static const luaL_Reg ubus[] = { { "connect", ubus_lua_connect }, { "objects", ubus_lua_objects }, { "add", ubus_lua_add }, { "notify", ubus_lua_notify }, { "reply", ubus_lua_reply }, { "defer_request", ubus_lua_defer_request }, { "complete_deferred_request", ubus_lua_complete_deferred_request }, { "signatures", ubus_lua_signatures }, { "call", ubus_lua_call }, { "close", ubus_lua__gc }, { "listen", ubus_lua_listen }, { "send", ubus_lua_send }, { "subscribe", ubus_lua_subscribe }, { "__gc", ubus_lua__gc }, { NULL, NULL }, }; /* avoid missing prototype warning */ int luaopen_ubus(lua_State *L); int luaopen_ubus(lua_State *L) { /* create metatable */ luaL_newmetatable(L, METANAME); /* metatable.__index = metatable */ lua_pushvalue(L, -1); lua_setfield(L, -2, "__index"); /* fill metatable */ luaL_register(L, NULL, ubus); lua_pop(L, 1); /* create module */ luaL_register(L, MODNAME, ubus); /* set some enum defines */ lua_pushinteger(L, BLOBMSG_TYPE_ARRAY); lua_setfield(L, -2, "ARRAY"); lua_pushinteger(L, BLOBMSG_TYPE_TABLE); lua_setfield(L, -2, "TABLE"); lua_pushinteger(L, BLOBMSG_TYPE_STRING); lua_setfield(L, -2, "STRING"); lua_pushinteger(L, BLOBMSG_TYPE_INT64); lua_setfield(L, -2, "INT64"); lua_pushinteger(L, BLOBMSG_TYPE_INT32); lua_setfield(L, -2, "INT32"); lua_pushinteger(L, BLOBMSG_TYPE_INT16); lua_setfield(L, -2, "INT16"); lua_pushinteger(L, BLOBMSG_TYPE_INT8); lua_setfield(L, -2, "INT8"); lua_pushinteger(L, BLOBMSG_TYPE_BOOL); lua_setfield(L, -2, "BOOLEAN"); /* used in our callbacks */ state = L; /* create the callback table */ lua_createtable(L, 1, 0); lua_setglobal(L, "__ubus_cb"); /* create the event table */ lua_createtable(L, 1, 0); lua_setglobal(L, "__ubus_cb_event"); /* create the subscriber table */ lua_createtable(L, 1, 0); lua_setglobal(L, "__ubus_cb_subscribe"); /* create the publisher table - notifications of new subs */ lua_createtable(L, 1, 0); lua_setglobal(L, "__ubus_cb_publisher"); return 0; }