• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/libubox/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, 3);
237         if (!flags) {
238                 lua_pushstring(L, "flags cannot be zero");
239                 lua_error(L);
240         }
241 
242         luaL_checktype(L, 2, LUA_TFUNCTION);
243 
244         fd = get_sock_fd(L, 1);
245 
246         lua_getglobal(L, "__uloop_cb");
247         lua_pushvalue(L, 2);
248         ref = luaL_ref(L, -2);
249         lua_pop(L, 1);
250 
251         lua_getglobal(L, "__uloop_fds");
252         lua_pushvalue(L, 1);
253         fd_ref = luaL_ref(L, -2);
254         lua_pop(L, 1);
255 
256         ufd = ul_create_userdata(L, sizeof(*ufd), ufd_m, ul_ufd_delete);
257         ufd->r = ref;
258         ufd->fd.fd = fd;
259         ufd->fd_r = fd_ref;
260         ufd->fd.cb = ul_ufd_cb;
261         uloop_fd_add(&ufd->fd, flags);
262 
263         return 1;
264 }
265 
266 static int ul_process_free(lua_State *L)
267 {
268         struct lua_uloop_process *proc = lua_touserdata(L, 1);
269 
270         /* obj.__index.__gc = nil , make sure executing only once*/
271         lua_getfield(L, -1, "__index");
272         lua_pushstring(L, "__gc");
273         lua_pushnil(L);
274         lua_settable(L, -3);
275 
276         if (proc->r != LUA_NOREF) {
277                 uloop_process_delete(&proc->p);
278 
279                 lua_getglobal(state, "__uloop_cb");
280                 luaL_unref(state, -1, proc->r);
281                 lua_remove(state, -1);
282         }
283 
284         return 1;
285 }
286 
287 static int ul_process_pid(lua_State *L)
288 {
289         struct lua_uloop_process *proc = lua_touserdata(L, 1);
290 
291         if (proc->p.pid) {
292                 lua_pushnumber(L, proc->p.pid);
293                 return 1;
294         }
295 
296         return 0;
297 }
298 
299 static const luaL_Reg process_m[] = {
300         { "delete", ul_process_free },
301         { "pid", ul_process_pid },
302         { NULL, NULL }
303 };
304 
305 static void ul_process_cb(struct uloop_process *p, int ret)
306 {
307         struct lua_uloop_process *proc = container_of(p, struct lua_uloop_process, p);
308 
309         lua_getglobal(state, "__uloop_cb");
310         lua_rawgeti(state, -1, proc->r);
311 
312         luaL_unref(state, -2, proc->r);
313         proc->r = LUA_NOREF;
314         lua_remove(state, -2);
315         lua_pushinteger(state, ret >> 8);
316         lua_call(state, 1, 0);
317 }
318 
319 static int ul_process(lua_State *L)
320 {
321         struct lua_uloop_process *proc;
322         pid_t pid;
323         int ref;
324 
325         if (!lua_isfunction(L, -1) || !lua_istable(L, -2) ||
326                         !lua_istable(L, -3) || !lua_isstring(L, -4)) {
327                 lua_pushstring(L, "invalid arg list");
328                 lua_error(L);
329 
330                 return 0;
331         }
332 
333         pid = fork();
334 
335         if (pid == -1) {
336                 lua_pushstring(L, "failed to fork");
337                 lua_error(L);
338 
339                 return 0;
340         }
341 
342         if (pid == 0) {
343                 /* child */
344                 int argn = lua_objlen(L, -3);
345                 int envn = lua_objlen(L, -2);
346                 char** argp = malloc(sizeof(char*) * (argn + 2));
347                 char** envp = malloc(sizeof(char*) * (envn + 1));
348                 int i = 1;
349 
350                 if (!argp || !envp)
351                         _exit(-1);
352 
353                 argp[0] = (char*) lua_tostring(L, -4);
354                 for (i = 1; i <= argn; i++) {
355                         lua_rawgeti(L, -3, i);
356                         argp[i] = (char*) lua_tostring(L, -1);
357                         lua_pop(L, 1);
358                 }
359                 argp[i] = NULL;
360 
361                 for (i = 1; i <= envn; i++) {
362                         lua_rawgeti(L, -2, i);
363                         envp[i - 1] = (char*) lua_tostring(L, -1);
364                         lua_pop(L, 1);
365                 }
366                 envp[i - 1] = NULL;
367 
368                 execve(*argp, argp, envp);
369                 _exit(-1);
370         }
371 
372         lua_getglobal(L, "__uloop_cb");
373         lua_pushvalue(L, -2);
374         ref = luaL_ref(L, -2);
375 
376         proc = ul_create_userdata(L, sizeof(*proc), process_m, ul_process_free);
377         proc->r = ref;
378         proc->p.pid = pid;
379         proc->p.cb = ul_process_cb;
380         uloop_process_add(&proc->p);
381 
382         return 1;
383 }
384 
385 static int ul_init(lua_State *L)
386 {
387         uloop_init();
388         lua_pushboolean(L, 1);
389 
390         return 1;
391 }
392 
393 static int ul_run(lua_State *L)
394 {
395         uloop_run();
396         lua_pushboolean(L, 1);
397 
398         return 1;
399 }
400 
401 static int ul_end(lua_State *L)
402 {
403         uloop_end();
404         return 1;
405 }
406 
407 static luaL_reg uloop_func[] = {
408         {"init", ul_init},
409         {"run", ul_run},
410         {"timer", ul_timer},
411         {"process", ul_process},
412         {"fd_add", ul_ufd_add},
413         {"cancel", ul_end},
414         {NULL, NULL},
415 };
416 
417 /* avoid warnings about missing declarations */
418 int luaopen_uloop(lua_State *L);
419 int luaclose_uloop(lua_State *L);
420 
421 int luaopen_uloop(lua_State *L)
422 {
423         state = L;
424 
425         lua_createtable(L, 1, 0);
426         lua_setglobal(L, "__uloop_cb");
427 
428         lua_createtable(L, 1, 0);
429         lua_setglobal(L, "__uloop_fds");
430 
431         luaL_openlib(L, "uloop", uloop_func, 0);
432         lua_pushstring(L, "_VERSION");
433         lua_pushstring(L, "1.0");
434         lua_rawset(L, -3);
435 
436         lua_pushstring(L, "ULOOP_READ");
437         lua_pushinteger(L, ULOOP_READ);
438         lua_rawset(L, -3);
439 
440         lua_pushstring(L, "ULOOP_WRITE");
441         lua_pushinteger(L, ULOOP_WRITE);
442         lua_rawset(L, -3);
443 
444         lua_pushstring(L, "ULOOP_EDGE_TRIGGER");
445         lua_pushinteger(L, ULOOP_EDGE_TRIGGER);
446         lua_rawset(L, -3);
447 
448         lua_pushstring(L, "ULOOP_BLOCKING");
449         lua_pushinteger(L, ULOOP_BLOCKING);
450         lua_rawset(L, -3);
451 
452         return 1;
453 }
454 
455 int luaclose_uloop(lua_State *L)
456 {
457         lua_pushstring(L, "Called");
458 
459         return 1;
460 }
461 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt