lua/ubus.c

   1 /*
   2  * Copyright (C) 2012 Jo-Philipp Wich <jow@openwrt.org>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License version 2.1
   6  * as published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <unistd.h>
  15 #include <libubus.h>
  16 #include <libubox/blobmsg.h>
  17 #include <lauxlib.h>
  18
  19
  20 #define MODNAME        "ubus"
  21 #define METANAME       MODNAME ".meta"
  22
  23
  24 struct ubus_lua_connection {
  25         int timeout;
  26         struct blob_buf buf;
  27         struct ubus_context *ctx;
  28 };
  29
  30
  31 static int
  32 ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table);
  33
  34 static int
  35 ubus_lua_parse_blob_array(lua_State *L, struct blob_attr *attr, int len, bool table)
  36 {
  37         int rv;
  38         int idx = 1;
  39         int rem = len;
  40         struct blob_attr *pos;
  41
  42         lua_newtable(L);
  43
  44         __blob_for_each_attr(pos, attr, rem)
  45         {
  46                 rv = ubus_lua_parse_blob(L, pos, table);
  47
  48                 if (rv > 1)
  49                         lua_rawset(L, -3);
  50                 else if (rv > 0)
  51                         lua_rawseti(L, -2, idx++);
  52         }
  53
  54         return 1;
  55 }
  56
  57 static int
  58 ubus_lua_parse_blob(lua_State *L, struct blob_attr *attr, bool table)
  59 {
  60         int len;
  61         int off = 0;
  62         void *data;
  63         char buf[32];
  64
  65         if (!blobmsg_check_attr(attr, false))
  66                 return 0;
  67
  68         if (table && blobmsg_name(attr)[0])
  69         {
  70                 lua_pushstring(L, blobmsg_name(attr));
  71                 off++;
  72         }
  73
  74         data = blobmsg_data(attr);
  75         len = blobmsg_data_len(attr);
  76
  77         switch (blob_id(attr))
  78         {
  79         case BLOBMSG_TYPE_BOOL:
  80                 lua_pushboolean(L, *(uint8_t *)data);
  81                 break;
  82
  83         case BLOBMSG_TYPE_INT16:
  84                 lua_pushinteger(L, be16_to_cpu(*(uint16_t *)data));
  85                 break;
  86
  87         case BLOBMSG_TYPE_INT32:
  88                 lua_pushinteger(L, be32_to_cpu(*(uint32_t *)data));
  89                 break;
  90
  91         case BLOBMSG_TYPE_INT64:
  92                 /* NB: Lua cannot handle 64bit, format value as string and push that */
  93                 sprintf(buf, "%lld", (long long int) be64_to_cpu(*(uint64_t *)data));
  94                 lua_pushstring(L, buf);
  95                 break;
  96
  97         case BLOBMSG_TYPE_STRING:
  98                 lua_pushstring(L, data);
  99                 break;
 100
 101         case BLOBMSG_TYPE_ARRAY:
 102                 ubus_lua_parse_blob_array(L, data, len, false);
 103                 break;
 104
 105         case BLOBMSG_TYPE_TABLE:
 106                 ubus_lua_parse_blob_array(L, data, len, true);
 107                 break;
 108
 109         default:
 110                 lua_pushnil(L);
 111                 break;
 112         }
 113
 114         return off + 1;
 115 }
 116
 117
 118 static bool
 119 ubus_lua_format_blob_is_array(lua_State *L)
 120 {
 121         lua_Integer prv = 0;
 122         lua_Integer cur = 0;
 123
 124         /* Find out whether table is array-like */
 125         for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1))
 126         {
 127 #ifdef LUA_TINT
 128                 if (lua_type(L, -2) != LUA_TNUMBER && lua_type(L, -2) != LUA_TINT)
 129 #else
 130                 if (lua_type(L, -2) != LUA_TNUMBER)
 131 #endif
 132                 {
 133                         lua_pop(L, 1);
 134                         return false;
 135                 }
 136
 137                 cur = lua_tointeger(L, -2);
 138
 139                 if ((cur - 1) != prv)
 140                 {
 141                         lua_pop(L, 1);
 142                         return false;
 143                 }
 144
 145                 prv = cur;
 146         }
 147
 148         return true;
 149 }
 150
 151 static int
 152 ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table);
 153
 154 static int
 155 ubus_lua_format_blob(lua_State *L, struct blob_buf *b, bool table)
 156 {
 157         void *c;
 158         bool rv = true;
 159         const char *key = table ? lua_tostring(L, -2) : NULL;
 160
 161         switch (lua_type(L, -1))
 162         {
 163         case LUA_TBOOLEAN:
 164                 blobmsg_add_u8(b, key, (uint8_t)lua_toboolean(L, -1));
 165                 break;
 166
 167 #ifdef LUA_TINT
 168         case LUA_TINT:
 169 #endif
 170         case LUA_TNUMBER:
 171                 blobmsg_add_u32(b, key, (uint32_t)lua_tointeger(L, -1));
 172                 break;
 173
 174         case LUA_TSTRING:
 175         case LUA_TUSERDATA:
 176         case LUA_TLIGHTUSERDATA:
 177                 blobmsg_add_string(b, key, lua_tostring(L, -1));
 178                 break;
 179
 180         case LUA_TTABLE:
 181                 if (ubus_lua_format_blob_is_array(L))
 182                 {
 183                         c = blobmsg_open_array(b, key);
 184                         rv = ubus_lua_format_blob_array(L, b, false);
 185                         blobmsg_close_array(b, c);
 186                 }
 187                 else
 188                 {
 189                         c = blobmsg_open_table(b, key);
 190                         rv = ubus_lua_format_blob_array(L, b, true);
 191                         blobmsg_close_table(b, c);
 192                 }
 193                 break;
 194
 195         default:
 196                 rv = false;
 197                 break;
 198         }
 199
 200         return rv;
 201 }
 202
 203 static int
 204 ubus_lua_format_blob_array(lua_State *L, struct blob_buf *b, bool table)
 205 {
 206         for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1))
 207         {
 208                 if (!ubus_lua_format_blob(L, b, table))
 209                 {
 210                         lua_pop(L, 1);
 211                         return false;
 212                 }
 213         }
 214
 215         return true;
 216 }
 217
 218
 219 static int
 220 ubus_lua_connect(lua_State *L)
 221 {
 222         struct ubus_lua_connection *c;
 223         const char *sockpath = luaL_optstring(L, 1, NULL);
 224         int timeout = luaL_optint(L, 2, 30);
 225
 226         if ((c = lua_newuserdata(L, sizeof(*c))) != NULL &&
 227                 (c->ctx = ubus_connect(sockpath)) != NULL)
 228         {
 229                 ubus_add_uloop(c->ctx);
 230                 c->timeout = timeout;
 231                 memset(&c->buf, 0, sizeof(c->buf));
 232                 luaL_getmetatable(L, METANAME);
 233                 lua_setmetatable(L, -2);
 234                 return 1;
 235         }
 236
 237         /* NB: no errors from ubus_connect() yet */
 238         lua_pushnil(L);
 239         lua_pushinteger(L, UBUS_STATUS_UNKNOWN_ERROR);
 240         return 2;
 241 }
 242
 243
 244 static void
 245 ubus_lua_objects_cb(struct ubus_context *c, struct ubus_object_data *o, void *p)
 246 {
 247         lua_State *L = (lua_State *)p;
 248
 249         lua_pushstring(L, o->path);
 250         lua_rawseti(L, -2, lua_objlen(L, -2) + 1);
 251 }
 252
 253 static int
 254 ubus_lua_objects(lua_State *L)
 255 {
 256         int rv;
 257         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
 258
 259         lua_newtable(L);
 260         rv = ubus_lookup(c->ctx, NULL, ubus_lua_objects_cb, L);
 261
 262         if (rv != UBUS_STATUS_OK)
 263         {
 264                 lua_pop(L, 1);
 265                 lua_pushnil(L);
 266                 lua_pushinteger(L, rv);
 267                 return 2;
 268         }
 269
 270         return 1;
 271 }
 272
 273
 274 static void
 275 ubus_lua_signatures_cb(struct ubus_context *c, struct ubus_object_data *o, void *p)
 276 {
 277         lua_State *L = (lua_State *)p;
 278
 279         if (!o->signature)
 280                 return;
 281
 282         ubus_lua_parse_blob_array(L, blob_data(o->signature), blob_len(o->signature), true);
 283 }
 284
 285 static int
 286 ubus_lua_signatures(lua_State *L)
 287 {
 288         int rv;
 289         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
 290         const char *path = luaL_checkstring(L, 2);
 291
 292         rv = ubus_lookup(c->ctx, path, ubus_lua_signatures_cb, L);
 293
 294         if (rv != UBUS_STATUS_OK)
 295         {
 296                 lua_pop(L, 1);
 297                 lua_pushnil(L);
 298                 lua_pushinteger(L, rv);
 299                 return 2;
 300         }
 301
 302         return 1;
 303 }
 304
 305
 306 static void
 307 ubus_lua_call_cb(struct ubus_request *req, int type, struct blob_attr *msg)
 308 {
 309         lua_State *L = (lua_State *)req->priv;
 310
 311         if (!msg)
 312                 lua_pushnil(L);
 313
 314         ubus_lua_parse_blob_array(L, blob_data(msg), blob_len(msg), true);
 315 }
 316
 317 static int
 318 ubus_lua_call(lua_State *L)
 319 {
 320         int rv;
 321         uint32_t id;
 322         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
 323         const char *path = luaL_checkstring(L, 2);
 324         const char *func = luaL_checkstring(L, 3);
 325
 326         luaL_checktype(L, 4, LUA_TTABLE);
 327         blob_buf_init(&c->buf, 0);
 328
 329         if (!ubus_lua_format_blob_array(L, &c->buf, true))
 330         {
 331                 lua_pushnil(L);
 332                 lua_pushinteger(L, UBUS_STATUS_INVALID_ARGUMENT);
 333                 return 2;
 334         }
 335
 336         rv = ubus_lookup_id(c->ctx, path, &id);
 337
 338         if (rv)
 339         {
 340                 lua_pushnil(L);
 341                 lua_pushinteger(L, rv);
 342                 return 2;
 343         }
 344
 345         rv = ubus_invoke(c->ctx, id, func, c->buf.head, ubus_lua_call_cb, L, c->timeout * 1000);
 346
 347         if (rv != UBUS_STATUS_OK)
 348         {
 349                 lua_pop(L, 1);
 350                 lua_pushnil(L);
 351                 lua_pushinteger(L, rv);
 352                 return 2;
 353         }
 354
 355         return 1;
 356 }
 357
 358
 359 static int
 360 ubus_lua__gc(lua_State *L)
 361 {
 362         struct ubus_lua_connection *c = luaL_checkudata(L, 1, METANAME);
 363
 364         if (c->ctx != NULL)
 365         {
 366                 ubus_free(c->ctx);
 367                 memset(c, 0, sizeof(*c));
 368         }
 369
 370         return 0;
 371 }
 372
 373 static const luaL_Reg ubus[] = {
 374         { "connect", ubus_lua_connect },
 375         { "objects", ubus_lua_objects },
 376         { "signatures", ubus_lua_signatures },
 377         { "call", ubus_lua_call },
 378         { "close", ubus_lua__gc },
 379         { "__gc", ubus_lua__gc },
 380         { NULL, NULL },
 381 };
 382
 383 /* avoid missing prototype warning */
 384 int luaopen_ubus(lua_State *L);
 385
 386 int
 387 luaopen_ubus(lua_State *L)
 388 {
 389         /* create metatable */
 390         luaL_newmetatable(L, METANAME);
 391
 392         /* metatable.__index = metatable */
 393         lua_pushvalue(L, -1);
 394         lua_setfield(L, -2, "__index");
 395
 396         /* fill metatable */
 397         luaL_register(L, NULL, ubus);
 398         lua_pop(L, 1);
 399
 400         /* create module */
 401         luaL_register(L, MODNAME, ubus);
 402
 403         return 0;
 404 }