source: trunk/debian/packages/libubox/trunk/lua/uloop.c @ 857

Last change on this file since 857 was 857, checked in by amain, 4 years ago

libubox: initial import / part 4

File size: 8.6 KB
Line 
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
28struct lua_uloop_fd {
29        struct uloop_fd fd;
30        int r;
31        int fd_r;
32};
33
34struct lua_uloop_timeout {
35        struct uloop_timeout t;
36        int r;
37};
38
39struct lua_uloop_process {
40        struct uloop_process p;
41        int r;
42};
43
44static lua_State *state;
45
46static void *
47ul_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
66static 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
78static 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
97static int ul_timer_free(lua_State *L)
98{
99        struct lua_uloop_timeout *tout = lua_touserdata(L, 1);
100
101        uloop_timeout_cancel(&tout->t);
102
103        /* obj.__index.__gc = nil , make sure executing only once*/
104        lua_getfield(L, -1, "__index");
105        lua_pushstring(L, "__gc");
106        lua_pushnil(L);
107        lua_settable(L, -3);
108
109        lua_getglobal(state, "__uloop_cb");
110        luaL_unref(state, -1, tout->r);
111
112        return 1;
113}
114
115static const luaL_Reg timer_m[] = {
116        { "set", ul_timer_set },
117        { "cancel", ul_timer_free },
118        { NULL, NULL }
119};
120
121static int ul_timer(lua_State *L)
122{
123        struct lua_uloop_timeout *tout;
124        int set = 0;
125        int ref;
126
127        if (lua_isnumber(L, -1)) {
128                set = lua_tointeger(L, -1);
129                lua_pop(L, 1);
130        }
131
132        if (!lua_isfunction(L, -1)) {
133                lua_pushstring(L, "invalid arg list");
134                lua_error(L);
135
136                return 0;
137        }
138
139        lua_getglobal(L, "__uloop_cb");
140        lua_pushvalue(L, -2);
141        ref = luaL_ref(L, -2);
142
143        tout = ul_create_userdata(L, sizeof(*tout), timer_m, ul_timer_free);
144        tout->r = ref;
145        tout->t.cb = ul_timer_cb;
146
147        if (set)
148                uloop_timeout_set(&tout->t, set);
149
150        return 1;
151}
152
153static void ul_ufd_cb(struct uloop_fd *fd, unsigned int events)
154{
155        struct lua_uloop_fd *ufd = container_of(fd, struct lua_uloop_fd, fd);
156
157        lua_getglobal(state, "__uloop_cb");
158        lua_rawgeti(state, -1, ufd->r);
159        lua_remove(state, -2);
160
161        /* push fd object */
162        lua_getglobal(state, "__uloop_fds");
163        lua_rawgeti(state, -1, ufd->fd_r);
164        lua_remove(state, -2);
165
166        /* push events */
167        lua_pushinteger(state, events);
168        lua_call(state, 2, 0);
169}
170
171
172static int get_sock_fd(lua_State* L, int idx) {
173        int fd;
174        if(lua_isnumber(L, idx)) {
175                fd = lua_tonumber(L, idx);
176        } else {
177                luaL_checktype(L, idx, LUA_TUSERDATA);
178                lua_getfield(L, idx, "getfd");
179                if(lua_isnil(L, -1))
180                        return luaL_error(L, "socket type missing 'getfd' method");
181                lua_pushvalue(L, idx - 1);
182                lua_call(L, 1, 1);
183                fd = lua_tointeger(L, -1);
184                lua_pop(L, 1);
185        }
186        return fd;
187}
188
189static int ul_ufd_delete(lua_State *L)
190{
191        struct lua_uloop_fd *ufd = lua_touserdata(L, 1);
192
193        uloop_fd_delete(&ufd->fd);
194
195        /* obj.__index.__gc = nil , make sure executing only once*/
196        lua_getfield(L, -1, "__index");
197        lua_pushstring(L, "__gc");
198        lua_pushnil(L);
199        lua_settable(L, -3);
200
201        lua_getglobal(state, "__uloop_cb");
202        luaL_unref(state, -1, ufd->r);
203        lua_remove(state, -1);
204
205        lua_getglobal(state, "__uloop_fds");
206        luaL_unref(state, -1, ufd->fd_r);
207        lua_remove(state, -1);
208
209        return 1;
210}
211
212static const luaL_Reg ufd_m[] = {
213        { "delete", ul_ufd_delete },
214        { NULL, NULL }
215};
216
217static int ul_ufd_add(lua_State *L)
218{
219        struct lua_uloop_fd *ufd;
220        int fd = 0;
221        unsigned int flags = 0;
222        int ref;
223        int fd_ref;
224
225        if (lua_isnumber(L, -1)) {
226                flags = lua_tointeger(L, -1);
227                lua_pop(L, 1);
228        }
229
230        if (!lua_isfunction(L, -1)) {
231                lua_pushstring(L, "invalid arg list");
232                lua_error(L);
233
234                return 0;
235        }
236
237        fd = get_sock_fd(L, -2);
238
239        lua_getglobal(L, "__uloop_cb");
240        lua_pushvalue(L, -2);
241        ref = luaL_ref(L, -2);
242        lua_pop(L, 1);
243
244        lua_getglobal(L, "__uloop_fds");
245        lua_pushvalue(L, -3);
246        fd_ref = luaL_ref(L, -2);
247        lua_pop(L, 1);
248
249        ufd = ul_create_userdata(L, sizeof(*ufd), ufd_m, ul_ufd_delete);
250        ufd->r = ref;
251        ufd->fd.fd = fd;
252        ufd->fd_r = fd_ref;
253        ufd->fd.cb = ul_ufd_cb;
254        if (flags)
255                uloop_fd_add(&ufd->fd, flags);
256
257        return 1;
258}
259
260static int ul_process_free(lua_State *L)
261{
262        struct lua_uloop_process *proc = lua_touserdata(L, 1);
263
264        /* obj.__index.__gc = nil , make sure executing only once*/
265        lua_getfield(L, -1, "__index");
266        lua_pushstring(L, "__gc");
267        lua_pushnil(L);
268        lua_settable(L, -3);
269
270        if (proc->r != LUA_NOREF) {
271                uloop_process_delete(&proc->p);
272
273                lua_getglobal(state, "__uloop_cb");
274                luaL_unref(state, -1, proc->r);
275                lua_remove(state, -1);
276        }
277
278        return 1;
279}
280
281static const luaL_Reg process_m[] = {
282        { "delete", ul_process_free },
283        { NULL, NULL }
284};
285
286static void ul_process_cb(struct uloop_process *p, int ret)
287{
288        struct lua_uloop_process *proc = container_of(p, struct lua_uloop_process, p);
289
290        lua_getglobal(state, "__uloop_cb");
291        lua_rawgeti(state, -1, proc->r);
292
293        luaL_unref(state, -2, proc->r);
294        proc->r = LUA_NOREF;
295        lua_remove(state, -2);
296        lua_pushinteger(state, ret >> 8);
297        lua_call(state, 1, 0);
298}
299
300static int ul_process(lua_State *L)
301{
302        struct lua_uloop_process *proc;
303        pid_t pid;
304        int ref;
305
306        if (!lua_isfunction(L, -1) || !lua_istable(L, -2) ||
307                        !lua_istable(L, -3) || !lua_isstring(L, -4)) {
308                lua_pushstring(L, "invalid arg list");
309                lua_error(L);
310
311                return 0;
312        }
313
314        pid = fork();
315
316        if (pid == -1) {
317                lua_pushstring(L, "failed to fork");
318                lua_error(L);
319
320                return 0;
321        }
322
323        if (pid == 0) {
324                /* child */
325                int argn = lua_objlen(L, -3);
326                int envn = lua_objlen(L, -2);
327                char** argp = malloc(sizeof(char*) * (argn + 2));
328                char** envp = malloc(sizeof(char*) * (envn + 1));
329                int i = 1;
330
331                if (!argp || !envp)
332                        _exit(-1);
333
334                argp[0] = (char*) lua_tostring(L, -4);
335                for (i = 1; i <= argn; i++) {
336                        lua_rawgeti(L, -3, i);
337                        argp[i] = (char*) lua_tostring(L, -1);
338                        lua_pop(L, 1);
339                }
340                argp[i] = NULL;
341
342                for (i = 1; i <= envn; i++) {
343                        lua_rawgeti(L, -2, i);
344                        envp[i - 1] = (char*) lua_tostring(L, -1);
345                        lua_pop(L, 1);
346                }
347                envp[i - 1] = NULL;
348
349                execve(*argp, argp, envp);
350                _exit(-1);
351        }
352
353        lua_getglobal(L, "__uloop_cb");
354        lua_pushvalue(L, -2);
355        ref = luaL_ref(L, -2);
356
357        proc = ul_create_userdata(L, sizeof(*proc), process_m, ul_process_free);
358        proc->r = ref;
359        proc->p.pid = pid;
360        proc->p.cb = ul_process_cb;
361        uloop_process_add(&proc->p);
362
363        return 1;
364}
365
366static int ul_init(lua_State *L)
367{
368        uloop_init();
369        lua_pushboolean(L, 1);
370
371        return 1;
372}
373
374static int ul_run(lua_State *L)
375{
376        uloop_run();
377        lua_pushboolean(L, 1);
378
379        return 1;
380}
381
382static int ul_end(lua_State *L)
383{
384        uloop_end();
385        return 1;
386}
387
388static luaL_reg uloop_func[] = {
389        {"init", ul_init},
390        {"run", ul_run},
391        {"timer", ul_timer},
392        {"process", ul_process},
393        {"fd_add", ul_ufd_add},
394        {"cancel", ul_end},
395        {NULL, NULL},
396};
397
398/* avoid warnings about missing declarations */
399int luaopen_uloop(lua_State *L);
400int luaclose_uloop(lua_State *L);
401
402int luaopen_uloop(lua_State *L)
403{
404        state = L;
405
406        lua_createtable(L, 1, 0);
407        lua_setglobal(L, "__uloop_cb");
408
409        lua_createtable(L, 1, 0);
410        lua_setglobal(L, "__uloop_fds");
411
412        luaL_openlib(L, "uloop", uloop_func, 0);
413        lua_pushstring(L, "_VERSION");
414        lua_pushstring(L, "1.0");
415        lua_rawset(L, -3);
416
417        lua_pushstring(L, "ULOOP_READ");
418        lua_pushinteger(L, ULOOP_READ);
419        lua_rawset(L, -3);
420
421        lua_pushstring(L, "ULOOP_WRITE");
422        lua_pushinteger(L, ULOOP_WRITE);
423        lua_rawset(L, -3);
424
425        lua_pushstring(L, "ULOOP_EDGE_TRIGGER");
426        lua_pushinteger(L, ULOOP_EDGE_TRIGGER);
427        lua_rawset(L, -3);
428
429        lua_pushstring(L, "ULOOP_BLOCKING");
430        lua_pushinteger(L, ULOOP_BLOCKING);
431        lua_rawset(L, -3);
432
433        return 1;
434}
435
436int luaclose_uloop(lua_State *L)
437{
438        lua_pushstring(L, "Called");
439
440        return 1;
441}
Note: See TracBrowser for help on using the repository browser.