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