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