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