luaa.c

   1 /*
   2  * luaa.c - Lua configuration management
   3  *
   4  * Copyright © 2008-2009 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #define _GNU_SOURCE
  23
  24 #include <ev.h>
  25
  26 #include <lua.h>
  27 #include <lauxlib.h>
  28 #include <lualib.h>
  29
  30 #include <basedir_fs.h>
  31
  32 #include <oopango.h>
  33 #include <oocairo.h>
  34
  35 #include "awesome.h"
  36 #include "config.h"
  37 #include "objects/timer.h"
  38 #include "awesome-version-internal.h"
  39 #include "ewmh.h"
  40 #include "luaa.h"
  41 #include "spawn.h"
  42 #include "objects/tag.h"
  43 #include "objects/client.h"
  44 #include "objects/drawin.h"
  45 #include "screen.h"
  46 #include "event.h"
  47 #include "selection.h"
  48 #include "systray.h"
  49 #include "common/xcursor.h"
  50 #include "common/buffer.h"
  51 #include "common/backtrace.h"
  52
  53 #ifdef WITH_DBUS
  54 extern const struct luaL_reg awesome_dbus_lib[];
  55 #endif
  56 extern const struct luaL_reg awesome_keygrabber_lib[];
  57 extern const struct luaL_reg awesome_mousegrabber_lib[];
  58 extern const struct luaL_reg awesome_root_lib[];
  59 extern const struct luaL_reg awesome_mouse_methods[];
  60 extern const struct luaL_reg awesome_mouse_meta[];
  61 extern const struct luaL_reg awesome_screen_methods[];
  62 extern const struct luaL_reg awesome_screen_meta[];
  63
  64 /** Path to config file */
  65 static char *conffile;
  66
  67 /** Quit awesome.
  68  * \param L The Lua VM state.
  69  * \return The number of elements pushed on stack.
  70  */
  71 static int
  72 luaA_quit(lua_State *L)
  73 {
  74     ev_unloop(globalconf.loop, 1);
  75     return 0;
  76 }
  77
  78 /** Execute another application, probably a window manager, to replace
  79  * awesome.
  80  * \param L The Lua VM state.
  81  * \return The number of elements pushed on stack.
  82  * \luastack
  83  * \lparam The command line to execute.
  84  */
  85 static int
  86 luaA_exec(lua_State *L)
  87 {
  88     const char *cmd = luaL_checkstring(L, 1);
  89
  90     awesome_atexit(false);
  91
  92     a_exec(cmd);
  93     return 0;
  94 }
  95
  96 /** Restart awesome.
  97  */
  98 static int
  99 luaA_restart(lua_State *L)
 100 {
 101     awesome_restart();
 102     return 0;
 103 }
 104
 105 /** UTF-8 aware string length computing.
 106  * \param L The Lua VM state.
 107  * \return The number of elements pushed on stack.
 108  */
 109 static int
 110 luaA_mbstrlen(lua_State *L)
 111 {
 112     const char *cmd = luaL_checkstring(L, 1);
 113     lua_pushnumber(L, (ssize_t) mbstowcs(NULL, NONULL(cmd), 0));
 114     return 1;
 115 }
 116
 117 /** Overload standard Lua next function to use __next key on metatable.
 118  * \param L The Lua VM state.
 119  * \return The number of elements pushed on stack.
 120  */
 121 static int
 122 luaAe_next(lua_State *L)
 123 {
 124     if(luaL_getmetafield(L, 1, "__next"))
 125     {
 126         lua_insert(L, 1);
 127         lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
 128         return lua_gettop(L);
 129     }
 130
 131     luaL_checktype(L, 1, LUA_TTABLE);
 132     lua_settop(L, 2);
 133     if(lua_next(L, 1))
 134         return 2;
 135     lua_pushnil(L);
 136     return 1;
 137 }
 138
 139 /** Overload lua_next() function by using __next metatable field
 140  * to get next elements.
 141  * \param L The Lua VM stack.
 142  * \param idx The index number of elements in stack.
 143  * \return 1 if more elements to come, 0 otherwise.
 144  */
 145 static int
 146 luaA_next(lua_State *L, int idx)
 147 {
 148     if(luaL_getmetafield(L, idx, "__next"))
 149     {
 150         /* if idx is relative, reduce it since we got __next */
 151         if(idx < 0) idx--;
 152         /* copy table and then move key */
 153         lua_pushvalue(L, idx);
 154         lua_pushvalue(L, -3);
 155         lua_remove(L, -4);
 156         lua_pcall(L, 2, 2, 0);
 157         /* next returned nil, it's the end */
 158         if(lua_isnil(L, -1))
 159         {
 160             /* remove nil */
 161             lua_pop(L, 2);
 162             return 0;
 163         }
 164         return 1;
 165     }
 166     else if(lua_istable(L, idx))
 167         return lua_next(L, idx);
 168     /* remove the key */
 169     lua_pop(L, 1);
 170     return 0;
 171 }
 172
 173 /** Generic pairs function.
 174  * \param L The Lua VM state.
 175  * \return The number of elements pushed on stack.
 176  */
 177 static int
 178 luaA_generic_pairs(lua_State *L)
 179 {
 180     lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
 181     lua_pushvalue(L, 1);  /* state, */
 182     lua_pushnil(L);  /* and initial value */
 183     return 3;
 184 }
 185
 186 /** Overload standard pairs function to use __pairs field of metatables.
 187  * \param L The Lua VM state.
 188  * \return The number of elements pushed on stack.
 189  */
 190 static int
 191 luaAe_pairs(lua_State *L)
 192 {
 193     if(luaL_getmetafield(L, 1, "__pairs"))
 194     {
 195         lua_insert(L, 1);
 196         lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
 197         return lua_gettop(L);
 198     }
 199
 200     luaL_checktype(L, 1, LUA_TTABLE);
 201     return luaA_generic_pairs(L);
 202 }
 203
 204 static int
 205 luaA_ipairs_aux(lua_State *L)
 206 {
 207     int i = luaL_checkint(L, 2) + 1;
 208     luaL_checktype(L, 1, LUA_TTABLE);
 209     lua_pushinteger(L, i);
 210     lua_rawgeti(L, 1, i);
 211     return (lua_isnil(L, -1)) ? 0 : 2;
 212 }
 213
 214 /** Overload standard ipairs function to use __ipairs field of metatables.
 215  * \param L The Lua VM state.
 216  * \return The number of elements pushed on stack.
 217  */
 218 static int
 219 luaAe_ipairs(lua_State *L)
 220 {
 221     if(luaL_getmetafield(L, 1, "__ipairs"))
 222     {
 223         lua_insert(L, 1);
 224         lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
 225         return lua_gettop(L);
 226     }
 227
 228     luaL_checktype(L, 1, LUA_TTABLE);
 229     lua_pushvalue(L, lua_upvalueindex(1));
 230     lua_pushvalue(L, 1);
 231     lua_pushinteger(L, 0);  /* and initial value */
 232     return 3;
 233 }
 234
 235 /** Enhanced type() function which recognize awesome objects.
 236  * \param L The Lua VM state.
 237  * \return The number of arguments pushed on the stack.
 238  */
 239 static int
 240 luaAe_type(lua_State *L)
 241 {
 242     luaL_checkany(L, 1);
 243     lua_pushstring(L, luaA_typename(L, 1));
 244     return 1;
 245 }
 246
 247 /** Replace various standards Lua functions with our own.
 248  * \param L The Lua VM state.
 249  */
 250 static void
 251 luaA_fixups(lua_State *L)
 252 {
 253     /* export string.wlen */
 254     lua_getglobal(L, "string");
 255     lua_pushcfunction(L, luaA_mbstrlen);
 256     lua_setfield(L, -2, "wlen");
 257     lua_pop(L, 1);
 258     /* replace next */
 259     lua_pushliteral(L, "next");
 260     lua_pushcfunction(L, luaAe_next);
 261     lua_settable(L, LUA_GLOBALSINDEX);
 262     /* replace pairs */
 263     lua_pushliteral(L, "pairs");
 264     lua_pushcfunction(L, luaAe_next);
 265     lua_pushcclosure(L, luaAe_pairs, 1); /* pairs get next as upvalue */
 266     lua_settable(L, LUA_GLOBALSINDEX);
 267     /* replace ipairs */
 268     lua_pushliteral(L, "ipairs");
 269     lua_pushcfunction(L, luaA_ipairs_aux);
 270     lua_pushcclosure(L, luaAe_ipairs, 1);
 271     lua_settable(L, LUA_GLOBALSINDEX);
 272     /* replace type */
 273     lua_pushliteral(L, "type");
 274     lua_pushcfunction(L, luaAe_type);
 275     lua_settable(L, LUA_GLOBALSINDEX);
 276     /* set selection */
 277     lua_pushliteral(L, "selection");
 278     lua_pushcfunction(L, luaA_selection_get);
 279     lua_settable(L, LUA_GLOBALSINDEX);
 280 }
 281
 282 /** Look for an item: table, function, etc.
 283  * \param L The Lua VM state.
 284  * \param item The pointer item.
 285  */
 286 bool
 287 luaA_hasitem(lua_State *L, const void *item)
 288 {
 289     lua_pushnil(L);
 290     while(luaA_next(L, -2))
 291     {
 292         if(lua_topointer(L, -1) == item)
 293         {
 294             /* remove value and key */
 295             lua_pop(L, 2);
 296             return true;
 297         }
 298         if(lua_istable(L, -1))
 299             if(luaA_hasitem(L, item))
 300             {
 301                 /* remove key and value */
 302                 lua_pop(L, 2);
 303                 return true;
 304             }
 305         /* remove value */
 306         lua_pop(L, 1);
 307     }
 308     return false;
 309 }
 310
 311 /** Browse a table pushed on top of the index, and put all its table and
 312  * sub-table into an array.
 313  * \param L The Lua VM state.
 314  * \param elems The elements array.
 315  * \return False if we encounter an elements already in list.
 316  */
 317 static bool
 318 luaA_isloop_check(lua_State *L, cptr_array_t *elems)
 319 {
 320     if(lua_istable(L, -1))
 321     {
 322         const void *object = lua_topointer(L, -1);
 323
 324         /* Check that the object table is not already in the list */
 325         for(int i = 0; i < elems->len; i++)
 326             if(elems->tab[i] == object)
 327                 return false;
 328
 329         /* push the table in the elements list */
 330         cptr_array_append(elems, object);
 331
 332         /* look every object in the "table" */
 333         lua_pushnil(L);
 334         while(luaA_next(L, -2))
 335         {
 336             if(!luaA_isloop_check(L, elems))
 337             {
 338                 /* remove key and value */
 339                 lua_pop(L, 2);
 340                 return false;
 341             }
 342             /* remove value, keep key for next iteration */
 343             lua_pop(L, 1);
 344         }
 345     }
 346     return true;
 347 }
 348
 349 /** Check if a table is a loop. When using tables as direct acyclic digram,
 350  * this is useful.
 351  * \param L The Lua VM state.
 352  * \param idx The index of the table in the stack
 353  * \return True if the table loops.
 354  */
 355 bool
 356 luaA_isloop(lua_State *L, int idx)
 357 {
 358     /* elems is an elements array that we will fill with all array we
 359      * encounter while browsing the tables */
 360     cptr_array_t elems;
 361
 362     cptr_array_init(&elems);
 363
 364     /* push table on top */
 365     lua_pushvalue(L, idx);
 366
 367     bool ret = luaA_isloop_check(L, &elems);
 368
 369     /* remove pushed table */
 370     lua_pop(L, 1);
 371
 372     cptr_array_wipe(&elems);
 373
 374     return !ret;
 375 }
 376
 377 /** awesome global table.
 378  * \param L The Lua VM state.
 379  * \return The number of elements pushed on stack.
 380  * \luastack
 381  * \lfield font The default font.
 382  * \lfield font_height The default font height.
 383  * \lfield conffile The configuration file which has been loaded.
 384  */
 385 static int
 386 luaA_awesome_index(lua_State *L)
 387 {
 388     if(luaA_usemetatable(L, 1, 2))
 389         return 1;
 390
 391     const char *buf = luaL_checkstring(L, 2);
 392
 393     if(a_strcmp(buf, "conffile") == 0)
 394         lua_pushstring(L, conffile);
 395     else if(a_strcmp(buf, "version") == 0)
 396         lua_pushliteral(L, AWESOME_VERSION);
 397     else if(a_strcmp(buf, "release") == 0)
 398         lua_pushliteral(L, AWESOME_RELEASE);
 399     else
 400         return 0;
 401
 402     return 1;
 403 }
 404
 405 /** Add a global signal.
 406  * \param L The Lua VM state.
 407  * \return The number of elements pushed on stack.
 408  * \luastack
 409  * \lparam A string with the event name.
 410  * \lparam The function to call.
 411  */
 412 static int
 413 luaA_awesome_connect_signal(lua_State *L)
 414 {
 415     const char *name = luaL_checkstring(L, 1);
 416     luaA_checkfunction(L, 2);
 417     signal_connect(&global_signals, name, luaA_object_ref(L, 2));
 418     return 0;
 419 }
 420
 421 /** Remove a global signal.
 422  * \param L The Lua VM state.
 423  * \return The number of elements pushed on stack.
 424  * \luastack
 425  * \lparam A string with the event name.
 426  * \lparam The function to call.
 427  */
 428 static int
 429 luaA_awesome_disconnect_signal(lua_State *L)
 430 {
 431     const char *name = luaL_checkstring(L, 1);
 432     luaA_checkfunction(L, 2);
 433     const void *func = lua_topointer(L, 2);
 434     signal_disconnect(&global_signals, name, func);
 435     luaA_object_unref(L, (void *) func);
 436     return 0;
 437 }
 438
 439 /** Emit a global signal.
 440  * \param L The Lua VM state.
 441  * \return The number of elements pushed on stack.
 442  * \luastack
 443  * \lparam A string with the event name.
 444  * \lparam The function to call.
 445  */
 446 static int
 447 luaA_awesome_emit_signal(lua_State *L)
 448 {
 449     signal_object_emit(L, &global_signals, luaL_checkstring(L, 1), lua_gettop(L) - 1);
 450     return 0;
 451 }
 452
 453 static int
 454 luaA_panic(lua_State *L)
 455 {
 456     warn("unprotected error in call to Lua API (%s)",
 457          lua_tostring(L, -1));
 458     buffer_t buf;
 459     backtrace_get(&buf);
 460     warn("dumping backtrace\n%s", buf.s);
 461     warn("restarting awesome");
 462     awesome_restart();
 463     return 0;
 464 }
 465
 466 static int
 467 luaA_dofunction_on_error(lua_State *L)
 468 {
 469     /* duplicate string error */
 470     lua_pushvalue(L, -1);
 471     /* emit error signal */
 472     signal_object_emit(L, &global_signals, "debug::error", 1);
 473
 474     if(!luaL_dostring(L, "return debug.traceback(\"error while running function\", 3)"))
 475     {
 476         /* Move traceback before error */
 477         lua_insert(L, -2);
 478         /* Insert sentence */
 479         lua_pushliteral(L, "\nerror: ");
 480         /* Move it before error */
 481         lua_insert(L, -2);
 482         lua_concat(L, 3);
 483     }
 484     return 1;
 485 }
 486
 487 /** Initialize the Lua VM
 488  * \param xdg An xdg handle to use to get XDG basedir.
 489  */
 490 void
 491 luaA_init(xdgHandle* xdg)
 492 {
 493     lua_State *L;
 494     static const struct luaL_reg awesome_lib[] =
 495     {
 496         { "quit", luaA_quit },
 497         { "exec", luaA_exec },
 498         { "spawn", luaA_spawn },
 499         { "restart", luaA_restart },
 500         { "connect_signal", luaA_awesome_connect_signal },
 501         { "disconnect_signal", luaA_awesome_disconnect_signal },
 502         { "emit_signal", luaA_awesome_emit_signal },
 503         { "systray", luaA_systray },
 504         { "__index", luaA_awesome_index },
 505         { NULL, NULL }
 506     };
 507
 508     L = globalconf.L = luaL_newstate();
 509
 510     /* Set panic function */
 511     lua_atpanic(L, luaA_panic);
 512
 513     /* Set error handling function */
 514     lualib_dofunction_on_error = luaA_dofunction_on_error;
 515
 516     luaL_openlibs(L);
 517
 518     luaA_fixups(L);
 519
 520     luaA_object_setup(L);
 521
 522     /* Export awesome lib */
 523     luaA_openlib(L, "awesome", awesome_lib, awesome_lib);
 524
 525     /* Export root lib */
 526     luaL_register(L, "root", awesome_root_lib);
 527     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 528
 529 #ifdef WITH_DBUS
 530     /* Export D-Bus lib */
 531     luaL_register(L, "dbus", awesome_dbus_lib);
 532     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 533 #endif
 534
 535     /* Export keygrabber lib */
 536     luaL_register(L, "keygrabber", awesome_keygrabber_lib);
 537     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 538
 539     /* Export mousegrabber lib */
 540     luaL_register(L, "mousegrabber", awesome_mousegrabber_lib);
 541     lua_pop(L, 1); /* luaL_register() leaves the table on stack */
 542
 543     /* Export screen */
 544     luaA_openlib(L, "screen", awesome_screen_methods, awesome_screen_meta);
 545
 546     /* Export mouse */
 547     luaA_openlib(L, "mouse", awesome_mouse_methods, awesome_mouse_meta);
 548
 549     /* Export button */
 550     button_class_setup(L);
 551
 552     /* Export tag */
 553     tag_class_setup(L);
 554
 555     /* Export window */
 556     window_class_setup(L);
 557
 558     /* Export drawin */
 559     drawin_class_setup(L);
 560
 561     /* Export client */
 562     client_class_setup(L);
 563
 564     /* Export keys */
 565     key_class_setup(L);
 566
 567     /* Export timer */
 568     timer_class_setup(L);
 569
 570     /* add Lua search paths */
 571     lua_getglobal(L, "package");
 572     if (LUA_TTABLE != lua_type(L, 1))
 573     {
 574         warn("package is not a table");
 575         return;
 576     }
 577     lua_getfield(L, 1, "path");
 578     if (LUA_TSTRING != lua_type(L, 2))
 579     {
 580         warn("package.path is not a string");
 581         lua_pop(L, 1);
 582         return;
 583     }
 584
 585     /* add XDG_CONFIG_DIR as include path */
 586     const char * const *xdgconfigdirs = xdgSearchableConfigDirectories(xdg);
 587     for(; *xdgconfigdirs; xdgconfigdirs++)
 588     {
 589         size_t len = a_strlen(*xdgconfigdirs);
 590         lua_pushliteral(L, ";");
 591         lua_pushlstring(L, *xdgconfigdirs, len);
 592         lua_pushliteral(L, "/awesome/?.lua");
 593         lua_concat(L, 3);
 594
 595         lua_pushliteral(L, ";");
 596         lua_pushlstring(L, *xdgconfigdirs, len);
 597         lua_pushliteral(L, "/awesome/?/init.lua");
 598         lua_concat(L, 3);
 599
 600         lua_concat(L, 3); /* concatenate with package.path */
 601     }
 602
 603     /* add Lua lib path (/usr/share/awesome/lib by default) */
 604     lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?.lua");
 605     lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?/init.lua");
 606     lua_concat(L, 3); /* concatenate with package.path */
 607     lua_setfield(L, 1, "path"); /* package.path = "concatenated string" */
 608
 609     lua_getfield(L, 1, "loaded");
 610
 611     /* Load oocairo */
 612     if (luaopen_oocairo(L) != 1)
 613         fatal("Loading oocairo failed");
 614     lua_pushvalue(L, 3); /* Copy the module */
 615     lua_setglobal(L, "oocairo"); /* Set the global entry */
 616     lua_setfield(L, 2, "oocairo"); /* Make it require()able */
 617
 618     /* Load oopango */
 619     if (luaopen_oopango(L) != 1)
 620         fatal("Loading oopango failed");
 621     lua_pushvalue(L, 3); /* Copy the module */
 622     lua_setglobal(L, "oopango"); /* Set the global entry */
 623     lua_setfield(L, 2, "oopango"); /* Make it require()able */
 624
 625     lua_pop(L, 2); /* pop "package" and "package.loaded" */
 626
 627     signal_add(&global_signals, "debug::error");
 628     signal_add(&global_signals, "debug::index::miss");
 629     signal_add(&global_signals, "debug::newindex::miss");
 630     signal_add(&global_signals, "systray::update");
 631     signal_add(&global_signals, "refresh");
 632     signal_add(&global_signals, "exit");
 633 }
 634
 635 static bool
 636 luaA_loadrc(const char *confpath, bool run)
 637 {
 638     if(!luaL_loadfile(globalconf.L, confpath))
 639     {
 640         if(run)
 641         {
 642             if(lua_pcall(globalconf.L, 0, LUA_MULTRET, 0))
 643                 fprintf(stderr, "%s\n", lua_tostring(globalconf.L, -1));
 644             else
 645             {
 646                 conffile = a_strdup(confpath);
 647                 return true;
 648             }
 649         }
 650         else
 651         {
 652             lua_pop(globalconf.L, 1);
 653             return true;
 654         }
 655     }
 656     else
 657         fprintf(stderr, "%s\n", lua_tostring(globalconf.L, -1));
 658
 659     return false;
 660 }
 661
 662 /** Load a configuration file.
 663  * \param xdg An xdg handle to use to get XDG basedir.
 664  * \param confpatharg The configuration file to load.
 665  * \param run Run the configuration file.
 666  */
 667 bool
 668 luaA_parserc(xdgHandle* xdg, const char *confpatharg, bool run)
 669 {
 670     char *confpath = NULL;
 671     bool ret = false;
 672
 673     /* try to load, return if it's ok */
 674     if(confpatharg)
 675     {
 676         if(luaA_loadrc(confpatharg, run))
 677         {
 678             ret = true;
 679             goto bailout;
 680         }
 681         else if(!run)
 682             goto bailout;
 683     }
 684
 685     confpath = xdgConfigFind("awesome/rc.lua", xdg);
 686
 687     char *tmp = confpath;
 688
 689     /* confpath is "string1\0string2\0string3\0\0" */
 690     while(*tmp)
 691     {
 692         if(luaA_loadrc(tmp, run))
 693         {
 694             ret = true;
 695             goto bailout;
 696         }
 697         else if(!run)
 698             goto bailout;
 699         tmp += a_strlen(tmp) + 1;
 700     }
 701
 702 bailout:
 703
 704     p_delete(&confpath);
 705
 706     return ret;
 707 }
 708
 709 int
 710 luaA_class_index_miss_property(lua_State *L, lua_object_t *obj)
 711 {
 712     signal_object_emit(L, &global_signals, "debug::index::miss", 2);
 713     return 0;
 714 }
 715
 716 int
 717 luaA_class_newindex_miss_property(lua_State *L, lua_object_t *obj)
 718 {
 719     signal_object_emit(L, &global_signals, "debug::newindex::miss", 3);
 720     return 0;
 721 }
 722
 723 void
 724 luaA_emit_refresh()
 725 {
 726     signal_object_emit(globalconf.L, &global_signals, "refresh", 0);
 727 }
 728
 729 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80