git.meshlink.io Git - catta/blob - avahi-daemon/dbus-protocol.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <glib.h>
  27 #include <string.h>
  28
  29 #define DBUS_API_SUBJECT_TO_CHANGE
  30 #include <dbus/dbus.h>
  31 #include <dbus/dbus-glib-lowlevel.h>
  32
  33 #include <avahi-core/llist.h>
  34 #include <avahi-core/log.h>
  35 #include <avahi-core/core.h>
  36 #include <avahi-common/dbus.h>
  37
  38 #include "dbus-protocol.h"
  39 #include "main.h"
  40
  41 typedef struct Server Server;
  42 typedef struct Client Client;
  43 typedef struct EntryGroupInfo EntryGroupInfo;
  44 typedef struct HostNameResolverInfo HostNameResolverInfo;
  45 typedef struct AddressResolverInfo AddressResolverInfo;
  46 typedef struct DomainBrowserInfo DomainBrowserInfo;
  47 typedef struct ServiceTypeBrowserInfo ServiceTypeBrowserInfo;
  48 typedef struct ServiceBrowserInfo ServiceBrowserInfo;
  49 typedef struct ServiceResolverInfo ServiceResolverInfo;
  50
  51 struct EntryGroupInfo {
  52     guint id;
  53     Client *client;
  54     AvahiEntryGroup *entry_group;
  55     gchar *path;
  56
  57     AVAHI_LLIST_FIELDS(EntryGroupInfo, entry_groups);
  58 };
  59
  60 struct HostNameResolverInfo {
  61     Client *client;
  62     AvahiHostNameResolver *host_name_resolver;
  63     DBusMessage *message;
  64
  65     AVAHI_LLIST_FIELDS(HostNameResolverInfo, host_name_resolvers);
  66 };
  67
  68 struct AddressResolverInfo {
  69     Client *client;
  70     AvahiAddressResolver *address_resolver;
  71     DBusMessage *message;
  72
  73     AVAHI_LLIST_FIELDS(AddressResolverInfo, address_resolvers);
  74 };
  75
  76 struct DomainBrowserInfo {
  77     guint id;
  78     Client *client;
  79     AvahiDomainBrowser *domain_browser;
  80     gchar *path;
  81
  82     AVAHI_LLIST_FIELDS(DomainBrowserInfo, domain_browsers);
  83 };
  84
  85 struct ServiceTypeBrowserInfo {
  86     guint id;
  87     Client *client;
  88     AvahiServiceTypeBrowser *service_type_browser;
  89     gchar *path;
  90
  91     AVAHI_LLIST_FIELDS(ServiceTypeBrowserInfo, service_type_browsers);
  92 };
  93
  94 struct ServiceBrowserInfo {
  95     guint id;
  96     Client *client;
  97     AvahiServiceBrowser *service_browser;
  98     gchar *path;
  99
 100     AVAHI_LLIST_FIELDS(ServiceBrowserInfo, service_browsers);
 101 };
 102
 103 struct ServiceResolverInfo {
 104     Client *client;
 105     AvahiServiceResolver *service_resolver;
 106     DBusMessage *message;
 107
 108     AVAHI_LLIST_FIELDS(ServiceResolverInfo, service_resolvers);
 109 };
 110
 111 struct Client {
 112     guint id;
 113     gchar *name;
 114     guint current_id;
 115
 116     AVAHI_LLIST_FIELDS(Client, clients);
 117     AVAHI_LLIST_HEAD(EntryGroupInfo, entry_groups);
 118     AVAHI_LLIST_HEAD(HostNameResolverInfo, host_name_resolvers);
 119     AVAHI_LLIST_HEAD(AddressResolverInfo, address_resolvers);
 120     AVAHI_LLIST_HEAD(DomainBrowserInfo, domain_browsers);
 121     AVAHI_LLIST_HEAD(ServiceTypeBrowserInfo, service_type_browsers);
 122     AVAHI_LLIST_HEAD(ServiceBrowserInfo, service_browsers);
 123     AVAHI_LLIST_HEAD(ServiceResolverInfo, service_resolvers);
 124 };
 125
 126 struct Server {
 127     DBusConnection *bus;
 128     AVAHI_LLIST_HEAD(Client, clients);
 129     guint current_id;
 130 };
 131
 132 static Server *server = NULL;
 133
 134 static void entry_group_free(EntryGroupInfo *i) {
 135     g_assert(i);
 136
 137     if (i->entry_group)
 138         avahi_entry_group_free(i->entry_group);
 139     dbus_connection_unregister_object_path(server->bus, i->path);
 140     g_free(i->path);
 141     AVAHI_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i);
 142     g_free(i);
 143  }
 144
 145 static void host_name_resolver_free(HostNameResolverInfo *i) {
 146     g_assert(i);
 147
 148     if (i->host_name_resolver)
 149         avahi_host_name_resolver_free(i->host_name_resolver);
 150     dbus_message_unref(i->message);
 151     AVAHI_LLIST_REMOVE(HostNameResolverInfo, host_name_resolvers, i->client->host_name_resolvers, i);
 152     g_free(i);
 153 }
 154
 155 static void address_resolver_free(AddressResolverInfo *i) {
 156     g_assert(i);
 157
 158     if (i->address_resolver)
 159         avahi_address_resolver_free(i->address_resolver);
 160     dbus_message_unref(i->message);
 161     AVAHI_LLIST_REMOVE(AddressResolverInfo, address_resolvers, i->client->address_resolvers, i);
 162     g_free(i);
 163 }
 164
 165 static void domain_browser_free(DomainBrowserInfo *i) {
 166     g_assert(i);
 167
 168     if (i->domain_browser)
 169         avahi_domain_browser_free(i->domain_browser);
 170     dbus_connection_unregister_object_path(server->bus, i->path);
 171     g_free(i->path);
 172     AVAHI_LLIST_REMOVE(DomainBrowserInfo, domain_browsers, i->client->domain_browsers, i);
 173     g_free(i);
 174 }
 175
 176 static void service_type_browser_free(ServiceTypeBrowserInfo *i) {
 177     g_assert(i);
 178
 179     if (i->service_type_browser)
 180         avahi_service_type_browser_free(i->service_type_browser);
 181     dbus_connection_unregister_object_path(server->bus, i->path);
 182     g_free(i->path);
 183     AVAHI_LLIST_REMOVE(ServiceTypeBrowserInfo, service_type_browsers, i->client->service_type_browsers, i);
 184     g_free(i);
 185 }
 186
 187 static void service_browser_free(ServiceBrowserInfo *i) {
 188     g_assert(i);
 189
 190     if (i->service_browser)
 191         avahi_service_browser_free(i->service_browser);
 192     dbus_connection_unregister_object_path(server->bus, i->path);
 193     g_free(i->path);
 194     AVAHI_LLIST_REMOVE(ServiceBrowserInfo, service_browsers, i->client->service_browsers, i);
 195     g_free(i);
 196 }
 197
 198 static void service_resolver_free(ServiceResolverInfo *i) {
 199     g_assert(i);
 200
 201     if (i->service_resolver)
 202         avahi_service_resolver_free(i->service_resolver);
 203     dbus_message_unref(i->message);
 204     AVAHI_LLIST_REMOVE(ServiceResolverInfo, service_resolvers, i->client->service_resolvers, i);
 205     g_free(i);
 206 }
 207
 208 static void client_free(Client *c) {
 209
 210     g_assert(server);
 211     g_assert(c);
 212
 213     while (c->entry_groups)
 214         entry_group_free(c->entry_groups);
 215
 216     while (c->host_name_resolvers)
 217         host_name_resolver_free(c->host_name_resolvers);
 218
 219     while (c->address_resolvers)
 220         address_resolver_free(c->address_resolvers);
 221
 222     while (c->domain_browsers)
 223         domain_browser_free(c->domain_browsers);
 224
 225     while (c->service_type_browsers)
 226         service_type_browser_free(c->service_type_browsers);
 227
 228     while (c->service_browsers)
 229         service_browser_free(c->service_browsers);
 230
 231     while (c->service_resolvers)
 232         service_resolver_free(c->service_resolvers);
 233
 234     g_free(c->name);
 235     AVAHI_LLIST_REMOVE(Client, clients, server->clients, c);
 236     g_free(c);
 237 }
 238
 239 static Client *client_get(const gchar *name, gboolean create) {
 240     Client *client;
 241
 242     g_assert(server);
 243     g_assert(name);
 244
 245     for (client = server->clients; client; client = client->clients_next)
 246         if (!strcmp(name, client->name))
 247             return client;
 248
 249     if (!create)
 250         return NULL;
 251
 252     /* If not existant yet, create a new entry */
 253     client = g_new(Client, 1);
 254     client->id = server->current_id++;
 255     client->name = g_strdup(name);
 256     client->current_id = 0;
 257     AVAHI_LLIST_HEAD_INIT(EntryGroupInfo, client->entry_groups);
 258     AVAHI_LLIST_HEAD_INIT(HostNameResolverInfo, client->host_name_resolvers);
 259     AVAHI_LLIST_HEAD_INIT(AddressResolverInfo, client->address_resolvers);
 260     AVAHI_LLIST_HEAD_INIT(DomainBrowserInfo, client->domain_browsers);
 261     AVAHI_LLIST_HEAD_INIT(ServiceTypeBrowserInfo, client->service_type_browsers);
 262     AVAHI_LLIST_HEAD_INIT(ServiceBrowserInfo, client->service_browsers);
 263     AVAHI_LLIST_HEAD_INIT(ServiceResolverInfo, client->service_resolvers);
 264
 265     AVAHI_LLIST_PREPEND(Client, clients, server->clients, client);
 266     return client;
 267 }
 268
 269 static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, const gchar *error, const gchar *text) {
 270     DBusMessage *reply;
 271
 272     reply = dbus_message_new_error(m, error, text);
 273     dbus_connection_send(c, reply, NULL);
 274     dbus_message_unref(reply);
 275
 276     return DBUS_HANDLER_RESULT_HANDLED;
 277 }
 278
 279 static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const gchar *text) {
 280     DBusMessage *reply;
 281
 282     reply = dbus_message_new_method_return(m);
 283     dbus_message_append_args(reply, DBUS_TYPE_STRING, &text, DBUS_TYPE_INVALID);
 284     dbus_connection_send(c, reply, NULL);
 285     dbus_message_unref(reply);
 286
 287     return DBUS_HANDLER_RESULT_HANDLED;
 288 }
 289
 290 static DBusHandlerResult respond_ok(DBusConnection *c, DBusMessage *m) {
 291     DBusMessage *reply;
 292
 293     reply = dbus_message_new_method_return(m);
 294     dbus_connection_send(c, reply, NULL);
 295     dbus_message_unref(reply);
 296
 297     return DBUS_HANDLER_RESULT_HANDLED;
 298 }
 299
 300 static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const gchar *path) {
 301     DBusMessage *reply;
 302
 303     reply = dbus_message_new_method_return(m);
 304     dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
 305     dbus_connection_send(c, reply, NULL);
 306     dbus_message_unref(reply);
 307
 308     return DBUS_HANDLER_RESULT_HANDLED;
 309 }
 310
 311 static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 312     GMainLoop *loop = userdata;
 313     DBusError error;
 314
 315     dbus_error_init(&error);
 316
 317 /*     avahi_log_debug("dbus: interface=%s, path=%s, member=%s", */
 318 /*                     dbus_message_get_interface(m), */
 319 /*                     dbus_message_get_path(m), */
 320 /*                     dbus_message_get_member(m)); */
 321
 322     if (dbus_message_is_signal(m, DBUS_INTERFACE_LOCAL, "Disconnected")) {
 323         /* No, we shouldn't quit, but until we get somewhere
 324          * usefull such that we can restore our state, we will */
 325         avahi_log_warn("Disconnnected from d-bus, terminating...");
 326         g_main_loop_quit (loop);
 327         return DBUS_HANDLER_RESULT_HANDLED;
 328
 329     } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameAcquired")) {
 330         gchar *name;
 331
 332         if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) {
 333             avahi_log_warn("Error parsing NameAcquired message");
 334             goto fail;
 335         }
 336
 337 /*         avahi_log_info("dbus: name acquired (%s)", name); */
 338         return DBUS_HANDLER_RESULT_HANDLED;
 339
 340     } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
 341         gchar *name, *old, *new;
 342
 343         if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID)) {
 344             avahi_log_warn("Error parsing NameOwnerChanged message");
 345             goto fail;
 346         }
 347
 348         if (!*new) {
 349             Client *client;
 350
 351             if ((client = client_get(name, FALSE))) {
 352 /*                 avahi_log_info("dbus: client %s vanished", name); */
 353                 client_free(client);
 354             }
 355         }
 356     }
 357
 358 fail:
 359     if (dbus_error_is_set(&error))
 360         dbus_error_free(&error);
 361
 362     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 363 }
 364
 365
 366 static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) {
 367     EntryGroupInfo *i = userdata;
 368     DBusMessage *m;
 369     gint32 t;
 370
 371     g_assert(s);
 372     g_assert(g);
 373     g_assert(i);
 374
 375     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged");
 376     t = (gint32) state;
 377     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
 378     dbus_message_set_destination(m, i->client->name);
 379     dbus_connection_send(server->bus, m, NULL);
 380     dbus_message_unref(m);
 381 }
 382
 383 static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 384     DBusError error;
 385     EntryGroupInfo *i = userdata;
 386
 387     g_assert(c);
 388     g_assert(m);
 389     g_assert(i);
 390
 391     dbus_error_init(&error);
 392
 393     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 394                     dbus_message_get_interface(m),
 395                     dbus_message_get_path(m),
 396                     dbus_message_get_member(m));
 397
 398     /* Access control */
 399     if (strcmp(dbus_message_get_sender(m), i->client->name))
 400         return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL);
 401
 402     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Free")) {
 403
 404         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 405             avahi_log_warn("Error parsing EntryGroup::Free message");
 406             goto fail;
 407         }
 408
 409         entry_group_free(i);
 410         return respond_ok(c, m);
 411
 412     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Commit")) {
 413
 414         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 415             avahi_log_warn("Error parsing EntryGroup::Commit message");
 416             goto fail;
 417         }
 418
 419         avahi_entry_group_commit(i->entry_group);
 420         return respond_ok(c, m);
 421
 422     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) {
 423         DBusMessage *reply;
 424         gint32 t;
 425
 426         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 427             avahi_log_warn("Error parsing EntryGroup::GetState message");
 428             goto fail;
 429         }
 430
 431         t = (gint32) avahi_entry_group_get_state(i->entry_group);
 432         reply = dbus_message_new_method_return(m);
 433         dbus_message_append_args(reply, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
 434         dbus_connection_send(c, reply, NULL);
 435         dbus_message_unref(reply);
 436
 437         return DBUS_HANDLER_RESULT_HANDLED;
 438
 439     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) {
 440         gint32 interface, protocol;
 441         gchar *type, *name, *domain, *host;
 442         guint16 port;
 443         gchar **txt = NULL;
 444         gint txt_len;
 445         AvahiStringList *strlst;
 446
 447         if (!dbus_message_get_args(
 448                 m, &error,
 449                 DBUS_TYPE_INT32, &interface,
 450                 DBUS_TYPE_INT32, &protocol,
 451                 DBUS_TYPE_STRING, &name,
 452                 DBUS_TYPE_STRING, &type,
 453                 DBUS_TYPE_STRING, &domain,
 454                 DBUS_TYPE_STRING, &host,
 455                 DBUS_TYPE_UINT16, &port,
 456                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &txt, &txt_len,
 457                 DBUS_TYPE_INVALID) || !type || !*type || !name || !*name || !port) {
 458             avahi_log_warn("Error parsing EntryGroup::AddService message");
 459             goto fail;
 460         }
 461
 462         strlst = avahi_string_list_new_from_array((const gchar**) txt, txt_len);
 463         dbus_free_string_array(txt);
 464
 465         if (domain && !*domain)
 466             domain = NULL;
 467
 468         if (host && !*host)
 469             host = NULL;
 470
 471         if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, host, port, strlst) < 0) {
 472             avahi_log_warn("Failed to add service: %s", name);
 473             return respond_error(c, m, "org.freedesktop.Avahi.InvalidServiceError", NULL);
 474         } /* else */
 475 /*             avahi_log_info("Successfully added service: %s", name); */
 476
 477         return respond_ok(c, m);
 478
 479     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress")) {
 480         gint32 interface, protocol;
 481         gchar *name, *address;
 482         AvahiAddress a;
 483
 484         if (!dbus_message_get_args(
 485                 m, &error,
 486                 DBUS_TYPE_INT32, &interface,
 487                 DBUS_TYPE_INT32, &protocol,
 488                 DBUS_TYPE_STRING, &name,
 489                 DBUS_TYPE_STRING, &address,
 490                 DBUS_TYPE_INVALID) || !name || !*name || !address || !*address) {
 491             avahi_log_warn("Error parsing EntryGroup::AddAddress message");
 492             goto fail;
 493         }
 494
 495         if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))) {
 496             avahi_log_warn("Error parsing address data");
 497             return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL);
 498         }
 499
 500         if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, 0, name, &a) < 0) {
 501             avahi_log_warn("Failed to add service: %s", name);
 502             return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL);
 503         }/*  else */
 504 /*             avahi_log_info("Successfully added address: %s -> %s", name, address); */
 505
 506         return respond_ok(c, m);
 507     }
 508
 509     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 510
 511 fail:
 512     if (dbus_error_is_set(&error))
 513         dbus_error_free(&error);
 514
 515     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 516 }
 517
 518 static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata) {
 519     HostNameResolverInfo *i = userdata;
 520     DBusMessage *reply;
 521
 522     g_assert(r);
 523     g_assert(host_name);
 524     g_assert(i);
 525
 526     if (event == AVAHI_RESOLVER_FOUND) {
 527         char t[256], *pt = t;
 528         gint32 i_interface, i_protocol, i_aprotocol;
 529
 530         g_assert(a);
 531         avahi_address_snprint(t, sizeof(t), a);
 532
 533         i_interface = (gint32) interface;
 534         i_protocol = (gint32) protocol;
 535         i_aprotocol = (gint32) a->family;
 536
 537         reply = dbus_message_new_method_return(i->message);
 538         dbus_message_append_args(
 539             reply,
 540             DBUS_TYPE_INT32, &i_interface,
 541             DBUS_TYPE_INT32, &i_protocol,
 542             DBUS_TYPE_STRING, &host_name,
 543             DBUS_TYPE_INT32, &i_aprotocol,
 544             DBUS_TYPE_STRING, &pt,
 545             DBUS_TYPE_INVALID);
 546
 547     } else {
 548         g_assert(event == AVAHI_RESOLVER_TIMEOUT);
 549         reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL);
 550     }
 551
 552     dbus_connection_send(server->bus, reply, NULL);
 553     dbus_message_unref(reply);
 554
 555     host_name_resolver_free(i);
 556 }
 557
 558 static void address_resolver_callback(AvahiAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const gchar *host_name, gpointer userdata) {
 559     AddressResolverInfo *i = userdata;
 560     DBusMessage *reply;
 561
 562     g_assert(r);
 563     g_assert(address);
 564     g_assert(i);
 565
 566     if (event == AVAHI_RESOLVER_FOUND) {
 567         char t[256], *pt = t;
 568         gint32 i_interface, i_protocol, i_aprotocol;
 569
 570         g_assert(host_name);
 571         avahi_address_snprint(t, sizeof(t), address);
 572
 573         i_interface = (gint32) interface;
 574         i_protocol = (gint32) protocol;
 575         i_aprotocol = (gint32) address->family;
 576
 577         reply = dbus_message_new_method_return(i->message);
 578         dbus_message_append_args(
 579             reply,
 580             DBUS_TYPE_INT32, &i_interface,
 581             DBUS_TYPE_INT32, &i_protocol,
 582             DBUS_TYPE_INT32, &i_aprotocol,
 583             DBUS_TYPE_STRING, &pt,
 584             DBUS_TYPE_STRING, &host_name,
 585             DBUS_TYPE_INVALID);
 586
 587     } else {
 588         g_assert(event == AVAHI_RESOLVER_TIMEOUT);
 589         reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL);
 590     }
 591
 592     dbus_connection_send(server->bus, reply, NULL);
 593     dbus_message_unref(reply);
 594
 595     address_resolver_free(i);
 596 }
 597
 598 static DBusHandlerResult msg_domain_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 599     DBusError error;
 600     DomainBrowserInfo *i = userdata;
 601
 602     g_assert(c);
 603     g_assert(m);
 604     g_assert(i);
 605
 606     dbus_error_init(&error);
 607
 608     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 609                     dbus_message_get_interface(m),
 610                     dbus_message_get_path(m),
 611                     dbus_message_get_member(m));
 612
 613     /* Access control */
 614     if (strcmp(dbus_message_get_sender(m), i->client->name))
 615         return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL);
 616
 617     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free")) {
 618
 619         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 620             avahi_log_warn("Error parsing DomainBrowser::Free message");
 621             goto fail;
 622         }
 623
 624         domain_browser_free(i);
 625         return respond_ok(c, m);
 626
 627     }
 628
 629     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 630
 631 fail:
 632     if (dbus_error_is_set(&error))
 633         dbus_error_free(&error);
 634
 635     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 636 }
 637
 638 static void domain_browser_callback(AvahiDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *domain, gpointer userdata) {
 639     DomainBrowserInfo *i = userdata;
 640     DBusMessage *m;
 641     gint32 i_interface, i_protocol;
 642
 643     g_assert(b);
 644     g_assert(domain);
 645     g_assert(i);
 646
 647     i_interface = (gint32) interface;
 648     i_protocol = (gint32) protocol;
 649
 650     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, event == AVAHI_BROWSER_NEW ? "ItemNew" : "ItemRemove");
 651     dbus_message_append_args(
 652         m,
 653         DBUS_TYPE_INT32, &i_interface,
 654         DBUS_TYPE_INT32, &i_protocol,
 655         DBUS_TYPE_STRING, &domain,
 656         DBUS_TYPE_INVALID);
 657     dbus_message_set_destination(m, i->client->name);
 658     dbus_connection_send(server->bus, m, NULL);
 659     dbus_message_unref(m);
 660 }
 661
 662 static DBusHandlerResult msg_service_type_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 663     DBusError error;
 664     ServiceTypeBrowserInfo *i = userdata;
 665
 666     g_assert(c);
 667     g_assert(m);
 668     g_assert(i);
 669
 670     dbus_error_init(&error);
 671
 672     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 673                     dbus_message_get_interface(m),
 674                     dbus_message_get_path(m),
 675                     dbus_message_get_member(m));
 676
 677     /* Access control */
 678     if (strcmp(dbus_message_get_sender(m), i->client->name))
 679         return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL);
 680
 681     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free")) {
 682
 683         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 684             avahi_log_warn("Error parsing ServiceTypeBrowser::Free message");
 685             goto fail;
 686         }
 687
 688         service_type_browser_free(i);
 689         return respond_ok(c, m);
 690
 691     }
 692
 693     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 694
 695 fail:
 696     if (dbus_error_is_set(&error))
 697         dbus_error_free(&error);
 698
 699     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 700 }
 701
 702 static void service_type_browser_callback(AvahiServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *type, const gchar *domain, gpointer userdata) {
 703     ServiceTypeBrowserInfo *i = userdata;
 704     DBusMessage *m;
 705     gint32 i_interface, i_protocol;
 706
 707     g_assert(b);
 708     g_assert(type);
 709     g_assert(domain);
 710     g_assert(i);
 711
 712     i_interface = (gint32) interface;
 713     i_protocol = (gint32) protocol;
 714
 715     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, event == AVAHI_BROWSER_NEW ? "ItemNew" : "ItemRemove");
 716     dbus_message_append_args(
 717         m,
 718         DBUS_TYPE_INT32, &i_interface,
 719         DBUS_TYPE_INT32, &i_protocol,
 720         DBUS_TYPE_STRING, &type,
 721         DBUS_TYPE_STRING, &domain,
 722         DBUS_TYPE_INVALID);
 723     dbus_message_set_destination(m, i->client->name);
 724     dbus_connection_send(server->bus, m, NULL);
 725     dbus_message_unref(m);
 726 }
 727
 728 static DBusHandlerResult msg_service_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 729     DBusError error;
 730     ServiceBrowserInfo *i = userdata;
 731
 732     g_assert(c);
 733     g_assert(m);
 734     g_assert(i);
 735
 736     dbus_error_init(&error);
 737
 738     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 739                     dbus_message_get_interface(m),
 740                     dbus_message_get_path(m),
 741                     dbus_message_get_member(m));
 742
 743     /* Access control */
 744     if (strcmp(dbus_message_get_sender(m), i->client->name))
 745         return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL);
 746
 747     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free")) {
 748
 749         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 750             avahi_log_warn("Error parsing ServiceBrowser::Free message");
 751             goto fail;
 752         }
 753
 754         service_browser_free(i);
 755         return respond_ok(c, m);
 756
 757     }
 758
 759     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 760
 761 fail:
 762     if (dbus_error_is_set(&error))
 763         dbus_error_free(&error);
 764
 765     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 766 }
 767
 768 static void service_browser_callback(AvahiServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const gchar *name, const gchar *type, const gchar *domain, gpointer userdata) {
 769     ServiceBrowserInfo *i = userdata;
 770     DBusMessage *m;
 771     gint32 i_interface, i_protocol;
 772
 773     g_assert(b);
 774     g_assert(name);
 775     g_assert(type);
 776     g_assert(domain);
 777     g_assert(i);
 778
 779     i_interface = (gint32) interface;
 780     i_protocol = (gint32) protocol;
 781
 782     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, event == AVAHI_BROWSER_NEW ? "ItemNew" : "ItemRemove");
 783     dbus_message_append_args(
 784         m,
 785         DBUS_TYPE_INT32, &i_interface,
 786         DBUS_TYPE_INT32, &i_protocol,
 787         DBUS_TYPE_STRING, &name,
 788         DBUS_TYPE_STRING, &type,
 789         DBUS_TYPE_STRING, &domain,
 790         DBUS_TYPE_INVALID);
 791     dbus_message_set_destination(m, i->client->name);
 792     dbus_connection_send(server->bus, m, NULL);
 793     dbus_message_unref(m);
 794 }
 795
 796 static void service_resolver_callback(
 797     AvahiServiceResolver *r,
 798     AvahiIfIndex interface,
 799     AvahiProtocol protocol,
 800     AvahiResolverEvent event,
 801     const gchar *name,
 802     const gchar *type,
 803     const gchar *domain,
 804     const gchar *host_name,
 805     const AvahiAddress *a,
 806     guint16 port,
 807     AvahiStringList *txt,
 808     gpointer userdata) {
 809
 810     ServiceResolverInfo *i = userdata;
 811     DBusMessage *reply;
 812
 813     g_assert(r);
 814     g_assert(host_name);
 815     g_assert(i);
 816
 817     if (event == AVAHI_RESOLVER_FOUND) {
 818         char t[256], *pt = t;
 819         gint32 i_interface, i_protocol, i_aprotocol;
 820         gchar **array;
 821         guint n, j;
 822         AvahiStringList *p;
 823
 824         g_assert(a);
 825         avahi_address_snprint(t, sizeof(t), a);
 826
 827         i_interface = (gint32) interface;
 828         i_protocol = (gint32) protocol;
 829         i_aprotocol = (gint32) a->family;
 830
 831         array = g_new(gchar*, (n = avahi_string_list_length(txt)));
 832
 833         /** FIXME: DBUS doesn't support strings that include NUL bytes (?) */
 834         for (p = txt, j = n-1; p; p = p->next, j--)
 835             array[j] = g_strndup((gchar*) p->text, p->size);
 836
 837         reply = dbus_message_new_method_return(i->message);
 838         dbus_message_append_args(
 839             reply,
 840             DBUS_TYPE_INT32, &i_interface,
 841             DBUS_TYPE_INT32, &i_protocol,
 842             DBUS_TYPE_STRING, &name,
 843             DBUS_TYPE_STRING, &type,
 844             DBUS_TYPE_STRING, &domain,
 845             DBUS_TYPE_STRING, &host_name,
 846             DBUS_TYPE_INT32, &i_aprotocol,
 847             DBUS_TYPE_STRING, &pt,
 848             DBUS_TYPE_UINT16, &port,
 849             DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &array, n,
 850             DBUS_TYPE_INVALID);
 851
 852         for (j = 0; j < n; j++)
 853             g_free(array[j]);
 854
 855     } else {
 856         g_assert(event == AVAHI_RESOLVER_TIMEOUT);
 857         reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL);
 858     }
 859
 860     dbus_connection_send(server->bus, reply, NULL);
 861     dbus_message_unref(reply);
 862
 863     service_resolver_free(i);
 864 }
 865
 866 static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 867     DBusError error;
 868
 869     dbus_error_init(&error);
 870
 871     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 872                     dbus_message_get_interface(m),
 873                     dbus_message_get_path(m),
 874                     dbus_message_get_member(m));
 875
 876     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) {
 877
 878         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 879             avahi_log_warn("Error parsing Server::GetHostName message");
 880             goto fail;
 881         }
 882
 883         return respond_string(c, m, avahi_server_get_host_name(avahi_server));
 884
 885     } if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetDomainName")) {
 886
 887         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 888             avahi_log_warn("Error parsing Server::GetDomainName message");
 889             goto fail;
 890         }
 891
 892         return respond_string(c, m, avahi_server_get_domain_name(avahi_server));
 893
 894     } if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) {
 895
 896         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
 897             avahi_log_warn("Error parsing Server::GetHostNameFqdn message");
 898             goto fail;
 899         }
 900
 901         return respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server));
 902
 903     } if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")) {
 904
 905         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
 906             avahi_log_warn("Error parsing Server::GetVersionString message");
 907             goto fail;
 908         }
 909
 910         return respond_string(c, m, PACKAGE_STRING);
 911
 912     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "EntryGroupNew")) {
 913         Client *client;
 914         EntryGroupInfo *i;
 915         static const DBusObjectPathVTable vtable = {
 916             NULL,
 917             msg_entry_group_impl,
 918             NULL,
 919             NULL,
 920             NULL,
 921             NULL
 922         };
 923
 924         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 925             avahi_log_warn("Error parsing Server::EntryGroupNew message");
 926             goto fail;
 927         }
 928
 929         client = client_get(dbus_message_get_sender(m), TRUE);
 930
 931         i = g_new(EntryGroupInfo, 1);
 932         i->id = ++client->current_id;
 933         i->client = client;
 934         i->path = g_strdup_printf("/org/freedesktop/Avahi/Client%u/EntryGroup%u", client->id, i->id);
 935         AVAHI_LLIST_PREPEND(EntryGroupInfo, entry_groups, client->entry_groups, i);
 936
 937         if (!(i->entry_group = avahi_entry_group_new(avahi_server, entry_group_callback, i))) {
 938             avahi_log_warn("Failed to create entry group");
 939             entry_group_free(i);
 940             goto fail;
 941         }
 942
 943         dbus_connection_register_object_path(c, i->path, &vtable, i);
 944         return respond_path(c, m, i->path);
 945
 946     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveHostName")) {
 947         Client *client;
 948         gint32 interface, protocol, aprotocol;
 949         gchar *name;
 950         HostNameResolverInfo *i;
 951
 952         if (!dbus_message_get_args(
 953                 m, &error,
 954                 DBUS_TYPE_INT32, &interface,
 955                 DBUS_TYPE_INT32, &protocol,
 956                 DBUS_TYPE_STRING, &name,
 957                 DBUS_TYPE_INT32, &aprotocol,
 958                 DBUS_TYPE_INVALID) || !name || !*name) {
 959             avahi_log_warn("Error parsing Server::ResolveHostName message");
 960             goto fail;
 961         }
 962
 963         client = client_get(dbus_message_get_sender(m), TRUE);
 964
 965         i = g_new(HostNameResolverInfo, 1);
 966         i->client = client;
 967         i->message = dbus_message_ref(m);
 968         AVAHI_LLIST_PREPEND(HostNameResolverInfo, host_name_resolvers, client->host_name_resolvers, i);
 969
 970         if (!(i->host_name_resolver = avahi_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, host_name_resolver_callback, i))) {
 971             host_name_resolver_free(i);
 972             avahi_log_warn("Failed to create host name resolver");
 973             goto fail;
 974         }
 975
 976         return DBUS_HANDLER_RESULT_HANDLED;
 977
 978     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveAddress")) {
 979         Client *client;
 980         gint32 interface, protocol;
 981         gchar *address;
 982         AddressResolverInfo *i;
 983         AvahiAddress a;
 984
 985         if (!dbus_message_get_args(
 986                 m, &error,
 987                 DBUS_TYPE_INT32, &interface,
 988                 DBUS_TYPE_INT32, &protocol,
 989                 DBUS_TYPE_STRING, &address,
 990                 DBUS_TYPE_INVALID) || !address || !*address) {
 991             avahi_log_warn("Error parsing Server::ResolveAddress message");
 992             goto fail;
 993         }
 994
 995         if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a)) {
 996             avahi_log_warn("Error parsing address data");
 997             return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL);
 998         }
 999
1000         client = client_get(dbus_message_get_sender(m), TRUE);
1001
1002         i = g_new(AddressResolverInfo, 1);
1003         i->client = client;
1004         i->message = dbus_message_ref(m);
1005
1006         AVAHI_LLIST_PREPEND(AddressResolverInfo, address_resolvers, client->address_resolvers, i);
1007
1008         if (!(i->address_resolver = avahi_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, address_resolver_callback, i))) {
1009             address_resolver_free(i);
1010             avahi_log_warn("Failed to create address resolver");
1011             goto fail;
1012         }
1013
1014         return DBUS_HANDLER_RESULT_HANDLED;
1015
1016     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew")) {
1017         Client *client;
1018         DomainBrowserInfo *i;
1019         static const DBusObjectPathVTable vtable = {
1020             NULL,
1021             msg_domain_browser_impl,
1022             NULL,
1023             NULL,
1024             NULL,
1025             NULL
1026         };
1027         gint32 interface, protocol, type;
1028         gchar *domain;
1029
1030
1031         if (!dbus_message_get_args(
1032                 m, &error,
1033                 DBUS_TYPE_INT32, &interface,
1034                 DBUS_TYPE_INT32, &protocol,
1035                 DBUS_TYPE_STRING, &domain,
1036                 DBUS_TYPE_INT32, &type,
1037                 DBUS_TYPE_INVALID) || type < 0 || type >= AVAHI_DOMAIN_BROWSER_MAX) {
1038             avahi_log_warn("Error parsing Server::DomainBrowserNew message");
1039             goto fail;
1040         }
1041
1042         client = client_get(dbus_message_get_sender(m), TRUE);
1043
1044         if (!*domain)
1045             domain = NULL;
1046
1047         i = g_new(DomainBrowserInfo, 1);
1048         i->id = ++client->current_id;
1049         i->client = client;
1050         i->path = g_strdup_printf("/org/freedesktop/Avahi/Client%u/DomainBrowser%u", client->id, i->id);
1051
1052         AVAHI_LLIST_PREPEND(DomainBrowserInfo, domain_browsers, client->domain_browsers, i);
1053
1054         if (!(i->domain_browser = avahi_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, domain_browser_callback, i))) {
1055             avahi_log_warn("Failed to create domain browser");
1056             domain_browser_free(i);
1057             goto fail;
1058         }
1059
1060         dbus_connection_register_object_path(c, i->path, &vtable, i);
1061         return respond_path(c, m, i->path);
1062
1063     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew")) {
1064         Client *client;
1065         ServiceTypeBrowserInfo *i;
1066         static const DBusObjectPathVTable vtable = {
1067             NULL,
1068             msg_service_type_browser_impl,
1069             NULL,
1070             NULL,
1071             NULL,
1072             NULL
1073         };
1074         gint32 interface, protocol;
1075         gchar *domain;
1076
1077         if (!dbus_message_get_args(
1078                 m, &error,
1079                 DBUS_TYPE_INT32, &interface,
1080                 DBUS_TYPE_INT32, &protocol,
1081                 DBUS_TYPE_STRING, &domain,
1082                 DBUS_TYPE_INVALID)) {
1083             avahi_log_warn("Error parsing Server::ServiceTypeBrowserNew message");
1084             goto fail;
1085         }
1086
1087         client = client_get(dbus_message_get_sender(m), TRUE);
1088
1089         if (!*domain)
1090             domain = NULL;
1091
1092         i = g_new(ServiceTypeBrowserInfo, 1);
1093         i->id = ++client->current_id;
1094         i->client = client;
1095         i->path = g_strdup_printf("/org/freedesktop/Avahi/Client%u/ServiceTypeBrowser%u", client->id, i->id);
1096
1097         AVAHI_LLIST_PREPEND(ServiceTypeBrowserInfo, service_type_browsers, client->service_type_browsers, i);
1098
1099         if (!(i->service_type_browser = avahi_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, service_type_browser_callback, i))) {
1100             avahi_log_warn("Failed to create service type browser");
1101             service_type_browser_free(i);
1102             goto fail;
1103         }
1104
1105         dbus_connection_register_object_path(c, i->path, &vtable, i);
1106         return respond_path(c, m, i->path);
1107
1108      } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew")) {
1109         Client *client;
1110         ServiceBrowserInfo *i;
1111         static const DBusObjectPathVTable vtable = {
1112             NULL,
1113             msg_service_browser_impl,
1114             NULL,
1115             NULL,
1116             NULL,
1117             NULL
1118         };
1119         gint32 interface, protocol;
1120         gchar *domain, *type;
1121
1122         if (!dbus_message_get_args(
1123                 m, &error,
1124                 DBUS_TYPE_INT32, &interface,
1125                 DBUS_TYPE_INT32, &protocol,
1126                 DBUS_TYPE_STRING, &type,
1127                 DBUS_TYPE_STRING, &domain,
1128                 DBUS_TYPE_INVALID) || !type || !*type) {
1129             avahi_log_warn("Error parsing Server::ServiceBrowserNew message");
1130             goto fail;
1131         }
1132
1133         client = client_get(dbus_message_get_sender(m), TRUE);
1134
1135         if (!*domain)
1136             domain = NULL;
1137
1138         i = g_new(ServiceBrowserInfo, 1);
1139         i->id = ++client->current_id;
1140         i->client = client;
1141         i->path = g_strdup_printf("/org/freedesktop/Avahi/Client%u/ServiceBrowser%u", client->id, i->id);
1142
1143         AVAHI_LLIST_PREPEND(ServiceBrowserInfo, service_browsers, client->service_browsers, i);
1144
1145         if (!(i->service_browser = avahi_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, service_browser_callback, i))) {
1146             avahi_log_warn("Failed to create service browser");
1147             service_browser_free(i);
1148             goto fail;
1149         }
1150
1151         dbus_connection_register_object_path(c, i->path, &vtable, i);
1152         return respond_path(c, m, i->path);
1153
1154     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveService")) {
1155         Client *client;
1156         gint32 interface, protocol, aprotocol;
1157         gchar *name, *type, *domain;
1158         ServiceResolverInfo *i;
1159
1160         if (!dbus_message_get_args(
1161                 m, &error,
1162                 DBUS_TYPE_INT32, &interface,
1163                 DBUS_TYPE_INT32, &protocol,
1164                 DBUS_TYPE_STRING, &name,
1165                 DBUS_TYPE_STRING, &type,
1166                 DBUS_TYPE_STRING, &domain,
1167                 DBUS_TYPE_INT32, &aprotocol,
1168                 DBUS_TYPE_INVALID) || !name || !*name || !type || !*type) {
1169             avahi_log_warn("Error parsing Server::ResolveService message");
1170             goto fail;
1171         }
1172
1173         client = client_get(dbus_message_get_sender(m), TRUE);
1174
1175         if (!*domain)
1176             domain = NULL;
1177
1178         i = g_new(ServiceResolverInfo, 1);
1179         i->client = client;
1180         i->message = dbus_message_ref(m);
1181         AVAHI_LLIST_PREPEND(ServiceResolverInfo, service_resolvers, client->service_resolvers, i);
1182
1183         if (!(i->service_resolver = avahi_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, service_resolver_callback, i))) {
1184             service_resolver_free(i);
1185             avahi_log_warn("Failed to create service resolver");
1186             goto fail;
1187         }
1188
1189         return DBUS_HANDLER_RESULT_HANDLED;
1190      }
1191
1192     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1193
1194
1195 fail:
1196     if (dbus_error_is_set(&error))
1197         dbus_error_free(&error);
1198
1199     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1200 }
1201
1202 void dbus_protocol_server_state_changed(AvahiServerState state) {
1203     DBusMessage *m;
1204     gint32 t;
1205
1206     if (!server)
1207         return;
1208
1209     m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged");
1210     t = (gint32) state;
1211     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
1212     dbus_connection_send(server->bus, m, NULL);
1213     dbus_message_unref(m);
1214 }
1215
1216 int dbus_protocol_setup(GMainLoop *loop) {
1217     DBusError error;
1218
1219     static const DBusObjectPathVTable server_vtable = {
1220         NULL,
1221         msg_server_impl,
1222         NULL,
1223         NULL,
1224         NULL,
1225         NULL
1226     };
1227
1228     dbus_error_init(&error);
1229
1230     server = g_malloc(sizeof(Server));
1231     server->clients = NULL;
1232     server->current_id = 0;
1233
1234     server->bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
1235     if (dbus_error_is_set(&error)) {
1236         avahi_log_warn("dbus_bus_get(): %s", error.message);
1237         goto fail;
1238     }
1239
1240     dbus_connection_setup_with_g_main(server->bus, NULL);
1241     dbus_connection_set_exit_on_disconnect(server->bus, FALSE);
1242
1243     dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, 0, &error);
1244     if (dbus_error_is_set(&error)) {
1245         avahi_log_warn("dbus_bus_request_name(): %s", error.message);
1246         goto fail;
1247     }
1248
1249     dbus_bus_add_match(server->bus, "type='signal',""interface='" DBUS_INTERFACE_DBUS  "'", &error);
1250
1251     dbus_connection_add_filter(server->bus, msg_signal_filter_impl, loop, NULL);
1252     dbus_connection_register_object_path(server->bus, AVAHI_DBUS_PATH_SERVER, &server_vtable, NULL);
1253
1254     return 0;
1255
1256 fail:
1257     if (server->bus) {
1258         dbus_connection_disconnect(server->bus);
1259         dbus_connection_unref(server->bus);
1260     }
1261
1262     dbus_error_free (&error);
1263     g_free(server);
1264     server = NULL;
1265     return -1;
1266 }
1267
1268 void dbus_protocol_shutdown(void) {
1269
1270     if (server) {
1271
1272         while (server->clients)
1273             client_free(server->clients);
1274
1275         if (server->bus) {
1276             dbus_connection_disconnect(server->bus);
1277             dbus_connection_unref(server->bus);
1278         }
1279
1280         g_free(server);
1281         server = NULL;
1282     }
1283 }