pbx/pbx_lua.c

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