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