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 ul_timer_cb(struct uloop_timeout *t)
  47 {
  48         struct lua_uloop_timeout *tout = container_of(t, struct lua_uloop_timeout, t);
  49
  50         lua_getglobal(state, "__uloop_cb");
  51         lua_rawgeti(state, -1, tout->r);
  52         lua_remove(state, -2);
  53
  54         lua_call(state, 0, 0);
  55
  56 }
  57
  58 static int ul_timer_set(lua_State *L)
  59 {
  60         struct lua_uloop_timeout *tout;
  61         double set;
  62
  63         if (!lua_isnumber(L, -1)) {
  64                 lua_pushstring(L, "invalid arg list");
  65                 lua_error(L);
  66
  67                 return 0;
  68         }
  69
  70         set = lua_tointeger(L, -1);
  71         tout = lua_touserdata(L, 1);
  72         uloop_timeout_set(&tout->t, set);
  73
  74         return 1;
  75 }
  76
  77 static int ul_timer_free(lua_State *L)
  78 {
  79         struct lua_uloop_timeout *tout = lua_touserdata(L, 1);
  80
  81         uloop_timeout_cancel(&tout->t);
  82         lua_getglobal(state, "__uloop_cb");
  83         luaL_unref(L, -1, tout->r);
  84
  85         return 1;
  86 }
  87
  88 static const luaL_Reg timer_m[] = {
  89         { "set", ul_timer_set },
  90         { "cancel", ul_timer_free },
  91         { NULL, NULL }
  92 };
  93
  94 static int ul_timer(lua_State *L)
  95 {
  96         struct lua_uloop_timeout *tout;
  97         int set = 0;
  98         int ref;
  99
 100         if (lua_isnumber(L, -1)) {
 101                 set = lua_tointeger(L, -1);
 102                 lua_pop(L, 1);
 103         }
 104
 105         if (!lua_isfunction(L, -1)) {
 106                 lua_pushstring(L, "invalid arg list");
 107                 lua_error(L);
 108
 109                 return 0;
 110         }
 111
 112         lua_getglobal(L, "__uloop_cb");
 113         lua_pushvalue(L, -2);
 114         ref = luaL_ref(L, -2);
 115
 116         tout = lua_newuserdata(L, sizeof(*tout));
 117         lua_createtable(L, 0, 2);
 118         lua_pushvalue(L, -1);
 119         lua_setfield(L, -2, "__index");
 120         lua_pushcfunction(L, ul_timer_free);
 121         lua_setfield(L, -2, "__gc");
 122         lua_pushvalue(L, -1);
 123         lua_setmetatable(L, -3);
 124         lua_pushvalue(L, -2);
 125         luaI_openlib(L, NULL, timer_m, 1);
 126         lua_pushvalue(L, -2);
 127
 128         memset(tout, 0, sizeof(*tout));
 129
 130         tout->r = ref;
 131         tout->t.cb = ul_timer_cb;
 132         if (set)
 133                 uloop_timeout_set(&tout->t, set);
 134
 135         return 1;
 136 }
 137
 138 static void ul_ufd_cb(struct uloop_fd *fd, unsigned int events)
 139 {
 140         struct lua_uloop_fd *ufd = container_of(fd, struct lua_uloop_fd, fd);
 141
 142         lua_getglobal(state, "__uloop_cb");
 143         lua_rawgeti(state, -1, ufd->r);
 144         lua_remove(state, -2);
 145
 146         /* push fd object */
 147         lua_getglobal(state, "__uloop_fds");
 148         lua_rawgeti(state, -1, ufd->fd_r);
 149         lua_remove(state, -2);
 150
 151         /* push events */
 152         lua_pushinteger(state, events);
 153
 154         lua_call(state, 2, 0);
 155 }
 156
 157
 158 static int get_sock_fd(lua_State* L, int idx) {
 159         int fd;
 160         if(lua_isnumber(L, idx)) {
 161                 fd = lua_tonumber(L, idx);
 162         } else {
 163                 luaL_checktype(L, idx, LUA_TUSERDATA);
 164                 lua_getfield(L, idx, "getfd");
 165                 if(lua_isnil(L, -1))
 166                         return luaL_error(L, "socket type missing 'getfd' method");
 167                 lua_pushvalue(L, idx - 1);
 168                 lua_call(L, 1, 1);
 169                 fd = lua_tointeger(L, -1);
 170                 lua_pop(L, 1);
 171         }
 172         return fd;
 173 }
 174
 175 static int ul_ufd_delete(lua_State *L)
 176 {
 177         struct lua_uloop_fd *ufd = lua_touserdata(L, 1);
 178
 179         uloop_fd_delete(&ufd->fd);
 180         lua_getglobal(state, "__uloop_cb");
 181         luaL_unref(L, -1, ufd->r);
 182         lua_getglobal(state, "__uloop_fds");
 183         luaL_unref(L, -1, ufd->fd_r);
 184
 185         return 1;
 186 }
 187
 188 static const luaL_Reg ufd_m[] = {
 189         { "delete", ul_ufd_delete },
 190         { NULL, NULL }
 191 };
 192
 193 static int ul_ufd_add(lua_State *L)
 194 {
 195         struct lua_uloop_fd *ufd;
 196         int fd = 0;
 197         unsigned int flags = 0;
 198         int ref;
 199         int fd_ref;
 200
 201         if (lua_isnumber(L, -1)) {
 202                 flags = lua_tointeger(L, -1);
 203                 lua_pop(L, 1);
 204         }
 205
 206         if (!lua_isfunction(L, -1)) {
 207                 lua_pushstring(L, "invalid arg list");
 208                 lua_error(L);
 209
 210                 return 0;
 211         }
 212
 213         fd = get_sock_fd(L, -2);
 214
 215         lua_getglobal(L, "__uloop_cb");
 216         lua_pushvalue(L, -2);
 217         ref = luaL_ref(L, -2);
 218         lua_pop(L, 1);
 219
 220         lua_getglobal(L, "__uloop_fds");
 221         lua_pushvalue(L, -3);
 222         fd_ref = luaL_ref(L, -2);
 223         lua_pop(L, 1);
 224
 225         ufd = lua_newuserdata(L, sizeof(*ufd));
 226
 227         lua_createtable(L, 0, 2);
 228         lua_pushvalue(L, -1);
 229         lua_setfield(L, -2, "__index");
 230         lua_pushcfunction(L, ul_ufd_delete);
 231         lua_setfield(L, -2, "__gc");
 232         lua_pushvalue(L, -1);
 233         lua_setmetatable(L, -3);
 234         lua_pushvalue(L, -2);
 235         luaI_openlib(L, NULL, ufd_m, 1);
 236         lua_pushvalue(L, -2);
 237
 238         memset(ufd, 0, sizeof(*ufd));
 239
 240         ufd->r = ref;
 241         ufd->fd.fd = fd;
 242         ufd->fd_r = fd_ref;
 243         ufd->fd.cb = ul_ufd_cb;
 244         if (flags)
 245                 uloop_fd_add(&ufd->fd, flags);
 246
 247         return 1;
 248 }
 249
 250 static void ul_process_cb(struct uloop_process *p, int ret)
 251 {
 252         struct lua_uloop_process *proc = container_of(p, struct lua_uloop_process, p);
 253
 254         lua_getglobal(state, "__uloop_cb");
 255         lua_rawgeti(state, -1, proc->r);
 256
 257         luaL_unref(state, -2, proc->r);
 258         lua_remove(state, -2);
 259         lua_pushinteger(state, ret >> 8);
 260         lua_call(state, 1, 0);
 261 }
 262
 263 static int ul_process(lua_State *L)
 264 {
 265         struct lua_uloop_process *proc;
 266         pid_t pid;
 267         int ref;
 268
 269         if (!lua_isfunction(L, -1) || !lua_istable(L, -2) ||
 270                         !lua_istable(L, -3) || !lua_isstring(L, -4)) {
 271                 lua_pushstring(L, "invalid arg list");
 272                 lua_error(L);
 273
 274                 return 0;
 275         }
 276
 277         pid = fork();
 278
 279         if (pid == -1) {
 280                 lua_pushstring(L, "failed to fork");
 281                 lua_error(L);
 282
 283                 return 0;
 284         }
 285
 286         if (pid == 0) {
 287                 /* child */
 288                 int argn = lua_objlen(L, -3);
 289                 int envn = lua_objlen(L, -2);
 290                 char** argp = malloc(sizeof(char*) * (argn + 2));
 291                 char** envp = malloc(sizeof(char*) * envn + 1);
 292                 int i = 1;
 293
 294                 argp[0] = (char*) lua_tostring(L, -4);
 295                 for (i = 1; i <= argn; i++) {
 296                         lua_rawgeti(L, -3, i);
 297                         argp[i] = (char*) lua_tostring(L, -1);
 298                         lua_pop(L, 1);
 299                 }
 300                 argp[i] = NULL;
 301
 302                 for (i = 1; i <= envn; i++) {
 303                         lua_rawgeti(L, -2, i);
 304                         envp[i - 1] = (char*) lua_tostring(L, -1);
 305                         lua_pop(L, 1);
 306                 }
 307                 envp[i - 1] = NULL;
 308
 309                 execve(*argp, argp, envp);
 310                 exit(-1);
 311         }
 312
 313         lua_getglobal(L, "__uloop_cb");
 314         lua_pushvalue(L, -2);
 315         ref = luaL_ref(L, -2);
 316
 317         proc = lua_newuserdata(L, sizeof(*proc));
 318         memset(proc, 0, sizeof(*proc));
 319
 320         proc->r = ref;
 321         proc->p.pid = pid;
 322         proc->p.cb = ul_process_cb;
 323         uloop_process_add(&proc->p);
 324
 325         return 1;
 326 }
 327
 328 static int ul_init(lua_State *L)
 329 {
 330         uloop_init();
 331         lua_pushboolean(L, 1);
 332
 333         return 1;
 334 }
 335
 336 static int ul_run(lua_State *L)
 337 {
 338         uloop_run();
 339         lua_pushboolean(L, 1);
 340
 341         return 1;
 342 }
 343
 344 static luaL_reg uloop_func[] = {
 345         {"init", ul_init},
 346         {"run", ul_run},
 347         {"timer", ul_timer},
 348         {"process", ul_process},
 349         {"fd_add", ul_ufd_add},
 350         {NULL, NULL},
 351 };
 352
 353 /* avoid warnings about missing declarations */
 354 int luaopen_uloop(lua_State *L);
 355 int luaclose_uloop(lua_State *L);
 356
 357 int luaopen_uloop(lua_State *L)
 358 {
 359         state = L;
 360
 361         lua_createtable(L, 1, 0);
 362         lua_setglobal(L, "__uloop_cb");
 363
 364         lua_createtable(L, 1, 0);
 365         lua_setglobal(L, "__uloop_fds");
 366
 367         luaL_openlib(L, "uloop", uloop_func, 0);
 368         lua_pushstring(L, "_VERSION");
 369         lua_pushstring(L, "1.0");
 370         lua_rawset(L, -3);
 371
 372         lua_pushstring(L, "ULOOP_READ");
 373         lua_pushinteger(L, ULOOP_READ);
 374         lua_rawset(L, -3);
 375
 376         lua_pushstring(L, "ULOOP_WRITE");
 377         lua_pushinteger(L, ULOOP_WRITE);
 378         lua_rawset(L, -3);
 379
 380         lua_pushstring(L, "ULOOP_EDGE_TRIGGER");
 381         lua_pushinteger(L, ULOOP_EDGE_TRIGGER);
 382         lua_rawset(L, -3);
 383
 384         lua_pushstring(L, "ULOOP_BLOCKING");
 385         lua_pushinteger(L, ULOOP_BLOCKING);
 386         lua_rawset(L, -3);
 387
 388         return 1;
 389 }
 390
 391 int luaclose_uloop(lua_State *L)
 392 {
 393         lua_pushstring(L, "Called");
 394
 395         return 1;
 396 }