lua/uloop.c

   1 /*
   2  * Copyright (C) 2012 John Crispin <blogic@openwrt.org>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include <lua.h>
  22 #include <lualib.h>
  23 #include <lauxlib.h>
  24
  25 #include "../uloop.h"
  26 #include "../list.h"
  27
  28 struct lua_uloop_fd {
  29         struct uloop_fd fd;
  30         int r;
  31         int fd_r;
  32 };
  33
  34 struct lua_uloop_timeout {
  35         struct uloop_timeout t;
  36         int r;
  37 };
  38
  39 struct lua_uloop_process {
  40         struct uloop_process p;
  41         int r;
  42 };
  43
  44 static lua_State *state;
  45
  46 static void *
  47 ul_create_userdata(lua_State *L, size_t size, const luaL_Reg *reg, lua_CFunction gc)
  48 {
  49         void *ret = lua_newuserdata(L, size);
  50
  51         memset(ret, 0, size);
  52         lua_createtable(L, 0, 2);
  53         lua_pushvalue(L, -1);
  54         lua_setfield(L, -2, "__index");
  55         lua_pushcfunction(L, gc);
  56         lua_setfield(L, -2, "__gc");
  57         lua_pushvalue(L, -1);
  58         lua_setmetatable(L, -3);
  59         lua_pushvalue(L, -2);
  60         luaI_openlib(L, NULL, reg, 1);
  61         lua_pushvalue(L, -2);
  62
  63         return ret;
  64 }
  65
  66 static void ul_timer_cb(struct uloop_timeout *t)
  67 {
  68         struct lua_uloop_timeout *tout = container_of(t, struct lua_uloop_timeout, t);
  69
  70         lua_getglobal(state, "__uloop_cb");
  71         lua_rawgeti(state, -1, tout->r);
  72         lua_remove(state, -2);
  73
  74         lua_call(state, 0, 0);
  75
  76 }
  77
  78 static int ul_timer_set(lua_State *L)
  79 {
  80         struct lua_uloop_timeout *tout;
  81         double set;
  82
  83         if (!lua_isnumber(L, -1)) {
  84                 lua_pushstring(L, "invalid arg list");
  85                 lua_error(L);
  86
  87                 return 0;
  88         }
  89
  90         set = lua_tointeger(L, -1);
  91         tout = lua_touserdata(L, 1);
  92         uloop_timeout_set(&tout->t, set);
  93
  94         return 1;
  95 }
  96
  97 static int ul_timer_remaining(lua_State *L)
  98 {
  99         struct lua_uloop_timeout *tout;
 100
 101         tout = lua_touserdata(L, 1);
 102         lua_pushnumber(L, uloop_timeout_remaining(&tout->t));
 103         return 1;
 104 }
 105
 106 static int ul_timer_free(lua_State *L)
 107 {
 108         struct lua_uloop_timeout *tout = lua_touserdata(L, 1);
 109
 110         uloop_timeout_cancel(&tout->t);
 111
 112         /* obj.__index.__gc = nil , make sure executing only once*/
 113         lua_getfield(L, -1, "__index");
 114         lua_pushstring(L, "__gc");
 115         lua_pushnil(L);
 116         lua_settable(L, -3);
 117
 118         lua_getglobal(state, "__uloop_cb");
 119         luaL_unref(state, -1, tout->r);
 120
 121         return 1;
 122 }
 123
 124 static const luaL_Reg timer_m[] = {
 125         { "set", ul_timer_set },
 126         { "remaining", ul_timer_remaining },
 127         { "cancel", ul_timer_free },
 128         { NULL, NULL }
 129 };
 130
 131 static int ul_timer(lua_State *L)
 132 {
 133         struct lua_uloop_timeout *tout;
 134         int set = 0;
 135         int ref;
 136
 137         if (lua_isnumber(L, -1)) {
 138                 set = lua_tointeger(L, -1);
 139                 lua_pop(L, 1);
 140         }
 141
 142         if (!lua_isfunction(L, -1)) {
 143                 lua_pushstring(L, "invalid arg list");
 144                 lua_error(L);
 145
 146                 return 0;
 147         }
 148
 149         lua_getglobal(L, "__uloop_cb");
 150         lua_pushvalue(L, -2);
 151         ref = luaL_ref(L, -2);
 152
 153         tout = ul_create_userdata(L, sizeof(*tout), timer_m, ul_timer_free);
 154         tout->r = ref;
 155         tout->t.cb = ul_timer_cb;
 156
 157         if (set)
 158                 uloop_timeout_set(&tout->t, set);
 159
 160         return 1;
 161 }
 162
 163 static void ul_ufd_cb(struct uloop_fd *fd, unsigned int events)
 164 {
 165         struct lua_uloop_fd *ufd = container_of(fd, struct lua_uloop_fd, fd);
 166
 167         lua_getglobal(state, "__uloop_cb");
 168         lua_rawgeti(state, -1, ufd->r);
 169         lua_remove(state, -2);
 170
 171         /* push fd object */
 172         lua_getglobal(state, "__uloop_fds");
 173         lua_rawgeti(state, -1, ufd->fd_r);
 174         lua_remove(state, -2);
 175
 176         /* push events */
 177         lua_pushinteger(state, events);
 178         lua_call(state, 2, 0);
 179 }
 180
 181
 182 static int get_sock_fd(lua_State* L, int idx) {
 183         int fd;
 184         if(lua_isnumber(L, idx)) {
 185                 fd = lua_tonumber(L, idx);
 186         } else {
 187                 luaL_checktype(L, idx, LUA_TUSERDATA);
 188                 lua_getfield(L, idx, "getfd");
 189                 if(lua_isnil(L, -1))
 190                         return luaL_error(L, "socket type missing 'getfd' method");
 191                 /* if we have absolute, no need to adjust for getfield() call */
 192                 lua_pushvalue(L, idx > 0 ? idx: idx - 1);
 193                 lua_call(L, 1, 1);
 194                 fd = lua_tointeger(L, -1);
 195                 lua_pop(L, 1);
 196         }
 197         return fd;
 198 }
 199
 200 static int ul_ufd_delete(lua_State *L)
 201 {
 202         struct lua_uloop_fd *ufd = lua_touserdata(L, 1);
 203
 204         uloop_fd_delete(&ufd->fd);
 205
 206         /* obj.__index.__gc = nil , make sure executing only once*/
 207         lua_getfield(L, -1, "__index");
 208         lua_pushstring(L, "__gc");
 209         lua_pushnil(L);
 210         lua_settable(L, -3);
 211
 212         lua_getglobal(state, "__uloop_cb");
 213         luaL_unref(state, -1, ufd->r);
 214         lua_remove(state, -1);
 215
 216         lua_getglobal(state, "__uloop_fds");
 217         luaL_unref(state, -1, ufd->fd_r);
 218         lua_remove(state, -1);
 219
 220         return 1;
 221 }
 222
 223 static const luaL_Reg ufd_m[] = {
 224         { "delete", ul_ufd_delete },
 225         { NULL, NULL }
 226 };
 227
 228 static int ul_ufd_add(lua_State *L)
 229 {
 230         struct lua_uloop_fd *ufd;
 231         int fd = 0;
 232         unsigned int flags = 0;
 233         int ref;
 234         int fd_ref;
 235
 236         flags = luaL_checkinteger(L, -1);
 237         if (!flags) {
 238                 lua_pushstring(L, "flags cannot be zero");
 239                 lua_error(L);
 240         }
 241         lua_pop(L, 1);
 242
 243         luaL_checktype(L, -1, LUA_TFUNCTION);
 244
 245         fd = get_sock_fd(L, -2);
 246
 247         lua_getglobal(L, "__uloop_cb");
 248         lua_pushvalue(L, -2);
 249         ref = luaL_ref(L, -2);
 250         lua_pop(L, 1);
 251
 252         lua_getglobal(L, "__uloop_fds");
 253         lua_pushvalue(L, -3);
 254         fd_ref = luaL_ref(L, -2);
 255         lua_pop(L, 1);
 256
 257         ufd = ul_create_userdata(L, sizeof(*ufd), ufd_m, ul_ufd_delete);
 258         ufd->r = ref;
 259         ufd->fd.fd = fd;
 260         ufd->fd_r = fd_ref;
 261         ufd->fd.cb = ul_ufd_cb;
 262         uloop_fd_add(&ufd->fd, flags);
 263
 264         return 1;
 265 }
 266
 267 static int ul_process_free(lua_State *L)
 268 {
 269         struct lua_uloop_process *proc = lua_touserdata(L, 1);
 270
 271         /* obj.__index.__gc = nil , make sure executing only once*/
 272         lua_getfield(L, -1, "__index");
 273         lua_pushstring(L, "__gc");
 274         lua_pushnil(L);
 275         lua_settable(L, -3);
 276
 277         if (proc->r != LUA_NOREF) {
 278                 uloop_process_delete(&proc->p);
 279
 280                 lua_getglobal(state, "__uloop_cb");
 281                 luaL_unref(state, -1, proc->r);
 282                 lua_remove(state, -1);
 283         }
 284
 285         return 1;
 286 }
 287
 288 static int ul_process_pid(lua_State *L)
 289 {
 290         struct lua_uloop_process *proc = lua_touserdata(L, 1);
 291
 292         if (proc->p.pid) {
 293                 lua_pushnumber(L, proc->p.pid);
 294                 return 1;
 295         }
 296
 297         return 0;
 298 }
 299
 300 static const luaL_Reg process_m[] = {
 301         { "delete", ul_process_free },
 302         { "pid", ul_process_pid },
 303         { NULL, NULL }
 304 };
 305
 306 static void ul_process_cb(struct uloop_process *p, int ret)
 307 {
 308         struct lua_uloop_process *proc = container_of(p, struct lua_uloop_process, p);
 309
 310         lua_getglobal(state, "__uloop_cb");
 311         lua_rawgeti(state, -1, proc->r);
 312
 313         luaL_unref(state, -2, proc->r);
 314         proc->r = LUA_NOREF;
 315         lua_remove(state, -2);
 316         lua_pushinteger(state, ret >> 8);
 317         lua_call(state, 1, 0);
 318 }
 319
 320 static int ul_process(lua_State *L)
 321 {
 322         struct lua_uloop_process *proc;
 323         pid_t pid;
 324         int ref;
 325
 326         if (!lua_isfunction(L, -1) || !lua_istable(L, -2) ||
 327                         !lua_istable(L, -3) || !lua_isstring(L, -4)) {
 328                 lua_pushstring(L, "invalid arg list");
 329                 lua_error(L);
 330
 331                 return 0;
 332         }
 333
 334         pid = fork();
 335
 336         if (pid == -1) {
 337                 lua_pushstring(L, "failed to fork");
 338                 lua_error(L);
 339
 340                 return 0;
 341         }
 342
 343         if (pid == 0) {
 344                 /* child */
 345                 int argn = lua_objlen(L, -3);
 346                 int envn = lua_objlen(L, -2);
 347                 char** argp = malloc(sizeof(char*) * (argn + 2));
 348                 char** envp = malloc(sizeof(char*) * (envn + 1));
 349                 int i = 1;
 350
 351                 if (!argp || !envp)
 352                         _exit(-1);
 353
 354                 argp[0] = (char*) lua_tostring(L, -4);
 355                 for (i = 1; i <= argn; i++) {
 356                         lua_rawgeti(L, -3, i);
 357                         argp[i] = (char*) lua_tostring(L, -1);
 358                         lua_pop(L, 1);
 359                 }
 360                 argp[i] = NULL;
 361
 362                 for (i = 1; i <= envn; i++) {
 363                         lua_rawgeti(L, -2, i);
 364                         envp[i - 1] = (char*) lua_tostring(L, -1);
 365                         lua_pop(L, 1);
 366                 }
 367                 envp[i - 1] = NULL;
 368
 369                 execve(*argp, argp, envp);
 370                 _exit(-1);
 371         }
 372
 373         lua_getglobal(L, "__uloop_cb");
 374         lua_pushvalue(L, -2);
 375         ref = luaL_ref(L, -2);
 376
 377         proc = ul_create_userdata(L, sizeof(*proc), process_m, ul_process_free);
 378         proc->r = ref;
 379         proc->p.pid = pid;
 380         proc->p.cb = ul_process_cb;
 381         uloop_process_add(&proc->p);
 382
 383         return 1;
 384 }
 385
 386 static int ul_init(lua_State *L)
 387 {
 388         uloop_init();
 389         lua_pushboolean(L, 1);
 390
 391         return 1;
 392 }
 393
 394 static int ul_run(lua_State *L)
 395 {
 396         uloop_run();
 397         lua_pushboolean(L, 1);
 398
 399         return 1;
 400 }
 401
 402 static int ul_end(lua_State *L)
 403 {
 404         uloop_end();
 405         return 1;
 406 }
 407
 408 static luaL_reg uloop_func[] = {
 409         {"init", ul_init},
 410         {"run", ul_run},
 411         {"timer", ul_timer},
 412         {"process", ul_process},
 413         {"fd_add", ul_ufd_add},
 414         {"cancel", ul_end},
 415         {NULL, NULL},
 416 };
 417
 418 /* avoid warnings about missing declarations */
 419 int luaopen_uloop(lua_State *L);
 420 int luaclose_uloop(lua_State *L);
 421
 422 int luaopen_uloop(lua_State *L)
 423 {
 424         state = L;
 425
 426         lua_createtable(L, 1, 0);
 427         lua_setglobal(L, "__uloop_cb");
 428
 429         lua_createtable(L, 1, 0);
 430         lua_setglobal(L, "__uloop_fds");
 431
 432         luaL_openlib(L, "uloop", uloop_func, 0);
 433         lua_pushstring(L, "_VERSION");
 434         lua_pushstring(L, "1.0");
 435         lua_rawset(L, -3);
 436
 437         lua_pushstring(L, "ULOOP_READ");
 438         lua_pushinteger(L, ULOOP_READ);
 439         lua_rawset(L, -3);
 440
 441         lua_pushstring(L, "ULOOP_WRITE");
 442         lua_pushinteger(L, ULOOP_WRITE);
 443         lua_rawset(L, -3);
 444
 445         lua_pushstring(L, "ULOOP_EDGE_TRIGGER");
 446         lua_pushinteger(L, ULOOP_EDGE_TRIGGER);
 447         lua_rawset(L, -3);
 448
 449         lua_pushstring(L, "ULOOP_BLOCKING");
 450         lua_pushinteger(L, ULOOP_BLOCKING);
 451         lua_rawset(L, -3);
 452
 453         return 1;
 454 }
 455
 456 int luaclose_uloop(lua_State *L)
 457 {
 458         lua_pushstring(L, "Called");
 459
 460         return 1;
 461 }