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
  37 #include "dbus-protocol.h"
  38 #include "main.h"
  39
  40 #define AVAHI_DBUS_NAME "org.freedesktop.Avahi"
  41 #define AVAHI_DBUS_INTERFACE_SERVER AVAHI_DBUS_NAME".Server"
  42 #define AVAHI_DBUS_PATH_SERVER "/org/freedesktop/Avahi/Server"
  43 #define AVAHI_DBUS_INTERFACE_ENTRY_GROUP AVAHI_DBUS_NAME".EntryGroup"
  44
  45 /* Needs wrapping:
  46    - AvahiServiceResolver
  47    - AvahiDomainBrowser
  48    - AvahiServiceTypeBrowser
  49    - AvahiServiceBrowser */
  50
  51 typedef struct Server Server;
  52 typedef struct Client Client;
  53 typedef struct EntryGroupInfo EntryGroupInfo;
  54 typedef struct HostNameResolverInfo HostNameResolverInfo;
  55 typedef struct AddressResolverInfo AddressResolverInfo;
  56
  57 struct EntryGroupInfo {
  58     guint id;
  59     Client *client;
  60     AvahiEntryGroup *entry_group;
  61     gchar *path;
  62
  63     AVAHI_LLIST_FIELDS(EntryGroupInfo, entry_groups);
  64 };
  65
  66 struct HostNameResolverInfo {
  67     Client *client;
  68     AvahiHostNameResolver *host_name_resolver;
  69     DBusMessage *message;
  70
  71     AVAHI_LLIST_FIELDS(HostNameResolverInfo, host_name_resolvers);
  72 };
  73
  74 struct AddressResolverInfo {
  75     Client *client;
  76     AvahiAddressResolver *address_resolver;
  77     DBusMessage *message;
  78
  79     AVAHI_LLIST_FIELDS(AddressResolverInfo, address_resolvers);
  80 };
  81
  82 struct Client {
  83     guint id;
  84     gchar *name;
  85     guint current_id;
  86
  87     AVAHI_LLIST_FIELDS(Client, clients);
  88     AVAHI_LLIST_HEAD(EntryGroupInfo, entry_groups);
  89     AVAHI_LLIST_HEAD(HostNameResolverInfo, host_name_resolvers);
  90     AVAHI_LLIST_HEAD(AddressResolverInfo, address_resolvers);
  91 };
  92
  93 struct Server {
  94     DBusConnection *bus;
  95     AVAHI_LLIST_HEAD(Client, clients);
  96     guint current_id;
  97 };
  98
  99 static Server *server = NULL;
 100
 101 static void entry_group_free(EntryGroupInfo *i) {
 102     g_assert(i);
 103
 104     avahi_entry_group_free(i->entry_group);
 105     dbus_connection_unregister_object_path(server->bus, i->path);
 106     g_free(i->path);
 107     AVAHI_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i);
 108     g_free(i);
 109  }
 110
 111 static void host_name_resolver_free(HostNameResolverInfo *i) {
 112     g_assert(i);
 113
 114     avahi_host_name_resolver_free(i->host_name_resolver);
 115     dbus_message_unref(i->message);
 116     AVAHI_LLIST_REMOVE(HostNameResolverInfo, host_name_resolvers, i->client->host_name_resolvers, i);
 117     g_free(i);
 118 }
 119
 120 static void address_resolver_free(AddressResolverInfo *i) {
 121     g_assert(i);
 122
 123     avahi_address_resolver_free(i->address_resolver);
 124     dbus_message_unref(i->message);
 125     AVAHI_LLIST_REMOVE(AddressResolverInfo, address_resolvers, i->client->address_resolvers, i);
 126     g_free(i);
 127 }
 128
 129 static void client_free(Client *c) {
 130
 131     g_assert(server);
 132     g_assert(c);
 133
 134     while (c->entry_groups)
 135         entry_group_free(c->entry_groups);
 136
 137     while (c->host_name_resolvers)
 138         host_name_resolver_free(c->host_name_resolvers);
 139
 140     while (c->address_resolvers)
 141         address_resolver_free(c->address_resolvers);
 142
 143     g_free(c->name);
 144     AVAHI_LLIST_REMOVE(Client, clients, server->clients, c);
 145     g_free(c);
 146 }
 147
 148 static Client *client_get(const gchar *name, gboolean create) {
 149     Client *client;
 150
 151     g_assert(server);
 152     g_assert(name);
 153
 154     for (client = server->clients; client; client = client->clients_next)
 155         if (!strcmp(name, client->name))
 156             return client;
 157
 158     if (!create)
 159         return NULL;
 160
 161     /* If not existant yet, create a new entry */
 162     client = g_new(Client, 1);
 163     client->id = server->current_id++;
 164     client->name = g_strdup(name);
 165     client->current_id = 0;
 166     AVAHI_LLIST_HEAD_INIT(EntryGroupInfo, client->entry_groups);
 167     AVAHI_LLIST_HEAD_INIT(HostNameResolverInfo, client->host_name_resolvers);
 168     AVAHI_LLIST_HEAD_INIT(AddressResolverInfo, client->address_resolvers);
 169
 170     AVAHI_LLIST_PREPEND(Client, clients, server->clients, client);
 171     return client;
 172 }
 173
 174 static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 175     GMainLoop *loop = userdata;
 176     DBusError error;
 177
 178     dbus_error_init(&error);
 179
 180 /*     avahi_log_debug("dbus: interface=%s, path=%s, member=%s", */
 181 /*                     dbus_message_get_interface(m), */
 182 /*                     dbus_message_get_path(m), */
 183 /*                     dbus_message_get_member(m)); */
 184
 185     if (dbus_message_is_signal(m, DBUS_INTERFACE_LOCAL, "Disconnected")) {
 186         /* No, we shouldn't quit, but until we get somewhere
 187          * usefull such that we can restore our state, we will */
 188         avahi_log_warn("Disconnnected from d-bus, terminating...");
 189         g_main_loop_quit (loop);
 190         return DBUS_HANDLER_RESULT_HANDLED;
 191
 192     } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameAcquired")) {
 193         gchar *name;
 194
 195         if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) {
 196             avahi_log_warn("Error parsing NameAcquired message");
 197             goto fail;
 198         }
 199
 200         avahi_log_info("dbus: name acquired (%s)", name);
 201         return DBUS_HANDLER_RESULT_HANDLED;
 202
 203     } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
 204         gchar *name, *old, *new;
 205
 206         if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID)) {
 207             avahi_log_warn("Error parsing NameOwnerChanged message");
 208             goto fail;
 209         }
 210
 211         if (!*new) {
 212             Client *client;
 213
 214             if ((client = client_get(name, FALSE))) {
 215                 avahi_log_info("dbus: client %s vanished", name);
 216                 client_free(client);
 217             }
 218         }
 219     }
 220
 221 fail:
 222     if (dbus_error_is_set(&error))
 223         dbus_error_free(&error);
 224
 225     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 226 }
 227
 228 static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, const gchar *error, const gchar *text) {
 229     DBusMessage *reply;
 230
 231     reply = dbus_message_new_error(m, error, text);
 232     dbus_connection_send(c, reply, NULL);
 233     dbus_message_unref(reply);
 234
 235     return DBUS_HANDLER_RESULT_HANDLED;
 236 }
 237
 238 static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *g, AvahiEntryGroupState state, gpointer userdata) {
 239     EntryGroupInfo *i = userdata;
 240     DBusMessage *m;
 241     gint32 t;
 242
 243     g_assert(s);
 244     g_assert(g);
 245     g_assert(i);
 246
 247     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged");
 248     t = (gint32) state;
 249     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
 250     dbus_message_set_destination(m, i->client->name);
 251     dbus_connection_send(server->bus, m, NULL);
 252     dbus_message_unref(m);
 253 }
 254
 255 static DBusHandlerResult respond_ok(DBusConnection *c, DBusMessage *m) {
 256     DBusMessage *reply;
 257
 258     reply = dbus_message_new_method_return(m);
 259     dbus_connection_send(c, reply, NULL);
 260     dbus_message_unref(reply);
 261
 262     return DBUS_HANDLER_RESULT_HANDLED;
 263 }
 264
 265 static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 266     DBusError error;
 267     EntryGroupInfo *i = userdata;
 268
 269     g_assert(c);
 270     g_assert(m);
 271     g_assert(i);
 272
 273     dbus_error_init(&error);
 274
 275     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 276                     dbus_message_get_interface(m),
 277                     dbus_message_get_path(m),
 278                     dbus_message_get_member(m));
 279
 280     /* Access control */
 281     if (strcmp(dbus_message_get_sender(m), i->client->name))
 282         return respond_error(c, m, DBUS_ERROR_ACCESS_DENIED, NULL);
 283
 284     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Free")) {
 285
 286         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 287             avahi_log_warn("Error parsing EntryGroup::Free message");
 288             goto fail;
 289         }
 290
 291         entry_group_free(i);
 292         return respond_ok(c, m);
 293
 294     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Commit")) {
 295
 296         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 297             avahi_log_warn("Error parsing EntryGroup::Commit message");
 298             goto fail;
 299         }
 300
 301         avahi_entry_group_commit(i->entry_group);
 302         return respond_ok(c, m);
 303
 304     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) {
 305         DBusMessage *reply;
 306         gint32 t;
 307
 308         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 309             avahi_log_warn("Error parsing EntryGroup::GetState message");
 310             goto fail;
 311         }
 312
 313         t = (gint32) avahi_entry_group_get_state(i->entry_group);
 314         reply = dbus_message_new_method_return(m);
 315         dbus_message_append_args(reply, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
 316         dbus_connection_send(c, reply, NULL);
 317         dbus_message_unref(reply);
 318
 319         return DBUS_HANDLER_RESULT_HANDLED;
 320
 321     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) {
 322         gint32 interface, protocol;
 323         gchar *type, *name, *domain, *host;
 324         guint16 port;
 325         gchar **txt = NULL;
 326         gint txt_len;
 327         AvahiStringList *strlst;
 328
 329         if (!dbus_message_get_args(
 330                 m, &error,
 331                 DBUS_TYPE_INT32, &interface,
 332                 DBUS_TYPE_INT32, &protocol,
 333                 DBUS_TYPE_STRING, &name,
 334                 DBUS_TYPE_STRING, &type,
 335                 DBUS_TYPE_STRING, &domain,
 336                 DBUS_TYPE_STRING, &host,
 337                 DBUS_TYPE_UINT16, &port,
 338                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &txt, &txt_len,
 339                 DBUS_TYPE_INVALID) || !type || !*type || !name || !*name || !port) {
 340             avahi_log_warn("Error parsing EntryGroup::AddService message");
 341             goto fail;
 342         }
 343
 344         strlst = avahi_string_list_new_from_array((const gchar**) txt, txt_len);
 345         dbus_free_string_array(txt);
 346
 347         if (domain && !*domain)
 348             domain = NULL;
 349
 350         if (host && !*host)
 351             host = NULL;
 352
 353         if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, host, port, strlst) < 0) {
 354             avahi_log_warn("Failed to add service: %s", name);
 355             return respond_error(c, m, "org.freedesktop.Avahi.InvalidServiceError", NULL);
 356         } else
 357             avahi_log_info("Successfully added service: %s", name);
 358
 359         return respond_ok(c, m);
 360
 361     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress")) {
 362         gint32 interface, protocol;
 363         gchar *name, *address;
 364         AvahiAddress a;
 365
 366         if (!dbus_message_get_args(
 367                 m, &error,
 368                 DBUS_TYPE_INT32, &interface,
 369                 DBUS_TYPE_INT32, &protocol,
 370                 DBUS_TYPE_STRING, &name,
 371                 DBUS_TYPE_STRING, &address,
 372                 DBUS_TYPE_INVALID) || !name || !*name || !address || !*address) {
 373             avahi_log_warn("Error parsing EntryGroup::AddAddress message");
 374             goto fail;
 375         }
 376
 377         if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))) {
 378             avahi_log_warn("Error parsing address data");
 379             return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL);
 380         }
 381
 382         if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, 0, name, &a) < 0) {
 383             avahi_log_warn("Failed to add service: %s", name);
 384             return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL);
 385         } else
 386             avahi_log_info("Successfully added address: %s -> %s", name, address);
 387
 388         return respond_ok(c, m);
 389     }
 390
 391     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 392
 393 fail:
 394     if (dbus_error_is_set(&error))
 395         dbus_error_free(&error);
 396
 397     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 398 }
 399
 400 static void host_name_resolver_callback(AvahiHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const gchar *host_name, const AvahiAddress *a, gpointer userdata) {
 401     HostNameResolverInfo *i = userdata;
 402     DBusMessage *reply;
 403
 404     g_assert(r);
 405     g_assert(host_name);
 406     g_assert(i);
 407
 408     if (event == AVAHI_RESOLVER_FOUND) {
 409         char t[256], *pt = t;
 410         gint32 i_interface, i_protocol, i_aprotocol;
 411
 412         g_assert(a);
 413         avahi_address_snprint(t, sizeof(t), a);
 414
 415         i_interface = (gint32) interface;
 416         i_protocol = (gint32) protocol;
 417         i_aprotocol = (gint32) a->family;
 418
 419         reply = dbus_message_new_method_return(i->message);
 420         dbus_message_append_args(
 421             reply,
 422             DBUS_TYPE_INT32, &i_interface,
 423             DBUS_TYPE_INT32, &i_protocol,
 424             DBUS_TYPE_STRING, &host_name,
 425             DBUS_TYPE_INT32, &i_aprotocol,
 426             DBUS_TYPE_STRING, &pt,
 427             DBUS_TYPE_INVALID);
 428
 429     } else {
 430         g_assert(event == AVAHI_RESOLVER_TIMEOUT);
 431         reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL);
 432     }
 433
 434     dbus_connection_send(server->bus, reply, NULL);
 435     dbus_message_unref(reply);
 436
 437     host_name_resolver_free(i);
 438 }
 439
 440 static void address_resolver_callback(AvahiAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const gchar *host_name, gpointer userdata) {
 441     AddressResolverInfo *i = userdata;
 442     DBusMessage *reply;
 443
 444     g_assert(r);
 445     g_assert(address);
 446     g_assert(i);
 447
 448     if (event == AVAHI_RESOLVER_FOUND) {
 449         char t[256], *pt = t;
 450         gint32 i_interface, i_protocol, i_aprotocol;
 451
 452         g_assert(host_name);
 453         avahi_address_snprint(t, sizeof(t), address);
 454
 455         i_interface = (gint32) interface;
 456         i_protocol = (gint32) protocol;
 457         i_aprotocol = (gint32) address->family;
 458
 459         reply = dbus_message_new_method_return(i->message);
 460         dbus_message_append_args(
 461             reply,
 462             DBUS_TYPE_INT32, &i_interface,
 463             DBUS_TYPE_INT32, &i_protocol,
 464             DBUS_TYPE_INT32, &i_aprotocol,
 465             DBUS_TYPE_STRING, &pt,
 466             DBUS_TYPE_STRING, &host_name,
 467             DBUS_TYPE_INVALID);
 468
 469     } else {
 470         g_assert(event == AVAHI_RESOLVER_TIMEOUT);
 471         reply = dbus_message_new_error(i->message, "org.freedesktop.Avahi.TimeoutError", NULL);
 472     }
 473
 474     dbus_connection_send(server->bus, reply, NULL);
 475     dbus_message_unref(reply);
 476
 477     address_resolver_free(i);
 478 }
 479
 480 static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const gchar *text) {
 481     DBusMessage *reply;
 482
 483     reply = dbus_message_new_method_return(m);
 484     dbus_message_append_args(reply, DBUS_TYPE_STRING, &text, DBUS_TYPE_INVALID);
 485     dbus_connection_send(c, reply, NULL);
 486     dbus_message_unref(reply);
 487
 488     return DBUS_HANDLER_RESULT_HANDLED;
 489 }
 490
 491 static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 492     DBusError error;
 493
 494     dbus_error_init(&error);
 495
 496     avahi_log_debug("dbus: interface=%s, path=%s, member=%s",
 497                     dbus_message_get_interface(m),
 498                     dbus_message_get_path(m),
 499                     dbus_message_get_member(m));
 500
 501     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) {
 502
 503         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 504             avahi_log_warn("Error parsing Server::GetHostName message");
 505             goto fail;
 506         }
 507
 508         return respond_string(c, m, avahi_server_get_host_name(avahi_server));
 509
 510     } if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetDomainName")) {
 511
 512         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 513             avahi_log_warn("Error parsing Server::GetDomainName message");
 514             goto fail;
 515         }
 516
 517         return respond_string(c, m, avahi_server_get_domain_name(avahi_server));
 518
 519     } if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) {
 520
 521         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
 522             avahi_log_warn("Error parsing Server::GetHostNameFqdn message");
 523             goto fail;
 524         }
 525
 526         return respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server));
 527
 528     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "EntryGroupNew")) {
 529         Client *client;
 530         EntryGroupInfo *i;
 531         static const DBusObjectPathVTable vtable = {
 532             NULL,
 533             msg_entry_group_impl,
 534             NULL,
 535             NULL,
 536             NULL,
 537             NULL
 538         };
 539         DBusMessage *reply;
 540
 541         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 542             avahi_log_warn("Error parsing Server::EntryGroupNew message");
 543             goto fail;
 544         }
 545
 546         client = client_get(dbus_message_get_sender(m), TRUE);
 547
 548         i = g_new(EntryGroupInfo, 1);
 549         i->id = ++client->current_id;
 550         i->client = client;
 551         i->entry_group = avahi_entry_group_new(avahi_server, entry_group_callback, i);
 552         i->path = g_strdup_printf("/org/freedesktop/Avahi/Client%u/EntryGroup%u", client->id, i->id);
 553
 554         AVAHI_LLIST_PREPEND(EntryGroupInfo, entry_groups, client->entry_groups, i);
 555
 556         dbus_connection_register_object_path(c, i->path, &vtable, i);
 557         reply = dbus_message_new_method_return(m);
 558         dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &i->path, DBUS_TYPE_INVALID);
 559         dbus_connection_send(c, reply, NULL);
 560         dbus_message_unref(reply);
 561
 562         return DBUS_HANDLER_RESULT_HANDLED;
 563
 564     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveHostName")) {
 565         Client *client;
 566         gint32 interface, protocol, aprotocol;
 567         gchar *name;
 568         HostNameResolverInfo *i;
 569
 570         if (!dbus_message_get_args(
 571                 m, &error,
 572                 DBUS_TYPE_INT32, &interface,
 573                 DBUS_TYPE_INT32, &protocol,
 574                 DBUS_TYPE_STRING, &name,
 575                 DBUS_TYPE_INT32, &aprotocol,
 576                 DBUS_TYPE_INVALID) || !name || !*name) {
 577             avahi_log_warn("Error parsing EntryGroup::ResolveHostName message");
 578             goto fail;
 579         }
 580
 581         client = client_get(dbus_message_get_sender(m), TRUE);
 582
 583         i = g_new(HostNameResolverInfo, 1);
 584         i->client = client;
 585         i->message = dbus_message_ref(m);
 586         i->host_name_resolver = avahi_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, host_name_resolver_callback, i);
 587
 588         AVAHI_LLIST_PREPEND(HostNameResolverInfo, host_name_resolvers, client->host_name_resolvers, i);
 589
 590         return DBUS_HANDLER_RESULT_HANDLED;
 591
 592     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveAddress")) {
 593         Client *client;
 594         gint32 interface, protocol;
 595         gchar *address;
 596         AddressResolverInfo *i;
 597         AvahiAddress a;
 598
 599         if (!dbus_message_get_args(
 600                 m, &error,
 601                 DBUS_TYPE_INT32, &interface,
 602                 DBUS_TYPE_INT32, &protocol,
 603                 DBUS_TYPE_STRING, &address,
 604                 DBUS_TYPE_INVALID) || !address || !*address) {
 605             avahi_log_warn("Error parsing EntryGroup::ResolveAddress message");
 606             goto fail;
 607         }
 608
 609         if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a)) {
 610             avahi_log_warn("Error parsing address data");
 611             return respond_error(c, m, "org.freedesktop.Avahi.InvalidAddressError", NULL);
 612         }
 613
 614         client = client_get(dbus_message_get_sender(m), TRUE);
 615
 616         i = g_new(AddressResolverInfo, 1);
 617         i->client = client;
 618         i->message = dbus_message_ref(m);
 619         i->address_resolver = avahi_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, address_resolver_callback, i);
 620
 621         AVAHI_LLIST_PREPEND(AddressResolverInfo, address_resolvers, client->address_resolvers, i);
 622
 623         return DBUS_HANDLER_RESULT_HANDLED;
 624     }
 625
 626     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 627
 628
 629 fail:
 630     if (dbus_error_is_set(&error))
 631         dbus_error_free(&error);
 632
 633     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 634 }
 635
 636 void dbus_protocol_server_state_changed(AvahiServerState state) {
 637     DBusMessage *m;
 638     gint32 t;
 639
 640     if (!server)
 641         return;
 642
 643     m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged");
 644     t = (gint32) state;
 645     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
 646     dbus_connection_send(server->bus, m, NULL);
 647     dbus_message_unref(m);
 648 }
 649
 650 int dbus_protocol_setup(GMainLoop *loop) {
 651     DBusError error;
 652
 653     static const DBusObjectPathVTable server_vtable = {
 654         NULL,
 655         msg_server_impl,
 656         NULL,
 657         NULL,
 658         NULL,
 659         NULL
 660     };
 661
 662     dbus_error_init(&error);
 663
 664     server = g_malloc(sizeof(Server));
 665     server->clients = NULL;
 666     server->current_id = 0;
 667
 668     server->bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
 669     if (dbus_error_is_set(&error)) {
 670         avahi_log_warn("dbus_bus_get(): %s", error.message);
 671         goto fail;
 672     }
 673
 674     dbus_connection_setup_with_g_main(server->bus, NULL);
 675     dbus_connection_set_exit_on_disconnect(server->bus, FALSE);
 676
 677     dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, 0, &error);
 678     if (dbus_error_is_set(&error)) {
 679         avahi_log_warn("dbus_bus_request_name(): %s", error.message);
 680         goto fail;
 681     }
 682
 683     dbus_bus_add_match(server->bus, "type='signal',""interface='" DBUS_INTERFACE_DBUS  "'", &error);
 684
 685     dbus_connection_add_filter(server->bus, msg_signal_filter_impl, loop, NULL);
 686     dbus_connection_register_object_path(server->bus, AVAHI_DBUS_PATH_SERVER, &server_vtable, NULL);
 687
 688     return 0;
 689
 690 fail:
 691     if (server->bus) {
 692         dbus_connection_disconnect(server->bus);
 693         dbus_connection_unref(server->bus);
 694     }
 695
 696     dbus_error_free (&error);
 697     g_free(server);
 698     server = NULL;
 699     return -1;
 700 }
 701
 702 void dbus_protocol_shutdown(void) {
 703
 704     if (server) {
 705
 706         while (server->clients)
 707             client_free(server->clients);
 708
 709         if (server->bus) {
 710             dbus_connection_disconnect(server->bus);
 711             dbus_connection_unref(server->bus);
 712         }
 713
 714         g_free(server);
 715         server = NULL;
 716     }
 717 }