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