dbus.c

   1 /*
   2  * dbus.c - awesome dbus support
   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 #include "config.h"
  23
  24 #include "dbus.h"
  25
  26 #ifdef WITH_DBUS
  27
  28 #include <ev.h>
  29 #include <dbus/dbus.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32
  33 #include "event.h"
  34 #include "luaa.h"
  35
  36 static DBusConnection *dbus_connection_session = NULL;
  37 static DBusConnection *dbus_connection_system = NULL;
  38 ev_io dbusio_ses = { .fd = -1 };
  39 ev_io dbusio_sys = { .fd = -1 };
  40
  41 static signal_array_t dbus_signals;
  42
  43 /** Clean up the D-Bus connection data members
  44  * \param dbus_connection The D-Bus connection to clean up
  45  * \param dbusio The D-Bus event watcher
  46  */
  47 static void
  48 a_dbus_cleanup_bus(DBusConnection *dbus_connection, ev_io *dbusio)
  49 {
  50     if(!dbus_connection)
  51         return;
  52
  53     if(dbusio->fd >= 0)
  54     {
  55         ev_ref(EV_DEFAULT_UC);
  56         ev_io_stop(EV_DEFAULT_UC_ dbusio);
  57         dbusio->fd = -1;
  58     }
  59
  60     /* This is a shared connection owned by libdbus
  61      * Do not close it, only unref
  62      */
  63     dbus_connection_unref(dbus_connection);
  64 }
  65
  66 /** Iterate through the D-Bus messages counting each or traverse each sub message.
  67  * \param iter The D-Bus message iterator pointer
  68  * \return The number of arguments in the iterator
  69  */
  70 static int
  71 a_dbus_message_iter(DBusMessageIter *iter)
  72 {
  73     int nargs = 0;
  74
  75     do
  76     {
  77         switch(dbus_message_iter_get_arg_type(iter))
  78         {
  79           default:
  80             lua_pushnil(globalconf.L);
  81             nargs++;
  82             break;
  83           case DBUS_TYPE_INVALID:
  84             break;
  85           case DBUS_TYPE_VARIANT:
  86             {
  87                 DBusMessageIter subiter;
  88                 dbus_message_iter_recurse(iter, &subiter);
  89                 a_dbus_message_iter(&subiter);
  90             }
  91             nargs++;
  92             break;
  93           case DBUS_TYPE_DICT_ENTRY:
  94             {
  95                 DBusMessageIter subiter;
  96
  97                 /* initialize a sub iterator */
  98                 dbus_message_iter_recurse(iter, &subiter);
  99                 /* create a new table to store the dict */
 100                 a_dbus_message_iter(&subiter);
 101             }
 102             nargs++;
 103             break;
 104           case DBUS_TYPE_STRUCT:
 105             {
 106                 DBusMessageIter subiter;
 107                 /* initialize a sub iterator */
 108                 dbus_message_iter_recurse(iter, &subiter);
 109
 110                 int n = a_dbus_message_iter(&subiter);
 111
 112                 /* create a new table to store all the value */
 113                 lua_createtable(globalconf.L, n, 0);
 114                 /* move the table before array elements */
 115                 lua_insert(globalconf.L, - n - 1);
 116
 117                 for(int i = n; i > 0; i--)
 118                     lua_rawseti(globalconf.L, - i - 1, i);
 119             }
 120             nargs++;
 121             break;
 122           case DBUS_TYPE_ARRAY:
 123             {
 124                 int array_type = dbus_message_iter_get_element_type(iter);
 125
 126                 if(dbus_type_is_fixed(array_type))
 127                 {
 128                     DBusMessageIter sub;
 129                     dbus_message_iter_recurse(iter, &sub);
 130
 131                     switch(array_type)
 132                     {
 133                       int datalen = 0;
 134 #define DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(type, dbustype) \
 135                       case dbustype: \
 136                         { \
 137                             const type *data; \
 138                             dbus_message_iter_get_fixed_array(&sub, &data, &datalen); \
 139                             lua_createtable(globalconf.L, datalen, 0); \
 140                             for(int i = 0; i < datalen; i++) \
 141                             { \
 142                                 lua_pushnumber(globalconf.L, data[i]); \
 143                                 lua_rawseti(globalconf.L, -2, i + 1); \
 144                             } \
 145                         } \
 146                         break;
 147                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 148                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 149                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 150                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 151                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 152                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 153                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(double, DBUS_TYPE_DOUBLE)
 154 #undef DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER
 155                       case DBUS_TYPE_BYTE:
 156                         {
 157                             const char *c;
 158                             dbus_message_iter_get_fixed_array(&sub, &c, &datalen);
 159                             lua_pushlstring(globalconf.L, c, datalen);
 160                         }
 161                         break;
 162                       case DBUS_TYPE_BOOLEAN:
 163                         {
 164                             const dbus_bool_t *b;
 165                             dbus_message_iter_get_fixed_array(&sub, &b, &datalen);
 166                             lua_createtable(globalconf.L, datalen, 0);
 167                             for(int i = 0; i < datalen; i++)
 168                             {
 169                                 lua_pushboolean(globalconf.L, b[i]);
 170                                 lua_rawseti(globalconf.L, -2, i + 1);
 171                             }
 172                         }
 173                         break;
 174                     }
 175                 }
 176                 else if(array_type == DBUS_TYPE_DICT_ENTRY)
 177                 {
 178                     DBusMessageIter subiter;
 179                     /* initialize a sub iterator */
 180                     dbus_message_iter_recurse(iter, &subiter);
 181
 182                     /* get the keys and the values
 183                      * n is the number of entry in dict */
 184                     int n = a_dbus_message_iter(&subiter);
 185
 186                     /* create a new table to store all the value */
 187                     lua_createtable(globalconf.L, n, 0);
 188                     /* move the table before array elements */
 189                     lua_insert(globalconf.L, - (n * 2) - 1);
 190
 191                     for(int i = 0; i < n; i ++)
 192                         lua_rawset(globalconf.L, - (n * 2) - 1 + i * 2);
 193                 }
 194                 else
 195                 {
 196                     DBusMessageIter subiter;
 197                     /* prepare to dig into the array*/
 198                     dbus_message_iter_recurse(iter, &subiter);
 199
 200                     /* now iterate over every element of the array */
 201                     int n = a_dbus_message_iter(&subiter);
 202
 203                     /* create a new table to store all the value */
 204                     lua_createtable(globalconf.L, n, 0);
 205                     /* move the table before array elements */
 206                     lua_insert(globalconf.L, - n - 1);
 207
 208                     for(int i = n; i > 0; i--)
 209                         lua_rawseti(globalconf.L, - i - 1, i);
 210                 }
 211             }
 212             nargs++;
 213             break;
 214           case DBUS_TYPE_BOOLEAN:
 215             {
 216                 dbus_bool_t b;
 217                 dbus_message_iter_get_basic(iter, &b);
 218                 lua_pushboolean(globalconf.L, b);
 219             }
 220             nargs++;
 221             break;
 222           case DBUS_TYPE_BYTE:
 223             {
 224                 char c;
 225                 dbus_message_iter_get_basic(iter, &c);
 226                 lua_pushlstring(globalconf.L, &c, 1);
 227             }
 228             nargs++;
 229             break;
 230 #define DBUS_MSG_HANDLE_TYPE_NUMBER(type, dbustype) \
 231           case dbustype: \
 232             { \
 233                 type ui; \
 234                 dbus_message_iter_get_basic(iter, &ui); \
 235                 lua_pushnumber(globalconf.L, ui); \
 236             } \
 237             nargs++; \
 238             break;
 239           DBUS_MSG_HANDLE_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 240           DBUS_MSG_HANDLE_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 241           DBUS_MSG_HANDLE_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 242           DBUS_MSG_HANDLE_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 243           DBUS_MSG_HANDLE_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 244           DBUS_MSG_HANDLE_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 245 #undef DBUS_MSG_HANDLE_TYPE_NUMBER
 246           case DBUS_TYPE_STRING:
 247             {
 248                 char *s;
 249                 dbus_message_iter_get_basic(iter, &s);
 250                 lua_pushstring(globalconf.L, s);
 251             }
 252             nargs++;
 253             break;
 254         }
 255     } while(dbus_message_iter_next(iter));
 256
 257     return nargs;
 258 }
 259
 260 /** Process a single request from D-Bus
 261  * \param dbus_connection  The connection to the D-Bus server.
 262  * \param msg  The D-Bus message request being sent to the D-Bus connection.
 263  */
 264 static void
 265 a_dbus_process_request(DBusConnection *dbus_connection, DBusMessage *msg)
 266 {
 267     const char *interface = dbus_message_get_interface(msg);
 268
 269     lua_createtable(globalconf.L, 0, 5);
 270
 271     switch(dbus_message_get_type(msg))
 272     {
 273       case DBUS_MESSAGE_TYPE_SIGNAL:
 274         lua_pushliteral(globalconf.L, "signal");
 275         break;
 276       case DBUS_MESSAGE_TYPE_METHOD_CALL:
 277         lua_pushliteral(globalconf.L, "method_call");
 278         break;
 279       case DBUS_MESSAGE_TYPE_METHOD_RETURN:
 280         lua_pushliteral(globalconf.L, "method_return");
 281         break;
 282       case DBUS_MESSAGE_TYPE_ERROR:
 283         lua_pushliteral(globalconf.L, "error");
 284         break;
 285       default:
 286         lua_pushliteral(globalconf.L, "unknown");
 287         break;
 288     }
 289
 290     lua_setfield(globalconf.L, -2, "type");
 291
 292     lua_pushstring(globalconf.L, NONULL(interface));
 293     lua_setfield(globalconf.L, -2, "interface");
 294
 295     const char *s = dbus_message_get_path(msg);
 296     lua_pushstring(globalconf.L, NONULL(s));
 297     lua_setfield(globalconf.L, -2, "path");
 298
 299     s = dbus_message_get_member(msg);
 300     lua_pushstring(globalconf.L, NONULL(s));
 301     lua_setfield(globalconf.L, -2, "member");
 302
 303     if(dbus_connection == dbus_connection_system)
 304         lua_pushliteral(globalconf.L, "system");
 305     else
 306         lua_pushliteral(globalconf.L, "session");
 307     lua_setfield(globalconf.L, -2, "bus");
 308
 309     /* + 1 for the table above */
 310     DBusMessageIter iter;
 311     int nargs = 1;
 312
 313     if(dbus_message_iter_init(msg, &iter))
 314         nargs += a_dbus_message_iter(&iter);
 315
 316     if(dbus_message_get_no_reply(msg))
 317         /* emit signals */
 318         signal_object_emit(globalconf.L, &dbus_signals, interface, nargs);
 319     else
 320     {
 321         signal_t *sig = signal_array_getbyid(&dbus_signals,
 322                                              a_strhash((const unsigned char *) interface));
 323         if(sig)
 324         {
 325             /* there can be only ONE handler to send reply */
 326             void *func = (void *) sig->sigfuncs.tab[0];
 327
 328             int n = lua_gettop(globalconf.L) - nargs;
 329
 330             luaA_object_push(globalconf.L, (void *) func);
 331             luaA_dofunction(globalconf.L, nargs, LUA_MULTRET);
 332
 333             n -= lua_gettop(globalconf.L);
 334
 335             DBusMessage *reply = dbus_message_new_method_return(msg);
 336
 337             dbus_message_iter_init_append(reply, &iter);
 338
 339             /* i is negative */
 340             for(int i = n; i < 0; i += 2)
 341             {
 342                 /* i is the type name, i+1 the value */
 343                 size_t len;
 344                 const char *type = lua_tolstring(globalconf.L, i, &len);
 345
 346                 if(!type || len != 1)
 347                 {
 348                     luaA_warn(globalconf.L,
 349                               "your D-Bus signal handling method returned bad data");
 350                     break;
 351                 }
 352
 353                 switch(*type)
 354                 {
 355                   case DBUS_TYPE_BOOLEAN:
 356                     {
 357                         dbus_bool_t  b = lua_toboolean(globalconf.L, i + 1);
 358                         dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b);
 359                     }
 360                     break;
 361 #define DBUS_MSG_RETURN_HANDLE_TYPE_STRING(dbustype) \
 362                   case dbustype: \
 363                                  if((s = lua_tostring(globalconf.L, i + 1))) \
 364                     dbus_message_iter_append_basic(&iter, dbustype, &s); \
 365                     break;
 366                     DBUS_MSG_RETURN_HANDLE_TYPE_STRING(DBUS_TYPE_STRING)
 367                         DBUS_MSG_RETURN_HANDLE_TYPE_STRING(DBUS_TYPE_BYTE)
 368 #undef DBUS_MSG_RETURN_HANDLE_TYPE_STRING
 369 #define DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(type, dbustype) \
 370                   case dbustype: \
 371                                  { \
 372                                      type num = lua_tonumber(globalconf.L, i + 1); \
 373                                      dbus_message_iter_append_basic(&iter, dbustype, &num); \
 374                                  } \
 375                         break;
 376                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 377                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 378                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 379                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 380                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 381                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 382                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(double, DBUS_TYPE_DOUBLE)
 383 #undef DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER
 384                 }
 385
 386                 lua_remove(globalconf.L, i);
 387                 lua_remove(globalconf.L, i + 1);
 388             }
 389
 390             dbus_connection_send(dbus_connection, reply, NULL);
 391             dbus_message_unref(reply);
 392         }
 393     }
 394 }
 395
 396 /** Attempt to process all the requests in the D-Bus connection.
 397  * \param dbus_connection The D-Bus connection to process from
 398  * \param dbusio The D-Bus event watcher
 399  */
 400 static void
 401 a_dbus_process_requests_on_bus(DBusConnection *dbus_connection, ev_io *dbusio)
 402 {
 403     DBusMessage *msg;
 404     int nmsg = 0;
 405
 406     while(true)
 407     {
 408         dbus_connection_read_write(dbus_connection, 0);
 409
 410         if(!(msg = dbus_connection_pop_message(dbus_connection)))
 411             break;
 412
 413         if(dbus_message_is_signal(msg, DBUS_INTERFACE_LOCAL, "Disconnected"))
 414         {
 415             a_dbus_cleanup_bus(dbus_connection, dbusio);
 416             dbus_message_unref(msg);
 417             return;
 418         }
 419         else
 420             a_dbus_process_request(dbus_connection, msg);
 421
 422         dbus_message_unref(msg);
 423
 424         nmsg++;
 425     }
 426
 427     if(nmsg)
 428         dbus_connection_flush(dbus_connection);
 429 }
 430
 431 /** Foreword D-Bus process session requests on too the correct function.
 432  * \param w The D-Bus event watcher
 433  * \param revents (not used)
 434  */
 435 static void
 436 a_dbus_process_requests_session(EV_P_ ev_io *w, int revents)
 437 {
 438     a_dbus_process_requests_on_bus(dbus_connection_session, w);
 439 }
 440
 441 /** Foreword D-Bus process system requests on too the correct function.
 442  * \param w The D-Bus event watcher
 443  * \param revents (not used)
 444  */
 445 static void
 446 a_dbus_process_requests_system(EV_P_ ev_io *w, int revents)
 447 {
 448     a_dbus_process_requests_on_bus(dbus_connection_system, w);
 449 }
 450
 451 /** Attempt to request a D-Bus name
 452  * \param dbus_connection The application's connection to D-Bus
 453  * \param name The D-Bus connection name to be requested
 454  * \return true if the name is primary owner or the name is already
 455  * the owner, otherwise false.
 456  */
 457 static bool
 458 a_dbus_request_name(DBusConnection *dbus_connection, const char *name)
 459 {
 460     DBusError err;
 461
 462     if(!dbus_connection)
 463         return false;
 464
 465     dbus_error_init(&err);
 466
 467     int ret = dbus_bus_request_name(dbus_connection, name, 0, &err);
 468
 469     if(dbus_error_is_set(&err))
 470     {
 471         warn("failed to request D-Bus name: %s", err.message);
 472         dbus_error_free(&err);
 473         return false;
 474     }
 475
 476     switch(ret)
 477     {
 478       case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
 479         return true;
 480       case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
 481         warn("already primary D-Bus name owner for %s", name);
 482         return true;
 483     }
 484     return false;
 485 }
 486
 487 /** Attempt to release the D-Bus name owner
 488  * \param dbus_connection The application's connection to the D-Bus
 489  * \param name The name to be released
 490  * \return True on success. False if the name is not
 491  * the owner, or does not exist.
 492  */
 493 static bool
 494 a_dbus_release_name(DBusConnection *dbus_connection, const char *name)
 495 {
 496     DBusError err;
 497
 498     if(!dbus_connection)
 499         return false;
 500
 501     dbus_error_init(&err);
 502
 503     int ret = dbus_bus_release_name(dbus_connection, name, &err);
 504
 505     if(dbus_error_is_set(&err))
 506     {
 507         warn("failed to release D-Bus name: %s", err.message);
 508         dbus_error_free(&err);
 509         return false;
 510     }
 511
 512     switch(ret)
 513     {
 514       case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
 515         warn("not primary D-Bus name owner for %s", name);
 516         return false;
 517       case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
 518         warn("non existent D-Bus name: %s", name);
 519         return false;
 520     }
 521     return true;
 522 }
 523
 524 /** Attempt to create a new connection to D-Bus
 525  * \param type The bus type to use when connecting to D-Bus
 526  * \param type_name The bus type name eg: "session" or "system"
 527  * \param dbusio The D-Bus event watcher
 528  * \param cb Function callback to use when processing requests
 529  * \return The requested D-Bus connection on success, NULL on failure.
 530  */
 531 static DBusConnection *
 532 a_dbus_connect(DBusBusType type, const char *type_name,
 533                ev_io *dbusio, void *cb)
 534 {
 535     int fd;
 536     DBusConnection *dbus_connection;
 537     DBusError err;
 538
 539     dbus_error_init(&err);
 540
 541     dbus_connection = dbus_bus_get(type, &err);
 542     if(dbus_error_is_set(&err))
 543     {
 544         warn("D-Bus session bus %s failed: %s", type_name, err.message);
 545         dbus_connection = NULL;
 546         dbus_error_free(&err);
 547     }
 548     else
 549     {
 550         dbus_connection_set_exit_on_disconnect(dbus_connection, false);
 551         if(dbus_connection_get_unix_fd(dbus_connection, &fd))
 552         {
 553             fcntl(fd, F_SETFD, FD_CLOEXEC);
 554
 555             ev_io_init(dbusio, cb, fd, EV_READ);
 556             ev_io_start(EV_DEFAULT_UC_ dbusio);
 557             ev_unref(EV_DEFAULT_UC);
 558         }
 559         else
 560         {
 561             warn("cannot get D-Bus connection file descriptor");
 562             a_dbus_cleanup_bus(dbus_connection, dbusio);
 563         }
 564     }
 565
 566     return dbus_connection;
 567 }
 568
 569 /** Initialize the D-Bus session and system
 570  */
 571 void
 572 a_dbus_init(void)
 573 {
 574     dbus_connection_session = a_dbus_connect(DBUS_BUS_SESSION, "session",
 575                                              &dbusio_ses, a_dbus_process_requests_session);
 576     dbus_connection_system = a_dbus_connect(DBUS_BUS_SYSTEM, "system",
 577                                             &dbusio_sys, a_dbus_process_requests_system);
 578 }
 579
 580 /** Cleanup the D-Bus session and system
 581  */
 582 void
 583 a_dbus_cleanup(void)
 584 {
 585     a_dbus_cleanup_bus(dbus_connection_session, &dbusio_ses);
 586     a_dbus_cleanup_bus(dbus_connection_system, &dbusio_sys);
 587 }
 588
 589 /** Retrieve the D-Bus bus by it's name
 590  * \param name The name of the bus
 591  * \param len The length of the name variable
 592  * \return The corresponding D-Bus connection
 593  */
 594 static DBusConnection *
 595 a_dbus_bus_getbyname(const char *name, size_t len)
 596 {
 597     switch(a_tokenize(name, len))
 598     {
 599       case A_TK_SYSTEM:
 600         return dbus_connection_system;
 601       case A_TK_SESSION:
 602         return dbus_connection_session;
 603       default:
 604         return NULL;
 605     }
 606 }
 607
 608 /** Register a D-Bus name to receive message from.
 609  * \param L The Lua VM state.
 610  * \return The number of elements pushed on stack.
 611  * \luastack
 612  * \lparam A string indicating if we are using system or session bus.
 613  * \lparam A string with the name of the D-Bus name to register.
 614  * \lreturn True if everything worked fine, false otherwise.
 615  */
 616 static int
 617 luaA_dbus_request_name(lua_State *L)
 618 {
 619     size_t len;
 620     const char *bus = luaL_checklstring(L, 1, &len);
 621     const char *name = luaL_checkstring(L, 2);
 622     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 623     lua_pushboolean(L, a_dbus_request_name(dbus_connection, name));
 624     return 1;
 625 }
 626
 627 /** Release a D-Bus name.
 628  * \param L The Lua VM state.
 629  * \return The number of elements pushed on stack.
 630  * \luastack
 631  * \lparam A string indicating if we are using system or session bus.
 632  * \lparam A string with the name of the D-Bus name to unregister.
 633  * \lreturn True if everything worked fine, false otherwise.
 634  */
 635 static int
 636 luaA_dbus_release_name(lua_State *L)
 637 {
 638     size_t len;
 639     const char *bus = luaL_checklstring(L, 1, &len);
 640     const char *name = luaL_checkstring(L, 2);
 641     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 642     lua_pushboolean(L, a_dbus_release_name(dbus_connection, name));
 643     return 1;
 644 }
 645
 646 /** Add a match rule to match messages going through the message bus.
 647  * \param L The Lua VM state.
 648  * \return The number of elements pushed on stack.
 649  * \luastack
 650  * \lparam A string indicating if we are using system or session bus.
 651  * \lparam A string with the name of the match rule.
 652  */
 653 static int
 654 luaA_dbus_add_match(lua_State *L)
 655 {
 656     size_t len;
 657     const char *bus = luaL_checklstring(L, 1, &len);
 658     const char *name = luaL_checkstring(L, 2);
 659     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 660
 661     if(dbus_connection)
 662     {
 663         dbus_bus_add_match(dbus_connection, name, NULL);
 664         dbus_connection_flush(dbus_connection);
 665     }
 666
 667     return 0;
 668 }
 669
 670 /** Remove a previously added match rule "by value"
 671  * (the most recently-added identical rule gets removed).
 672  * \param L The Lua VM state.
 673  * \return The number of elements pushed on stack.
 674  * \luastack
 675  * \lparam A string indicating if we are using system or session bus.
 676  * \lparam A string with the name of the match rule.
 677  */
 678 static int
 679 luaA_dbus_remove_match(lua_State *L)
 680 {
 681     size_t len;
 682     const char *bus = luaL_checklstring(L, 1, &len);
 683     const char *name = luaL_checkstring(L, 2);
 684     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 685
 686     if(dbus_connection)
 687     {
 688         dbus_bus_remove_match(dbus_connection, name, NULL);
 689         dbus_connection_flush(dbus_connection);
 690     }
 691
 692     return 0;
 693 }
 694
 695 /** Add a signal receiver on the D-Bus.
 696  * \param L The Lua VM state.
 697  * \return The number of elements pushed on stack.
 698  * \luastack
 699  * \lparam A string with the interface name.
 700  * \lparam The function to call.
 701  */
 702 static int
 703 luaA_dbus_add_signal(lua_State *L)
 704 {
 705     const char *name = luaL_checkstring(L, 1);
 706     luaA_checkfunction(L, 2);
 707     signal_t *sig = signal_array_getbyid(&dbus_signals,
 708                                          a_strhash((const unsigned char *) name));
 709     if(sig)
 710         luaA_warn(L, "cannot add signal %s on D-Bus, already existing", name);
 711     else
 712         signal_add(&dbus_signals, name, luaA_object_ref(L, 2));
 713     return 0;
 714 }
 715
 716 /** Add a signal receiver on the D-Bus.
 717  * \param L The Lua VM state.
 718  * \return The number of elements pushed on stack.
 719  * \luastack
 720  * \lparam A string with the interface name.
 721  * \lparam The function to call.
 722  */
 723 static int
 724 luaA_dbus_remove_signal(lua_State *L)
 725 {
 726     const char *name = luaL_checkstring(L, 1);
 727     luaA_checkfunction(L, 2);
 728     const void *func = lua_topointer(L, 2);
 729     signal_remove(&dbus_signals, name, func);
 730     luaA_object_unref(L, (void *) func);
 731     return 0;
 732 }
 733
 734 const struct luaL_reg awesome_dbus_lib[] =
 735 {
 736     { "request_name", luaA_dbus_request_name },
 737     { "release_name", luaA_dbus_release_name },
 738     { "add_match", luaA_dbus_add_match },
 739     { "remove_match", luaA_dbus_remove_match },
 740     { "add_signal", luaA_dbus_add_signal },
 741     { "remove_signal", luaA_dbus_remove_signal },
 742     { NULL, NULL }
 743 };
 744
 745 #else /* WITH_DBUS */
 746
 747 /** Empty stub if dbus is not enabled */
 748 void
 749 a_dbus_init(void)
 750 {
 751 }
 752
 753 /** Empty stub if dbus is not enabled */
 754 void
 755 a_dbus_cleanup(void)
 756 {
 757 }
 758
 759 #endif
 760 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80