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