inotify support for pbx_spool
[asterisk/asterisk.git] / pbx / pbx_lua.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2007, Digium, Inc.
5  *
6  * Matthew Nicholson <mnicholson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file
21  *
22  * \author Matthew Nicholson <mnicholson@digium.com>
23  * \brief Lua PBX Switch
24  *
25  */
26
27 /*** MODULEINFO
28         <depend>lua</depend>
29  ***/
30
31 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include "asterisk/logger.h"
36 #include "asterisk/channel.h"
37 #include "asterisk/pbx.h"
38 #include "asterisk/module.h"
39 #include "asterisk/cli.h"
40 #include "asterisk/utils.h"
41 #include "asterisk/term.h"
42 #include "asterisk/paths.h"
43 #include "asterisk/hashtab.h"
44
45 #ifdef LUA51_PREFIX
46 #include <lua5.1/lua.h>
47 #include <lua5.1/lauxlib.h>
48 #include <lua5.1/lualib.h>
49 #else
50 #include <lua.h>
51 #include <lauxlib.h>
52 #include <lualib.h>
53 #endif
54
55 static char *config = "extensions.lua";
56 static char *registrar = "pbx_lua";
57
58 #define LUA_EXT_DATA_SIZE 256
59 #define LUA_BUF_SIZE 4096
60
61 static char *lua_read_extensions_file(lua_State *L, long *size);
62 static int lua_load_extensions(lua_State *L, struct ast_channel *chan);
63 static int lua_reload_extensions(lua_State *L);
64 static void lua_free_extensions(void);
65 static int lua_sort_extensions(lua_State *L);
66 static int lua_register_switches(lua_State *L);
67 static int lua_extension_cmp(lua_State *L);
68 static int lua_find_extension(lua_State *L, const char *context, const char *exten, int priority, ast_switch_f *func, int push_func);
69 static int lua_pbx_findapp(lua_State *L);
70 static int lua_pbx_exec(lua_State *L);
71
72 static int lua_get_variable_value(lua_State *L);
73 static int lua_set_variable_value(lua_State *L);
74 static int lua_get_variable(lua_State *L);
75 static int lua_set_variable(lua_State *L);
76 static int lua_func_read(lua_State *L);
77
78 static int lua_autoservice_start(lua_State *L);
79 static int lua_autoservice_stop(lua_State *L);
80 static int lua_autoservice_status(lua_State *L);
81 static int lua_check_hangup(lua_State *L);
82 static int lua_error_function(lua_State *L);
83
84 static void lua_update_registry(lua_State *L, const char *context, const char *exten, int priority);
85 static void lua_push_variable_table(lua_State *L, const char *name);
86 static void lua_create_app_table(lua_State *L);
87 static void lua_create_channel_table(lua_State *L);
88 static void lua_create_variable_metatable(lua_State *L);
89 static void lua_create_application_metatable(lua_State *L);
90 static void lua_create_autoservice_functions(lua_State *L);
91 static void lua_create_hangup_function(lua_State *L);
92
93 void lua_state_destroy(void *data);
94 static lua_State *lua_get_state(struct ast_channel *chan);
95
96 static int exists(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data);
97 static int canmatch(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data);
98 static int matchmore(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data);
99 static int exec(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data);
100
101 AST_MUTEX_DEFINE_STATIC(config_file_lock);
102 static char *config_file_data = NULL;
103 static long config_file_size = 0;
104
105 static struct ast_context *local_contexts = NULL;
106 static struct ast_hashtab *local_table = NULL;
107
108 static const struct ast_datastore_info lua_datastore = {
109         .type = "lua",
110         .destroy = lua_state_destroy,
111 };
112
113
114 /*!
115  * \brief The destructor for lua_datastore
116  */
117 void lua_state_destroy(void *data)
118 {
119         if (data)
120                 lua_close(data);
121 }
122
123 /*!
124  * \brief [lua_CFunction] Find an app and return it in a lua table (for access from lua, don't
125  * call directly)
126  *
127  * This function would be called in the following example as it would be found
128  * in extensions.lua.
129  *
130  * \code
131  * app.dial
132  * \endcode
133  */
134 static int lua_pbx_findapp(lua_State *L)
135 {
136         const char *app_name = luaL_checkstring(L, 2);
137         
138         lua_newtable(L);
139
140         lua_pushstring(L, "name");
141         lua_pushstring(L, app_name);
142         lua_settable(L, -3);
143
144         luaL_getmetatable(L, "application");
145         lua_setmetatable(L, -2);
146
147         return 1;
148 }
149
150 /*!
151  * \brief [lua_CFunction] This function is part of the 'application' metatable
152  * and is used to execute applications similar to pbx_exec() (for access from
153  * lua, don't call directly)
154  *
155  * \param L the lua_State to use
156  * \return nothing
157  *
158  * This funciton is executed as the '()' operator for apps accessed through the
159  * 'app' table.
160  *
161  * \code
162  * app.playback('demo-congrats')
163  * \endcode
164  */
165 static int lua_pbx_exec(lua_State *L)
166 {
167         int res, nargs = lua_gettop(L);
168         char data[LUA_EXT_DATA_SIZE] = "";
169         char *data_next = data, *app_name;
170         char *context, *exten;
171         char tmp[80], tmp2[80], tmp3[LUA_EXT_DATA_SIZE];
172         int priority, autoservice;
173         size_t data_left = sizeof(data);
174         struct ast_app *app;
175         struct ast_channel *chan;
176         
177         lua_getfield(L, 1, "name");
178         app_name = ast_strdupa(lua_tostring(L, -1));
179         lua_pop(L, 1);
180         
181         if (!(app = pbx_findapp(app_name))) {
182                 lua_pushstring(L, "application '");
183                 lua_pushstring(L, app_name);
184                 lua_pushstring(L, "' not found");
185                 lua_concat(L, 3);
186                 return lua_error(L);
187         }
188         
189
190         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
191         chan = lua_touserdata(L, -1);
192         lua_pop(L, 1);
193         
194         
195         lua_getfield(L, LUA_REGISTRYINDEX, "context");
196         context = ast_strdupa(lua_tostring(L, -1));
197         lua_pop(L, 1);
198         
199         lua_getfield(L, LUA_REGISTRYINDEX, "exten");
200         exten = ast_strdupa(lua_tostring(L, -1));
201         lua_pop(L, 1);
202         
203         lua_getfield(L, LUA_REGISTRYINDEX, "priority");
204         priority = lua_tointeger(L, -1);
205         lua_pop(L, 1);
206
207
208         if (nargs > 1) {
209                 int i;
210
211                 if (!lua_isnil(L, 2))
212                         ast_build_string(&data_next, &data_left, "%s", luaL_checkstring(L, 2));
213
214                 for (i = 3; i <= nargs; i++) {
215                         if (lua_isnil(L, i))
216                                 ast_build_string(&data_next, &data_left, ",");
217                         else
218                                 ast_build_string(&data_next, &data_left, ",%s", luaL_checkstring(L, i));
219                 }
220         }
221         
222         ast_verb(3, "Executing [%s@%s:%d] %s(\"%s\", \"%s\")\n",
223                         exten, context, priority,
224                         term_color(tmp, app_name, COLOR_BRCYAN, 0, sizeof(tmp)),
225                         term_color(tmp2, chan->name, COLOR_BRMAGENTA, 0, sizeof(tmp2)),
226                         term_color(tmp3, data, COLOR_BRMAGENTA, 0, sizeof(tmp3)));
227
228         lua_getfield(L, LUA_REGISTRYINDEX, "autoservice");
229         autoservice = lua_toboolean(L, -1);
230         lua_pop(L, 1);
231
232         if (autoservice)
233                 ast_autoservice_stop(chan);
234
235         res = pbx_exec(chan, app, data);
236         
237         if (autoservice)
238                 ast_autoservice_start(chan);
239
240         /* error executing an application, report it */
241         if (res) {
242                 lua_pushinteger(L, res);
243                 return lua_error(L);
244         }
245         return 0;
246 }
247
248 /*!
249  * \brief [lua_CFunction] Used to get the value of a variable or dialplan
250  * function (for access from lua, don't call directly)
251  * 
252  * The value of the variable or function is returned.  This function is the
253  * 'get()' function in the following example as would be seen in
254  * extensions.lua.
255  *
256  * \code
257  * channel.variable:get()
258  * \endcode
259  */
260 static int lua_get_variable_value(lua_State *L)
261 {
262         struct ast_channel *chan;
263         char *value = NULL, *name;
264         char *workspace = alloca(LUA_BUF_SIZE);
265         int autoservice;
266
267         workspace[0] = '\0';
268
269         if (!lua_istable(L, 1)) {
270                 lua_pushstring(L, "User probably used '.' instead of ':' for retrieving a channel variable value");
271                 return lua_error(L);
272         }
273         
274         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
275         chan = lua_touserdata(L, -1);
276         lua_pop(L, 1);
277
278         lua_getfield(L, 1, "name");
279         name = ast_strdupa(lua_tostring(L, -1));
280         lua_pop(L, 1);
281         
282         lua_getfield(L, LUA_REGISTRYINDEX, "autoservice");
283         autoservice = lua_toboolean(L, -1);
284         lua_pop(L, 1);
285
286         if (autoservice)
287                 ast_autoservice_stop(chan);
288         
289         /* if this is a dialplan function then use ast_func_read(), otherwise
290          * use pbx_retrieve_variable() */
291         if (!ast_strlen_zero(name) && name[strlen(name) - 1] == ')') {
292                 value = ast_func_read(chan, name, workspace, LUA_BUF_SIZE) ? NULL : workspace;
293         } else {
294                 pbx_retrieve_variable(chan, name, &value, workspace, LUA_BUF_SIZE, &chan->varshead);
295         }
296         
297         if (autoservice)
298                 ast_autoservice_start(chan);
299
300         if (value) {
301                 lua_pushstring(L, value);
302         } else {
303                 lua_pushnil(L);
304         }
305
306         return 1;
307 }
308
309 /*!
310  * \brief [lua_CFunction] Used to set the value of a variable or dialplan
311  * function (for access from lua, don't call directly)
312  * 
313  * This function is the 'set()' function in the following example as would be
314  * seen in extensions.lua.
315  *
316  * \code
317  * channel.variable:set("value")
318  * \endcode
319  */
320 static int lua_set_variable_value(lua_State *L)
321 {
322         const char *name, *value;
323         struct ast_channel *chan;
324         int autoservice;
325
326         if (!lua_istable(L, 1)) {
327                 lua_pushstring(L, "User probably used '.' instead of ':' for setting a channel variable");
328                 return lua_error(L);
329         }
330
331         lua_getfield(L, 1, "name");
332         name = ast_strdupa(lua_tostring(L, -1));
333         lua_pop(L, 1);
334
335         value = luaL_checkstring(L, 2);
336         
337         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
338         chan = lua_touserdata(L, -1);
339         lua_pop(L, 1);
340
341         lua_getfield(L, LUA_REGISTRYINDEX, "autoservice");
342         autoservice = lua_toboolean(L, -1);
343         lua_pop(L, 1);
344
345         if (autoservice)
346                 ast_autoservice_stop(chan);
347
348         pbx_builtin_setvar_helper(chan, name, value);
349         
350         if (autoservice)
351                 ast_autoservice_start(chan);
352
353         return 0;
354 }
355
356 /*!
357  * \brief Update the lua registry with the given context, exten, and priority.
358  *
359  * \param L the lua_State to use
360  * \param context the new context
361  * \param exten the new exten
362  * \param priority the new priority
363  */
364 static void lua_update_registry(lua_State *L, const char *context, const char *exten, int priority)
365 {
366         lua_pushstring(L, context);
367         lua_setfield(L, LUA_REGISTRYINDEX, "context");
368
369         lua_pushstring(L, exten);
370         lua_setfield(L, LUA_REGISTRYINDEX, "exten");
371
372         lua_pushinteger(L, priority);
373         lua_setfield(L, LUA_REGISTRYINDEX, "priority");
374 }
375
376 /*!
377  * \brief Push a 'variable' table on the stack for access the channel variable
378  * with the given name.
379  *
380  * \param L the lua_State to use
381  * \param name the name of the variable
382  */
383 static void lua_push_variable_table(lua_State *L, const char *name)
384 {
385         lua_newtable(L);
386         luaL_getmetatable(L, "variable");
387         lua_setmetatable(L, -2);
388
389         lua_pushstring(L, name);
390         lua_setfield(L, -2, "name");
391         
392         lua_pushcfunction(L, &lua_get_variable_value);
393         lua_setfield(L, -2, "get");
394         
395         lua_pushcfunction(L, &lua_set_variable_value);
396         lua_setfield(L, -2, "set");
397 }
398
399 /*!
400  * \brief Create the global 'app' table for executing applications
401  *
402  * \param L the lua_State to use
403  */
404 static void lua_create_app_table(lua_State *L)
405 {
406         lua_newtable(L);
407         luaL_newmetatable(L, "app");
408
409         lua_pushstring(L, "__index");
410         lua_pushcfunction(L, &lua_pbx_findapp);
411         lua_settable(L, -3);
412
413         lua_setmetatable(L, -2);
414         lua_setglobal(L, "app");
415 }
416
417 /*!
418  * \brief Create the global 'channel' table for accesing channel variables
419  *
420  * \param L the lua_State to use
421  */
422 static void lua_create_channel_table(lua_State *L)
423 {
424         lua_newtable(L);
425         luaL_newmetatable(L, "channel_data");
426
427         lua_pushstring(L, "__index");
428         lua_pushcfunction(L, &lua_get_variable);
429         lua_settable(L, -3);
430
431         lua_pushstring(L, "__newindex");
432         lua_pushcfunction(L, &lua_set_variable);
433         lua_settable(L, -3);
434
435         lua_setmetatable(L, -2);
436         lua_setglobal(L, "channel");
437 }
438
439 /*!
440  * \brief Create the 'variable' metatable, used to retrieve channel variables
441  *
442  * \param L the lua_State to use
443  */
444 static void lua_create_variable_metatable(lua_State *L)
445 {
446         luaL_newmetatable(L, "variable");
447
448         lua_pushstring(L, "__call");
449         lua_pushcfunction(L, &lua_func_read);
450         lua_settable(L, -3);
451
452         lua_pop(L, 1);
453 }
454
455 /*!
456  * \brief Create the 'application' metatable, used to execute asterisk
457  * applications from lua 
458  *
459  * \param L the lua_State to use
460  */
461 static void lua_create_application_metatable(lua_State *L)
462 {
463         luaL_newmetatable(L, "application");
464
465         lua_pushstring(L, "__call");
466         lua_pushcfunction(L, &lua_pbx_exec);
467         lua_settable(L, -3);
468
469         lua_pop(L, 1);
470 }
471
472 /*!
473  * \brief Create the autoservice functions
474  *
475  * \param L the lua_State to use
476  */
477 static void lua_create_autoservice_functions(lua_State *L)
478 {
479         lua_pushcfunction(L, &lua_autoservice_start);
480         lua_setglobal(L, "autoservice_start");
481         
482         lua_pushcfunction(L, &lua_autoservice_stop);
483         lua_setglobal(L, "autoservice_stop");
484
485         lua_pushcfunction(L, &lua_autoservice_status);
486         lua_setglobal(L, "autoservice_status");
487
488         lua_pushboolean(L, 0);
489         lua_setfield(L, LUA_REGISTRYINDEX, "autoservice");
490 }
491
492 /*!
493  * \brief Create the hangup check function
494  *
495  * \param L the lua_State to use
496  */
497 static void lua_create_hangup_function(lua_State *L)
498 {
499         lua_pushcfunction(L, &lua_check_hangup);
500         lua_setglobal(L, "check_hangup");
501 }
502
503 /*!
504  * \brief [lua_CFunction] Return a lua 'variable' object (for access from lua, don't call
505  * directly)
506  * 
507  * This function is called to lookup a variable construct a 'variable' object.
508  * It would be called in the following example as would be seen in
509  * extensions.lua.
510  *
511  * \code
512  * channel.variable
513  * \endcode
514  */
515 static int lua_get_variable(lua_State *L)
516 {
517         struct ast_channel *chan;
518         char *name = ast_strdupa(luaL_checkstring(L, 2));
519         char *value = NULL;
520         char *workspace = alloca(LUA_BUF_SIZE);
521         workspace[0] = '\0';
522         
523         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
524         chan = lua_touserdata(L, -1);
525         lua_pop(L, 1);
526
527         lua_push_variable_table(L, name);
528         
529         /* if this is not a request for a dialplan funciton attempt to retrieve
530          * the value of the variable */
531         if (!ast_strlen_zero(name) && name[strlen(name) - 1] != ')') {
532                 pbx_retrieve_variable(chan, name, &value, workspace, LUA_BUF_SIZE, &chan->varshead);
533         }
534
535         if (value) {
536                 lua_pushstring(L, value);
537                 lua_setfield(L, -2, "value");
538         }
539
540         return 1;       
541 }
542
543 /*!
544  * \brief [lua_CFunction] Set the value of a channel variable or dialplan
545  * function (for access from lua, don't call directly)
546  * 
547  * This function is called to set a variable or dialplan function.  It would be
548  * called in the following example as would be seen in extensions.lua.
549  *
550  * \code
551  * channel.variable = "value"
552  * \endcode
553  */
554 static int lua_set_variable(lua_State *L)
555 {
556         struct ast_channel *chan;
557         int autoservice;
558         const char *name = luaL_checkstring(L, 2);
559         const char *value = luaL_checkstring(L, 3);
560
561         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
562         chan = lua_touserdata(L, -1);
563         lua_pop(L, 1);
564
565         lua_getfield(L, LUA_REGISTRYINDEX, "autoservice");
566         autoservice = lua_toboolean(L, -1);
567         lua_pop(L, 1);
568
569         if (autoservice)
570                 ast_autoservice_stop(chan);
571
572         pbx_builtin_setvar_helper(chan, name, value);
573         
574         if (autoservice)
575                 ast_autoservice_start(chan);
576
577         return 0;
578 }
579
580 /*!
581  * \brief [lua_CFunction] Create a 'variable' object for accessing a dialplan
582  * function (for access from lua, don't call directly)
583  * 
584  * This function is called to create a 'variable' object to access a dialplan
585  * function.  It would be called in the following example as would be seen in
586  * extensions.lua.
587  *
588  * \code
589  * channel.func("arg1", "arg2", "arg3")
590  * \endcode
591  *
592  * To actually do anything with the resulting value you must use the 'get()'
593  * and 'set()' methods (the reason is the resulting value is not a value, but
594  * an object in the form of a lua table).
595  */
596 static int lua_func_read(lua_State *L)
597 {
598         int nargs = lua_gettop(L);
599         char fullname[LUA_EXT_DATA_SIZE] = "";
600         char *fullname_next = fullname, *name;
601         size_t fullname_left = sizeof(fullname);
602         
603         lua_getfield(L, 1, "name");
604         name = ast_strdupa(lua_tostring(L, -1));
605         lua_pop(L, 1);
606
607         ast_build_string(&fullname_next, &fullname_left, "%s(", name);
608         
609         if (nargs > 1) {
610                 int i;
611
612                 if (!lua_isnil(L, 2))
613                         ast_build_string(&fullname_next, &fullname_left, "%s", luaL_checkstring(L, 2));
614
615                 for (i = 3; i <= nargs; i++) {
616                         if (lua_isnil(L, i))
617                                 ast_build_string(&fullname_next, &fullname_left, ",");
618                         else
619                                 ast_build_string(&fullname_next, &fullname_left, ",%s", luaL_checkstring(L, i));
620                 }
621         }
622
623         ast_build_string(&fullname_next, &fullname_left, ")");
624         
625         lua_push_variable_table(L, fullname);
626         
627         return 1;
628 }
629
630 /*!
631  * \brief [lua_CFunction] Tell pbx_lua to maintain an autoservice on this
632  * channel (for access from lua, don't call directly)
633  *
634  * \param L the lua_State to use
635  *
636  * This function will set a flag that will cause pbx_lua to maintain an
637  * autoservice on this channel.  The autoservice will automatically be stopped
638  * and restarted before calling applications and functions.
639  *
640  * \return This function returns the result of the ast_autoservice_start()
641  * function as a boolean to its lua caller.
642  */
643 static int lua_autoservice_start(lua_State *L)
644 {
645         struct ast_channel *chan;
646         int res;
647
648         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
649         chan = lua_touserdata(L, -1);
650         lua_pop(L, 1);
651
652         res = ast_autoservice_start(chan);
653
654         lua_pushboolean(L, !res);
655         lua_setfield(L, LUA_REGISTRYINDEX, "autoservice");
656
657         lua_pushboolean(L, !res);
658         return 1;
659 }
660
661 /*!
662  * \brief [lua_CFunction] Tell pbx_lua to stop maintaning an autoservice on
663  * this channel (for access from lua, don't call directly)
664  *
665  * \param L the lua_State to use
666  *
667  * This function will stop any autoservice running and turn off the autoservice
668  * flag.  If this function returns false, it's probably because no autoservice
669  * was running to begin with.
670  *
671  * \return This function returns the result of the ast_autoservice_stop()
672  * function as a boolean to its lua caller.
673  */
674 static int lua_autoservice_stop(lua_State *L)
675 {
676         struct ast_channel *chan;
677         int res;
678
679         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
680         chan = lua_touserdata(L, -1);
681         lua_pop(L, 1);
682
683         res = ast_autoservice_stop(chan);
684
685         lua_pushboolean(L, 0);
686         lua_setfield(L, LUA_REGISTRYINDEX, "autoservice");
687
688         lua_pushboolean(L, !res);
689         return 1;
690 }
691
692 /*!
693  * \brief [lua_CFunction] Get the status of the autoservice flag (for access
694  * from lua, don't call directly)
695  *
696  * \param L the lua_State to use
697  *
698  * \return This function returns the status of the autoservice flag as a
699  * boolean to its lua caller.
700  */
701 static int lua_autoservice_status(lua_State *L)
702 {
703         lua_getfield(L, LUA_REGISTRYINDEX, "autoservice");
704         return 1;
705 }
706
707 /*!
708  * \brief [lua_CFunction] Check if this channel has been hungup or not (for
709  * access from lua, don't call directly)
710  *
711  * \param L the lua_State to use
712  *
713  * \return This function returns true if the channel was hungup
714  */
715 static int lua_check_hangup(lua_State *L)
716 {
717         struct ast_channel *chan;
718         lua_getfield(L, LUA_REGISTRYINDEX, "channel");
719         chan = lua_touserdata(L, -1);
720         lua_pop(L, 1);
721
722         lua_pushboolean(L, ast_check_hangup(chan));
723         return 1;
724 }
725
726 /*!
727  * \brief [lua_CFunction] Handle lua errors (for access from lua, don't call
728  * directly)
729  *
730  * \param L the lua_State to use
731  */
732 static int lua_error_function(lua_State *L)
733 {
734         int message_index;
735
736         /* pass number arguments right through back to asterisk*/
737         if (lua_isnumber(L, -1)) {
738                 return 1;
739         }
740
741         /* if we are here then we have a string error message, let's attach a
742          * backtrace to it */
743         message_index = lua_gettop(L);
744
745         lua_getglobal(L, "debug");
746         lua_getfield(L, -1, "traceback");
747         lua_remove(L, -2); /* remove the 'debug' table */
748
749         lua_pushvalue(L, message_index);
750         lua_remove(L, message_index);
751
752         lua_pushnumber(L, 2);
753
754         lua_call(L, 2, 1);
755
756         return 1;
757 }
758
759 /*!
760  * \brief Store the sort order of each context
761  
762  * In the event of an error, an error string will be pushed onto the lua stack.
763  *
764  * \retval 0 success
765  * \retval 1 failure
766  */
767 static int lua_sort_extensions(lua_State *L)
768 {
769         int extensions, extensions_order;
770
771         /* create the extensions_order table */
772         lua_newtable(L);
773         lua_setfield(L, LUA_REGISTRYINDEX, "extensions_order");
774         lua_getfield(L, LUA_REGISTRYINDEX, "extensions_order");
775         extensions_order = lua_gettop(L);
776
777         /* sort each context in the extensions table */
778         /* load the 'extensions' table */
779         lua_getglobal(L, "extensions");
780         extensions = lua_gettop(L);
781         if (lua_isnil(L, -1)) {
782                 lua_pop(L, 1);
783                 lua_pushstring(L, "Unable to find 'extensions' table in extensions.lua\n");
784                 return 1;
785         }
786
787         /* iterate through the extensions table and create a
788          * matching table (holding the sort order) in the
789          * extensions_order table for each context that is found
790          */
791         for (lua_pushnil(L); lua_next(L, extensions); lua_pop(L, 1)) {
792                 int context = lua_gettop(L);
793                 int context_name = context - 1;
794                 int context_order;
795
796                 lua_pushvalue(L, context_name);
797                 lua_newtable(L);
798                 context_order = lua_gettop(L);
799
800                 /* iterate through this context an popluate the corrisponding
801                  * table in the extensions_order table */
802                 for (lua_pushnil(L); lua_next(L, context); lua_pop(L, 1)) {
803                         int exten = lua_gettop(L) - 1;
804
805                         lua_pushinteger(L, lua_objlen(L, context_order) + 1);
806                         lua_pushvalue(L, exten);
807                         lua_settable(L, context_order);
808                 }
809                 lua_settable(L, extensions_order); /* put the context_order table in the extensions_order table */
810
811                 /* now sort the new table */
812
813                 /* push the table.sort function */
814                 lua_getglobal(L, "table");
815                 lua_getfield(L, -1, "sort");
816                 lua_remove(L, -2); /* remove the 'table' table */
817
818                 /* push the context_order table */
819                 lua_pushvalue(L, context_name);
820                 lua_gettable(L, extensions_order);
821
822                 /* push the comp function */
823                 lua_pushcfunction(L, &lua_extension_cmp);
824
825                 if (lua_pcall(L, 2, 0, 0)) {
826                         lua_insert(L, -5);
827                         lua_pop(L, 4);
828                         return 1;
829                 }
830         }
831         
832         /* remove the extensions table and the extensions_order table */
833         lua_pop(L, 2);
834         return 0;
835 }
836
837 /*!
838  * \brief Register dialplan switches for our pbx_lua contexs.
839  *
840  * In the event of an error, an error string will be pushed onto the lua stack.
841  *
842  * \retval 0 success
843  * \retval 1 failure
844  */
845 static int lua_register_switches(lua_State *L)
846 {
847         int extensions;
848         struct ast_context *con = NULL;
849
850         /* create the hash table for our contexts */
851         /* XXX do we ever need to destroy this? pbx_config does not */
852         if (!local_table)
853                 local_table = ast_hashtab_create(17, ast_hashtab_compare_contexts, ast_hashtab_resize_java, ast_hashtab_newsize_java, ast_hashtab_hash_contexts, 0);
854
855         /* load the 'extensions' table */
856         lua_getglobal(L, "extensions");
857         extensions = lua_gettop(L);
858         if (lua_isnil(L, -1)) {
859                 lua_pop(L, 1);
860                 lua_pushstring(L, "Unable to find 'extensions' table in extensions.lua\n");
861                 return 1;
862         }
863
864         /* iterate through the extensions table and register a context and
865          * dialplan switch for each lua context
866          */
867         for (lua_pushnil(L); lua_next(L, extensions); lua_pop(L, 1)) {
868                 int context = lua_gettop(L);
869                 int context_name = context - 1;
870                 const char *context_str = lua_tostring(L, context_name);
871
872                 /* find or create this context */
873                 con = ast_context_find_or_create(&local_contexts, local_table, context_str, registrar);
874                 if (!con) {
875                         /* remove extensions table and context key and value */
876                         lua_pop(L, 3);
877                         lua_pushstring(L, "Failed to find or create context\n");
878                         return 1;
879                 }
880
881                 /* register the switch */
882                 if (ast_context_add_switch2(con, "Lua", "", 0, registrar)) {
883                         /* remove extensions table and context key and value */
884                         lua_pop(L, 3);
885                         lua_pushstring(L, "Unable to create switch for context\n");
886                         return 1;
887                 }
888         }
889         
890         /* remove the extensions table */
891         lua_pop(L, 1);
892         return 0;
893 }
894
895
896 /*!
897  * \brief [lua_CFunction] Compare two extensions (for access from lua, don't
898  * call directly)
899  *
900  * This function returns true if the first extension passed should match after
901  * the second.  It behaves like the '<' operator.
902  */
903 static int lua_extension_cmp(lua_State *L)
904 {
905         const char *a = luaL_checkstring(L, -2);
906         const char *b = luaL_checkstring(L, -1);
907
908         if (ast_extension_cmp(a, b) == -1)
909                 lua_pushboolean(L, 1);
910         else
911                 lua_pushboolean(L, 0);
912
913         return 1;
914 }
915
916 /*!
917  * \brief Load the extensions.lua file in to a buffer and execute the file
918  *
919  * \param L the lua_State to use
920  * \param size a pointer to store the size of the buffer
921  *
922  * \note The caller is expected to free the buffer at some point.
923  *
924  * \return a pointer to the buffer
925  */
926 static char *lua_read_extensions_file(lua_State *L, long *size)
927 {
928         FILE *f;
929         char *data;
930         char *path = alloca(strlen(config) + strlen(ast_config_AST_CONFIG_DIR) + 2);
931         sprintf(path, "%s/%s", ast_config_AST_CONFIG_DIR, config);
932
933         if (!(f = fopen(path, "r"))) {
934                 lua_pushstring(L, "cannot open '");
935                 lua_pushstring(L, path);
936                 lua_pushstring(L, "' for reading: ");
937                 lua_pushstring(L, strerror(errno));
938                 lua_concat(L, 4);
939
940                 return NULL;
941         }
942
943         fseek(f, 0l, SEEK_END);
944         *size = ftell(f);
945
946         fseek(f, 0l, SEEK_SET);
947
948         if (!(data = ast_malloc(*size))) {
949                 *size = 0;
950                 fclose(f);
951                 lua_pushstring(L, "not enough memory");
952                 return NULL;
953         }
954
955         if (fread(data, sizeof(char), *size, f) != *size) {
956                 ast_log(LOG_WARNING, "fread() failed: %s\n", strerror(errno));
957         }
958         fclose(f);
959
960         if (luaL_loadbuffer(L, data, *size, "extensions.lua")
961                         || lua_pcall(L, 0, LUA_MULTRET, 0)
962                         || lua_sort_extensions(L)
963                         || lua_register_switches(L)) {
964                 ast_free(data);
965                 data = NULL;
966                 *size = 0;
967         }
968         return data;
969 }
970
971 /*!
972  * \brief Load the extensions.lua file from the internal buffer
973  *
974  * \param L the lua_State to use
975  * \param chan channel to work on
976  *
977  * This function also sets up some constructs used by the extensions.lua file.
978  * In the event of an error, an error string will be pushed onto the lua stack.
979  *
980  * \retval 0 success
981  * \retval 1 failure
982  */
983 static int lua_load_extensions(lua_State *L, struct ast_channel *chan)
984 {
985         
986         /* store a pointer to this channel */
987         lua_pushlightuserdata(L, chan);
988         lua_setfield(L, LUA_REGISTRYINDEX, "channel");
989         
990         luaL_openlibs(L);
991
992         /* load and sort extensions */
993         ast_mutex_lock(&config_file_lock);
994         if (luaL_loadbuffer(L, config_file_data, config_file_size, "extensions.lua")
995                         || lua_pcall(L, 0, LUA_MULTRET, 0)
996                         || lua_sort_extensions(L)) {
997                 ast_mutex_unlock(&config_file_lock);
998                 return 1;
999         }
1000         ast_mutex_unlock(&config_file_lock);
1001
1002         /* now we setup special tables and functions */
1003
1004         lua_create_app_table(L);
1005         lua_create_channel_table(L);
1006
1007         lua_create_variable_metatable(L);
1008         lua_create_application_metatable(L);
1009
1010         lua_create_autoservice_functions(L);
1011         lua_create_hangup_function(L);
1012
1013         return 0;
1014 }
1015
1016 /*!
1017  * \brief Reload the extensions file and update the internal buffers if it
1018  * loads correctly.
1019  *
1020  * \warning This function should not be called on a lua_State returned from
1021  * lua_get_state().
1022  *
1023  * \param L the lua_State to use (must be freshly allocated with
1024  * luaL_newstate(), don't use lua_get_state())
1025  */
1026 static int lua_reload_extensions(lua_State *L)
1027 {
1028         long size = 0;
1029         char *data = NULL;
1030
1031         luaL_openlibs(L);
1032
1033         if (!(data = lua_read_extensions_file(L, &size))) {
1034                 return 1;
1035         }
1036
1037         ast_mutex_lock(&config_file_lock);
1038
1039         if (config_file_data)
1040                 ast_free(config_file_data);
1041
1042         config_file_data = data;
1043         config_file_size = size;
1044         
1045         /* merge our new contexts */
1046         ast_merge_contexts_and_delete(&local_contexts, local_table, registrar);
1047         /* merge_contexts_and_delete will actually, at the correct moment, 
1048            set the global dialplan pointers to your local_contexts and local_table.
1049            It then will free up the old tables itself. Just be sure not to
1050            hang onto the pointers. */
1051         local_table = NULL;
1052         local_contexts = NULL;
1053
1054         ast_mutex_unlock(&config_file_lock);
1055         return 0;
1056 }
1057
1058 /*!
1059  * \brief Free the internal extensions buffer.
1060  */
1061 static void lua_free_extensions()
1062 {
1063         ast_mutex_lock(&config_file_lock);
1064         config_file_size = 0;
1065         ast_free(config_file_data);
1066         ast_mutex_unlock(&config_file_lock);
1067 }
1068
1069 /*!
1070  * \brief Get the lua_State for this channel
1071  *
1072  * If no channel is passed then a new state is allocated.  States with no
1073  * channel assocatied with them should only be used for matching extensions.
1074  * If the channel does not yet have a lua state associated with it, one will be
1075  * created.
1076  *
1077  * \note If no channel was passed then the caller is expected to free the state
1078  * using lua_close().
1079  *
1080  * \return a lua_State
1081  */
1082 static lua_State *lua_get_state(struct ast_channel *chan)
1083 {
1084         struct ast_datastore *datastore = NULL;
1085         lua_State *L;
1086
1087         if (!chan) {
1088                 lua_State *L = luaL_newstate();
1089                 if (!L) {
1090                         ast_log(LOG_ERROR, "Error allocating lua_State, no memory\n");
1091                         return NULL;
1092                 }
1093
1094                 if (lua_load_extensions(L, NULL)) {
1095                         const char *error = lua_tostring(L, -1);
1096                         ast_log(LOG_ERROR, "Error loading extensions.lua: %s\n", error);
1097                         lua_close(L);
1098                         return NULL;
1099                 }
1100                 return L;
1101         } else {
1102                 ast_channel_lock(chan);
1103                 datastore = ast_channel_datastore_find(chan, &lua_datastore, NULL);
1104                 ast_channel_unlock(chan);
1105
1106                 if (!datastore) {
1107                         /* nothing found, allocate a new lua state */
1108                         datastore = ast_datastore_alloc(&lua_datastore, NULL);
1109                         if (!datastore) {
1110                                 ast_log(LOG_ERROR, "Error allocation channel datastore for lua_State\n");
1111                                 return NULL;
1112                         }
1113
1114                         datastore->data = luaL_newstate();
1115                         if (!datastore->data) {
1116                                 ast_datastore_free(datastore);
1117                                 ast_log(LOG_ERROR, "Error allocating lua_State, no memory\n");
1118                                 return NULL;
1119                         }
1120
1121                         ast_channel_lock(chan);
1122                         ast_channel_datastore_add(chan, datastore);
1123                         ast_channel_unlock(chan);
1124
1125                         L = datastore->data;
1126
1127                         if (lua_load_extensions(L, chan)) {
1128                                 const char *error = lua_tostring(L, -1);
1129                                 ast_log(LOG_ERROR, "Error loading extensions.lua for %s: %s\n", chan->name, error);
1130
1131                                 ast_channel_lock(chan);
1132                                 ast_channel_datastore_remove(chan, datastore);
1133                                 ast_channel_unlock(chan);
1134
1135                                 ast_datastore_free(datastore);
1136                                 return NULL;
1137                         }
1138                 }
1139
1140                 return datastore->data;
1141         }
1142 }
1143
1144 static int exists(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
1145 {
1146         int res;
1147         lua_State *L;
1148         struct ast_module_user *u = ast_module_user_add(chan);
1149         if (!u) {
1150                 ast_log(LOG_ERROR, "Error adjusting use count, probably could not allocate memory\n");
1151                 return 0;
1152         }
1153
1154         L = lua_get_state(chan);
1155         if (!L) {
1156                 ast_module_user_remove(u);
1157                 return 0;
1158         }
1159
1160         res = lua_find_extension(L, context, exten, priority, &exists, 0);
1161
1162         if (!chan) lua_close(L);
1163         ast_module_user_remove(u);
1164         return res;
1165 }
1166
1167 static int canmatch(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
1168 {
1169         int res;
1170         lua_State *L;
1171         struct ast_module_user *u = ast_module_user_add(chan);
1172         if (!u) {
1173                 ast_log(LOG_ERROR, "Error adjusting use count, probably could not allocate memory\n");
1174                 return 0;
1175         }
1176
1177         L = lua_get_state(chan);
1178         if (!L) {
1179                 ast_module_user_remove(u);
1180                 return 0;
1181         }
1182
1183         res = lua_find_extension(L, context, exten, priority, &canmatch, 0);
1184
1185         if (!chan) lua_close(L);
1186         ast_module_user_remove(u);
1187         return res;
1188 }
1189
1190 static int matchmore(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
1191 {
1192         int res;
1193         lua_State *L;
1194         struct ast_module_user *u = ast_module_user_add(chan);
1195         if (!u) {
1196                 ast_log(LOG_ERROR, "Error adjusting use count, probably could not allocate memory\n");
1197                 return 0;
1198         }
1199
1200         L = lua_get_state(chan);
1201         if (!L) {
1202                 ast_module_user_remove(u);
1203                 return 0;
1204         }
1205         
1206         res = lua_find_extension(L, context, exten, priority, &matchmore, 0);
1207
1208         if (!chan) lua_close(L);
1209         ast_module_user_remove(u);
1210         return res;
1211 }
1212
1213
1214 static int exec(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *callerid, const char *data)
1215 {
1216         int res, error_func;
1217         lua_State *L;
1218         struct ast_module_user *u = ast_module_user_add(chan);
1219         if (!u) {
1220                 ast_log(LOG_ERROR, "Error adjusting use count, probably could not allocate memory\n");
1221                 return -1;
1222         }
1223         
1224         L = lua_get_state(chan);
1225         if (!L) {
1226                 ast_module_user_remove(u);
1227                 return -1;
1228         }
1229
1230         lua_pushcfunction(L, &lua_error_function);
1231         error_func = lua_gettop(L);
1232
1233         /* push the extension function onto the stack */
1234         if (!lua_find_extension(L, context, exten, priority, &exists, 1)) {
1235                 lua_pop(L, 1); /* pop the debug function */
1236                 ast_log(LOG_ERROR, "Could not find extension %s in context %s\n", exten, context);
1237                 if (!chan) lua_close(L);
1238                 ast_module_user_remove(u);
1239                 return -1;
1240         }
1241                 
1242         lua_update_registry(L, context, exten, priority);
1243         
1244         lua_pushstring(L, context);
1245         lua_pushstring(L, exten);
1246         
1247         res = lua_pcall(L, 2, 0, error_func);
1248         if (res) {
1249                 if (res == LUA_ERRRUN) {
1250                         res = -1;
1251                         if (lua_isnumber(L, -1)) {
1252                                 res = lua_tointeger(L, -1);
1253                         } else if (lua_isstring(L, -1)) {
1254                                 const char *error = lua_tostring(L, -1);
1255                                 ast_log(LOG_ERROR, "Error executing lua extension: %s\n", error);
1256                         }
1257                 } else if (res == LUA_ERRERR) {
1258                         res = -1;
1259                         ast_log(LOG_ERROR, "Error in the lua error handler (this is probably a bug in pbx_lua)\n");
1260                 } else if (res == LUA_ERRMEM) {
1261                         res = -1;
1262                         ast_log(LOG_ERROR, "Memory allocation error\n");
1263                 }
1264                 lua_pop(L, 1);
1265         }
1266         lua_remove(L, error_func);
1267         if (!chan) lua_close(L);
1268         ast_module_user_remove(u);
1269         return res;
1270 }
1271
1272 /*!
1273  * \brief Locate an extensions and optionally push the matching function on the
1274  * stack
1275  *
1276  * \param L the lua_State to use
1277  * \param context the context to look in
1278  * \param exten the extension to look up
1279  * \param priority the priority to check, '1' is the only valid priority
1280  * \param func the calling func, used to adjust matching behavior between,
1281  * match, canmatch, and matchmore
1282  * \param push_func whether or not to push the lua function for the given
1283  * extension onto the stack
1284  */
1285 static int lua_find_extension(lua_State *L, const char *context, const char *exten, int priority, ast_switch_f *func, int push_func)
1286 {
1287         int context_table, context_order_table, i;
1288
1289         ast_debug(2, "Looking up %s@%s:%i\n", exten, context, priority);
1290         if (priority != 1)
1291                 return 0;
1292
1293         /* load the 'extensions' table */
1294         lua_getglobal(L, "extensions");
1295         if (lua_isnil(L, -1)) {
1296                 ast_log(LOG_ERROR, "Unable to find 'extensions' table in extensions.lua\n");
1297                 lua_pop(L, 1);
1298                 return 0;
1299         }
1300
1301         /* load the given context */
1302         lua_getfield(L, -1, context);
1303         if (lua_isnil(L, -1)) {
1304                 lua_pop(L, 2);
1305                 return 0;
1306         }
1307
1308         /* remove the extensions table */
1309         lua_remove(L, -2);
1310
1311         context_table = lua_gettop(L);
1312
1313         /* load the extensions order table for this context */
1314         lua_getfield(L, LUA_REGISTRYINDEX, "extensions_order");
1315         lua_getfield(L, -1, context);
1316
1317         lua_remove(L, -2);  /* remove the extensions order table */
1318
1319         context_order_table = lua_gettop(L);
1320         
1321         /* step through the extensions looking for a match */
1322         for (i = 1; i < lua_objlen(L, context_order_table) + 1; i++) {
1323                 int e_index, e_index_copy, match = 0;
1324                 const char *e;
1325
1326                 lua_pushinteger(L, i);
1327                 lua_gettable(L, context_order_table);
1328                 e_index = lua_gettop(L);
1329
1330                 /* copy the key at the top of the stack for use later */
1331                 lua_pushvalue(L, -1);
1332                 e_index_copy = lua_gettop(L);
1333
1334                 if (!(e = lua_tostring(L, e_index_copy))) {
1335                         lua_pop(L, 2);
1336                         continue;
1337                 }
1338
1339                 /* make sure this is not the 'include' extension */
1340                 if (!strcasecmp(e, "include")) {
1341                         lua_pop(L, 2);
1342                         continue;
1343                 }
1344
1345                 if (func == &matchmore)
1346                         match = ast_extension_close(e, exten, E_MATCHMORE);
1347                 else if (func == &canmatch)
1348                         match = ast_extension_close(e, exten, E_CANMATCH);
1349                 else
1350                         match = ast_extension_match(e, exten);
1351
1352                 /* the extension matching functions return 0 on fail, 1 on
1353                  * match, 2 on earlymatch */
1354
1355                 if (!match) {
1356                         /* pop the copy and the extension */
1357                         lua_pop(L, 2);
1358                         continue;       /* keep trying */
1359                 }
1360
1361                 if (func == &matchmore && match == 2) {
1362                         /* We match an extension ending in '!'. The decision in
1363                          * this case is final and counts as no match. */
1364                         lua_pop(L, 4);
1365                         return 0;
1366                 }
1367
1368                 /* remove the context table, the context order table, the
1369                  * extension, and the extension copy (or replace the extension
1370                  * with the corresponding function) */
1371                 if (push_func) {
1372                         lua_pop(L, 1);  /* pop the copy */
1373                         lua_gettable(L, context_table);
1374                         lua_insert(L, -3);
1375                         lua_pop(L, 2);
1376                 } else {
1377                         lua_pop(L, 4);
1378                 }
1379
1380                 return 1;
1381         }
1382
1383         /* load the includes for this context */
1384         lua_getfield(L, context_table, "include");
1385         if (lua_isnil(L, -1)) {
1386                 lua_pop(L, 3);
1387                 return 0;
1388         }
1389
1390         /* remove the context and the order table*/
1391         lua_remove(L, context_order_table);
1392         lua_remove(L, context_table);
1393
1394         /* Now try any includes we have in this context */
1395         for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
1396                 const char *c = lua_tostring(L, -1);
1397                 if (!c)
1398                         continue;
1399
1400                 if (lua_find_extension(L, c, exten, priority, func, push_func)) {
1401                         /* remove the value, the key, and the includes table
1402                          * from the stack.  Leave the function behind if
1403                          * necessary */
1404
1405                         if (push_func)
1406                                 lua_insert(L, -4);
1407
1408                         lua_pop(L, 3);
1409                         return 1;
1410                 }
1411         }
1412
1413         /* pop the includes table */
1414         lua_pop(L, 1);
1415         return 0;
1416 }
1417
1418 static struct ast_switch lua_switch = {
1419         .name           = "Lua",
1420         .description    = "Lua PBX Switch",
1421         .exists         = exists,
1422         .canmatch       = canmatch,
1423         .exec           = exec,
1424         .matchmore      = matchmore,
1425 };
1426
1427
1428 static int load_or_reload_lua_stuff(void)
1429 {
1430         int res = AST_MODULE_LOAD_SUCCESS;
1431
1432         lua_State *L = luaL_newstate();
1433         if (!L) {
1434                 ast_log(LOG_ERROR, "Error allocating lua_State, no memory\n");
1435                 return AST_MODULE_LOAD_DECLINE;
1436         }
1437
1438         if (lua_reload_extensions(L)) {
1439                 const char *error = lua_tostring(L, -1);
1440                 ast_log(LOG_ERROR, "Error loading extensions.lua: %s\n", error);
1441                 res = AST_MODULE_LOAD_DECLINE;
1442         }
1443
1444         lua_close(L);
1445         return res;
1446 }
1447
1448 static int unload_module(void)
1449 {
1450         ast_context_destroy(NULL, registrar);
1451         ast_unregister_switch(&lua_switch);
1452         lua_free_extensions();
1453         return 0;
1454 }
1455
1456 static int reload(void)
1457 {
1458         return load_or_reload_lua_stuff();
1459 }
1460
1461 static int load_module(void)
1462 {
1463         int res;
1464
1465         if ((res = load_or_reload_lua_stuff()))
1466                 return res;
1467
1468         if (ast_register_switch(&lua_switch)) {
1469                 ast_log(LOG_ERROR, "Unable to register LUA PBX switch\n");
1470                 return AST_MODULE_LOAD_DECLINE;
1471         }
1472
1473         return AST_MODULE_LOAD_SUCCESS;
1474 }
1475
1476 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Lua PBX Switch",
1477                 .load = load_module,
1478                 .unload = unload_module,
1479                 .reload = reload,
1480                );
1481