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