gdbus/watch.c

   1 /*
   2  *
   3  *  D-Bus helper library
   4  *
   5  *  Copyright (C) 2004-2011  Marcel Holtmann <marcel@holtmann.org>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include <glib.h>
  32 #include <dbus/dbus.h>
  33
  34 #include "gdbus.h"
  35
  36 #define info(fmt...)
  37 #define error(fmt...)
  38 #define debug(fmt...)
  39
  40 static DBusHandlerResult message_filter(DBusConnection *connection,
  41                                         DBusMessage *message, void *user_data);
  42
  43 static guint listener_id = 0;
  44 static GSList *listeners = NULL;
  45
  46 struct service_data {
  47         DBusConnection *conn;
  48         DBusPendingCall *call;
  49         char *name;
  50         const char *owner;
  51         guint id;
  52         struct filter_callback *callback;
  53 };
  54
  55 struct filter_callback {
  56         GDBusWatchFunction conn_func;
  57         GDBusWatchFunction disc_func;
  58         GDBusSignalFunction signal_func;
  59         GDBusDestroyFunction destroy_func;
  60         struct service_data *data;
  61         void *user_data;
  62         guint id;
  63 };
  64
  65 struct filter_data {
  66         DBusConnection *connection;
  67         DBusHandleMessageFunction handle_func;
  68         char *name;
  69         char *owner;
  70         char *path;
  71         char *interface;
  72         char *member;
  73         char *argument;
  74         GSList *callbacks;
  75         GSList *processed;
  76         guint name_watch;
  77         gboolean lock;
  78         gboolean registered;
  79 };
  80
  81 static struct filter_data *filter_data_find_match(DBusConnection *connection,
  82                                                         const char *name,
  83                                                         const char *owner,
  84                                                         const char *path,
  85                                                         const char *interface,
  86                                                         const char *member,
  87                                                         const char *argument)
  88 {
  89         GSList *current;
  90
  91         for (current = listeners;
  92                         current != NULL; current = current->next) {
  93                 struct filter_data *data = current->data;
  94
  95                 if (connection != data->connection)
  96                         continue;
  97
  98                 if (g_strcmp0(name, data->name) != 0)
  99                         continue;
 100
 101                 if (g_strcmp0(owner, data->owner) != 0)
 102                         continue;
 103
 104                 if (g_strcmp0(path, data->path) != 0)
 105                         continue;
 106
 107                 if (g_strcmp0(interface, data->interface) != 0)
 108                         continue;
 109
 110                 if (g_strcmp0(member, data->member) != 0)
 111                         continue;
 112
 113                 if (g_strcmp0(argument, data->argument) != 0)
 114                         continue;
 115
 116                 return data;
 117         }
 118
 119         return NULL;
 120 }
 121
 122 static struct filter_data *filter_data_find(DBusConnection *connection)
 123 {
 124         GSList *current;
 125
 126         for (current = listeners;
 127                         current != NULL; current = current->next) {
 128                 struct filter_data *data = current->data;
 129
 130                 if (connection != data->connection)
 131                         continue;
 132
 133                 return data;
 134         }
 135
 136         return NULL;
 137 }
 138
 139 static char *format_rule(struct filter_data *data)
 140 {
 141         char *rule, *tmp;
 142         const char *sender;
 143
 144         rule = g_strdup("type='signal'");
 145         sender = data->name ? : data->owner;
 146
 147         if (sender) {
 148                 tmp = rule;
 149                 rule = g_strdup_printf("%s,sender='%s'", rule, sender);
 150                 g_free(tmp);
 151         }
 152
 153         if (data->path) {
 154                 tmp = rule;
 155                 rule = g_strdup_printf("%s,path='%s'", rule, data->path);
 156                 g_free(tmp);
 157         }
 158
 159         if (data->interface){
 160                 tmp = rule;
 161                 rule = g_strdup_printf("%s,interface='%s'", rule,
 162                                 data->interface);
 163                 g_free(tmp);
 164         }
 165
 166         if (data->member) {
 167                 tmp = rule;
 168                 rule = g_strdup_printf("%s,member='%s'", rule, data->member);
 169                 g_free(tmp);
 170         }
 171
 172         if (data->argument) {
 173                 tmp = rule;
 174                 rule = g_strdup_printf("%s,arg0='%s'", rule, data->argument);
 175                 g_free(tmp);
 176         }
 177
 178         return rule;
 179 }
 180
 181 static gboolean add_match(struct filter_data *data,
 182                                 DBusHandleMessageFunction filter)
 183 {
 184         DBusError err;
 185         char *rule;
 186
 187         rule = format_rule(data);
 188         dbus_error_init(&err);
 189
 190         dbus_bus_add_match(data->connection, rule, &err);
 191         if (dbus_error_is_set(&err)) {
 192                 error("Adding match rule \"%s\" failed: %s", rule,
 193                                 err.message);
 194                 dbus_error_free(&err);
 195                 g_free(rule);
 196                 return FALSE;
 197         }
 198
 199         data->handle_func = filter;
 200         data->registered = TRUE;
 201
 202         g_free(rule);
 203         return TRUE;
 204 }
 205
 206 static gboolean remove_match(struct filter_data *data)
 207 {
 208         DBusError err;
 209         char *rule;
 210
 211         rule = format_rule(data);
 212
 213         dbus_error_init(&err);
 214
 215         dbus_bus_remove_match(data->connection, rule, &err);
 216         if (dbus_error_is_set(&err)) {
 217                 error("Removing owner match rule for %s failed: %s",
 218                                 rule, err.message);
 219                 dbus_error_free(&err);
 220                 g_free(rule);
 221                 return FALSE;
 222         }
 223
 224         g_free(rule);
 225         return TRUE;
 226 }
 227
 228 static void filter_data_free(struct filter_data *data)
 229 {
 230         GSList *l;
 231
 232         /* Remove filter if there are no listeners left for the connection */
 233         if (filter_data_find(data->connection) == NULL)
 234                 dbus_connection_remove_filter(data->connection, message_filter,
 235                                                                         NULL);
 236
 237         for (l = data->callbacks; l != NULL; l = l->next)
 238                 g_free(l->data);
 239
 240         g_slist_free(data->callbacks);
 241         g_dbus_remove_watch(data->connection, data->name_watch);
 242         g_free(data->name);
 243         g_free(data->owner);
 244         g_free(data->path);
 245         g_free(data->interface);
 246         g_free(data->member);
 247         g_free(data->argument);
 248         dbus_connection_unref(data->connection);
 249         g_free(data);
 250 }
 251
 252 static struct filter_data *filter_data_get(DBusConnection *connection,
 253                                         DBusHandleMessageFunction filter,
 254                                         const char *sender,
 255                                         const char *path,
 256                                         const char *interface,
 257                                         const char *member,
 258                                         const char *argument)
 259 {
 260         struct filter_data *data;
 261         const char *name = NULL, *owner = NULL;
 262
 263         if (filter_data_find(connection) == NULL) {
 264                 if (!dbus_connection_add_filter(connection,
 265                                         message_filter, NULL, NULL)) {
 266                         error("dbus_connection_add_filter() failed");
 267                         return NULL;
 268                 }
 269         }
 270
 271         if (sender == NULL)
 272                 goto proceed;
 273
 274         if (sender[0] == ':')
 275                 owner = sender;
 276         else
 277                 name = sender;
 278
 279 proceed:
 280         data = filter_data_find_match(connection, name, owner, path,
 281                                                 interface, member, argument);
 282         if (data)
 283                 return data;
 284
 285         data = g_new0(struct filter_data, 1);
 286
 287         data->connection = dbus_connection_ref(connection);
 288         data->name = g_strdup(name);
 289         data->owner = g_strdup(owner);
 290         data->path = g_strdup(path);
 291         data->interface = g_strdup(interface);
 292         data->member = g_strdup(member);
 293         data->argument = g_strdup(argument);
 294
 295         if (!add_match(data, filter)) {
 296                 filter_data_free(data);
 297                 return NULL;
 298         }
 299
 300         listeners = g_slist_append(listeners, data);
 301
 302         return data;
 303 }
 304
 305 static struct filter_callback *filter_data_find_callback(
 306                                                 struct filter_data *data,
 307                                                 guint id)
 308 {
 309         GSList *l;
 310
 311         for (l = data->callbacks; l; l = l->next) {
 312                 struct filter_callback *cb = l->data;
 313                 if (cb->id == id)
 314                         return cb;
 315         }
 316         for (l = data->processed; l; l = l->next) {
 317                 struct filter_callback *cb = l->data;
 318                 if (cb->id == id)
 319                         return cb;
 320         }
 321
 322         return NULL;
 323 }
 324
 325 static void filter_data_call_and_free(struct filter_data *data)
 326 {
 327         GSList *l;
 328
 329         for (l = data->callbacks; l != NULL; l = l->next) {
 330                 struct filter_callback *cb = l->data;
 331                 if (cb->disc_func)
 332                         cb->disc_func(data->connection, cb->user_data);
 333                 if (cb->destroy_func)
 334                         cb->destroy_func(cb->user_data);
 335                 g_free(cb);
 336         }
 337
 338         filter_data_free(data);
 339 }
 340
 341 static struct filter_callback *filter_data_add_callback(
 342                                                 struct filter_data *data,
 343                                                 GDBusWatchFunction connect,
 344                                                 GDBusWatchFunction disconnect,
 345                                                 GDBusSignalFunction signal,
 346                                                 GDBusDestroyFunction destroy,
 347                                                 void *user_data)
 348 {
 349         struct filter_callback *cb = NULL;
 350
 351         cb = g_new0(struct filter_callback, 1);
 352
 353         cb->conn_func = connect;
 354         cb->disc_func = disconnect;
 355         cb->signal_func = signal;
 356         cb->destroy_func = destroy;
 357         cb->user_data = user_data;
 358         cb->id = ++listener_id;
 359
 360         if (data->lock)
 361                 data->processed = g_slist_append(data->processed, cb);
 362         else
 363                 data->callbacks = g_slist_append(data->callbacks, cb);
 364
 365         return cb;
 366 }
 367
 368 static void service_data_free(struct service_data *data)
 369 {
 370         struct filter_callback *callback = data->callback;
 371
 372         dbus_connection_unref(data->conn);
 373
 374         if (data->call)
 375                 dbus_pending_call_unref(data->call);
 376
 377         if (data->id)
 378                 g_source_remove(data->id);
 379
 380         g_free(data->name);
 381         g_free(data);
 382
 383         callback->data = NULL;
 384 }
 385
 386 /* Returns TRUE if data is freed */
 387 static gboolean filter_data_remove_callback(struct filter_data *data,
 388                                                 struct filter_callback *cb)
 389 {
 390         data->callbacks = g_slist_remove(data->callbacks, cb);
 391         data->processed = g_slist_remove(data->processed, cb);
 392
 393         /* Cancel pending operations */
 394         if (cb->data) {
 395                 if (cb->data->call)
 396                         dbus_pending_call_cancel(cb->data->call);
 397                 service_data_free(cb->data);
 398         }
 399
 400         if (cb->destroy_func)
 401                 cb->destroy_func(cb->user_data);
 402
 403         g_free(cb);
 404
 405         /* Don't remove the filter if other callbacks exist or data is lock
 406          * processing callbacks */
 407         if (data->callbacks || data->lock)
 408                 return FALSE;
 409
 410         if (data->registered && !remove_match(data))
 411                 return FALSE;
 412
 413         listeners = g_slist_remove(listeners, data);
 414         filter_data_free(data);
 415
 416         return TRUE;
 417 }
 418
 419 static DBusHandlerResult signal_filter(DBusConnection *connection,
 420                                         DBusMessage *message, void *user_data)
 421 {
 422         struct filter_data *data = user_data;
 423         struct filter_callback *cb;
 424
 425         while (data->callbacks) {
 426                 cb = data->callbacks->data;
 427
 428                 if (cb->signal_func && !cb->signal_func(connection, message,
 429                                                         cb->user_data)) {
 430                         if (filter_data_remove_callback(data, cb))
 431                                 break;
 432
 433                         continue;
 434                 }
 435
 436                 /* Check if the watch was removed/freed by the callback
 437                  * function */
 438                 if (!g_slist_find(data->callbacks, cb))
 439                         continue;
 440
 441                 data->callbacks = g_slist_remove(data->callbacks, cb);
 442                 data->processed = g_slist_append(data->processed, cb);
 443         }
 444
 445         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 446 }
 447
 448 static void update_name_cache(const char *name, const char *owner)
 449 {
 450         GSList *l;
 451
 452         for (l = listeners; l != NULL; l = l->next) {
 453                 struct filter_data *data = l->data;
 454
 455                 if (g_strcmp0(data->name, name) != 0)
 456                         continue;
 457
 458                 g_free(data->owner);
 459                 data->owner = g_strdup(owner);
 460         }
 461 }
 462
 463 static const char *check_name_cache(const char *name)
 464 {
 465         GSList *l;
 466
 467         for (l = listeners; l != NULL; l = l->next) {
 468                 struct filter_data *data = l->data;
 469
 470                 if (g_strcmp0(data->name, name) != 0)
 471                         continue;
 472
 473                 return data->owner;
 474         }
 475
 476         return NULL;
 477 }
 478
 479 static DBusHandlerResult service_filter(DBusConnection *connection,
 480                                         DBusMessage *message, void *user_data)
 481 {
 482         struct filter_data *data = user_data;
 483         struct filter_callback *cb;
 484         char *name, *old, *new;
 485
 486         if (!dbus_message_get_args(message, NULL,
 487                                 DBUS_TYPE_STRING, &name,
 488                                 DBUS_TYPE_STRING, &old,
 489                                 DBUS_TYPE_STRING, &new,
 490                                 DBUS_TYPE_INVALID)) {
 491                 error("Invalid arguments for NameOwnerChanged signal");
 492                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 493         }
 494
 495         update_name_cache(name, new);
 496
 497         while (data->callbacks) {
 498                 cb = data->callbacks->data;
 499
 500                 if (*new == '\0') {
 501                         if (cb->disc_func)
 502                                 cb->disc_func(connection, cb->user_data);
 503                 } else {
 504                         if (cb->conn_func)
 505                                 cb->conn_func(connection, cb->user_data);
 506                 }
 507
 508                 /* Check if the watch was removed/freed by the callback
 509                  * function */
 510                 if (!g_slist_find(data->callbacks, cb))
 511                         continue;
 512
 513                 /* Only auto remove if it is a bus name watch */
 514                 if (data->argument[0] == ':' &&
 515                                 (cb->conn_func == NULL || cb->disc_func == NULL)) {
 516                         if (filter_data_remove_callback(data, cb))
 517                                 break;
 518
 519                         continue;
 520                 }
 521
 522                 data->callbacks = g_slist_remove(data->callbacks, cb);
 523                 data->processed = g_slist_append(data->processed, cb);
 524         }
 525
 526         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 527 }
 528
 529
 530 static DBusHandlerResult message_filter(DBusConnection *connection,
 531                                         DBusMessage *message, void *user_data)
 532 {
 533         struct filter_data *data;
 534         const char *sender, *path, *iface, *member, *arg = NULL;
 535         GSList *current, *delete_listener = NULL;
 536
 537         /* Only filter signals */
 538         if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
 539                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 540
 541         sender = dbus_message_get_sender(message);
 542         path = dbus_message_get_path(message);
 543         iface = dbus_message_get_interface(message);
 544         member = dbus_message_get_member(message);
 545         dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
 546
 547         /* If sender != NULL it is always the owner */
 548
 549         for (current = listeners; current != NULL; current = current->next) {
 550                 data = current->data;
 551
 552                 if (connection != data->connection)
 553                         continue;
 554
 555                 if (!sender && data->owner)
 556                         continue;
 557
 558                 if (data->owner && g_str_equal(sender, data->owner) == FALSE)
 559                         continue;
 560
 561                 if (data->path && g_str_equal(path, data->path) == FALSE)
 562                         continue;
 563
 564                 if (data->interface && g_str_equal(iface,
 565                                                 data->interface) == FALSE)
 566                         continue;
 567
 568                 if (data->member && g_str_equal(member, data->member) == FALSE)
 569                         continue;
 570
 571                 if (data->argument && g_str_equal(arg,
 572                                                 data->argument) == FALSE)
 573                         continue;
 574
 575                 if (data->handle_func) {
 576                         data->lock = TRUE;
 577
 578                         data->handle_func(connection, message, data);
 579
 580                         data->callbacks = data->processed;
 581                         data->processed = NULL;
 582                         data->lock = FALSE;
 583                 }
 584
 585                 if (!data->callbacks)
 586                         delete_listener = g_slist_prepend(delete_listener,
 587                                                                 current);
 588         }
 589
 590         if (delete_listener == NULL)
 591                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 592
 593         for (current = delete_listener; current != NULL;
 594                                         current = delete_listener->next) {
 595                 GSList *l = current->data;
 596
 597                 data = l->data;
 598
 599                 /* Has any other callback added callbacks back to this data? */
 600                 if (data->callbacks != NULL)
 601                         continue;
 602
 603                 remove_match(data);
 604                 listeners = g_slist_delete_link(listeners, l);
 605
 606                 filter_data_free(data);
 607         }
 608
 609         g_slist_free(delete_listener);
 610
 611         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 612 }
 613
 614 static gboolean update_service(void *user_data)
 615 {
 616         struct service_data *data = user_data;
 617         struct filter_callback *cb = data->callback;
 618         DBusConnection *conn;
 619
 620         conn = dbus_connection_ref(data->conn);
 621         service_data_free(data);
 622
 623         if (cb->conn_func)
 624                 cb->conn_func(conn, cb->user_data);
 625
 626         dbus_connection_unref(conn);
 627
 628         return FALSE;
 629 }
 630
 631 static void service_reply(DBusPendingCall *call, void *user_data)
 632 {
 633         struct service_data *data = user_data;
 634         DBusMessage *reply;
 635         DBusError err;
 636
 637         reply = dbus_pending_call_steal_reply(call);
 638         if (reply == NULL)
 639                 return;
 640
 641         dbus_error_init(&err);
 642
 643         if (dbus_set_error_from_message(&err, reply))
 644                 goto fail;
 645
 646         if (dbus_message_get_args(reply, &err,
 647                                         DBUS_TYPE_STRING, &data->owner,
 648                                                 DBUS_TYPE_INVALID) == FALSE)
 649                 goto fail;
 650
 651         update_service(data);
 652
 653         goto done;
 654
 655 fail:
 656         error("%s", err.message);
 657         dbus_error_free(&err);
 658         service_data_free(data);
 659 done:
 660         dbus_message_unref(reply);
 661 }
 662
 663 static void check_service(DBusConnection *connection,
 664                                         const char *name,
 665                                         struct filter_callback *callback)
 666 {
 667         DBusMessage *message;
 668         struct service_data *data;
 669
 670         data = g_try_malloc0(sizeof(*data));
 671         if (data == NULL) {
 672                 error("Can't allocate data structure");
 673                 return;
 674         }
 675
 676         data->conn = dbus_connection_ref(connection);
 677         data->name = g_strdup(name);
 678         data->callback = callback;
 679         callback->data = data;
 680
 681         data->owner = check_name_cache(name);
 682         if (data->owner != NULL) {
 683                 data->id = g_idle_add(update_service, data);
 684                 return;
 685         }
 686
 687         message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
 688                         DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
 689         if (message == NULL) {
 690                 error("Can't allocate new message");
 691                 g_free(data);
 692                 return;
 693         }
 694
 695         dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
 696                                                         DBUS_TYPE_INVALID);
 697
 698         if (dbus_connection_send_with_reply(connection, message,
 699                                                         &data->call, -1) == FALSE) {
 700                 error("Failed to execute method call");
 701                 g_free(data);
 702                 goto done;
 703         }
 704
 705         if (data->call == NULL) {
 706                 error("D-Bus connection not available");
 707                 g_free(data);
 708                 goto done;
 709         }
 710
 711         dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
 712
 713 done:
 714         dbus_message_unref(message);
 715 }
 716
 717 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
 718                                 GDBusWatchFunction connect,
 719                                 GDBusWatchFunction disconnect,
 720                                 void *user_data, GDBusDestroyFunction destroy)
 721 {
 722         struct filter_data *data;
 723         struct filter_callback *cb;
 724
 725         if (name == NULL)
 726                 return 0;
 727
 728         data = filter_data_get(connection, service_filter,
 729                                 DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
 730                                 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
 731                                 name);
 732         if (data == NULL)
 733                 return 0;
 734
 735         cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
 736                                         user_data);
 737         if (cb == NULL)
 738                 return 0;
 739
 740         if (connect)
 741                 check_service(connection, name, cb);
 742
 743         return cb->id;
 744 }
 745
 746 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
 747                                 GDBusWatchFunction func,
 748                                 void *user_data, GDBusDestroyFunction destroy)
 749 {
 750         return g_dbus_add_service_watch(connection, name, NULL, func,
 751                                                         user_data, destroy);
 752 }
 753
 754 guint g_dbus_add_signal_watch(DBusConnection *connection,
 755                                 const char *sender, const char *path,
 756                                 const char *interface, const char *member,
 757                                 GDBusSignalFunction function, void *user_data,
 758                                 GDBusDestroyFunction destroy)
 759 {
 760         struct filter_data *data;
 761         struct filter_callback *cb;
 762
 763         data = filter_data_get(connection, signal_filter, sender, path,
 764                                 interface, member, NULL);
 765         if (data == NULL)
 766                 return 0;
 767
 768         cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
 769                                         user_data);
 770         if (cb == NULL)
 771                 return 0;
 772
 773         if (data->name != NULL && data->name_watch == 0)
 774                 data->name_watch = g_dbus_add_service_watch(connection,
 775                                                         data->name, NULL,
 776                                                         NULL, NULL, NULL);
 777
 778         return cb->id;
 779 }
 780
 781 guint g_dbus_add_properties_watch(DBusConnection *connection,
 782                                 const char *sender, const char *path,
 783                                 const char *interface,
 784                                 GDBusSignalFunction function, void *user_data,
 785                                 GDBusDestroyFunction destroy)
 786 {
 787         struct filter_data *data;
 788         struct filter_callback *cb;
 789
 790         data = filter_data_get(connection, signal_filter, sender, path,
 791                                 DBUS_INTERFACE_PROPERTIES, "PropertiesChanged",
 792                                 interface);
 793         if (data == NULL)
 794                 return 0;
 795
 796         cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
 797                                         user_data);
 798         if (cb == NULL)
 799                 return 0;
 800
 801         if (data->name != NULL && data->name_watch == 0)
 802                 data->name_watch = g_dbus_add_service_watch(connection,
 803                                                         data->name, NULL,
 804                                                         NULL, NULL, NULL);
 805
 806         return cb->id;
 807 }
 808
 809 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
 810 {
 811         struct filter_data *data;
 812         struct filter_callback *cb;
 813         GSList *ldata;
 814
 815         if (id == 0)
 816                 return FALSE;
 817
 818         for (ldata = listeners; ldata; ldata = ldata->next) {
 819                 data = ldata->data;
 820
 821                 cb = filter_data_find_callback(data, id);
 822                 if (cb) {
 823                         filter_data_remove_callback(data, cb);
 824                         return TRUE;
 825                 }
 826         }
 827
 828         return FALSE;
 829 }
 830
 831 void g_dbus_remove_all_watches(DBusConnection *connection)
 832 {
 833         struct filter_data *data;
 834
 835         while ((data = filter_data_find(connection))) {
 836                 listeners = g_slist_remove(listeners, data);
 837                 filter_data_call_and_free(data);
 838         }
 839 }