dbus.c

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