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