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 <string.h>
  27 #include <sys/ioctl.h>
  28 #include <net/if.h>
  29 #include <errno.h>
  30 #include <unistd.h>
  31 #include <assert.h>
  32 #include <sys/stat.h>
  33 #include <fcntl.h>
  34 #include <stdio.h>
  35 #include <signal.h>
  36 #include <stdlib.h>
  37
  38 #include <dbus/dbus.h>
  39
  40 #include <avahi-common/dbus.h>
  41 #include <avahi-common/llist.h>
  42 #include <avahi-common/malloc.h>
  43 #include <avahi-common/dbus.h>
  44 #include <avahi-common/dbus-watch-glue.h>
  45 #include <avahi-common/alternative.h>
  46 #include <avahi-common/error.h>
  47
  48 #include <avahi-core/log.h>
  49 #include <avahi-core/core.h>
  50 #include <avahi-core/lookup.h>
  51 #include <avahi-core/publish.h>
  52
  53 #include "dbus-protocol.h"
  54 #include "main.h"
  55
  56 typedef struct Server Server;
  57 typedef struct Client Client;
  58 typedef struct EntryGroupInfo EntryGroupInfo;
  59 typedef struct SyncHostNameResolverInfo SyncHostNameResolverInfo;
  60 typedef struct AsyncHostNameResolverInfo AsyncHostNameResolverInfo;
  61 typedef struct SyncAddressResolverInfo SyncAddressResolverInfo;
  62 typedef struct AsyncAddressResolverInfo AsyncAddressResolverInfo;
  63 typedef struct DomainBrowserInfo DomainBrowserInfo;
  64 typedef struct ServiceTypeBrowserInfo ServiceTypeBrowserInfo;
  65 typedef struct ServiceBrowserInfo ServiceBrowserInfo;
  66 typedef struct SyncServiceResolverInfo SyncServiceResolverInfo;
  67 typedef struct AsyncServiceResolverInfo AsyncServiceResolverInfo;
  68
  69 #define MAX_CLIENTS 20
  70 #define MAX_OBJECTS_PER_CLIENT 50
  71 #define MAX_ENTRIES_PER_ENTRY_GROUP 20
  72
  73 /* #define VALGRIND_WORKAROUND 1 */
  74
  75 struct EntryGroupInfo {
  76     unsigned id;
  77     Client *client;
  78     AvahiSEntryGroup *entry_group;
  79     char *path;
  80
  81     int n_entries;
  82
  83     AVAHI_LLIST_FIELDS(EntryGroupInfo, entry_groups);
  84 };
  85
  86 struct SyncHostNameResolverInfo {
  87     Client *client;
  88     AvahiSHostNameResolver *host_name_resolver;
  89     DBusMessage *message;
  90
  91     AVAHI_LLIST_FIELDS(SyncHostNameResolverInfo, sync_host_name_resolvers);
  92 };
  93
  94 struct AsyncHostNameResolverInfo {
  95     unsigned id;
  96     Client *client;
  97     AvahiSHostNameResolver *host_name_resolver;
  98     char *path;
  99
 100     AVAHI_LLIST_FIELDS(AsyncHostNameResolverInfo, async_host_name_resolvers);
 101 };
 102
 103 struct SyncAddressResolverInfo {
 104     Client *client;
 105     AvahiSAddressResolver *address_resolver;
 106     DBusMessage *message;
 107
 108     AVAHI_LLIST_FIELDS(SyncAddressResolverInfo, sync_address_resolvers);
 109 };
 110
 111 struct AsyncAddressResolverInfo {
 112     unsigned id;
 113     Client *client;
 114     AvahiSAddressResolver *address_resolver;
 115     char *path;
 116
 117     AVAHI_LLIST_FIELDS(AsyncAddressResolverInfo, async_address_resolvers);
 118 };
 119
 120 struct DomainBrowserInfo {
 121     unsigned id;
 122     Client *client;
 123     AvahiSDomainBrowser *domain_browser;
 124     char *path;
 125
 126     AVAHI_LLIST_FIELDS(DomainBrowserInfo, domain_browsers);
 127 };
 128
 129 struct ServiceTypeBrowserInfo {
 130     unsigned id;
 131     Client *client;
 132     AvahiSServiceTypeBrowser *service_type_browser;
 133     char *path;
 134
 135     AVAHI_LLIST_FIELDS(ServiceTypeBrowserInfo, service_type_browsers);
 136 };
 137
 138 struct ServiceBrowserInfo {
 139     unsigned id;
 140     Client *client;
 141     AvahiSServiceBrowser *service_browser;
 142     char *path;
 143
 144     AVAHI_LLIST_FIELDS(ServiceBrowserInfo, service_browsers);
 145 };
 146
 147 struct SyncServiceResolverInfo {
 148     Client *client;
 149     AvahiSServiceResolver *service_resolver;
 150     DBusMessage *message;
 151
 152     AVAHI_LLIST_FIELDS(SyncServiceResolverInfo, sync_service_resolvers);
 153 };
 154
 155 struct AsyncServiceResolverInfo {
 156     unsigned id;
 157     Client *client;
 158     AvahiSServiceResolver *service_resolver;
 159     char *path;
 160
 161     AVAHI_LLIST_FIELDS(AsyncServiceResolverInfo, async_service_resolvers);
 162 };
 163
 164 struct Client {
 165     unsigned id;
 166     char *name;
 167     unsigned current_id;
 168     int n_objects;
 169
 170     AVAHI_LLIST_FIELDS(Client, clients);
 171     AVAHI_LLIST_HEAD(EntryGroupInfo, entry_groups);
 172     AVAHI_LLIST_HEAD(SyncHostNameResolverInfo, sync_host_name_resolvers);
 173     AVAHI_LLIST_HEAD(AsyncHostNameResolverInfo, async_host_name_resolvers);
 174     AVAHI_LLIST_HEAD(SyncAddressResolverInfo, sync_address_resolvers);
 175     AVAHI_LLIST_HEAD(AsyncAddressResolverInfo, async_address_resolvers);
 176     AVAHI_LLIST_HEAD(DomainBrowserInfo, domain_browsers);
 177     AVAHI_LLIST_HEAD(ServiceTypeBrowserInfo, service_type_browsers);
 178     AVAHI_LLIST_HEAD(ServiceBrowserInfo, service_browsers);
 179     AVAHI_LLIST_HEAD(SyncServiceResolverInfo, sync_service_resolvers);
 180     AVAHI_LLIST_HEAD(AsyncServiceResolverInfo, async_service_resolvers);
 181 };
 182
 183 struct Server {
 184     DBusConnection *bus;
 185     AVAHI_LLIST_HEAD(Client, clients);
 186     int n_clients;
 187     unsigned current_id;
 188 };
 189
 190 static Server *server = NULL;
 191
 192 static void entry_group_free(EntryGroupInfo *i) {
 193     assert(i);
 194
 195     if (i->entry_group)
 196         avahi_s_entry_group_free(i->entry_group);
 197     dbus_connection_unregister_object_path(server->bus, i->path);
 198     avahi_free(i->path);
 199     AVAHI_LLIST_REMOVE(EntryGroupInfo, entry_groups, i->client->entry_groups, i);
 200
 201     i->client->n_objects--;
 202     assert(i->client->n_objects >= 0);
 203
 204     avahi_free(i);
 205 }
 206
 207 static void sync_host_name_resolver_free(SyncHostNameResolverInfo *i) {
 208     assert(i);
 209
 210     if (i->host_name_resolver)
 211         avahi_s_host_name_resolver_free(i->host_name_resolver);
 212     dbus_message_unref(i->message);
 213     AVAHI_LLIST_REMOVE(SyncHostNameResolverInfo, sync_host_name_resolvers, i->client->sync_host_name_resolvers, i);
 214
 215     i->client->n_objects--;
 216     assert(i->client->n_objects >= 0);
 217
 218     avahi_free(i);
 219 }
 220
 221 static void async_host_name_resolver_free(AsyncHostNameResolverInfo *i) {
 222     assert(i);
 223
 224     if (i->host_name_resolver)
 225         avahi_s_host_name_resolver_free(i->host_name_resolver);
 226     dbus_connection_unregister_object_path(server->bus, i->path);
 227     AVAHI_LLIST_REMOVE(AsyncHostNameResolverInfo, async_host_name_resolvers, i->client->async_host_name_resolvers, i);
 228
 229     i->client->n_objects--;
 230     assert(i->client->n_objects >= 0);
 231
 232     avahi_free(i);
 233 }
 234
 235 static void sync_address_resolver_free(SyncAddressResolverInfo *i) {
 236     assert(i);
 237
 238     if (i->address_resolver)
 239         avahi_s_address_resolver_free(i->address_resolver);
 240     dbus_message_unref(i->message);
 241     AVAHI_LLIST_REMOVE(SyncAddressResolverInfo, sync_address_resolvers, i->client->sync_address_resolvers, i);
 242
 243     i->client->n_objects--;
 244     assert(i->client->n_objects >= 0);
 245
 246     avahi_free(i);
 247 }
 248
 249 static void async_address_resolver_free(AsyncAddressResolverInfo *i) {
 250     assert(i);
 251
 252     if (i->address_resolver)
 253         avahi_s_address_resolver_free(i->address_resolver);
 254     dbus_connection_unregister_object_path(server->bus, i->path);
 255     AVAHI_LLIST_REMOVE(AsyncAddressResolverInfo, async_address_resolvers, i->client->async_address_resolvers, i);
 256
 257     i->client->n_objects--;
 258     assert(i->client->n_objects >= 0);
 259
 260     avahi_free(i);
 261 }
 262
 263 static void domain_browser_free(DomainBrowserInfo *i) {
 264     assert(i);
 265
 266     if (i->domain_browser)
 267         avahi_s_domain_browser_free(i->domain_browser);
 268     dbus_connection_unregister_object_path(server->bus, i->path);
 269     avahi_free(i->path);
 270     AVAHI_LLIST_REMOVE(DomainBrowserInfo, domain_browsers, i->client->domain_browsers, i);
 271
 272     i->client->n_objects--;
 273     assert(i->client->n_objects >= 0);
 274
 275     avahi_free(i);
 276 }
 277
 278 static void service_type_browser_free(ServiceTypeBrowserInfo *i) {
 279     assert(i);
 280
 281     if (i->service_type_browser)
 282         avahi_s_service_type_browser_free(i->service_type_browser);
 283     dbus_connection_unregister_object_path(server->bus, i->path);
 284     avahi_free(i->path);
 285     AVAHI_LLIST_REMOVE(ServiceTypeBrowserInfo, service_type_browsers, i->client->service_type_browsers, i);
 286
 287     i->client->n_objects--;
 288     assert(i->client->n_objects >= 0);
 289
 290     avahi_free(i);
 291 }
 292
 293 static void service_browser_free(ServiceBrowserInfo *i) {
 294     assert(i);
 295
 296     if (i->service_browser)
 297         avahi_s_service_browser_free(i->service_browser);
 298     dbus_connection_unregister_object_path(server->bus, i->path);
 299     avahi_free(i->path);
 300     AVAHI_LLIST_REMOVE(ServiceBrowserInfo, service_browsers, i->client->service_browsers, i);
 301
 302     i->client->n_objects--;
 303     assert(i->client->n_objects >= 0);
 304
 305     avahi_free(i);
 306 }
 307
 308 static void sync_service_resolver_free(SyncServiceResolverInfo *i) {
 309     assert(i);
 310
 311     if (i->service_resolver)
 312         avahi_s_service_resolver_free(i->service_resolver);
 313     dbus_message_unref(i->message);
 314     AVAHI_LLIST_REMOVE(SyncServiceResolverInfo, sync_service_resolvers, i->client->sync_service_resolvers, i);
 315
 316     i->client->n_objects--;
 317     assert(i->client->n_objects >= 0);
 318
 319     avahi_free(i);
 320 }
 321
 322 static void async_service_resolver_free(AsyncServiceResolverInfo *i) {
 323     assert(i);
 324
 325     if (i->service_resolver)
 326         avahi_s_service_resolver_free(i->service_resolver);
 327
 328     dbus_connection_unregister_object_path(server->bus, i->path);
 329     AVAHI_LLIST_REMOVE(AsyncServiceResolverInfo, async_service_resolvers, i->client->async_service_resolvers, i);
 330
 331     i->client->n_objects--;
 332     assert(i->client->n_objects >= 0);
 333
 334     avahi_free(i);
 335 }
 336
 337 static void client_free(Client *c) {
 338
 339     assert(server);
 340     assert(c);
 341
 342     while (c->entry_groups)
 343         entry_group_free(c->entry_groups);
 344
 345     while (c->sync_host_name_resolvers)
 346         sync_host_name_resolver_free(c->sync_host_name_resolvers);
 347
 348     while (c->async_host_name_resolvers)
 349         async_host_name_resolver_free(c->async_host_name_resolvers);
 350
 351     while (c->sync_address_resolvers)
 352         sync_address_resolver_free(c->sync_address_resolvers);
 353
 354     while (c->async_address_resolvers)
 355         async_address_resolver_free(c->async_address_resolvers);
 356
 357     while (c->domain_browsers)
 358         domain_browser_free(c->domain_browsers);
 359
 360     while (c->service_type_browsers)
 361         service_type_browser_free(c->service_type_browsers);
 362
 363     while (c->service_browsers)
 364         service_browser_free(c->service_browsers);
 365
 366     while (c->sync_service_resolvers)
 367         sync_service_resolver_free(c->sync_service_resolvers);
 368
 369     while (c->async_service_resolvers)
 370         async_service_resolver_free(c->async_service_resolvers);
 371
 372     assert(c->n_objects == 0);
 373
 374     avahi_free(c->name);
 375     AVAHI_LLIST_REMOVE(Client, clients, server->clients, c);
 376     avahi_free(c);
 377
 378     server->n_clients --;
 379     assert(server->n_clients >= 0);
 380 }
 381
 382 static Client *client_get(const char *name, int create) {
 383     Client *client;
 384
 385     assert(server);
 386     assert(name);
 387
 388     for (client = server->clients; client; client = client->clients_next)
 389         if (!strcmp(name, client->name))
 390             return client;
 391
 392     if (!create)
 393         return NULL;
 394
 395     if (server->n_clients >= MAX_CLIENTS)
 396         return NULL;
 397
 398     /* If not existant yet, create a new entry */
 399     client = avahi_new(Client, 1);
 400     client->id = server->current_id++;
 401     client->name = avahi_strdup(name);
 402     client->current_id = 0;
 403     client->n_objects = 0;
 404
 405     AVAHI_LLIST_HEAD_INIT(EntryGroupInfo, client->entry_groups);
 406     AVAHI_LLIST_HEAD_INIT(SyncHostNameResolverInfo, client->sync_host_name_resolvers);
 407     AVAHI_LLIST_HEAD_INIT(AsyncHostNameResolverInfo, client->async_host_name_resolvers);
 408     AVAHI_LLIST_HEAD_INIT(SyncAddressResolverInfo, client->sync_address_resolvers);
 409     AVAHI_LLIST_HEAD_INIT(AsyncAddressResolverInfo, client->async_address_resolvers);
 410     AVAHI_LLIST_HEAD_INIT(DomainBrowserInfo, client->domain_browsers);
 411     AVAHI_LLIST_HEAD_INIT(ServiceTypeBrowserInfo, client->service_type_browsers);
 412     AVAHI_LLIST_HEAD_INIT(ServiceBrowserInfo, client->service_browsers);
 413     AVAHI_LLIST_HEAD_INIT(SyncServiceResolverInfo, client->sync_service_resolvers);
 414     AVAHI_LLIST_HEAD_INIT(AsyncServiceResolverInfo, client->async_service_resolvers);
 415
 416     AVAHI_LLIST_PREPEND(Client, clients, server->clients, client);
 417
 418     server->n_clients++;
 419     assert(server->n_clients > 0);
 420
 421     return client;
 422 }
 423
 424 static DBusHandlerResult respond_error(DBusConnection *c, DBusMessage *m, int error, const char *text) {
 425     DBusMessage *reply;
 426
 427     assert(-error > -AVAHI_OK);
 428     assert(-error < -AVAHI_ERR_MAX);
 429
 430     if (!text)
 431         text = avahi_strerror(error);
 432
 433     reply = dbus_message_new_error(m, avahi_error_number_to_dbus(error), text);
 434     dbus_connection_send(c, reply, NULL);
 435     dbus_message_unref(reply);
 436
 437     avahi_log_debug(__FILE__": Responding error '%s' (%i)", text, error);
 438
 439     return DBUS_HANDLER_RESULT_HANDLED;
 440 }
 441
 442 static DBusHandlerResult respond_string(DBusConnection *c, DBusMessage *m, const char *text) {
 443     DBusMessage *reply;
 444
 445     reply = dbus_message_new_method_return(m);
 446     dbus_message_append_args(reply, DBUS_TYPE_STRING, &text, DBUS_TYPE_INVALID);
 447     dbus_connection_send(c, reply, NULL);
 448     dbus_message_unref(reply);
 449
 450     return DBUS_HANDLER_RESULT_HANDLED;
 451 }
 452
 453 static DBusHandlerResult respond_int32(DBusConnection *c, DBusMessage *m, int32_t i) {
 454     DBusMessage *reply;
 455
 456     reply = dbus_message_new_method_return(m);
 457     dbus_message_append_args(reply, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID);
 458     dbus_connection_send(c, reply, NULL);
 459     dbus_message_unref(reply);
 460
 461     return DBUS_HANDLER_RESULT_HANDLED;
 462 }
 463
 464 static DBusHandlerResult respond_uint32(DBusConnection *c, DBusMessage *m, uint32_t u) {
 465     DBusMessage *reply;
 466
 467     reply = dbus_message_new_method_return(m);
 468     dbus_message_append_args(reply, DBUS_TYPE_UINT32, &u, DBUS_TYPE_INVALID);
 469     dbus_connection_send(c, reply, NULL);
 470     dbus_message_unref(reply);
 471
 472     return DBUS_HANDLER_RESULT_HANDLED;
 473 }
 474
 475 static DBusHandlerResult respond_boolean(DBusConnection *c, DBusMessage *m, int b) {
 476     DBusMessage *reply;
 477
 478     reply = dbus_message_new_method_return(m);
 479     dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID);
 480     dbus_connection_send(c, reply, NULL);
 481     dbus_message_unref(reply);
 482
 483     return DBUS_HANDLER_RESULT_HANDLED;
 484 }
 485
 486 static DBusHandlerResult respond_ok(DBusConnection *c, DBusMessage *m) {
 487     DBusMessage *reply;
 488
 489     reply = dbus_message_new_method_return(m);
 490     dbus_connection_send(c, reply, NULL);
 491     dbus_message_unref(reply);
 492
 493     return DBUS_HANDLER_RESULT_HANDLED;
 494 }
 495
 496 static DBusHandlerResult respond_path(DBusConnection *c, DBusMessage *m, const char *path) {
 497     DBusMessage *reply;
 498
 499     reply = dbus_message_new_method_return(m);
 500     dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
 501     dbus_connection_send(c, reply, NULL);
 502     dbus_message_unref(reply);
 503
 504     return DBUS_HANDLER_RESULT_HANDLED;
 505 }
 506
 507 static void append_server_error(DBusMessage *reply) {
 508     const char *t;
 509
 510     t = avahi_error_number_to_dbus(avahi_server_errno(avahi_server));
 511
 512     dbus_message_append_args(
 513         reply,
 514         DBUS_TYPE_STRING, &t,
 515         DBUS_TYPE_INVALID);
 516 }
 517
 518 static char *file_get_contents(char *fname) {
 519     int fd = -1;
 520     struct stat st;
 521     ssize_t size;
 522     char *buf = NULL;
 523
 524     assert(fname);
 525
 526     if (!(fd = open(fname, O_RDONLY))) {
 527         avahi_log_error("Failed to open %s: %s", fname, strerror(errno));
 528         goto fail;
 529     }
 530
 531     if (fstat(fd, &st) < 0) {
 532         avahi_log_error("stat(%s) failed: %s", fname, strerror(errno));
 533         goto fail;
 534     }
 535
 536     if (!(S_ISREG(st.st_mode))) {
 537         avahi_log_error("Invalid file %s", fname);
 538         goto fail;
 539     }
 540
 541     if (st.st_size > 1024*1024) { /** 1MB */
 542         avahi_log_error("File too large %s", fname);
 543         goto fail;
 544     }
 545
 546     buf = avahi_new(char, st.st_size+1);
 547
 548     if ((size = read(fd, buf, st.st_size)) < 0) {
 549         avahi_log_error("read() failed: %s\n", strerror(errno));
 550         goto fail;
 551     }
 552
 553     buf[size] = 0;
 554
 555     close(fd);
 556     return buf;
 557
 558 fail:
 559     if (fd >= 0)
 560         close(fd);
 561
 562     if (buf)
 563         avahi_free(buf);
 564
 565     return NULL;
 566
 567 }
 568
 569 static const char *map_browse_signal_name(AvahiBrowserEvent e) {
 570     switch (e) {
 571         case AVAHI_BROWSER_NEW : return "ItemNew";
 572         case AVAHI_BROWSER_REMOVE : return "ItemRemove";
 573         case AVAHI_BROWSER_FAILURE : return "Failure";
 574         case AVAHI_BROWSER_CACHE_EXHAUSTED : return "CacheExhausted";
 575         case AVAHI_BROWSER_ALL_FOR_NOW : return "AllForNow";
 576     }
 577
 578     abort();
 579 }
 580
 581 static const char *map_resolve_signal_name(AvahiResolverEvent e) {
 582     switch (e) {
 583         case AVAHI_RESOLVER_FOUND : return "Found";
 584         case AVAHI_RESOLVER_FAILURE : return "Failure";
 585     }
 586
 587     abort();
 588 }
 589
 590
 591 static DBusHandlerResult handle_introspect(DBusConnection *c, DBusMessage *m, const char *fname) {
 592     char *path, *contents;
 593     DBusError error;
 594
 595     assert(c);
 596     assert(m);
 597     assert(fname);
 598
 599     dbus_error_init(&error);
 600
 601     if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 602         avahi_log_error("Error parsing Introspect message: %s", error.message);
 603         goto fail;
 604     }
 605
 606     path = avahi_strdup_printf("%s/%s", AVAHI_DBUS_INTROSPECTION_DIR, fname);
 607     contents = file_get_contents(path);
 608     avahi_free(path);
 609
 610     if (!contents) {
 611         avahi_log_error("Failed to load introspection data.");
 612         goto fail;
 613     }
 614
 615     respond_string(c, m, contents);
 616     avahi_free(contents);
 617
 618     return DBUS_HANDLER_RESULT_HANDLED;
 619
 620 fail:
 621     if (dbus_error_is_set(&error))
 622         dbus_error_free(&error);
 623
 624     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 625
 626 }
 627
 628 static DBusHandlerResult msg_signal_filter_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 629     DBusError error;
 630
 631     dbus_error_init(&error);
 632
 633 /*     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", */
 634 /*                     dbus_message_get_interface(m), */
 635 /*                     dbus_message_get_path(m), */
 636 /*                     dbus_message_get_member(m)); */
 637
 638     if (dbus_message_is_signal(m, DBUS_INTERFACE_LOCAL, "Disconnected")) {
 639         /* No, we shouldn't quit, but until we get somewhere
 640          * usefull such that we can restore our state, we will */
 641         avahi_log_warn("Disconnnected from D-BUS, terminating...");
 642
 643         raise(SIGQUIT); /* The signal handler will catch this and terminate the process cleanly*/
 644
 645         return DBUS_HANDLER_RESULT_HANDLED;
 646
 647     } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameAcquired")) {
 648         char *name;
 649
 650         if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) {
 651             avahi_log_warn("Error parsing NameAcquired message");
 652             goto fail;
 653         }
 654
 655 /*         avahi_log_info(__FILE__": name acquired (%s)", name); */
 656         return DBUS_HANDLER_RESULT_HANDLED;
 657
 658     } else if (dbus_message_is_signal(m, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
 659         char *name, *old, *new;
 660
 661         if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID)) {
 662             avahi_log_warn("Error parsing NameOwnerChanged message");
 663             goto fail;
 664         }
 665
 666         if (!*new) {
 667             Client *client;
 668
 669             if ((client = client_get(name, FALSE))) {
 670                 avahi_log_debug(__FILE__": client %s vanished.", name);
 671                 client_free(client);
 672             }
 673         }
 674     }
 675
 676 fail:
 677     if (dbus_error_is_set(&error))
 678         dbus_error_free(&error);
 679
 680     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 681 }
 682
 683 static void entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntryGroupState state, void* userdata) {
 684     EntryGroupInfo *i = userdata;
 685     DBusMessage *m;
 686     int32_t t;
 687
 688     assert(s);
 689     assert(g);
 690     assert(i);
 691
 692     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "StateChanged");
 693     t = (int32_t) state;
 694     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
 695     dbus_message_set_destination(m, i->client->name);
 696     dbus_connection_send(server->bus, m, NULL);
 697     dbus_message_unref(m);
 698 }
 699
 700 static int read_strlst(DBusMessage *m, int idx, AvahiStringList **l) {
 701     DBusMessageIter iter, sub;
 702     int j;
 703     AvahiStringList *strlst = NULL;
 704
 705     assert(m);
 706     assert(l);
 707
 708     dbus_message_iter_init(m, &iter);
 709
 710     for (j = 0; j < idx; j++)
 711         dbus_message_iter_next(&iter);
 712
 713     if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
 714         dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY)
 715         goto fail;
 716
 717     dbus_message_iter_recurse(&iter, &sub);
 718
 719     for (;;) {
 720         DBusMessageIter sub2;
 721         int at, n;
 722         uint8_t *k;
 723
 724         if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID)
 725             break;
 726
 727         assert(at == DBUS_TYPE_ARRAY);
 728
 729         if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE)
 730             goto fail;
 731
 732         dbus_message_iter_recurse(&sub, &sub2);
 733         dbus_message_iter_get_fixed_array(&sub2, &k, &n);
 734         strlst = avahi_string_list_add_arbitrary(strlst, k, n);
 735
 736         dbus_message_iter_next(&sub);
 737     }
 738
 739     *l = strlst;
 740
 741     return 0;
 742
 743 fail:
 744     avahi_log_warn("Error parsing TXT data");
 745
 746     avahi_string_list_free(strlst);
 747     *l = NULL;
 748     return -1;
 749 }
 750
 751
 752 static DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 753     DBusError error;
 754     EntryGroupInfo *i = userdata;
 755
 756     assert(c);
 757     assert(m);
 758     assert(i);
 759
 760     dbus_error_init(&error);
 761
 762     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
 763                     dbus_message_get_interface(m),
 764                     dbus_message_get_path(m),
 765                     dbus_message_get_member(m));
 766
 767     /* Introspection */
 768     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
 769         return handle_introspect(c, m, "EntryGroup.introspect");
 770
 771     /* Access control */
 772     if (strcmp(dbus_message_get_sender(m), i->client->name))
 773         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
 774
 775     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Free")) {
 776
 777         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 778             avahi_log_warn("Error parsing EntryGroup::Free message");
 779             goto fail;
 780         }
 781
 782         entry_group_free(i);
 783         return respond_ok(c, m);
 784
 785     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Commit")) {
 786
 787         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 788             avahi_log_warn("Error parsing EntryGroup::Commit message");
 789             goto fail;
 790         }
 791
 792         avahi_s_entry_group_commit(i->entry_group);
 793         return respond_ok(c, m);
 794
 795
 796     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Reset")) {
 797
 798         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 799             avahi_log_warn("Error parsing EntryGroup::Reset message");
 800             goto fail;
 801         }
 802
 803         avahi_s_entry_group_reset(i->entry_group);
 804         i->n_entries = 0;
 805         return respond_ok(c, m);
 806
 807     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty")) {
 808         DBusMessage *reply;
 809         int b;
 810
 811         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 812             avahi_log_warn("Error parsing EntryGroup::IsEmpty message");
 813             goto fail;
 814         }
 815
 816         b = !!avahi_s_entry_group_is_empty(i->entry_group);
 817
 818         reply = dbus_message_new_method_return(m);
 819         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID);
 820         dbus_connection_send(c, reply, NULL);
 821         dbus_message_unref(reply);
 822
 823         return DBUS_HANDLER_RESULT_HANDLED;
 824
 825     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) {
 826         AvahiEntryGroupState state;
 827
 828         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 829             avahi_log_warn("Error parsing EntryGroup::GetState message");
 830             goto fail;
 831         }
 832
 833         state = avahi_s_entry_group_get_state(i->entry_group);
 834         return respond_int32(c, m, (int32_t) state);
 835
 836     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) {
 837         int32_t interface, protocol;
 838         uint32_t flags;
 839         char *type, *name, *domain, *host;
 840         uint16_t port;
 841         AvahiStringList *strlst = NULL;
 842
 843         if (!dbus_message_get_args(
 844                 m, &error,
 845                 DBUS_TYPE_INT32, &interface,
 846                 DBUS_TYPE_INT32, &protocol,
 847                 DBUS_TYPE_UINT32, &flags,
 848                 DBUS_TYPE_STRING, &name,
 849                 DBUS_TYPE_STRING, &type,
 850                 DBUS_TYPE_STRING, &domain,
 851                 DBUS_TYPE_STRING, &host,
 852                 DBUS_TYPE_UINT16, &port,
 853                 DBUS_TYPE_INVALID) ||
 854             !type || !name ||
 855             read_strlst(m, 8, &strlst) < 0) {
 856             avahi_log_warn("Error parsing EntryGroup::AddService message");
 857             goto fail;
 858         }
 859
 860         if (!(flags & AVAHI_PUBLISH_UPDATE) && i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) {
 861             avahi_string_list_free(strlst);
 862             return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
 863         }
 864
 865         if (domain && !*domain)
 866             domain = NULL;
 867
 868         if (host && !*host)
 869             host = NULL;
 870
 871         if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, host, port, strlst) < 0) {
 872             avahi_string_list_free(strlst);
 873             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 874         }
 875
 876         if (!(flags & AVAHI_PUBLISH_UPDATE))
 877             i->n_entries ++;
 878
 879         avahi_string_list_free(strlst);
 880
 881         return respond_ok(c, m);
 882
 883     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype")) {
 884
 885         int32_t interface, protocol;
 886         uint32_t flags;
 887         char *type, *name, *domain, *subtype;
 888
 889         if (!dbus_message_get_args(
 890                 m, &error,
 891                 DBUS_TYPE_INT32, &interface,
 892                 DBUS_TYPE_INT32, &protocol,
 893                 DBUS_TYPE_UINT32, &flags,
 894                 DBUS_TYPE_STRING, &name,
 895                 DBUS_TYPE_STRING, &type,
 896                 DBUS_TYPE_STRING, &domain,
 897                 DBUS_TYPE_STRING, &subtype,
 898                 DBUS_TYPE_INVALID) || !type || !name || !subtype) {
 899             avahi_log_warn("Error parsing EntryGroup::AddServiceSubtype message");
 900             goto fail;
 901         }
 902
 903         if (!(flags & AVAHI_PUBLISH_UPDATE) && i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP)
 904             return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
 905
 906         if (domain && !*domain)
 907             domain = NULL;
 908
 909         if (avahi_server_add_service_subtype(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, subtype) < 0)
 910             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 911
 912         if (!(flags & AVAHI_PUBLISH_UPDATE))
 913             i->n_entries ++;
 914
 915         return respond_ok(c, m);
 916
 917     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "UpdateServiceTxt")) {
 918         int32_t interface, protocol;
 919         uint32_t flags;
 920         char *type, *name, *domain;
 921         AvahiStringList *strlst;
 922
 923         if (!dbus_message_get_args(
 924                 m, &error,
 925                 DBUS_TYPE_INT32, &interface,
 926                 DBUS_TYPE_INT32, &protocol,
 927                 DBUS_TYPE_UINT32, &flags,
 928                 DBUS_TYPE_STRING, &name,
 929                 DBUS_TYPE_STRING, &type,
 930                 DBUS_TYPE_STRING, &domain,
 931                 DBUS_TYPE_INVALID) ||
 932             !type || !name ||
 933             read_strlst(m, 6, &strlst)) {
 934             avahi_log_warn("Error parsing EntryGroup::UpdateServiceTxt message");
 935             goto fail;
 936         }
 937
 938         if (domain && !*domain)
 939             domain = NULL;
 940
 941         if (avahi_server_update_service_txt_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, strlst) < 0) {
 942             avahi_string_list_free(strlst);
 943             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 944         }
 945
 946         avahi_string_list_free(strlst);
 947
 948         return respond_ok(c, m);
 949
 950     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress")) {
 951         int32_t interface, protocol;
 952         uint32_t flags;
 953         char *name, *address;
 954         AvahiAddress a;
 955
 956         if (!dbus_message_get_args(
 957                 m, &error,
 958                 DBUS_TYPE_INT32, &interface,
 959                 DBUS_TYPE_INT32, &protocol,
 960                 DBUS_TYPE_UINT32, &flags,
 961                 DBUS_TYPE_STRING, &name,
 962                 DBUS_TYPE_STRING, &address,
 963                 DBUS_TYPE_INVALID) || !name || !address) {
 964             avahi_log_warn("Error parsing EntryGroup::AddAddress message");
 965             goto fail;
 966         }
 967
 968         if (!(flags & AVAHI_PUBLISH_UPDATE) && i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP)
 969             return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
 970
 971         if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a)))
 972             return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL);
 973
 974         if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, &a) < 0)
 975             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 976
 977         if (!(flags & AVAHI_PUBLISH_UPDATE))
 978             i->n_entries ++;
 979
 980         return respond_ok(c, m);
 981     }
 982
 983     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 984
 985 fail:
 986     if (dbus_error_is_set(&error))
 987         dbus_error_free(&error);
 988
 989     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 990 }
 991
 992 static void sync_host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const char *host_name, const AvahiAddress *a, AvahiLookupResultFlags flags, void* userdata) {
 993     SyncHostNameResolverInfo *i = userdata;
 994
 995     assert(r);
 996     assert(host_name);
 997     assert(i);
 998
 999     if (event == AVAHI_RESOLVER_FOUND) {
1000         char t[256], *pt = t;
1001         int32_t i_interface, i_protocol, i_aprotocol;
1002         uint32_t u_flags;
1003         DBusMessage *reply;
1004
1005         assert(a);
1006         avahi_address_snprint(t, sizeof(t), a);
1007
1008         i_interface = (int32_t) interface;
1009         i_protocol = (int32_t) protocol;
1010         i_aprotocol = (int32_t) a->proto;
1011         u_flags = (uint32_t) flags;
1012
1013         reply = dbus_message_new_method_return(i->message);
1014         dbus_message_append_args(
1015             reply,
1016             DBUS_TYPE_INT32, &i_interface,
1017             DBUS_TYPE_INT32, &i_protocol,
1018             DBUS_TYPE_STRING, &host_name,
1019             DBUS_TYPE_INT32, &i_aprotocol,
1020             DBUS_TYPE_STRING, &pt,
1021             DBUS_TYPE_UINT32, &u_flags,
1022             DBUS_TYPE_INVALID);
1023
1024         dbus_connection_send(server->bus, reply, NULL);
1025         dbus_message_unref(reply);
1026     } else {
1027         assert(event == AVAHI_RESOLVER_FAILURE);
1028         respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL);
1029     }
1030
1031     sync_host_name_resolver_free(i);
1032 }
1033
1034 static void sync_address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const char *host_name, AvahiLookupResultFlags flags, void* userdata) {
1035     SyncAddressResolverInfo *i = userdata;
1036
1037     assert(r);
1038     assert(address);
1039     assert(i);
1040
1041     if (event == AVAHI_RESOLVER_FOUND) {
1042         char t[256], *pt = t;
1043         int32_t i_interface, i_protocol, i_aprotocol;
1044         uint32_t u_flags;
1045         DBusMessage *reply;
1046
1047         assert(host_name);
1048         avahi_address_snprint(t, sizeof(t), address);
1049
1050         i_interface = (int32_t) interface;
1051         i_protocol = (int32_t) protocol;
1052         i_aprotocol = (int32_t) address->proto;
1053         u_flags = (uint32_t) flags;
1054
1055         reply = dbus_message_new_method_return(i->message);
1056         dbus_message_append_args(
1057             reply,
1058             DBUS_TYPE_INT32, &i_interface,
1059             DBUS_TYPE_INT32, &i_protocol,
1060             DBUS_TYPE_INT32, &i_aprotocol,
1061             DBUS_TYPE_STRING, &pt,
1062             DBUS_TYPE_STRING, &host_name,
1063             DBUS_TYPE_UINT32, &u_flags,
1064             DBUS_TYPE_INVALID);
1065
1066         dbus_connection_send(server->bus, reply, NULL);
1067         dbus_message_unref(reply);
1068     } else {
1069         assert(event == AVAHI_RESOLVER_FAILURE);
1070         respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL);
1071     }
1072
1073     sync_address_resolver_free(i);
1074 }
1075
1076 static DBusHandlerResult msg_domain_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1077     DBusError error;
1078     DomainBrowserInfo *i = userdata;
1079
1080     assert(c);
1081     assert(m);
1082     assert(i);
1083
1084     dbus_error_init(&error);
1085
1086     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1087                     dbus_message_get_interface(m),
1088                     dbus_message_get_path(m),
1089                     dbus_message_get_member(m));
1090
1091     /* Introspection */
1092     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1093         return handle_introspect(c, m, "DomainBrowser.introspect");
1094
1095     /* Access control */
1096     if (strcmp(dbus_message_get_sender(m), i->client->name))
1097         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1098
1099     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free")) {
1100
1101         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1102             avahi_log_warn("Error parsing DomainBrowser::Free message");
1103             goto fail;
1104         }
1105
1106         domain_browser_free(i);
1107         return respond_ok(c, m);
1108
1109     }
1110
1111     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1112
1113 fail:
1114     if (dbus_error_is_set(&error))
1115         dbus_error_free(&error);
1116
1117     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1118 }
1119
1120 static void domain_browser_callback(AvahiSDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *domain, AvahiLookupResultFlags flags,  void* userdata) {
1121     DomainBrowserInfo *i = userdata;
1122     DBusMessage *m;
1123     int32_t i_interface, i_protocol;
1124     uint32_t u_flags;
1125
1126     assert(b);
1127     assert(i);
1128
1129     i_interface = (int32_t) interface;
1130     i_protocol = (int32_t) protocol;
1131     u_flags = (uint32_t) flags;
1132
1133     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, map_browse_signal_name(event));
1134
1135     if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) {
1136         assert(domain);
1137         dbus_message_append_args(
1138             m,
1139             DBUS_TYPE_INT32, &i_interface,
1140             DBUS_TYPE_INT32, &i_protocol,
1141             DBUS_TYPE_STRING, &domain,
1142             DBUS_TYPE_UINT32, &u_flags,
1143             DBUS_TYPE_INVALID);
1144     } else if (event == AVAHI_BROWSER_FAILURE)
1145         append_server_error(m);
1146
1147     dbus_message_set_destination(m, i->client->name);
1148     dbus_connection_send(server->bus, m, NULL);
1149     dbus_message_unref(m);
1150 }
1151
1152 static DBusHandlerResult msg_service_type_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1153     DBusError error;
1154     ServiceTypeBrowserInfo *i = userdata;
1155
1156     assert(c);
1157     assert(m);
1158     assert(i);
1159
1160     dbus_error_init(&error);
1161
1162     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1163                     dbus_message_get_interface(m),
1164                     dbus_message_get_path(m),
1165                     dbus_message_get_member(m));
1166
1167     /* Introspection */
1168     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1169         return handle_introspect(c, m, "ServiceTypeBrowser.introspect");
1170
1171     /* Access control */
1172     if (strcmp(dbus_message_get_sender(m), i->client->name))
1173         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1174
1175     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free")) {
1176
1177         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1178             avahi_log_warn("Error parsing ServiceTypeBrowser::Free message");
1179             goto fail;
1180         }
1181
1182         service_type_browser_free(i);
1183         return respond_ok(c, m);
1184
1185     }
1186
1187     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1188
1189 fail:
1190     if (dbus_error_is_set(&error))
1191         dbus_error_free(&error);
1192
1193     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1194 }
1195
1196 static void service_type_browser_callback(AvahiSServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *type, const char *domain, AvahiLookupResultFlags flags, void* userdata) {
1197     ServiceTypeBrowserInfo *i = userdata;
1198     DBusMessage *m;
1199     int32_t i_interface, i_protocol;
1200     uint32_t u_flags;
1201
1202     assert(b);
1203     assert(i);
1204
1205     i_interface = (int32_t) interface;
1206     i_protocol = (int32_t) protocol;
1207     u_flags = (uint32_t) flags;
1208
1209     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, map_browse_signal_name(event));
1210
1211     if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) {
1212         assert(type);
1213         assert(domain);
1214         dbus_message_append_args(
1215             m,
1216             DBUS_TYPE_INT32, &i_interface,
1217             DBUS_TYPE_INT32, &i_protocol,
1218             DBUS_TYPE_STRING, &type,
1219             DBUS_TYPE_STRING, &domain,
1220             DBUS_TYPE_UINT32, &u_flags,
1221             DBUS_TYPE_INVALID);
1222     } else if (event == AVAHI_BROWSER_FAILURE)
1223         append_server_error(m);
1224
1225     dbus_message_set_destination(m, i->client->name);
1226     dbus_connection_send(server->bus, m, NULL);
1227     dbus_message_unref(m);
1228 }
1229
1230 static DBusHandlerResult msg_service_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1231     DBusError error;
1232     ServiceBrowserInfo *i = userdata;
1233
1234     assert(c);
1235     assert(m);
1236     assert(i);
1237
1238     dbus_error_init(&error);
1239
1240     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1241                     dbus_message_get_interface(m),
1242                     dbus_message_get_path(m),
1243                     dbus_message_get_member(m));
1244
1245     /* Introspection */
1246     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1247         return handle_introspect(c, m, "ServiceBrowser.Introspect");
1248
1249     /* Access control */
1250     if (strcmp(dbus_message_get_sender(m), i->client->name))
1251         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1252
1253     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free")) {
1254
1255         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1256             avahi_log_warn("Error parsing ServiceBrowser::Free message");
1257             goto fail;
1258         }
1259
1260         service_browser_free(i);
1261         return respond_ok(c, m);
1262
1263     }
1264
1265     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1266
1267 fail:
1268     if (dbus_error_is_set(&error))
1269         dbus_error_free(&error);
1270
1271     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1272 }
1273
1274 static void service_browser_callback(AvahiSServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *name, const char *type, const char *domain, AvahiLookupResultFlags flags, void* userdata) {
1275     ServiceBrowserInfo *i = userdata;
1276     DBusMessage *m;
1277     int32_t i_interface, i_protocol;
1278     uint32_t u_flags;
1279
1280     assert(b);
1281     assert(i);
1282
1283     i_interface = (int32_t) interface;
1284     i_protocol = (int32_t) protocol;
1285     u_flags = (uint32_t) flags;
1286
1287     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, map_browse_signal_name(event));
1288
1289     if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) {
1290         assert(name);
1291         assert(type);
1292         assert(domain);
1293
1294         dbus_message_append_args(
1295             m,
1296             DBUS_TYPE_INT32, &i_interface,
1297             DBUS_TYPE_INT32, &i_protocol,
1298             DBUS_TYPE_STRING, &name,
1299             DBUS_TYPE_STRING, &type,
1300             DBUS_TYPE_STRING, &domain,
1301             DBUS_TYPE_UINT32, &u_flags,
1302             DBUS_TYPE_INVALID);
1303     } else if (event == AVAHI_BROWSER_FAILURE)
1304         append_server_error(m);
1305
1306     dbus_message_set_destination(m, i->client->name);
1307     dbus_connection_send(server->bus, m, NULL);
1308     dbus_message_unref(m);
1309 }
1310
1311 static void append_string_list(DBusMessage *reply, AvahiStringList *txt) {
1312     AvahiStringList *p;
1313     DBusMessageIter iter, sub;
1314
1315     assert(reply);
1316
1317     dbus_message_iter_init_append(reply, &iter);
1318     dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub);
1319
1320     for (p = txt; p; p = p->next) {
1321         DBusMessageIter sub2;
1322         const uint8_t *data = p->text;
1323
1324         dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2);
1325         dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size);
1326         dbus_message_iter_close_container(&sub, &sub2);
1327
1328     }
1329     dbus_message_iter_close_container(&iter, &sub);
1330 }
1331
1332 static void sync_service_resolver_callback(
1333     AvahiSServiceResolver *r,
1334     AvahiIfIndex interface,
1335     AvahiProtocol protocol,
1336     AvahiResolverEvent event,
1337     const char *name,
1338     const char *type,
1339     const char *domain,
1340     const char *host_name,
1341     const AvahiAddress *a,
1342     uint16_t port,
1343     AvahiStringList *txt,
1344     AvahiLookupResultFlags flags,
1345     void* userdata) {
1346
1347     SyncServiceResolverInfo *i = userdata;
1348
1349     assert(r);
1350     assert(i);
1351
1352     if (event == AVAHI_RESOLVER_FOUND) {
1353         char t[256], *pt = t;
1354         int32_t i_interface, i_protocol, i_aprotocol;
1355         uint32_t u_flags;
1356         DBusMessage *reply;
1357
1358         assert(host_name);
1359
1360         if (!name)
1361             name = "";
1362
1363         assert(a);
1364         avahi_address_snprint(t, sizeof(t), a);
1365
1366         i_interface = (int32_t) interface;
1367         i_protocol = (int32_t) protocol;
1368         i_aprotocol = (int32_t) a->proto;
1369         u_flags = (uint32_t) flags;
1370
1371         reply = dbus_message_new_method_return(i->message);
1372         dbus_message_append_args(
1373             reply,
1374             DBUS_TYPE_INT32, &i_interface,
1375             DBUS_TYPE_INT32, &i_protocol,
1376             DBUS_TYPE_STRING, &name,
1377             DBUS_TYPE_STRING, &type,
1378             DBUS_TYPE_STRING, &domain,
1379             DBUS_TYPE_STRING, &host_name,
1380             DBUS_TYPE_INT32, &i_aprotocol,
1381             DBUS_TYPE_STRING, &pt,
1382             DBUS_TYPE_UINT16, &port,
1383             DBUS_TYPE_INVALID);
1384
1385         append_string_list(reply, txt);
1386
1387         dbus_message_append_args(
1388             reply,
1389             DBUS_TYPE_UINT32, &u_flags,
1390             DBUS_TYPE_INVALID);
1391
1392         dbus_connection_send(server->bus, reply, NULL);
1393         dbus_message_unref(reply);
1394
1395     } else {
1396         assert(event == AVAHI_RESOLVER_FAILURE);
1397
1398         respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL);
1399     }
1400
1401     sync_service_resolver_free(i);
1402 }
1403
1404 static void async_address_resolver_callback(AvahiSAddressResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const AvahiAddress *address, const char *host_name, AvahiLookupResultFlags flags, void* userdata) {
1405     AsyncAddressResolverInfo *i = userdata;
1406     DBusMessage *reply;
1407
1408     assert(r);
1409     assert(i);
1410
1411     reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, map_resolve_signal_name(event));
1412
1413     if (event == AVAHI_RESOLVER_FOUND) {
1414         char t[256], *pt = t;
1415         int32_t i_interface, i_protocol, i_aprotocol;
1416         uint32_t u_flags;
1417
1418         assert(address);
1419         assert(host_name);
1420         avahi_address_snprint(t, sizeof(t), address);
1421
1422         i_interface = (int32_t) interface;
1423         i_protocol = (int32_t) protocol;
1424         i_aprotocol = (int32_t) address->proto;
1425         u_flags = (uint32_t) flags;
1426
1427         dbus_message_append_args(
1428             reply,
1429             DBUS_TYPE_INT32, &i_interface,
1430             DBUS_TYPE_INT32, &i_protocol,
1431             DBUS_TYPE_INT32, &i_aprotocol,
1432             DBUS_TYPE_STRING, &pt,
1433             DBUS_TYPE_STRING, &host_name,
1434             DBUS_TYPE_UINT32, &u_flags,
1435             DBUS_TYPE_INVALID);
1436
1437     }  else {
1438         assert(event == AVAHI_RESOLVER_FAILURE);
1439         append_server_error(reply);
1440     }
1441
1442     dbus_message_set_destination(reply, i->client->name);
1443     dbus_connection_send(server->bus, reply, NULL);
1444     dbus_message_unref(reply);
1445 }
1446
1447 static DBusHandlerResult msg_async_address_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1448     DBusError error;
1449     AsyncAddressResolverInfo *i = userdata;
1450
1451     assert(c);
1452     assert(m);
1453     assert(i);
1454
1455     dbus_error_init(&error);
1456
1457     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1458                     dbus_message_get_interface(m),
1459                     dbus_message_get_path(m),
1460                     dbus_message_get_member(m));
1461
1462     /* Introspection */
1463     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1464         return handle_introspect(c, m, "AddressResolver.Introspect");
1465
1466     /* Access control */
1467     if (strcmp(dbus_message_get_sender(m), i->client->name))
1468         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1469
1470     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Free")) {
1471
1472         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1473             avahi_log_warn("Error parsing AddressResolver::Free message");
1474             goto fail;
1475         }
1476
1477         async_address_resolver_free(i);
1478         return respond_ok(c, m);
1479
1480     }
1481
1482     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1483
1484 fail:
1485     if (dbus_error_is_set(&error))
1486         dbus_error_free(&error);
1487
1488     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1489 }
1490
1491 static void async_host_name_resolver_callback(AvahiSHostNameResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, const char *host_name, const AvahiAddress *a, AvahiLookupResultFlags flags, void* userdata) {
1492     AsyncHostNameResolverInfo *i = userdata;
1493     DBusMessage *reply;
1494
1495     assert(r);
1496     assert(i);
1497
1498     reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, map_resolve_signal_name(event));
1499
1500     if (event == AVAHI_RESOLVER_FOUND) {
1501         char t[256], *pt = t;
1502         int32_t i_interface, i_protocol, i_aprotocol;
1503         uint32_t u_flags;
1504
1505         assert(a);
1506         assert(host_name);
1507         avahi_address_snprint(t, sizeof(t), a);
1508
1509         i_interface = (int32_t) interface;
1510         i_protocol = (int32_t) protocol;
1511         i_aprotocol = (int32_t) a->proto;
1512         u_flags = (uint32_t) flags;
1513
1514         dbus_message_append_args(
1515             reply,
1516             DBUS_TYPE_INT32, &i_interface,
1517             DBUS_TYPE_INT32, &i_protocol,
1518             DBUS_TYPE_STRING, &host_name,
1519             DBUS_TYPE_INT32, &i_aprotocol,
1520             DBUS_TYPE_STRING, &pt,
1521             DBUS_TYPE_UINT32, &u_flags,
1522             DBUS_TYPE_INVALID);
1523     }  else {
1524         assert(event == AVAHI_RESOLVER_FAILURE);
1525         append_server_error(reply);
1526     }
1527
1528     dbus_message_set_destination(reply, i->client->name);
1529     dbus_connection_send(server->bus, reply, NULL);
1530     dbus_message_unref(reply);
1531 }
1532
1533 static DBusHandlerResult msg_async_host_name_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1534     DBusError error;
1535     AsyncHostNameResolverInfo *i = userdata;
1536
1537     assert(c);
1538     assert(m);
1539     assert(i);
1540
1541     dbus_error_init(&error);
1542
1543     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1544                     dbus_message_get_interface(m),
1545                     dbus_message_get_path(m),
1546                     dbus_message_get_member(m));
1547
1548     /* Introspection */
1549     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1550         return handle_introspect(c, m, "HostNameResolver.Introspect");
1551
1552     /* Access control */
1553     if (strcmp(dbus_message_get_sender(m), i->client->name))
1554         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1555
1556     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Free")) {
1557
1558         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1559             avahi_log_warn("Error parsing HostNameResolver::Free message");
1560             goto fail;
1561         }
1562
1563         async_host_name_resolver_free(i);
1564         return respond_ok(c, m);
1565     }
1566
1567     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1568
1569 fail:
1570     if (dbus_error_is_set(&error))
1571         dbus_error_free(&error);
1572
1573     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1574 }
1575
1576 static void async_service_resolver_callback(
1577     AvahiSServiceResolver *r,
1578     AvahiIfIndex interface,
1579     AvahiProtocol protocol,
1580     AvahiResolverEvent event,
1581     const char *name,
1582     const char *type,
1583     const char *domain,
1584     const char *host_name,
1585     const AvahiAddress *a,
1586     uint16_t port,
1587     AvahiStringList *txt,
1588     AvahiLookupResultFlags flags,
1589     void* userdata) {
1590
1591     AsyncServiceResolverInfo *i = userdata;
1592     DBusMessage *reply;
1593
1594     assert(r);
1595     assert(i);
1596
1597     reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, map_resolve_signal_name(event));
1598
1599     if (event == AVAHI_RESOLVER_FOUND) {
1600         char t[256], *pt = t;
1601         int32_t i_interface, i_protocol, i_aprotocol;
1602         uint32_t u_flags;
1603
1604         assert(host_name);
1605
1606 /*         avahi_log_debug(__FILE__": [%s] Successfully resolved service <%s.%s.%s>", i->path, name, type, domain); */
1607
1608         if (a)
1609             avahi_address_snprint(t, sizeof(t), a);
1610         else
1611             t[0] = 0;
1612
1613         if (!name)
1614             name = "";
1615
1616         i_interface = (int32_t) interface;
1617         i_protocol = (int32_t) protocol;
1618         if (a)
1619             i_aprotocol = (int32_t) a->proto;
1620         else
1621             i_aprotocol = AVAHI_PROTO_UNSPEC;
1622         u_flags = (uint32_t) flags;
1623
1624         dbus_message_append_args(
1625             reply,
1626             DBUS_TYPE_INT32, &i_interface,
1627             DBUS_TYPE_INT32, &i_protocol,
1628             DBUS_TYPE_STRING, &name,
1629             DBUS_TYPE_STRING, &type,
1630             DBUS_TYPE_STRING, &domain,
1631             DBUS_TYPE_STRING, &host_name,
1632             DBUS_TYPE_INT32, &i_aprotocol,
1633             DBUS_TYPE_STRING, &pt,
1634             DBUS_TYPE_UINT16, &port,
1635             DBUS_TYPE_INVALID);
1636
1637         append_string_list(reply, txt);
1638
1639         dbus_message_append_args(
1640             reply,
1641             DBUS_TYPE_UINT32, &u_flags,
1642             DBUS_TYPE_INVALID);
1643     }  else {
1644         assert(event == AVAHI_RESOLVER_FAILURE);
1645         append_server_error(reply);
1646     }
1647
1648     dbus_message_set_destination(reply, i->client->name);
1649     dbus_connection_send(server->bus, reply, NULL);
1650     dbus_message_unref(reply);
1651 }
1652
1653 static DBusHandlerResult msg_async_service_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1654     DBusError error;
1655     AsyncServiceResolverInfo *i = userdata;
1656
1657     assert(c);
1658     assert(m);
1659     assert(i);
1660
1661     dbus_error_init(&error);
1662
1663     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1664                     dbus_message_get_interface(m),
1665                     dbus_message_get_path(m),
1666                     dbus_message_get_member(m));
1667
1668     /* Introspection */
1669     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1670         return handle_introspect(c, m, "ServiceResolver.Introspect");
1671
1672     /* Access control */
1673     if (strcmp(dbus_message_get_sender(m), i->client->name))
1674         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1675
1676     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Free")) {
1677
1678         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1679             avahi_log_warn("Error parsing ServiceResolver::Free message");
1680             goto fail;
1681         }
1682
1683         async_service_resolver_free(i);
1684         return respond_ok(c, m);
1685     }
1686
1687     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1688
1689 fail:
1690     if (dbus_error_is_set(&error))
1691         dbus_error_free(&error);
1692
1693     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1694 }
1695
1696 static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1697     DBusError error;
1698
1699     dbus_error_init(&error);
1700
1701     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1702                     dbus_message_get_interface(m),
1703                     dbus_message_get_path(m),
1704                     dbus_message_get_member(m));
1705
1706     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1707         return handle_introspect(c, m, "Server.introspect");
1708
1709     else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) {
1710
1711         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1712             avahi_log_warn("Error parsing Server::GetHostName message");
1713             goto fail;
1714         }
1715
1716         return respond_string(c, m, avahi_server_get_host_name(avahi_server));
1717
1718     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetDomainName")) {
1719
1720         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1721             avahi_log_warn("Error parsing Server::GetDomainName message");
1722             goto fail;
1723         }
1724
1725         return respond_string(c, m, avahi_server_get_domain_name(avahi_server));
1726
1727     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) {
1728
1729         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1730             avahi_log_warn("Error parsing Server::GetHostNameFqdn message");
1731             goto fail;
1732         }
1733
1734         return respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server));
1735
1736     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")) {
1737
1738         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1739             avahi_log_warn("Error parsing Server::GetVersionString message");
1740             goto fail;
1741         }
1742
1743         return respond_string(c, m, PACKAGE_STRING);
1744
1745     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetState")) {
1746         AvahiServerState state;
1747
1748         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1749             avahi_log_warn("Error parsing Server::GetState message");
1750             goto fail;
1751         }
1752
1753         state = avahi_server_get_state(avahi_server);
1754         return respond_int32(c, m, (int32_t) state);
1755
1756     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetLocalServiceCookie")) {
1757
1758         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1759             avahi_log_warn("Error parsing Server::GetLocalServiceCookie message");
1760             goto fail;
1761         }
1762
1763         return respond_uint32(c, m, avahi_server_get_local_service_cookie(avahi_server));
1764
1765     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "IsServiceLocal")) {
1766         int32_t interface, protocol;
1767         char *name, *type, *domain;
1768         int b;
1769
1770         if (!dbus_message_get_args(
1771                 m, &error,
1772                 DBUS_TYPE_INT32, &interface,
1773                 DBUS_TYPE_INT32, &protocol,
1774                 DBUS_TYPE_STRING, &name,
1775                 DBUS_TYPE_STRING, &type,
1776                 DBUS_TYPE_STRING, &domain,
1777                 DBUS_TYPE_INVALID) || !name || !type || !domain) {
1778             avahi_log_warn("Error parsing Server::IsServiceLocal message");
1779             goto fail;
1780         }
1781
1782         if ((b = avahi_server_is_service_local(avahi_server, interface, protocol, name, type, domain)) < 0)
1783             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1784
1785         return respond_boolean(c, m, b);
1786
1787     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) {
1788         int32_t idx;
1789         int fd;
1790         struct ifreq ifr;
1791
1792         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &idx, DBUS_TYPE_INVALID))) {
1793             avahi_log_warn("Error parsing Server::GetNetworkInterfaceNameByIndex message");
1794             goto fail;
1795         }
1796
1797 #ifdef VALGRIND_WORKAROUND
1798         return respond_string(c, m, "blah");
1799 #else
1800
1801         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1802             if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
1803                 char txt[256];
1804                 snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1805                 return respond_error(c, m, AVAHI_ERR_OS, txt);
1806             }
1807
1808         memset(&ifr, 0, sizeof(ifr));
1809         ifr.ifr_ifindex = idx;
1810
1811         if (ioctl(fd, SIOCGIFNAME, &ifr) < 0) {
1812             char txt[256];
1813             snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1814             close(fd);
1815             return respond_error(c, m, AVAHI_ERR_OS, txt);
1816         }
1817
1818         close(fd);
1819
1820         return respond_string(c, m, ifr.ifr_name);
1821 #endif
1822
1823     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceIndexByName")) {
1824         char *n;
1825         int fd;
1826         struct ifreq ifr;
1827
1828         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) {
1829             avahi_log_warn("Error parsing Server::GetNetworkInterfaceIndexByName message");
1830             goto fail;
1831         }
1832
1833 #ifdef VALGRIND_WORKAROUND
1834         return respond_int32(c, m, 1);
1835 #else
1836         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1837             if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
1838                 char txt[256];
1839                 snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1840                 return respond_error(c, m, AVAHI_ERR_OS, txt);
1841             }
1842
1843         memset(&ifr, 0, sizeof(ifr));
1844         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", n);
1845
1846         if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
1847             char txt[256];
1848             snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1849             close(fd);
1850             return respond_error(c, m, AVAHI_ERR_OS, txt);
1851         }
1852
1853         close(fd);
1854
1855         return respond_int32(c, m, ifr.ifr_ifindex);
1856 #endif
1857
1858     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeHostName")) {
1859         char *n, * t;
1860
1861         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) {
1862             avahi_log_warn("Error parsing Server::GetAlternativeHostName message");
1863             goto fail;
1864         }
1865
1866         t = avahi_alternative_host_name(n);
1867         respond_string(c, m, t);
1868         avahi_free(t);
1869
1870         return DBUS_HANDLER_RESULT_HANDLED;
1871
1872     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeServiceName")) {
1873         char *n, *t;
1874
1875         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) {
1876             avahi_log_warn("Error parsing Server::GetAlternativeServiceName message");
1877             goto fail;
1878         }
1879
1880         t = avahi_alternative_service_name(n);
1881         respond_string(c, m, t);
1882         avahi_free(t);
1883
1884         return DBUS_HANDLER_RESULT_HANDLED;
1885
1886     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "EntryGroupNew")) {
1887         Client *client;
1888         EntryGroupInfo *i;
1889         static const DBusObjectPathVTable vtable = {
1890             NULL,
1891             msg_entry_group_impl,
1892             NULL,
1893             NULL,
1894             NULL,
1895             NULL
1896         };
1897
1898         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1899             avahi_log_warn("Error parsing Server::EntryGroupNew message");
1900             goto fail;
1901         }
1902
1903         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
1904             avahi_log_warn("Too many clients, client request failed.");
1905             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
1906         }
1907
1908         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
1909             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
1910             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
1911         }
1912
1913         i = avahi_new(EntryGroupInfo, 1);
1914         i->id = ++client->current_id;
1915         i->client = client;
1916         i->path = avahi_strdup_printf("/Client%u/EntryGroup%u", client->id, i->id);
1917         i->n_entries = 0;
1918         AVAHI_LLIST_PREPEND(EntryGroupInfo, entry_groups, client->entry_groups, i);
1919         client->n_objects++;
1920
1921         if (!(i->entry_group = avahi_s_entry_group_new(avahi_server, entry_group_callback, i))) {
1922             entry_group_free(i);
1923             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1924         }
1925
1926         dbus_connection_register_object_path(c, i->path, &vtable, i);
1927         return respond_path(c, m, i->path);
1928
1929     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveHostName")) {
1930         Client *client;
1931         int32_t interface, protocol, aprotocol;
1932         uint32_t flags;
1933         char *name;
1934         SyncHostNameResolverInfo *i;
1935
1936         if (!dbus_message_get_args(
1937                 m, &error,
1938                 DBUS_TYPE_INT32, &interface,
1939                 DBUS_TYPE_INT32, &protocol,
1940                 DBUS_TYPE_STRING, &name,
1941                 DBUS_TYPE_INT32, &aprotocol,
1942                 DBUS_TYPE_UINT32, &flags,
1943                 DBUS_TYPE_INVALID) || !name) {
1944             avahi_log_warn("Error parsing Server::ResolveHostName message");
1945             goto fail;
1946         }
1947
1948         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
1949             avahi_log_warn("Too many clients, client request failed.");
1950             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
1951         }
1952
1953         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
1954             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
1955             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
1956         }
1957
1958         i = avahi_new(SyncHostNameResolverInfo, 1);
1959         i->client = client;
1960         i->message = dbus_message_ref(m);
1961         AVAHI_LLIST_PREPEND(SyncHostNameResolverInfo, sync_host_name_resolvers, client->sync_host_name_resolvers, i);
1962         client->n_objects++;
1963
1964         if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, sync_host_name_resolver_callback, i))) {
1965             sync_host_name_resolver_free(i);
1966             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1967         }
1968
1969         return DBUS_HANDLER_RESULT_HANDLED;
1970
1971     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveAddress")) {
1972         Client *client;
1973         int32_t interface, protocol;
1974         uint32_t flags;
1975         char *address;
1976         SyncAddressResolverInfo *i;
1977         AvahiAddress a;
1978
1979         if (!dbus_message_get_args(
1980                 m, &error,
1981                 DBUS_TYPE_INT32, &interface,
1982                 DBUS_TYPE_INT32, &protocol,
1983                 DBUS_TYPE_STRING, &address,
1984                 DBUS_TYPE_UINT32, &flags,
1985                 DBUS_TYPE_INVALID) || !address) {
1986             avahi_log_warn("Error parsing Server::ResolveAddress message");
1987             goto fail;
1988         }
1989
1990         if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))
1991             return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL);
1992
1993         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
1994             avahi_log_warn("Too many clients, client request failed.");
1995             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
1996         }
1997
1998         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
1999             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2000             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2001         }
2002
2003         i = avahi_new(SyncAddressResolverInfo, 1);
2004         i->client = client;
2005         i->message = dbus_message_ref(m);
2006         AVAHI_LLIST_PREPEND(SyncAddressResolverInfo, sync_address_resolvers, client->sync_address_resolvers, i);
2007         client->n_objects++;
2008
2009         if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, sync_address_resolver_callback, i))) {
2010             sync_address_resolver_free(i);
2011             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2012         }
2013
2014         return DBUS_HANDLER_RESULT_HANDLED;
2015
2016     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew")) {
2017         Client *client;
2018         DomainBrowserInfo *i;
2019         static const DBusObjectPathVTable vtable = {
2020             NULL,
2021             msg_domain_browser_impl,
2022             NULL,
2023             NULL,
2024             NULL,
2025             NULL
2026         };
2027         int32_t interface, protocol, type;
2028         uint32_t flags;
2029         char *domain;
2030
2031         if (!dbus_message_get_args(
2032                 m, &error,
2033                 DBUS_TYPE_INT32, &interface,
2034                 DBUS_TYPE_INT32, &protocol,
2035                 DBUS_TYPE_STRING, &domain,
2036                 DBUS_TYPE_INT32, &type,
2037                 DBUS_TYPE_UINT32, &flags,
2038                 DBUS_TYPE_INVALID) || type < 0 || type >= AVAHI_DOMAIN_BROWSER_MAX) {
2039             avahi_log_warn("Error parsing Server::DomainBrowserNew message");
2040             goto fail;
2041         }
2042
2043         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2044             avahi_log_warn("Too many clients, client request failed.");
2045             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2046         }
2047
2048         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2049             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2050             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2051         }
2052
2053         if (!*domain)
2054             domain = NULL;
2055
2056         i = avahi_new(DomainBrowserInfo, 1);
2057         i->id = ++client->current_id;
2058         i->client = client;
2059         i->path = avahi_strdup_printf("/Client%u/DomainBrowser%u", client->id, i->id);
2060         AVAHI_LLIST_PREPEND(DomainBrowserInfo, domain_browsers, client->domain_browsers, i);
2061         client->n_objects++;
2062
2063         if (!(i->domain_browser = avahi_s_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, (AvahiLookupFlags) flags, domain_browser_callback, i))) {
2064             domain_browser_free(i);
2065             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2066         }
2067
2068         dbus_connection_register_object_path(c, i->path, &vtable, i);
2069         return respond_path(c, m, i->path);
2070
2071     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew")) {
2072         Client *client;
2073         ServiceTypeBrowserInfo *i;
2074         static const DBusObjectPathVTable vtable = {
2075             NULL,
2076             msg_service_type_browser_impl,
2077             NULL,
2078             NULL,
2079             NULL,
2080             NULL
2081         };
2082         int32_t interface, protocol;
2083         uint32_t flags;
2084         char *domain;
2085
2086         if (!dbus_message_get_args(
2087                 m, &error,
2088                 DBUS_TYPE_INT32, &interface,
2089                 DBUS_TYPE_INT32, &protocol,
2090                 DBUS_TYPE_STRING, &domain,
2091                 DBUS_TYPE_UINT32, &flags,
2092                 DBUS_TYPE_INVALID)) {
2093             avahi_log_warn("Error parsing Server::ServiceTypeBrowserNew message");
2094             goto fail;
2095         }
2096
2097         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2098             avahi_log_warn("Too many clients, client request failed.");
2099             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2100         }
2101
2102
2103         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2104             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2105             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2106         }
2107
2108         if (!*domain)
2109             domain = NULL;
2110
2111         i = avahi_new(ServiceTypeBrowserInfo, 1);
2112         i->id = ++client->current_id;
2113         i->client = client;
2114         i->path = avahi_strdup_printf("/Client%u/ServiceTypeBrowser%u", client->id, i->id);
2115         AVAHI_LLIST_PREPEND(ServiceTypeBrowserInfo, service_type_browsers, client->service_type_browsers, i);
2116         client->n_objects++;
2117
2118         if (!(i->service_type_browser = avahi_s_service_type_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiLookupFlags) flags, service_type_browser_callback, i))) {
2119             service_type_browser_free(i);
2120             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2121         }
2122
2123         dbus_connection_register_object_path(c, i->path, &vtable, i);
2124         return respond_path(c, m, i->path);
2125
2126     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew")) {
2127         Client *client;
2128         ServiceBrowserInfo *i;
2129         static const DBusObjectPathVTable vtable = {
2130             NULL,
2131             msg_service_browser_impl,
2132             NULL,
2133             NULL,
2134             NULL,
2135             NULL
2136         };
2137         int32_t interface, protocol;
2138         uint32_t flags;
2139         char *domain, *type;
2140
2141         if (!dbus_message_get_args(
2142                 m, &error,
2143                 DBUS_TYPE_INT32, &interface,
2144                 DBUS_TYPE_INT32, &protocol,
2145                 DBUS_TYPE_STRING, &type,
2146                 DBUS_TYPE_STRING, &domain,
2147                 DBUS_TYPE_UINT32, &flags,
2148                 DBUS_TYPE_INVALID) || !type) {
2149             avahi_log_warn("Error parsing Server::ServiceBrowserNew message");
2150             goto fail;
2151         }
2152
2153         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2154             avahi_log_warn("Too many clients, client request failed.");
2155             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2156         }
2157
2158
2159         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2160             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2161             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2162         }
2163
2164         if (!*domain)
2165             domain = NULL;
2166
2167         i = avahi_new(ServiceBrowserInfo, 1);
2168         i->id = ++client->current_id;
2169         i->client = client;
2170         i->path = avahi_strdup_printf("/Client%u/ServiceBrowser%u", client->id, i->id);
2171         AVAHI_LLIST_PREPEND(ServiceBrowserInfo, service_browsers, client->service_browsers, i);
2172         client->n_objects++;
2173
2174         if (!(i->service_browser = avahi_s_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, (AvahiLookupFlags) flags, service_browser_callback, i))) {
2175             service_browser_free(i);
2176             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2177         }
2178
2179         dbus_connection_register_object_path(c, i->path, &vtable, i);
2180         return respond_path(c, m, i->path);
2181
2182     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveService")) {
2183         Client *client;
2184         int32_t interface, protocol, aprotocol;
2185         uint32_t flags;
2186         char *name, *type, *domain;
2187         SyncServiceResolverInfo *i;
2188
2189         if (!dbus_message_get_args(
2190                 m, &error,
2191                 DBUS_TYPE_INT32, &interface,
2192                 DBUS_TYPE_INT32, &protocol,
2193                 DBUS_TYPE_STRING, &name,
2194                 DBUS_TYPE_STRING, &type,
2195                 DBUS_TYPE_STRING, &domain,
2196                 DBUS_TYPE_INT32, &aprotocol,
2197                 DBUS_TYPE_UINT32, &flags,
2198                 DBUS_TYPE_INVALID) || !type) {
2199             avahi_log_warn("Error parsing Server::ResolveService message");
2200             goto fail;
2201         }
2202
2203         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2204             avahi_log_warn("Too many clients, client request failed.");
2205             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2206         }
2207
2208         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2209             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2210             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2211         }
2212
2213         if (!*domain)
2214             domain = NULL;
2215
2216         if (!*name)
2217             name = NULL;
2218
2219         i = avahi_new(SyncServiceResolverInfo, 1);
2220         i->client = client;
2221         i->message = dbus_message_ref(m);
2222         AVAHI_LLIST_PREPEND(SyncServiceResolverInfo, sync_service_resolvers, client->sync_service_resolvers, i);
2223         client->n_objects++;
2224
2225         if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, sync_service_resolver_callback, i))) {
2226             sync_service_resolver_free(i);
2227             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2228         }
2229
2230         return DBUS_HANDLER_RESULT_HANDLED;
2231
2232     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceResolverNew")) {
2233         Client *client;
2234         int32_t interface, protocol, aprotocol;
2235         uint32_t flags;
2236         char *name, *type, *domain;
2237         AsyncServiceResolverInfo *i;
2238         static const DBusObjectPathVTable vtable = {
2239             NULL,
2240             msg_async_service_resolver_impl,
2241             NULL,
2242             NULL,
2243             NULL,
2244             NULL
2245         };
2246
2247         if (!dbus_message_get_args(
2248                 m, &error,
2249                 DBUS_TYPE_INT32, &interface,
2250                 DBUS_TYPE_INT32, &protocol,
2251                 DBUS_TYPE_STRING, &name,
2252                 DBUS_TYPE_STRING, &type,
2253                 DBUS_TYPE_STRING, &domain,
2254                 DBUS_TYPE_INT32, &aprotocol,
2255                 DBUS_TYPE_UINT32, &flags,
2256                 DBUS_TYPE_INVALID) || !type) {
2257             avahi_log_warn("Error parsing Server::ServiceResolverNew message");
2258             goto fail;
2259         }
2260
2261         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2262             avahi_log_warn(__FILE__": Too many clients, client request failed.");
2263             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2264         }
2265
2266         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2267             avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name);
2268             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2269         }
2270
2271         if (!*domain)
2272             domain = NULL;
2273
2274         if (!*name)
2275             name = NULL;
2276
2277         i = avahi_new(AsyncServiceResolverInfo, 1);
2278         i->id = ++client->current_id;
2279         i->client = client;
2280         i->path = avahi_strdup_printf("/Client%u/ServiceResolver%u", client->id, i->id);
2281         AVAHI_LLIST_PREPEND(AsyncServiceResolverInfo, async_service_resolvers, client->async_service_resolvers, i);
2282         client->n_objects++;
2283
2284         if (!(i->service_resolver = avahi_s_service_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, type, domain, (AvahiProtocol) aprotocol, (AvahiLookupFlags) flags, async_service_resolver_callback, i))) {
2285             async_service_resolver_free(i);
2286             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2287         }
2288
2289 /*         avahi_log_debug(__FILE__": [%s], new service resolver for <%s.%s.%s>", i->path, name, type, domain); */
2290
2291         dbus_connection_register_object_path(c, i->path, &vtable, i);
2292         return respond_path(c, m, i->path);
2293
2294     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "HostNameResolverNew")) {
2295         Client *client;
2296         int32_t interface, protocol, aprotocol;
2297         uint32_t flags;
2298         char *name;
2299         AsyncHostNameResolverInfo *i;
2300         static const DBusObjectPathVTable vtable = {
2301             NULL,
2302             msg_async_host_name_resolver_impl,
2303             NULL,
2304             NULL,
2305             NULL,
2306             NULL
2307         };
2308
2309         if (!dbus_message_get_args(
2310                 m, &error,
2311                 DBUS_TYPE_INT32, &interface,
2312                 DBUS_TYPE_INT32, &protocol,
2313                 DBUS_TYPE_STRING, &name,
2314                 DBUS_TYPE_INT32, &aprotocol,
2315                 DBUS_TYPE_UINT32, &flags,
2316                 DBUS_TYPE_INVALID) || !name) {
2317             avahi_log_warn("Error parsing Server::HostNameResolverNew message");
2318             goto fail;
2319         }
2320
2321         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2322             avahi_log_warn(__FILE__": Too many clients, client request failed.");
2323             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2324         }
2325
2326         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2327             avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name);
2328             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2329         }
2330
2331         i = avahi_new(AsyncHostNameResolverInfo, 1);
2332         i->id = ++client->current_id;
2333         i->client = client;
2334         i->path = avahi_strdup_printf("/Client%u/HostNameResolver%u", client->id, i->id);
2335         AVAHI_LLIST_PREPEND(AsyncHostNameResolverInfo, async_host_name_resolvers, client->async_host_name_resolvers, i);
2336         client->n_objects++;
2337
2338         if (!(i->host_name_resolver = avahi_s_host_name_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, name, aprotocol, (AvahiLookupFlags) flags, async_host_name_resolver_callback, i))) {
2339             async_host_name_resolver_free(i);
2340             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2341         }
2342
2343         dbus_connection_register_object_path(c, i->path, &vtable, i);
2344         return respond_path(c, m, i->path);
2345
2346     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "AddressResolverNew")) {
2347         Client *client;
2348         int32_t interface, protocol;
2349         uint32_t flags;
2350         char *address;
2351         AsyncAddressResolverInfo *i;
2352         AvahiAddress a;
2353         static const DBusObjectPathVTable vtable = {
2354             NULL,
2355             msg_async_address_resolver_impl,
2356             NULL,
2357             NULL,
2358             NULL,
2359             NULL
2360         };
2361
2362         if (!dbus_message_get_args(
2363                 m, &error,
2364                 DBUS_TYPE_INT32, &interface,
2365                 DBUS_TYPE_INT32, &protocol,
2366                 DBUS_TYPE_STRING, &address,
2367                 DBUS_TYPE_UINT32, &flags,
2368                 DBUS_TYPE_INVALID) || !address) {
2369             avahi_log_warn("Error parsing Server::AddressResolverNew message");
2370             goto fail;
2371         }
2372
2373         if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))
2374             return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL);
2375
2376         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2377             avahi_log_warn(__FILE__": Too many clients, client request failed.");
2378             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2379         }
2380
2381         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2382             avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name);
2383             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2384         }
2385
2386         i = avahi_new(AsyncAddressResolverInfo, 1);
2387         i->id = ++client->current_id;
2388         i->client = client;
2389         i->path = avahi_strdup_printf("/Client%u/AddressResolver%u", client->id, i->id);
2390         AVAHI_LLIST_PREPEND(AsyncAddressResolverInfo, async_address_resolvers, client->async_address_resolvers, i);
2391         client->n_objects++;
2392
2393         if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, async_address_resolver_callback, i))) {
2394             async_address_resolver_free(i);
2395             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2396         }
2397
2398         dbus_connection_register_object_path(c, i->path, &vtable, i);
2399         return respond_path(c, m, i->path);
2400     }
2401
2402     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
2403
2404 fail:
2405     if (dbus_error_is_set(&error))
2406         dbus_error_free(&error);
2407
2408     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2409 }
2410
2411 void dbus_protocol_server_state_changed(AvahiServerState state) {
2412     DBusMessage *m;
2413     int32_t t;
2414
2415     if (!server)
2416         return;
2417
2418     m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged");
2419     t = (int32_t) state;
2420     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
2421     dbus_connection_send(server->bus, m, NULL);
2422     dbus_message_unref(m);
2423 }
2424
2425 int dbus_protocol_setup(const AvahiPoll *poll_api) {
2426     DBusError error;
2427
2428     static const DBusObjectPathVTable server_vtable = {
2429         NULL,
2430         msg_server_impl,
2431         NULL,
2432         NULL,
2433         NULL,
2434         NULL
2435     };
2436
2437     dbus_error_init(&error);
2438
2439     server = avahi_new(Server, 1);
2440     AVAHI_LLIST_HEAD_INIT(Clients, server->clients);
2441     server->current_id = 0;
2442     server->n_clients = 0;
2443
2444     if (!(server->bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
2445         assert(dbus_error_is_set(&error));
2446         avahi_log_error("dbus_bus_get(): %s", error.message);
2447         goto fail;
2448     }
2449
2450     if (avahi_dbus_connection_glue(server->bus, poll_api) < 0) {
2451         avahi_log_error("avahi_dbus_connection_glue() failed");
2452         goto fail;
2453     }
2454
2455     if (dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT, &error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
2456         if (dbus_error_is_set(&error)) {
2457             avahi_log_error("dbus_bus_request_name(): %s", error.message);
2458             goto fail;
2459         }
2460
2461         avahi_log_error("Failed to acquire DBUS name '"AVAHI_DBUS_NAME"'");
2462         goto fail;
2463     }
2464
2465     if (!(dbus_connection_add_filter(server->bus, msg_signal_filter_impl, (void*) poll_api, NULL))) {
2466         avahi_log_error("dbus_connection_add_filter() failed");
2467         goto fail;
2468     }
2469
2470     dbus_bus_add_match(server->bus, "type='signal',""interface='" DBUS_INTERFACE_DBUS  "'", &error);
2471
2472     if (dbus_error_is_set(&error)) {
2473         avahi_log_error("dbus_bus_add_match(): %s", error.message);
2474         goto fail;
2475     }
2476
2477     if (!(dbus_connection_register_object_path(server->bus, AVAHI_DBUS_PATH_SERVER, &server_vtable, NULL))) {
2478         avahi_log_error("dbus_connection_register_object_path() failed");
2479         goto fail;
2480     }
2481
2482     return 0;
2483
2484 fail:
2485     if (server->bus) {
2486         dbus_connection_disconnect(server->bus);
2487         dbus_connection_unref(server->bus);
2488     }
2489
2490     if (dbus_error_is_set(&error))
2491         dbus_error_free(&error);
2492
2493     avahi_free(server);
2494     server = NULL;
2495     return -1;
2496 }
2497
2498 void dbus_protocol_shutdown(void) {
2499
2500     if (server) {
2501
2502         while (server->clients)
2503             client_free(server->clients);
2504
2505         assert(server->n_clients == 0);
2506
2507         if (server->bus) {
2508             dbus_connection_disconnect(server->bus);
2509             dbus_connection_unref(server->bus);
2510         }
2511
2512         avahi_free(server);
2513         server = NULL;
2514     }
2515 }