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
 256     lua_createtable(globalconf.L, 0, 5);
 257
 258     switch(dbus_message_get_type(msg))
 259     {
 260       case DBUS_MESSAGE_TYPE_SIGNAL:
 261         lua_pushliteral(globalconf.L, "signal");
 262         break;
 263       case DBUS_MESSAGE_TYPE_METHOD_CALL:
 264         lua_pushliteral(globalconf.L, "method_call");
 265         break;
 266       case DBUS_MESSAGE_TYPE_METHOD_RETURN:
 267         lua_pushliteral(globalconf.L, "method_return");
 268         break;
 269       case DBUS_MESSAGE_TYPE_ERROR:
 270         lua_pushliteral(globalconf.L, "error");
 271         break;
 272       default:
 273         lua_pushliteral(globalconf.L, "unknown");
 274         break;
 275     }
 276
 277     lua_setfield(globalconf.L, -2, "type");
 278
 279     lua_pushstring(globalconf.L, NONULL(interface));
 280     lua_setfield(globalconf.L, -2, "interface");
 281
 282     const char *s = dbus_message_get_path(msg);
 283     lua_pushstring(globalconf.L, NONULL(s));
 284     lua_setfield(globalconf.L, -2, "path");
 285
 286     s = dbus_message_get_member(msg);
 287     lua_pushstring(globalconf.L, NONULL(s));
 288     lua_setfield(globalconf.L, -2, "member");
 289
 290     if(dbus_connection == dbus_connection_system)
 291         lua_pushliteral(globalconf.L, "system");
 292     else
 293         lua_pushliteral(globalconf.L, "session");
 294     lua_setfield(globalconf.L, -2, "bus");
 295
 296     /* + 1 for the table above */
 297     DBusMessageIter iter;
 298     int nargs = 1;
 299
 300     if(dbus_message_iter_init(msg, &iter))
 301         nargs += a_dbus_message_iter(&iter);
 302
 303     if(dbus_message_get_no_reply(msg))
 304         /* emit signals */
 305         signal_object_emit(globalconf.L, &dbus_signals, interface, nargs);
 306     else
 307     {
 308         signal_t *sig = signal_array_getbyid(&dbus_signals,
 309                                              a_strhash((const unsigned char *) interface));
 310         if(sig)
 311         {
 312             /* there can be only ONE handler to send reply */
 313             void *func = (void *) sig->sigfuncs.tab[0];
 314
 315             int n = lua_gettop(globalconf.L) - nargs;
 316
 317             luaA_object_push(globalconf.L, (void *) func);
 318             luaA_dofunction(globalconf.L, nargs, LUA_MULTRET);
 319
 320             n -= lua_gettop(globalconf.L);
 321
 322             DBusMessage *reply = dbus_message_new_method_return(msg);
 323
 324             dbus_message_iter_init_append(reply, &iter);
 325
 326             /* i is negative */
 327             for(int i = n; i < 0; i += 2)
 328             {
 329                 /* i is the type name, i+1 the value */
 330                 size_t len;
 331                 const char *type = lua_tolstring(globalconf.L, i, &len);
 332
 333                 if(!type || len != 1)
 334                 {
 335                     luaA_warn(globalconf.L,
 336                               "your D-Bus signal handling method returned bad data");
 337                     break;
 338                 }
 339
 340                 switch(*type)
 341                 {
 342                   case DBUS_TYPE_BOOLEAN:
 343                     {
 344                         dbus_bool_t  b = lua_toboolean(globalconf.L, i + 1);
 345                         dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b);
 346                     }
 347                     break;
 348 #define DBUS_MSG_RETURN_HANDLE_TYPE_STRING(dbustype) \
 349                   case dbustype: \
 350                                  if((s = lua_tostring(globalconf.L, i + 1))) \
 351                     dbus_message_iter_append_basic(&iter, dbustype, &s); \
 352                     break;
 353                     DBUS_MSG_RETURN_HANDLE_TYPE_STRING(DBUS_TYPE_STRING)
 354                         DBUS_MSG_RETURN_HANDLE_TYPE_STRING(DBUS_TYPE_BYTE)
 355 #undef DBUS_MSG_RETURN_HANDLE_TYPE_STRING
 356 #define DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(type, dbustype) \
 357                   case dbustype: \
 358                                  { \
 359                                      type num = lua_tonumber(globalconf.L, i + 1); \
 360                                      dbus_message_iter_append_basic(&iter, dbustype, &num); \
 361                                  } \
 362                         break;
 363                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 364                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 365                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 366                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 367                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 368                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 369                         DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(double, DBUS_TYPE_DOUBLE)
 370 #undef DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER
 371                 }
 372
 373                 lua_remove(globalconf.L, i);
 374                 lua_remove(globalconf.L, i + 1);
 375             }
 376
 377             dbus_connection_send(dbus_connection, reply, NULL);
 378             dbus_message_unref(reply);
 379         }
 380     }
 381 }
 382
 383 static void
 384 a_dbus_process_requests_on_bus(DBusConnection *dbus_connection, ev_io *dbusio)
 385 {
 386     DBusMessage *msg;
 387     int nmsg = 0;
 388
 389     while(true)
 390     {
 391         dbus_connection_read_write(dbus_connection, 0);
 392
 393         if(!(msg = dbus_connection_pop_message(dbus_connection)))
 394             break;
 395
 396         if(dbus_message_is_signal(msg, DBUS_INTERFACE_LOCAL, "Disconnected"))
 397         {
 398             a_dbus_cleanup_bus(dbus_connection, dbusio);
 399             dbus_message_unref(msg);
 400             return;
 401         }
 402         else
 403             a_dbus_process_request(dbus_connection, msg);
 404
 405         dbus_message_unref(msg);
 406
 407         nmsg++;
 408     }
 409
 410     if(nmsg)
 411         dbus_connection_flush(dbus_connection);
 412 }
 413
 414 static void
 415 a_dbus_process_requests_session(EV_P_ ev_io *w, int revents)
 416 {
 417     a_dbus_process_requests_on_bus(dbus_connection_session, w);
 418 }
 419
 420 static void
 421 a_dbus_process_requests_system(EV_P_ ev_io *w, int revents)
 422 {
 423     a_dbus_process_requests_on_bus(dbus_connection_system, w);
 424 }
 425
 426 static bool
 427 a_dbus_request_name(DBusConnection *dbus_connection, const char *name)
 428 {
 429     DBusError err;
 430
 431     if(!dbus_connection)
 432         return false;
 433
 434     dbus_error_init(&err);
 435
 436     int ret = dbus_bus_request_name(dbus_connection, name, 0, &err);
 437
 438     if(dbus_error_is_set(&err))
 439     {
 440         warn("failed to request D-Bus name: %s", err.message);
 441         dbus_error_free(&err);
 442         return false;
 443     }
 444
 445     switch(ret)
 446     {
 447       case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
 448         return true;
 449       case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
 450         warn("already primary D-Bus name owner for %s", name);
 451         return true;
 452     }
 453     return false;
 454 }
 455
 456 static bool
 457 a_dbus_release_name(DBusConnection *dbus_connection, const char *name)
 458 {
 459     DBusError err;
 460
 461     if(!dbus_connection)
 462         return false;
 463
 464     dbus_error_init(&err);
 465
 466     int ret = dbus_bus_release_name(dbus_connection, name, &err);
 467
 468     if(dbus_error_is_set(&err))
 469     {
 470         warn("failed to release D-Bus name: %s", err.message);
 471         dbus_error_free(&err);
 472         return false;
 473     }
 474
 475     switch(ret)
 476     {
 477       case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
 478         warn("not primary D-Bus name owner for %s", name);
 479         return false;
 480       case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
 481         warn("non existent D-Bus name: %s", name);
 482         return false;
 483     }
 484     return true;
 485 }
 486
 487 static DBusConnection *
 488 a_dbus_connect(DBusBusType type, const char *type_name,
 489                ev_io *dbusio, void *cb)
 490 {
 491     int fd;
 492     DBusConnection *dbus_connection;
 493     DBusError err;
 494
 495     dbus_error_init(&err);
 496
 497     dbus_connection = dbus_bus_get(type, &err);
 498     if(dbus_error_is_set(&err))
 499     {
 500         warn("D-Bus session bus %s failed: %s", type_name, err.message);
 501         dbus_connection = NULL;
 502         dbus_error_free(&err);
 503     }
 504     else
 505     {
 506         dbus_connection_set_exit_on_disconnect(dbus_connection, false);
 507         if(dbus_connection_get_unix_fd(dbus_connection, &fd))
 508         {
 509             fcntl(fd, F_SETFD, FD_CLOEXEC);
 510
 511             ev_io_init(dbusio, cb, fd, EV_READ);
 512             ev_io_start(EV_DEFAULT_UC_ dbusio);
 513             ev_unref(EV_DEFAULT_UC);
 514         }
 515         else
 516         {
 517             warn("cannot get D-Bus connection file descriptor");
 518             a_dbus_cleanup_bus(dbus_connection, dbusio);
 519         }
 520     }
 521
 522     return dbus_connection;
 523 }
 524
 525 void
 526 a_dbus_init(void)
 527 {
 528     dbus_connection_session = a_dbus_connect(DBUS_BUS_SESSION, "session",
 529                                              &dbusio_ses, a_dbus_process_requests_session);
 530     dbus_connection_system = a_dbus_connect(DBUS_BUS_SYSTEM, "system",
 531                                             &dbusio_sys, a_dbus_process_requests_system);
 532 }
 533
 534 void
 535 a_dbus_cleanup(void)
 536 {
 537     a_dbus_cleanup_bus(dbus_connection_session, &dbusio_ses);
 538     a_dbus_cleanup_bus(dbus_connection_system, &dbusio_sys);
 539 }
 540
 541 static DBusConnection *
 542 a_dbus_bus_getbyname(const char *name, size_t len)
 543 {
 544     switch(a_tokenize(name, len))
 545     {
 546       case A_TK_SYSTEM:
 547         return dbus_connection_system;
 548       case A_TK_SESSION:
 549         return dbus_connection_session;
 550       default:
 551         return NULL;
 552     }
 553 }
 554
 555 /** Register a D-Bus name to receive message from.
 556  * \param L The Lua VM state.
 557  * \return The number of elements pushed on stack.
 558  * \luastack
 559  * \lparam A string indicating if we are using system or session bus.
 560  * \lparam A string with the name of the D-Bus name to register.
 561  * \lreturn True if everything worked fine, false otherwise.
 562  */
 563 static int
 564 luaA_dbus_request_name(lua_State *L)
 565 {
 566     size_t len;
 567     const char *bus = luaL_checklstring(L, 1, &len);
 568     const char *name = luaL_checkstring(L, 2);
 569     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 570     lua_pushboolean(L, a_dbus_request_name(dbus_connection, name));
 571     return 1;
 572 }
 573
 574 /** Release a D-Bus name.
 575  * \param L The Lua VM state.
 576  * \return The number of elements pushed on stack.
 577  * \luastack
 578  * \lparam A string indicating if we are using system or session bus.
 579  * \lparam A string with the name of the D-Bus name to unregister.
 580  * \lreturn True if everything worked fine, false otherwise.
 581  */
 582 static int
 583 luaA_dbus_release_name(lua_State *L)
 584 {
 585     size_t len;
 586     const char *bus = luaL_checklstring(L, 1, &len);
 587     const char *name = luaL_checkstring(L, 2);
 588     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 589     lua_pushboolean(L, a_dbus_release_name(dbus_connection, name));
 590     return 1;
 591 }
 592
 593 /** Add a match rule to match messages going through the message bus.
 594  * \param L The Lua VM state.
 595  * \return The number of elements pushed on stack.
 596  * \luastack
 597  * \lparam A string indicating if we are using system or session bus.
 598  * \lparam A string with the name of the match rule.
 599  */
 600 static int
 601 luaA_dbus_add_match(lua_State *L)
 602 {
 603     size_t len;
 604     const char *bus = luaL_checklstring(L, 1, &len);
 605     const char *name = luaL_checkstring(L, 2);
 606     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 607
 608     if(dbus_connection)
 609     {
 610         dbus_bus_add_match(dbus_connection, name, NULL);
 611         dbus_connection_flush(dbus_connection);
 612     }
 613
 614     return 0;
 615 }
 616
 617 /** Remove a previously added match rule "by value"
 618  * (the most recently-added identical rule gets removed).
 619  * \param L The Lua VM state.
 620  * \return The number of elements pushed on stack.
 621  * \luastack
 622  * \lparam A string indicating if we are using system or session bus.
 623  * \lparam A string with the name of the match rule.
 624  */
 625 static int
 626 luaA_dbus_remove_match(lua_State *L)
 627 {
 628     size_t len;
 629     const char *bus = luaL_checklstring(L, 1, &len);
 630     const char *name = luaL_checkstring(L, 2);
 631     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 632
 633     if(dbus_connection)
 634     {
 635         dbus_bus_remove_match(dbus_connection, name, NULL);
 636         dbus_connection_flush(dbus_connection);
 637     }
 638
 639     return 0;
 640 }
 641
 642 /** Add a signal receiver on the D-Bus.
 643  * \param L The Lua VM state.
 644  * \return The number of elements pushed on stack.
 645  * \luastack
 646  * \lparam A string with the interface name.
 647  * \lparam The function to call.
 648  */
 649 static int
 650 luaA_dbus_add_signal(lua_State *L)
 651 {
 652     const char *name = luaL_checkstring(L, 1);
 653     luaA_checkfunction(L, 2);
 654     signal_t *sig = signal_array_getbyid(&dbus_signals,
 655                                          a_strhash((const unsigned char *) name));
 656     if(sig)
 657         luaA_warn(L, "cannot add signal %s on D-Bus, already existing", name);
 658     else
 659         signal_add(&dbus_signals, name, luaA_object_ref(L, 2));
 660     return 0;
 661 }
 662
 663 /** Add a signal receiver on the D-Bus.
 664  * \param L The Lua VM state.
 665  * \return The number of elements pushed on stack.
 666  * \luastack
 667  * \lparam A string with the interface name.
 668  * \lparam The function to call.
 669  */
 670 static int
 671 luaA_dbus_remove_signal(lua_State *L)
 672 {
 673     const char *name = luaL_checkstring(L, 1);
 674     luaA_checkfunction(L, 2);
 675     const void *func = lua_topointer(L, 2);
 676     signal_remove(&dbus_signals, name, func);
 677     luaA_object_unref(L, (void *) func);
 678     return 0;
 679 }
 680
 681 const struct luaL_reg awesome_dbus_lib[] =
 682 {
 683     { "request_name", luaA_dbus_request_name },
 684     { "release_name", luaA_dbus_release_name },
 685     { "add_match", luaA_dbus_add_match },
 686     { "remove_match", luaA_dbus_remove_match },
 687     { "add_signal", luaA_dbus_add_signal },
 688     { "remove_signal", luaA_dbus_remove_signal },
 689     { NULL, NULL }
 690 };
 691
 692 #else /* HAVE_DBUS */
 693
 694 void
 695 a_dbus_init(void)
 696 {
 697 }
 698
 699 void
 700 a_dbus_cleanup(void)
 701 {
 702 }
 703
 704 #endif
 705 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80