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