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