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