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_add(lua_State *L)
 176 {
 177         struct lua_uloop_fd *ufd;
 178         int fd = 0;
 179         unsigned int flags = 0;
 180         int ref;
 181         int fd_ref;
 182
 183         if (lua_isnumber(L, -1)) {
 184                 flags = lua_tointeger(L, -1);
 185                 lua_pop(L, 1);
 186         }
 187
 188         if (!lua_isfunction(L, -1)) {
 189                 lua_pushstring(L, "invalid arg list");
 190                 lua_error(L);
 191
 192                 return 0;
 193         }
 194
 195         fd = get_sock_fd(L, -2);
 196
 197         lua_getglobal(L, "__uloop_cb");
 198         lua_pushvalue(L, -2);
 199         ref = luaL_ref(L, -2);
 200         lua_pop(L, 1);
 201
 202         lua_getglobal(L, "__uloop_fds");
 203         lua_pushvalue(L, -3);
 204         fd_ref = luaL_ref(L, -2);
 205         lua_pop(L, 1);
 206
 207         ufd = lua_newuserdata(L, sizeof(*ufd));
 208         memset(ufd, 0, sizeof(*ufd));
 209
 210         ufd->r = ref;
 211         ufd->fd.fd = fd;
 212         ufd->fd_r = fd_ref;
 213         ufd->fd.cb = ul_ufd_cb;
 214         if (flags)
 215                 uloop_fd_add(&ufd->fd, flags);
 216
 217         return 1;
 218 }
 219
 220 static void ul_process_cb(struct uloop_process *p, int ret)
 221 {
 222         struct lua_uloop_process *proc = container_of(p, struct lua_uloop_process, p);
 223
 224         lua_getglobal(state, "__uloop_cb");
 225         lua_rawgeti(state, -1, proc->r);
 226
 227         luaL_unref(state, -2, proc->r);
 228         lua_remove(state, -2);
 229         lua_pushinteger(state, ret >> 8);
 230         lua_call(state, 1, 0);
 231 }
 232
 233 static int ul_process(lua_State *L)
 234 {
 235         struct lua_uloop_process *proc;
 236         pid_t pid;
 237         int ref;
 238
 239         if (!lua_isfunction(L, -1) || !lua_istable(L, -2) ||
 240                         !lua_istable(L, -3) || !lua_isstring(L, -4)) {
 241                 lua_pushstring(L, "invalid arg list");
 242                 lua_error(L);
 243
 244                 return 0;
 245         }
 246
 247         pid = fork();
 248
 249         if (pid == -1) {
 250                 lua_pushstring(L, "failed to fork");
 251                 lua_error(L);
 252
 253                 return 0;
 254         }
 255
 256         if (pid == 0) {
 257                 /* child */
 258                 int argn = lua_objlen(L, -3);
 259                 int envn = lua_objlen(L, -2);
 260                 char** argp = malloc(sizeof(char*) * (argn + 2));
 261                 char** envp = malloc(sizeof(char*) * envn + 1);
 262                 int i = 1;
 263
 264                 argp[0] = (char*) lua_tostring(L, -4);
 265                 for (i = 1; i <= argn; i++) {
 266                         lua_rawgeti(L, -3, i);
 267                         argp[i] = (char*) lua_tostring(L, -1);
 268                         lua_pop(L, 1);
 269                 }
 270                 argp[i] = NULL;
 271
 272                 for (i = 1; i <= envn; i++) {
 273                         lua_rawgeti(L, -2, i);
 274                         envp[i - 1] = (char*) lua_tostring(L, -1);
 275                         lua_pop(L, 1);
 276                 }
 277                 envp[i - 1] = NULL;
 278
 279                 execve(*argp, argp, envp);
 280                 exit(-1);
 281         }
 282
 283         lua_getglobal(L, "__uloop_cb");
 284         lua_pushvalue(L, -2);
 285         ref = luaL_ref(L, -2);
 286
 287         proc = lua_newuserdata(L, sizeof(*proc));
 288         memset(proc, 0, sizeof(*proc));
 289
 290         proc->r = ref;
 291         proc->p.pid = pid;
 292         proc->p.cb = ul_process_cb;
 293         uloop_process_add(&proc->p);
 294
 295         return 1;
 296 }
 297
 298 static int ul_init(lua_State *L)
 299 {
 300         uloop_init();
 301         lua_pushboolean(L, 1);
 302
 303         return 1;
 304 }
 305
 306 static int ul_run(lua_State *L)
 307 {
 308         uloop_run();
 309         lua_pushboolean(L, 1);
 310
 311         return 1;
 312 }
 313
 314 static luaL_reg uloop_func[] = {
 315         {"init", ul_init},
 316         {"run", ul_run},
 317         {"timer", ul_timer},
 318         {"process", ul_process},
 319         {"fd_add", ul_ufd_add},
 320         {NULL, NULL},
 321 };
 322
 323 /* avoid warnings about missing declarations */
 324 int luaopen_uloop(lua_State *L);
 325 int luaclose_uloop(lua_State *L);
 326
 327 int luaopen_uloop(lua_State *L)
 328 {
 329         state = L;
 330
 331         lua_createtable(L, 1, 0);
 332         lua_setglobal(L, "__uloop_cb");
 333
 334         lua_createtable(L, 1, 0);
 335         lua_setglobal(L, "__uloop_fds");
 336
 337         luaL_openlib(L, "uloop", uloop_func, 0);
 338         lua_pushstring(L, "_VERSION");
 339         lua_pushstring(L, "1.0");
 340         lua_rawset(L, -3);
 341
 342         lua_pushstring(L, "ULOOP_READ");
 343         lua_pushinteger(L, ULOOP_READ);
 344         lua_rawset(L, -3);
 345
 346         lua_pushstring(L, "ULOOP_WRITE");
 347         lua_pushinteger(L, ULOOP_WRITE);
 348         lua_rawset(L, -3);
 349
 350         lua_pushstring(L, "ULOOP_EDGE_TRIGGER");
 351         lua_pushinteger(L, ULOOP_EDGE_TRIGGER);
 352         lua_rawset(L, -3);
 353
 354         lua_pushstring(L, "ULOOP_BLOCKING");
 355         lua_pushinteger(L, ULOOP_BLOCKING);
 356         lua_rawset(L, -3);
 357
 358         return 1;
 359 }
 360
 361 int luaclose_uloop(lua_State *L)
 362 {
 363         lua_pushstring(L, "Called");
 364
 365         return 1;
 366 }