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 DBusHandlerResult msg_entry_group_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
 701     DBusError error;
 702     EntryGroupInfo *i = userdata;
 703
 704     assert(c);
 705     assert(m);
 706     assert(i);
 707
 708     dbus_error_init(&error);
 709
 710     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
 711                     dbus_message_get_interface(m),
 712                     dbus_message_get_path(m),
 713                     dbus_message_get_member(m));
 714
 715     /* Introspection */
 716     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
 717         return handle_introspect(c, m, "EntryGroup.introspect");
 718
 719     /* Access control */
 720     if (strcmp(dbus_message_get_sender(m), i->client->name))
 721         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
 722
 723     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Free")) {
 724
 725         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 726             avahi_log_warn("Error parsing EntryGroup::Free message");
 727             goto fail;
 728         }
 729
 730         entry_group_free(i);
 731         return respond_ok(c, m);
 732
 733     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Commit")) {
 734
 735         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 736             avahi_log_warn("Error parsing EntryGroup::Commit message");
 737             goto fail;
 738         }
 739
 740         avahi_s_entry_group_commit(i->entry_group);
 741         return respond_ok(c, m);
 742
 743
 744     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "Reset")) {
 745
 746         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 747             avahi_log_warn("Error parsing EntryGroup::Reset message");
 748             goto fail;
 749         }
 750
 751         avahi_s_entry_group_reset(i->entry_group);
 752         i->n_entries = 0;
 753         return respond_ok(c, m);
 754
 755     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "IsEmpty")) {
 756         DBusMessage *reply;
 757         int b;
 758
 759         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 760             avahi_log_warn("Error parsing EntryGroup::IsEmpty message");
 761             goto fail;
 762         }
 763
 764         b = !!avahi_s_entry_group_is_empty(i->entry_group);
 765
 766         reply = dbus_message_new_method_return(m);
 767         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID);
 768         dbus_connection_send(c, reply, NULL);
 769         dbus_message_unref(reply);
 770
 771         return DBUS_HANDLER_RESULT_HANDLED;
 772
 773     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "GetState")) {
 774         AvahiEntryGroupState state;
 775
 776         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
 777             avahi_log_warn("Error parsing EntryGroup::GetState message");
 778             goto fail;
 779         }
 780
 781         state = avahi_s_entry_group_get_state(i->entry_group);
 782         return respond_int32(c, m, (int32_t) state);
 783
 784     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddService")) {
 785         int32_t interface, protocol;
 786         uint32_t flags;
 787         char *type, *name, *domain, *host;
 788         uint16_t port;
 789         AvahiStringList *strlst;
 790         DBusMessageIter iter, sub;
 791         int j;
 792
 793         if (!dbus_message_get_args(
 794                 m, &error,
 795                 DBUS_TYPE_INT32, &interface,
 796                 DBUS_TYPE_INT32, &protocol,
 797                 DBUS_TYPE_UINT32, &flags,
 798                 DBUS_TYPE_STRING, &name,
 799                 DBUS_TYPE_STRING, &type,
 800                 DBUS_TYPE_STRING, &domain,
 801                 DBUS_TYPE_STRING, &host,
 802                 DBUS_TYPE_UINT16, &port,
 803                 DBUS_TYPE_INVALID) || !type || !name) {
 804             avahi_log_warn("Error parsing EntryGroup::AddService message");
 805             goto fail;
 806         }
 807
 808         dbus_message_iter_init(m, &iter);
 809
 810         for (j = 0; j < 8; j++)
 811             dbus_message_iter_next(&iter);
 812
 813         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
 814             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY) {
 815             avahi_log_warn("Error parsing EntryGroup::AddService message 2");
 816             goto fail;
 817         }
 818
 819         strlst = NULL;
 820         dbus_message_iter_recurse(&iter, &sub);
 821
 822         for (;;) {
 823             DBusMessageIter sub2;
 824             int at, n;
 825             uint8_t *k;
 826
 827             if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID)
 828                 break;
 829
 830             assert(at == DBUS_TYPE_ARRAY);
 831
 832             if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) {
 833                 avahi_log_warn("Error parsing EntryGroup::AddService message");
 834                 goto fail;
 835             }
 836
 837             dbus_message_iter_recurse(&sub, &sub2);
 838             dbus_message_iter_get_fixed_array(&sub2, &k, &n);
 839             strlst = avahi_string_list_add_arbitrary(strlst, k, n);
 840
 841             dbus_message_iter_next(&sub);
 842         }
 843
 844         if (i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) {
 845             avahi_string_list_free(strlst);
 846             avahi_log_warn("Too many entries per entry group, client request failed.");
 847             return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
 848         }
 849
 850         if (domain && !*domain)
 851             domain = NULL;
 852
 853         if (host && !*host)
 854             host = NULL;
 855
 856         if (avahi_server_add_service_strlst(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, host, port, strlst) < 0) {
 857             avahi_string_list_free(strlst);
 858             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 859         }
 860
 861         i->n_entries ++;
 862         avahi_string_list_free(strlst);
 863
 864         return respond_ok(c, m);
 865
 866     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddServiceSubtype")) {
 867
 868         int32_t interface, protocol;
 869         uint32_t flags;
 870         char *type, *name, *domain, *subtype;
 871
 872         if (!dbus_message_get_args(
 873                 m, &error,
 874                 DBUS_TYPE_INT32, &interface,
 875                 DBUS_TYPE_INT32, &protocol,
 876                 DBUS_TYPE_UINT32, &flags,
 877                 DBUS_TYPE_STRING, &name,
 878                 DBUS_TYPE_STRING, &type,
 879                 DBUS_TYPE_STRING, &domain,
 880                 DBUS_TYPE_STRING, &subtype,
 881                 DBUS_TYPE_INVALID) || !type || !name || !subtype) {
 882             avahi_log_warn("Error parsing EntryGroup::AddServiceSubtype message");
 883             goto fail;
 884         }
 885
 886         if (i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) {
 887             avahi_log_warn("Too many entries per entry group, client request failed.");
 888             return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
 889         }
 890
 891         if (domain && !*domain)
 892             domain = NULL;
 893
 894         if (avahi_server_add_service_subtype(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, type, domain, subtype) < 0)
 895             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 896
 897         i->n_entries ++;
 898
 899         return respond_ok(c, m);
 900
 901     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ENTRY_GROUP, "AddAddress")) {
 902         int32_t interface, protocol;
 903         uint32_t flags;
 904         char *name, *address;
 905         AvahiAddress a;
 906
 907         if (!dbus_message_get_args(
 908                 m, &error,
 909                 DBUS_TYPE_INT32, &interface,
 910                 DBUS_TYPE_INT32, &protocol,
 911                 DBUS_TYPE_UINT32, &flags,
 912                 DBUS_TYPE_STRING, &name,
 913                 DBUS_TYPE_STRING, &address,
 914                 DBUS_TYPE_INVALID) || !name || !address) {
 915             avahi_log_warn("Error parsing EntryGroup::AddAddress message");
 916             goto fail;
 917         }
 918
 919         if (i->n_entries >= MAX_ENTRIES_PER_ENTRY_GROUP) {
 920             avahi_log_warn("Too many entries per entry group, client request failed.");
 921             return respond_error(c, m, AVAHI_ERR_TOO_MANY_ENTRIES, NULL);
 922         }
 923
 924         if (!(avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))) {
 925             return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL);
 926         }
 927
 928         if (avahi_server_add_address(avahi_server, i->entry_group, (AvahiIfIndex) interface, (AvahiProtocol) protocol, (AvahiPublishFlags) flags, name, &a) < 0)
 929             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
 930
 931         i->n_entries ++;
 932
 933         return respond_ok(c, m);
 934     }
 935
 936     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
 937
 938 fail:
 939     if (dbus_error_is_set(&error))
 940         dbus_error_free(&error);
 941
 942     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 943 }
 944
 945 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) {
 946     SyncHostNameResolverInfo *i = userdata;
 947
 948     assert(r);
 949     assert(host_name);
 950     assert(i);
 951
 952     if (event == AVAHI_RESOLVER_FOUND) {
 953         char t[256], *pt = t;
 954         int32_t i_interface, i_protocol, i_aprotocol;
 955         uint32_t u_flags;
 956         DBusMessage *reply;
 957
 958         assert(a);
 959         avahi_address_snprint(t, sizeof(t), a);
 960
 961         i_interface = (int32_t) interface;
 962         i_protocol = (int32_t) protocol;
 963         i_aprotocol = (int32_t) a->proto;
 964         u_flags = (uint32_t) flags;
 965
 966         reply = dbus_message_new_method_return(i->message);
 967         dbus_message_append_args(
 968             reply,
 969             DBUS_TYPE_INT32, &i_interface,
 970             DBUS_TYPE_INT32, &i_protocol,
 971             DBUS_TYPE_STRING, &host_name,
 972             DBUS_TYPE_INT32, &i_aprotocol,
 973             DBUS_TYPE_STRING, &pt,
 974             DBUS_TYPE_UINT32, &u_flags,
 975             DBUS_TYPE_INVALID);
 976
 977         dbus_connection_send(server->bus, reply, NULL);
 978         dbus_message_unref(reply);
 979     } else {
 980         assert(event == AVAHI_RESOLVER_FAILURE);
 981         respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL);
 982     }
 983
 984     sync_host_name_resolver_free(i);
 985 }
 986
 987 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) {
 988     SyncAddressResolverInfo *i = userdata;
 989
 990     assert(r);
 991     assert(address);
 992     assert(i);
 993
 994     if (event == AVAHI_RESOLVER_FOUND) {
 995         char t[256], *pt = t;
 996         int32_t i_interface, i_protocol, i_aprotocol;
 997         uint32_t u_flags;
 998         DBusMessage *reply;
 999
1000         assert(host_name);
1001         avahi_address_snprint(t, sizeof(t), address);
1002
1003         i_interface = (int32_t) interface;
1004         i_protocol = (int32_t) protocol;
1005         i_aprotocol = (int32_t) address->proto;
1006         u_flags = (uint32_t) flags;
1007
1008         reply = dbus_message_new_method_return(i->message);
1009         dbus_message_append_args(
1010             reply,
1011             DBUS_TYPE_INT32, &i_interface,
1012             DBUS_TYPE_INT32, &i_protocol,
1013             DBUS_TYPE_INT32, &i_aprotocol,
1014             DBUS_TYPE_STRING, &pt,
1015             DBUS_TYPE_STRING, &host_name,
1016             DBUS_TYPE_UINT32, &u_flags,
1017             DBUS_TYPE_INVALID);
1018
1019         dbus_connection_send(server->bus, reply, NULL);
1020         dbus_message_unref(reply);
1021     } else {
1022         assert(event == AVAHI_RESOLVER_FAILURE);
1023         respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL);
1024     }
1025
1026     sync_address_resolver_free(i);
1027 }
1028
1029 static DBusHandlerResult msg_domain_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1030     DBusError error;
1031     DomainBrowserInfo *i = userdata;
1032
1033     assert(c);
1034     assert(m);
1035     assert(i);
1036
1037     dbus_error_init(&error);
1038
1039     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1040                     dbus_message_get_interface(m),
1041                     dbus_message_get_path(m),
1042                     dbus_message_get_member(m));
1043
1044     /* Introspection */
1045     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1046         return handle_introspect(c, m, "DomainBrowser.introspect");
1047
1048     /* Access control */
1049     if (strcmp(dbus_message_get_sender(m), i->client->name))
1050         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1051
1052     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free")) {
1053
1054         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1055             avahi_log_warn("Error parsing DomainBrowser::Free message");
1056             goto fail;
1057         }
1058
1059         domain_browser_free(i);
1060         return respond_ok(c, m);
1061
1062     }
1063
1064     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1065
1066 fail:
1067     if (dbus_error_is_set(&error))
1068         dbus_error_free(&error);
1069
1070     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1071 }
1072
1073 static void domain_browser_callback(AvahiSDomainBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *domain, AvahiLookupResultFlags flags,  void* userdata) {
1074     DomainBrowserInfo *i = userdata;
1075     DBusMessage *m;
1076     int32_t i_interface, i_protocol;
1077     uint32_t u_flags;
1078
1079     assert(b);
1080     assert(i);
1081
1082     i_interface = (int32_t) interface;
1083     i_protocol = (int32_t) protocol;
1084     u_flags = (uint32_t) flags;
1085
1086     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, map_browse_signal_name(event));
1087
1088     if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) {
1089         assert(domain);
1090         dbus_message_append_args(
1091             m,
1092             DBUS_TYPE_INT32, &i_interface,
1093             DBUS_TYPE_INT32, &i_protocol,
1094             DBUS_TYPE_STRING, &domain,
1095             DBUS_TYPE_UINT32, &u_flags,
1096             DBUS_TYPE_INVALID);
1097     } else if (event == AVAHI_BROWSER_FAILURE)
1098         append_server_error(m);
1099
1100     dbus_message_set_destination(m, i->client->name);
1101     dbus_connection_send(server->bus, m, NULL);
1102     dbus_message_unref(m);
1103 }
1104
1105 static DBusHandlerResult msg_service_type_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1106     DBusError error;
1107     ServiceTypeBrowserInfo *i = userdata;
1108
1109     assert(c);
1110     assert(m);
1111     assert(i);
1112
1113     dbus_error_init(&error);
1114
1115     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1116                     dbus_message_get_interface(m),
1117                     dbus_message_get_path(m),
1118                     dbus_message_get_member(m));
1119
1120     /* Introspection */
1121     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1122         return handle_introspect(c, m, "ServiceTypeBrowser.introspect");
1123
1124     /* Access control */
1125     if (strcmp(dbus_message_get_sender(m), i->client->name))
1126         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1127
1128     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free")) {
1129
1130         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1131             avahi_log_warn("Error parsing ServiceTypeBrowser::Free message");
1132             goto fail;
1133         }
1134
1135         service_type_browser_free(i);
1136         return respond_ok(c, m);
1137
1138     }
1139
1140     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1141
1142 fail:
1143     if (dbus_error_is_set(&error))
1144         dbus_error_free(&error);
1145
1146     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1147 }
1148
1149 static void service_type_browser_callback(AvahiSServiceTypeBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, const char *type, const char *domain, AvahiLookupResultFlags flags, void* userdata) {
1150     ServiceTypeBrowserInfo *i = userdata;
1151     DBusMessage *m;
1152     int32_t i_interface, i_protocol;
1153     uint32_t u_flags;
1154
1155     assert(b);
1156     assert(i);
1157
1158     i_interface = (int32_t) interface;
1159     i_protocol = (int32_t) protocol;
1160     u_flags = (uint32_t) flags;
1161
1162     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, map_browse_signal_name(event));
1163
1164     if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) {
1165         assert(type);
1166         assert(domain);
1167         dbus_message_append_args(
1168             m,
1169             DBUS_TYPE_INT32, &i_interface,
1170             DBUS_TYPE_INT32, &i_protocol,
1171             DBUS_TYPE_STRING, &type,
1172             DBUS_TYPE_STRING, &domain,
1173             DBUS_TYPE_UINT32, &u_flags,
1174             DBUS_TYPE_INVALID);
1175     } else if (event == AVAHI_BROWSER_FAILURE)
1176         append_server_error(m);
1177
1178     dbus_message_set_destination(m, i->client->name);
1179     dbus_connection_send(server->bus, m, NULL);
1180     dbus_message_unref(m);
1181 }
1182
1183 static DBusHandlerResult msg_service_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1184     DBusError error;
1185     ServiceBrowserInfo *i = userdata;
1186
1187     assert(c);
1188     assert(m);
1189     assert(i);
1190
1191     dbus_error_init(&error);
1192
1193     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1194                     dbus_message_get_interface(m),
1195                     dbus_message_get_path(m),
1196                     dbus_message_get_member(m));
1197
1198     /* Introspection */
1199     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1200         return handle_introspect(c, m, "ServiceBrowser.Introspect");
1201
1202     /* Access control */
1203     if (strcmp(dbus_message_get_sender(m), i->client->name))
1204         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1205
1206     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free")) {
1207
1208         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1209             avahi_log_warn("Error parsing ServiceBrowser::Free message");
1210             goto fail;
1211         }
1212
1213         service_browser_free(i);
1214         return respond_ok(c, m);
1215
1216     }
1217
1218     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1219
1220 fail:
1221     if (dbus_error_is_set(&error))
1222         dbus_error_free(&error);
1223
1224     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1225 }
1226
1227 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) {
1228     ServiceBrowserInfo *i = userdata;
1229     DBusMessage *m;
1230     int32_t i_interface, i_protocol;
1231     uint32_t u_flags;
1232
1233     assert(b);
1234     assert(i);
1235
1236     i_interface = (int32_t) interface;
1237     i_protocol = (int32_t) protocol;
1238     u_flags = (uint32_t) flags;
1239
1240     m = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, map_browse_signal_name(event));
1241
1242     if (event == AVAHI_BROWSER_NEW || event == AVAHI_BROWSER_REMOVE) {
1243         assert(name);
1244         assert(type);
1245         assert(domain);
1246
1247         dbus_message_append_args(
1248             m,
1249             DBUS_TYPE_INT32, &i_interface,
1250             DBUS_TYPE_INT32, &i_protocol,
1251             DBUS_TYPE_STRING, &name,
1252             DBUS_TYPE_STRING, &type,
1253             DBUS_TYPE_STRING, &domain,
1254             DBUS_TYPE_UINT32, &u_flags,
1255             DBUS_TYPE_INVALID);
1256     } else if (event == AVAHI_BROWSER_FAILURE)
1257         append_server_error(m);
1258
1259     dbus_message_set_destination(m, i->client->name);
1260     dbus_connection_send(server->bus, m, NULL);
1261     dbus_message_unref(m);
1262 }
1263
1264 static void append_string_list(DBusMessage *reply, AvahiStringList *txt) {
1265     AvahiStringList *p;
1266     DBusMessageIter iter, sub;
1267
1268     assert(reply);
1269
1270     dbus_message_iter_init_append(reply, &iter);
1271     dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub);
1272
1273     for (p = txt; p; p = p->next) {
1274         DBusMessageIter sub2;
1275         const uint8_t *data = p->text;
1276
1277         dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2);
1278         dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size);
1279         dbus_message_iter_close_container(&sub, &sub2);
1280
1281     }
1282     dbus_message_iter_close_container(&iter, &sub);
1283 }
1284
1285 static void sync_service_resolver_callback(
1286     AvahiSServiceResolver *r,
1287     AvahiIfIndex interface,
1288     AvahiProtocol protocol,
1289     AvahiResolverEvent event,
1290     const char *name,
1291     const char *type,
1292     const char *domain,
1293     const char *host_name,
1294     const AvahiAddress *a,
1295     uint16_t port,
1296     AvahiStringList *txt,
1297     AvahiLookupResultFlags flags,
1298     void* userdata) {
1299
1300     SyncServiceResolverInfo *i = userdata;
1301
1302     assert(r);
1303     assert(i);
1304
1305     if (event == AVAHI_RESOLVER_FOUND) {
1306         char t[256], *pt = t;
1307         int32_t i_interface, i_protocol, i_aprotocol;
1308         uint32_t u_flags;
1309         DBusMessage *reply;
1310
1311         assert(host_name);
1312
1313         if (!name)
1314             name = "";
1315
1316         assert(a);
1317         avahi_address_snprint(t, sizeof(t), a);
1318
1319         i_interface = (int32_t) interface;
1320         i_protocol = (int32_t) protocol;
1321         i_aprotocol = (int32_t) a->proto;
1322         u_flags = (uint32_t) flags;
1323
1324         reply = dbus_message_new_method_return(i->message);
1325         dbus_message_append_args(
1326             reply,
1327             DBUS_TYPE_INT32, &i_interface,
1328             DBUS_TYPE_INT32, &i_protocol,
1329             DBUS_TYPE_STRING, &name,
1330             DBUS_TYPE_STRING, &type,
1331             DBUS_TYPE_STRING, &domain,
1332             DBUS_TYPE_STRING, &host_name,
1333             DBUS_TYPE_INT32, &i_aprotocol,
1334             DBUS_TYPE_STRING, &pt,
1335             DBUS_TYPE_UINT16, &port,
1336             DBUS_TYPE_INVALID);
1337
1338         append_string_list(reply, txt);
1339
1340         dbus_message_append_args(
1341             reply,
1342             DBUS_TYPE_UINT32, &u_flags,
1343             DBUS_TYPE_INVALID);
1344
1345         dbus_connection_send(server->bus, reply, NULL);
1346         dbus_message_unref(reply);
1347
1348     } else {
1349         assert(event == AVAHI_RESOLVER_FAILURE);
1350
1351         respond_error(server->bus, i->message, avahi_server_errno(avahi_server), NULL);
1352     }
1353
1354     sync_service_resolver_free(i);
1355 }
1356
1357 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) {
1358     AsyncAddressResolverInfo *i = userdata;
1359     DBusMessage *reply;
1360
1361     assert(r);
1362     assert(i);
1363
1364     reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, map_resolve_signal_name(event));
1365
1366     if (event == AVAHI_RESOLVER_FOUND) {
1367         char t[256], *pt = t;
1368         int32_t i_interface, i_protocol, i_aprotocol;
1369         uint32_t u_flags;
1370
1371         assert(address);
1372         assert(host_name);
1373         avahi_address_snprint(t, sizeof(t), address);
1374
1375         i_interface = (int32_t) interface;
1376         i_protocol = (int32_t) protocol;
1377         i_aprotocol = (int32_t) address->proto;
1378         u_flags = (uint32_t) flags;
1379
1380         dbus_message_append_args(
1381             reply,
1382             DBUS_TYPE_INT32, &i_interface,
1383             DBUS_TYPE_INT32, &i_protocol,
1384             DBUS_TYPE_INT32, &i_aprotocol,
1385             DBUS_TYPE_STRING, &pt,
1386             DBUS_TYPE_STRING, &host_name,
1387             DBUS_TYPE_UINT32, &u_flags,
1388             DBUS_TYPE_INVALID);
1389
1390     }  else {
1391         assert(event == AVAHI_RESOLVER_FAILURE);
1392         append_server_error(reply);
1393     }
1394
1395     dbus_message_set_destination(reply, i->client->name);
1396     dbus_connection_send(server->bus, reply, NULL);
1397     dbus_message_unref(reply);
1398 }
1399
1400 static DBusHandlerResult msg_async_address_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1401     DBusError error;
1402     AsyncAddressResolverInfo *i = userdata;
1403
1404     assert(c);
1405     assert(m);
1406     assert(i);
1407
1408     dbus_error_init(&error);
1409
1410     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1411                     dbus_message_get_interface(m),
1412                     dbus_message_get_path(m),
1413                     dbus_message_get_member(m));
1414
1415     /* Introspection */
1416     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1417         return handle_introspect(c, m, "AddressResolver.Introspect");
1418
1419     /* Access control */
1420     if (strcmp(dbus_message_get_sender(m), i->client->name))
1421         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1422
1423     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_ADDRESS_RESOLVER, "Free")) {
1424
1425         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1426             avahi_log_warn("Error parsing AddressResolver::Free message");
1427             goto fail;
1428         }
1429
1430         async_address_resolver_free(i);
1431         return respond_ok(c, m);
1432
1433     }
1434
1435     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1436
1437 fail:
1438     if (dbus_error_is_set(&error))
1439         dbus_error_free(&error);
1440
1441     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1442 }
1443
1444 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) {
1445     AsyncHostNameResolverInfo *i = userdata;
1446     DBusMessage *reply;
1447
1448     assert(r);
1449     assert(i);
1450
1451     reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, map_resolve_signal_name(event));
1452
1453     if (event == AVAHI_RESOLVER_FOUND) {
1454         char t[256], *pt = t;
1455         int32_t i_interface, i_protocol, i_aprotocol;
1456         uint32_t u_flags;
1457
1458         assert(a);
1459         assert(host_name);
1460         avahi_address_snprint(t, sizeof(t), a);
1461
1462         i_interface = (int32_t) interface;
1463         i_protocol = (int32_t) protocol;
1464         i_aprotocol = (int32_t) a->proto;
1465         u_flags = (uint32_t) flags;
1466
1467         dbus_message_append_args(
1468             reply,
1469             DBUS_TYPE_INT32, &i_interface,
1470             DBUS_TYPE_INT32, &i_protocol,
1471             DBUS_TYPE_STRING, &host_name,
1472             DBUS_TYPE_INT32, &i_aprotocol,
1473             DBUS_TYPE_STRING, &pt,
1474             DBUS_TYPE_UINT32, &u_flags,
1475             DBUS_TYPE_INVALID);
1476     }  else {
1477         assert(event == AVAHI_RESOLVER_FAILURE);
1478         append_server_error(reply);
1479     }
1480
1481     dbus_message_set_destination(reply, i->client->name);
1482     dbus_connection_send(server->bus, reply, NULL);
1483     dbus_message_unref(reply);
1484 }
1485
1486 static DBusHandlerResult msg_async_host_name_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1487     DBusError error;
1488     AsyncHostNameResolverInfo *i = userdata;
1489
1490     assert(c);
1491     assert(m);
1492     assert(i);
1493
1494     dbus_error_init(&error);
1495
1496     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1497                     dbus_message_get_interface(m),
1498                     dbus_message_get_path(m),
1499                     dbus_message_get_member(m));
1500
1501     /* Introspection */
1502     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1503         return handle_introspect(c, m, "HostNameResolver.Introspect");
1504
1505     /* Access control */
1506     if (strcmp(dbus_message_get_sender(m), i->client->name))
1507         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1508
1509     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_HOST_NAME_RESOLVER, "Free")) {
1510
1511         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1512             avahi_log_warn("Error parsing HostNameResolver::Free message");
1513             goto fail;
1514         }
1515
1516         async_host_name_resolver_free(i);
1517         return respond_ok(c, m);
1518     }
1519
1520     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1521
1522 fail:
1523     if (dbus_error_is_set(&error))
1524         dbus_error_free(&error);
1525
1526     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1527 }
1528
1529 static void async_service_resolver_callback(
1530     AvahiSServiceResolver *r,
1531     AvahiIfIndex interface,
1532     AvahiProtocol protocol,
1533     AvahiResolverEvent event,
1534     const char *name,
1535     const char *type,
1536     const char *domain,
1537     const char *host_name,
1538     const AvahiAddress *a,
1539     uint16_t port,
1540     AvahiStringList *txt,
1541     AvahiLookupResultFlags flags,
1542     void* userdata) {
1543
1544     AsyncServiceResolverInfo *i = userdata;
1545     DBusMessage *reply;
1546
1547     assert(r);
1548     assert(i);
1549
1550     reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, map_resolve_signal_name(event));
1551
1552     if (event == AVAHI_RESOLVER_FOUND) {
1553         char t[256], *pt = t;
1554         int32_t i_interface, i_protocol, i_aprotocol;
1555         uint32_t u_flags;
1556
1557         assert(host_name);
1558
1559 /*         avahi_log_debug(__FILE__": [%s] Successfully resolved service <%s.%s.%s>", i->path, name, type, domain); */
1560
1561         if (a)
1562             avahi_address_snprint(t, sizeof(t), a);
1563         else
1564             t[0] = 0;
1565
1566         if (!name)
1567             name = "";
1568
1569         i_interface = (int32_t) interface;
1570         i_protocol = (int32_t) protocol;
1571         i_aprotocol = (int32_t) a->proto;
1572         u_flags = (uint32_t) flags;
1573
1574         dbus_message_append_args(
1575             reply,
1576             DBUS_TYPE_INT32, &i_interface,
1577             DBUS_TYPE_INT32, &i_protocol,
1578             DBUS_TYPE_STRING, &name,
1579             DBUS_TYPE_STRING, &type,
1580             DBUS_TYPE_STRING, &domain,
1581             DBUS_TYPE_STRING, &host_name,
1582             DBUS_TYPE_INT32, &i_aprotocol,
1583             DBUS_TYPE_STRING, &pt,
1584             DBUS_TYPE_UINT16, &port,
1585             DBUS_TYPE_INVALID);
1586
1587         append_string_list(reply, txt);
1588
1589         dbus_message_append_args(
1590             reply,
1591             DBUS_TYPE_UINT32, &u_flags,
1592             DBUS_TYPE_INVALID);
1593     }  else {
1594         assert(event == AVAHI_RESOLVER_FAILURE);
1595         append_server_error(reply);
1596     }
1597
1598     dbus_message_set_destination(reply, i->client->name);
1599     dbus_connection_send(server->bus, reply, NULL);
1600     dbus_message_unref(reply);
1601 }
1602
1603 static DBusHandlerResult msg_async_service_resolver_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1604     DBusError error;
1605     AsyncServiceResolverInfo *i = userdata;
1606
1607     assert(c);
1608     assert(m);
1609     assert(i);
1610
1611     dbus_error_init(&error);
1612
1613     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1614                     dbus_message_get_interface(m),
1615                     dbus_message_get_path(m),
1616                     dbus_message_get_member(m));
1617
1618     /* Introspection */
1619     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1620         return handle_introspect(c, m, "ServiceResolver.Introspect");
1621
1622     /* Access control */
1623     if (strcmp(dbus_message_get_sender(m), i->client->name))
1624         return respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
1625
1626     if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, "Free")) {
1627
1628         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1629             avahi_log_warn("Error parsing ServiceResolver::Free message");
1630             goto fail;
1631         }
1632
1633         async_service_resolver_free(i);
1634         return respond_ok(c, m);
1635     }
1636
1637     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
1638
1639 fail:
1640     if (dbus_error_is_set(&error))
1641         dbus_error_free(&error);
1642
1643     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1644 }
1645
1646 static DBusHandlerResult msg_server_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
1647     DBusError error;
1648
1649     dbus_error_init(&error);
1650
1651     avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
1652                     dbus_message_get_interface(m),
1653                     dbus_message_get_path(m),
1654                     dbus_message_get_member(m));
1655
1656     if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
1657         return handle_introspect(c, m, "Server.introspect");
1658
1659     else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostName")) {
1660
1661         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1662             avahi_log_warn("Error parsing Server::GetHostName message");
1663             goto fail;
1664         }
1665
1666         return respond_string(c, m, avahi_server_get_host_name(avahi_server));
1667
1668     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetDomainName")) {
1669
1670         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1671             avahi_log_warn("Error parsing Server::GetDomainName message");
1672             goto fail;
1673         }
1674
1675         return respond_string(c, m, avahi_server_get_domain_name(avahi_server));
1676
1677     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetHostNameFqdn")) {
1678
1679         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1680             avahi_log_warn("Error parsing Server::GetHostNameFqdn message");
1681             goto fail;
1682         }
1683
1684         return respond_string(c, m, avahi_server_get_host_name_fqdn(avahi_server));
1685
1686     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetVersionString")) {
1687
1688         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1689             avahi_log_warn("Error parsing Server::GetVersionString message");
1690             goto fail;
1691         }
1692
1693         return respond_string(c, m, PACKAGE_STRING);
1694
1695     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetState")) {
1696         AvahiServerState state;
1697
1698         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1699             avahi_log_warn("Error parsing Server::GetState message");
1700             goto fail;
1701         }
1702
1703         state = avahi_server_get_state(avahi_server);
1704         return respond_int32(c, m, (int32_t) state);
1705
1706     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetLocalServiceCookie")) {
1707
1708         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INVALID))) {
1709             avahi_log_warn("Error parsing Server::GetLocalServiceCookie message");
1710             goto fail;
1711         }
1712
1713         return respond_uint32(c, m, avahi_server_get_local_service_cookie(avahi_server));
1714
1715     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "IsServiceLocal")) {
1716         int32_t interface, protocol;
1717         char *name, *type, *domain;
1718         int b;
1719
1720         if (!dbus_message_get_args(
1721                 m, &error,
1722                 DBUS_TYPE_INT32, &interface,
1723                 DBUS_TYPE_INT32, &protocol,
1724                 DBUS_TYPE_STRING, &name,
1725                 DBUS_TYPE_STRING, &type,
1726                 DBUS_TYPE_STRING, &domain,
1727                 DBUS_TYPE_INVALID) || !name || !type || !domain) {
1728             avahi_log_warn("Error parsing Server::IsServiceLocal message");
1729             goto fail;
1730         }
1731
1732         if ((b = avahi_server_is_service_local(avahi_server, interface, protocol, name, type, domain)) < 0)
1733             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1734
1735         return respond_boolean(c, m, b);
1736
1737     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceNameByIndex")) {
1738         int32_t idx;
1739         int fd;
1740         struct ifreq ifr;
1741
1742         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &idx, DBUS_TYPE_INVALID))) {
1743             avahi_log_warn("Error parsing Server::GetNetworkInterfaceNameByIndex message");
1744             goto fail;
1745         }
1746
1747 #ifdef VALGRIND_WORKAROUND
1748         return respond_string(c, m, "blah");
1749 #else
1750
1751         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1752             if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
1753                 char txt[256];
1754                 snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1755                 return respond_error(c, m, AVAHI_ERR_OS, txt);
1756             }
1757
1758         memset(&ifr, 0, sizeof(ifr));
1759         ifr.ifr_ifindex = idx;
1760
1761         if (ioctl(fd, SIOCGIFNAME, &ifr) < 0) {
1762             char txt[256];
1763             snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1764             close(fd);
1765             return respond_error(c, m, AVAHI_ERR_OS, txt);
1766         }
1767
1768         close(fd);
1769
1770         return respond_string(c, m, ifr.ifr_name);
1771 #endif
1772
1773     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetNetworkInterfaceIndexByName")) {
1774         char *n;
1775         int fd;
1776         struct ifreq ifr;
1777
1778         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) {
1779             avahi_log_warn("Error parsing Server::GetNetworkInterfaceIndexByName message");
1780             goto fail;
1781         }
1782
1783 #ifdef VALGRIND_WORKAROUND
1784         return respond_int32(c, m, 1);
1785 #else
1786         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1787             if ((fd = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
1788                 char txt[256];
1789                 snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1790                 return respond_error(c, m, AVAHI_ERR_OS, txt);
1791             }
1792
1793         memset(&ifr, 0, sizeof(ifr));
1794         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", n);
1795
1796         if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
1797             char txt[256];
1798             snprintf(txt, sizeof(txt), "OS Error: %s", strerror(errno));
1799             close(fd);
1800             return respond_error(c, m, AVAHI_ERR_OS, txt);
1801         }
1802
1803         close(fd);
1804
1805         return respond_int32(c, m, ifr.ifr_ifindex);
1806 #endif
1807
1808     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeHostName")) {
1809         char *n, * t;
1810
1811         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) {
1812             avahi_log_warn("Error parsing Server::GetAlternativeHostName message");
1813             goto fail;
1814         }
1815
1816         t = avahi_alternative_host_name(n);
1817         respond_string(c, m, t);
1818         avahi_free(t);
1819
1820         return DBUS_HANDLER_RESULT_HANDLED;
1821
1822     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "GetAlternativeServiceName")) {
1823         char *n, *t;
1824
1825         if (!(dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &n, DBUS_TYPE_INVALID)) || !n) {
1826             avahi_log_warn("Error parsing Server::GetAlternativeServiceName message");
1827             goto fail;
1828         }
1829
1830         t = avahi_alternative_service_name(n);
1831         respond_string(c, m, t);
1832         avahi_free(t);
1833
1834         return DBUS_HANDLER_RESULT_HANDLED;
1835
1836     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "EntryGroupNew")) {
1837         Client *client;
1838         EntryGroupInfo *i;
1839         static const DBusObjectPathVTable vtable = {
1840             NULL,
1841             msg_entry_group_impl,
1842             NULL,
1843             NULL,
1844             NULL,
1845             NULL
1846         };
1847
1848         if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
1849             avahi_log_warn("Error parsing Server::EntryGroupNew message");
1850             goto fail;
1851         }
1852
1853         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
1854             avahi_log_warn("Too many clients, client request failed.");
1855             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
1856         }
1857
1858         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
1859             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
1860             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
1861         }
1862
1863         i = avahi_new(EntryGroupInfo, 1);
1864         i->id = ++client->current_id;
1865         i->client = client;
1866         i->path = avahi_strdup_printf("/Client%u/EntryGroup%u", client->id, i->id);
1867         i->n_entries = 0;
1868         AVAHI_LLIST_PREPEND(EntryGroupInfo, entry_groups, client->entry_groups, i);
1869         client->n_objects++;
1870
1871         if (!(i->entry_group = avahi_s_entry_group_new(avahi_server, entry_group_callback, i))) {
1872             entry_group_free(i);
1873             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1874         }
1875
1876         dbus_connection_register_object_path(c, i->path, &vtable, i);
1877         return respond_path(c, m, i->path);
1878
1879     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveHostName")) {
1880         Client *client;
1881         int32_t interface, protocol, aprotocol;
1882         uint32_t flags;
1883         char *name;
1884         SyncHostNameResolverInfo *i;
1885
1886         if (!dbus_message_get_args(
1887                 m, &error,
1888                 DBUS_TYPE_INT32, &interface,
1889                 DBUS_TYPE_INT32, &protocol,
1890                 DBUS_TYPE_STRING, &name,
1891                 DBUS_TYPE_INT32, &aprotocol,
1892                 DBUS_TYPE_UINT32, &flags,
1893                 DBUS_TYPE_INVALID) || !name) {
1894             avahi_log_warn("Error parsing Server::ResolveHostName message");
1895             goto fail;
1896         }
1897
1898         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
1899             avahi_log_warn("Too many clients, client request failed.");
1900             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
1901         }
1902
1903         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
1904             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
1905             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
1906         }
1907
1908         i = avahi_new(SyncHostNameResolverInfo, 1);
1909         i->client = client;
1910         i->message = dbus_message_ref(m);
1911         AVAHI_LLIST_PREPEND(SyncHostNameResolverInfo, sync_host_name_resolvers, client->sync_host_name_resolvers, i);
1912         client->n_objects++;
1913
1914         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))) {
1915             sync_host_name_resolver_free(i);
1916             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1917         }
1918
1919         return DBUS_HANDLER_RESULT_HANDLED;
1920
1921     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveAddress")) {
1922         Client *client;
1923         int32_t interface, protocol;
1924         uint32_t flags;
1925         char *address;
1926         SyncAddressResolverInfo *i;
1927         AvahiAddress a;
1928
1929         if (!dbus_message_get_args(
1930                 m, &error,
1931                 DBUS_TYPE_INT32, &interface,
1932                 DBUS_TYPE_INT32, &protocol,
1933                 DBUS_TYPE_STRING, &address,
1934                 DBUS_TYPE_UINT32, &flags,
1935                 DBUS_TYPE_INVALID) || !address) {
1936             avahi_log_warn("Error parsing Server::ResolveAddress message");
1937             goto fail;
1938         }
1939
1940         if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))
1941             return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL);
1942
1943         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
1944             avahi_log_warn("Too many clients, client request failed.");
1945             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
1946         }
1947
1948         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
1949             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
1950             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
1951         }
1952
1953         i = avahi_new(SyncAddressResolverInfo, 1);
1954         i->client = client;
1955         i->message = dbus_message_ref(m);
1956         AVAHI_LLIST_PREPEND(SyncAddressResolverInfo, sync_address_resolvers, client->sync_address_resolvers, i);
1957         client->n_objects++;
1958
1959         if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, sync_address_resolver_callback, i))) {
1960             sync_address_resolver_free(i);
1961             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
1962         }
1963
1964         return DBUS_HANDLER_RESULT_HANDLED;
1965
1966     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew")) {
1967         Client *client;
1968         DomainBrowserInfo *i;
1969         static const DBusObjectPathVTable vtable = {
1970             NULL,
1971             msg_domain_browser_impl,
1972             NULL,
1973             NULL,
1974             NULL,
1975             NULL
1976         };
1977         int32_t interface, protocol, type;
1978         uint32_t flags;
1979         char *domain;
1980
1981         if (!dbus_message_get_args(
1982                 m, &error,
1983                 DBUS_TYPE_INT32, &interface,
1984                 DBUS_TYPE_INT32, &protocol,
1985                 DBUS_TYPE_STRING, &domain,
1986                 DBUS_TYPE_INT32, &type,
1987                 DBUS_TYPE_UINT32, &flags,
1988                 DBUS_TYPE_INVALID) || type < 0 || type >= AVAHI_DOMAIN_BROWSER_MAX) {
1989             avahi_log_warn("Error parsing Server::DomainBrowserNew message");
1990             goto fail;
1991         }
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         if (!*domain)
2004             domain = NULL;
2005
2006         i = avahi_new(DomainBrowserInfo, 1);
2007         i->id = ++client->current_id;
2008         i->client = client;
2009         i->path = avahi_strdup_printf("/Client%u/DomainBrowser%u", client->id, i->id);
2010         AVAHI_LLIST_PREPEND(DomainBrowserInfo, domain_browsers, client->domain_browsers, i);
2011         client->n_objects++;
2012
2013         if (!(i->domain_browser = avahi_s_domain_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, domain, (AvahiDomainBrowserType) type, (AvahiLookupFlags) flags, domain_browser_callback, i))) {
2014             domain_browser_free(i);
2015             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2016         }
2017
2018         dbus_connection_register_object_path(c, i->path, &vtable, i);
2019         return respond_path(c, m, i->path);
2020
2021     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceTypeBrowserNew")) {
2022         Client *client;
2023         ServiceTypeBrowserInfo *i;
2024         static const DBusObjectPathVTable vtable = {
2025             NULL,
2026             msg_service_type_browser_impl,
2027             NULL,
2028             NULL,
2029             NULL,
2030             NULL
2031         };
2032         int32_t interface, protocol;
2033         uint32_t flags;
2034         char *domain;
2035
2036         if (!dbus_message_get_args(
2037                 m, &error,
2038                 DBUS_TYPE_INT32, &interface,
2039                 DBUS_TYPE_INT32, &protocol,
2040                 DBUS_TYPE_STRING, &domain,
2041                 DBUS_TYPE_UINT32, &flags,
2042                 DBUS_TYPE_INVALID)) {
2043             avahi_log_warn("Error parsing Server::ServiceTypeBrowserNew message");
2044             goto fail;
2045         }
2046
2047         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2048             avahi_log_warn("Too many clients, client request failed.");
2049             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2050         }
2051
2052
2053         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2054             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2055             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2056         }
2057
2058         if (!*domain)
2059             domain = NULL;
2060
2061         i = avahi_new(ServiceTypeBrowserInfo, 1);
2062         i->id = ++client->current_id;
2063         i->client = client;
2064         i->path = avahi_strdup_printf("/Client%u/ServiceTypeBrowser%u", client->id, i->id);
2065         AVAHI_LLIST_PREPEND(ServiceTypeBrowserInfo, service_type_browsers, client->service_type_browsers, i);
2066         client->n_objects++;
2067
2068         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))) {
2069             service_type_browser_free(i);
2070             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2071         }
2072
2073         dbus_connection_register_object_path(c, i->path, &vtable, i);
2074         return respond_path(c, m, i->path);
2075
2076     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew")) {
2077         Client *client;
2078         ServiceBrowserInfo *i;
2079         static const DBusObjectPathVTable vtable = {
2080             NULL,
2081             msg_service_browser_impl,
2082             NULL,
2083             NULL,
2084             NULL,
2085             NULL
2086         };
2087         int32_t interface, protocol;
2088         uint32_t flags;
2089         char *domain, *type;
2090
2091         if (!dbus_message_get_args(
2092                 m, &error,
2093                 DBUS_TYPE_INT32, &interface,
2094                 DBUS_TYPE_INT32, &protocol,
2095                 DBUS_TYPE_STRING, &type,
2096                 DBUS_TYPE_STRING, &domain,
2097                 DBUS_TYPE_UINT32, &flags,
2098                 DBUS_TYPE_INVALID) || !type) {
2099             avahi_log_warn("Error parsing Server::ServiceBrowserNew message");
2100             goto fail;
2101         }
2102
2103         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2104             avahi_log_warn("Too many clients, client request failed.");
2105             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2106         }
2107
2108
2109         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2110             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2111             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2112         }
2113
2114         if (!*domain)
2115             domain = NULL;
2116
2117         i = avahi_new(ServiceBrowserInfo, 1);
2118         i->id = ++client->current_id;
2119         i->client = client;
2120         i->path = avahi_strdup_printf("/Client%u/ServiceBrowser%u", client->id, i->id);
2121         AVAHI_LLIST_PREPEND(ServiceBrowserInfo, service_browsers, client->service_browsers, i);
2122         client->n_objects++;
2123
2124         if (!(i->service_browser = avahi_s_service_browser_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, type, domain, (AvahiLookupFlags) flags, service_browser_callback, i))) {
2125             service_browser_free(i);
2126             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2127         }
2128
2129         dbus_connection_register_object_path(c, i->path, &vtable, i);
2130         return respond_path(c, m, i->path);
2131
2132     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ResolveService")) {
2133         Client *client;
2134         int32_t interface, protocol, aprotocol;
2135         uint32_t flags;
2136         char *name, *type, *domain;
2137         SyncServiceResolverInfo *i;
2138
2139         if (!dbus_message_get_args(
2140                 m, &error,
2141                 DBUS_TYPE_INT32, &interface,
2142                 DBUS_TYPE_INT32, &protocol,
2143                 DBUS_TYPE_STRING, &name,
2144                 DBUS_TYPE_STRING, &type,
2145                 DBUS_TYPE_STRING, &domain,
2146                 DBUS_TYPE_INT32, &aprotocol,
2147                 DBUS_TYPE_UINT32, &flags,
2148                 DBUS_TYPE_INVALID) || !type) {
2149             avahi_log_warn("Error parsing Server::ResolveService 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         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2159             avahi_log_warn("Too many objects for client '%s', client request failed.", client->name);
2160             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2161         }
2162
2163         if (!*domain)
2164             domain = NULL;
2165
2166         if (!*name)
2167             name = NULL;
2168
2169         i = avahi_new(SyncServiceResolverInfo, 1);
2170         i->client = client;
2171         i->message = dbus_message_ref(m);
2172         AVAHI_LLIST_PREPEND(SyncServiceResolverInfo, sync_service_resolvers, client->sync_service_resolvers, i);
2173         client->n_objects++;
2174
2175         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))) {
2176             sync_service_resolver_free(i);
2177             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2178         }
2179
2180         return DBUS_HANDLER_RESULT_HANDLED;
2181
2182     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "ServiceResolverNew")) {
2183         Client *client;
2184         int32_t interface, protocol, aprotocol;
2185         uint32_t flags;
2186         char *name, *type, *domain;
2187         AsyncServiceResolverInfo *i;
2188         static const DBusObjectPathVTable vtable = {
2189             NULL,
2190             msg_async_service_resolver_impl,
2191             NULL,
2192             NULL,
2193             NULL,
2194             NULL
2195         };
2196
2197         if (!dbus_message_get_args(
2198                 m, &error,
2199                 DBUS_TYPE_INT32, &interface,
2200                 DBUS_TYPE_INT32, &protocol,
2201                 DBUS_TYPE_STRING, &name,
2202                 DBUS_TYPE_STRING, &type,
2203                 DBUS_TYPE_STRING, &domain,
2204                 DBUS_TYPE_INT32, &aprotocol,
2205                 DBUS_TYPE_UINT32, &flags,
2206                 DBUS_TYPE_INVALID) || !type) {
2207             avahi_log_warn("Error parsing Server::ServiceResolverNew message");
2208             goto fail;
2209         }
2210
2211         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2212             avahi_log_warn(__FILE__": Too many clients, client request failed.");
2213             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2214         }
2215
2216         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2217             avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name);
2218             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2219         }
2220
2221         if (!*domain)
2222             domain = NULL;
2223
2224         if (!*name)
2225             name = NULL;
2226
2227         i = avahi_new(AsyncServiceResolverInfo, 1);
2228         i->id = ++client->current_id;
2229         i->client = client;
2230         i->path = avahi_strdup_printf("/Client%u/ServiceResolver%u", client->id, i->id);
2231         AVAHI_LLIST_PREPEND(AsyncServiceResolverInfo, async_service_resolvers, client->async_service_resolvers, i);
2232         client->n_objects++;
2233
2234         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))) {
2235             async_service_resolver_free(i);
2236             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2237         }
2238
2239 /*         avahi_log_debug(__FILE__": [%s], new service resolver for <%s.%s.%s>", i->path, name, type, domain); */
2240
2241         dbus_connection_register_object_path(c, i->path, &vtable, i);
2242         return respond_path(c, m, i->path);
2243
2244     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "HostNameResolverNew")) {
2245         Client *client;
2246         int32_t interface, protocol, aprotocol;
2247         uint32_t flags;
2248         char *name;
2249         AsyncHostNameResolverInfo *i;
2250         static const DBusObjectPathVTable vtable = {
2251             NULL,
2252             msg_async_host_name_resolver_impl,
2253             NULL,
2254             NULL,
2255             NULL,
2256             NULL
2257         };
2258
2259         if (!dbus_message_get_args(
2260                 m, &error,
2261                 DBUS_TYPE_INT32, &interface,
2262                 DBUS_TYPE_INT32, &protocol,
2263                 DBUS_TYPE_STRING, &name,
2264                 DBUS_TYPE_INT32, &aprotocol,
2265                 DBUS_TYPE_UINT32, &flags,
2266                 DBUS_TYPE_INVALID) || !name) {
2267             avahi_log_warn("Error parsing Server::HostNameResolverNew message");
2268             goto fail;
2269         }
2270
2271         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2272             avahi_log_warn(__FILE__": Too many clients, client request failed.");
2273             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2274         }
2275
2276         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2277             avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name);
2278             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2279         }
2280
2281         i = avahi_new(AsyncHostNameResolverInfo, 1);
2282         i->id = ++client->current_id;
2283         i->client = client;
2284         i->path = avahi_strdup_printf("/Client%u/HostNameResolver%u", client->id, i->id);
2285         AVAHI_LLIST_PREPEND(AsyncHostNameResolverInfo, async_host_name_resolvers, client->async_host_name_resolvers, i);
2286         client->n_objects++;
2287
2288         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))) {
2289             async_host_name_resolver_free(i);
2290             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2291         }
2292
2293         dbus_connection_register_object_path(c, i->path, &vtable, i);
2294         return respond_path(c, m, i->path);
2295
2296     } else if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_SERVER, "AddressResolverNew")) {
2297         Client *client;
2298         int32_t interface, protocol;
2299         uint32_t flags;
2300         char *address;
2301         AsyncAddressResolverInfo *i;
2302         AvahiAddress a;
2303         static const DBusObjectPathVTable vtable = {
2304             NULL,
2305             msg_async_address_resolver_impl,
2306             NULL,
2307             NULL,
2308             NULL,
2309             NULL
2310         };
2311
2312         if (!dbus_message_get_args(
2313                 m, &error,
2314                 DBUS_TYPE_INT32, &interface,
2315                 DBUS_TYPE_INT32, &protocol,
2316                 DBUS_TYPE_STRING, &address,
2317                 DBUS_TYPE_UINT32, &flags,
2318                 DBUS_TYPE_INVALID) || !address) {
2319             avahi_log_warn("Error parsing Server::AddressResolverNew message");
2320             goto fail;
2321         }
2322
2323         if (!avahi_address_parse(address, AVAHI_PROTO_UNSPEC, &a))
2324             return respond_error(c, m, AVAHI_ERR_INVALID_ADDRESS, NULL);
2325
2326         if (!(client = client_get(dbus_message_get_sender(m), TRUE))) {
2327             avahi_log_warn(__FILE__": Too many clients, client request failed.");
2328             return respond_error(c, m, AVAHI_ERR_TOO_MANY_CLIENTS, NULL);
2329         }
2330
2331         if (client->n_objects >= MAX_OBJECTS_PER_CLIENT) {
2332             avahi_log_warn(__FILE__": Too many objects for client '%s', client request failed.", client->name);
2333             return respond_error(c, m, AVAHI_ERR_TOO_MANY_OBJECTS, NULL);
2334         }
2335
2336         i = avahi_new(AsyncAddressResolverInfo, 1);
2337         i->id = ++client->current_id;
2338         i->client = client;
2339         i->path = avahi_strdup_printf("/Client%u/AddressResolver%u", client->id, i->id);
2340         AVAHI_LLIST_PREPEND(AsyncAddressResolverInfo, async_address_resolvers, client->async_address_resolvers, i);
2341         client->n_objects++;
2342
2343         if (!(i->address_resolver = avahi_s_address_resolver_new(avahi_server, (AvahiIfIndex) interface, (AvahiProtocol) protocol, &a, (AvahiLookupFlags) flags, async_address_resolver_callback, i))) {
2344             async_address_resolver_free(i);
2345             return respond_error(c, m, avahi_server_errno(avahi_server), NULL);
2346         }
2347
2348         dbus_connection_register_object_path(c, i->path, &vtable, i);
2349         return respond_path(c, m, i->path);
2350     }
2351
2352     avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
2353
2354 fail:
2355     if (dbus_error_is_set(&error))
2356         dbus_error_free(&error);
2357
2358     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2359 }
2360
2361 void dbus_protocol_server_state_changed(AvahiServerState state) {
2362     DBusMessage *m;
2363     int32_t t;
2364
2365     if (!server)
2366         return;
2367
2368     m = dbus_message_new_signal(AVAHI_DBUS_PATH_SERVER, AVAHI_DBUS_INTERFACE_SERVER, "StateChanged");
2369     t = (int32_t) state;
2370     dbus_message_append_args(m, DBUS_TYPE_INT32, &t, DBUS_TYPE_INVALID);
2371     dbus_connection_send(server->bus, m, NULL);
2372     dbus_message_unref(m);
2373 }
2374
2375 int dbus_protocol_setup(const AvahiPoll *poll_api) {
2376     DBusError error;
2377
2378     static const DBusObjectPathVTable server_vtable = {
2379         NULL,
2380         msg_server_impl,
2381         NULL,
2382         NULL,
2383         NULL,
2384         NULL
2385     };
2386
2387     dbus_error_init(&error);
2388
2389     server = avahi_new(Server, 1);
2390     AVAHI_LLIST_HEAD_INIT(Clients, server->clients);
2391     server->current_id = 0;
2392     server->n_clients = 0;
2393
2394     if (!(server->bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
2395         assert(dbus_error_is_set(&error));
2396         avahi_log_error("dbus_bus_get(): %s", error.message);
2397         goto fail;
2398     }
2399
2400     if (avahi_dbus_connection_glue(server->bus, poll_api) < 0) {
2401         avahi_log_error("avahi_dbus_connection_glue() failed");
2402         goto fail;
2403     }
2404
2405     if (dbus_bus_request_name(server->bus, AVAHI_DBUS_NAME, DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT, &error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
2406         if (dbus_error_is_set(&error)) {
2407             avahi_log_error("dbus_bus_request_name(): %s", error.message);
2408             goto fail;
2409         }
2410
2411         avahi_log_error("Failed to acquire DBUS name '"AVAHI_DBUS_NAME"'");
2412         goto fail;
2413     }
2414
2415     if (!(dbus_connection_add_filter(server->bus, msg_signal_filter_impl, (void*) poll_api, NULL))) {
2416         avahi_log_error("dbus_connection_add_filter() failed");
2417         goto fail;
2418     }
2419
2420     dbus_bus_add_match(server->bus, "type='signal',""interface='" DBUS_INTERFACE_DBUS  "'", &error);
2421
2422     if (dbus_error_is_set(&error)) {
2423         avahi_log_error("dbus_bus_add_match(): %s", error.message);
2424         goto fail;
2425     }
2426
2427     if (!(dbus_connection_register_object_path(server->bus, AVAHI_DBUS_PATH_SERVER, &server_vtable, NULL))) {
2428         avahi_log_error("dbus_connection_register_object_path() failed");
2429         goto fail;
2430     }
2431
2432     return 0;
2433
2434 fail:
2435     if (server->bus) {
2436         dbus_connection_disconnect(server->bus);
2437         dbus_connection_unref(server->bus);
2438     }
2439
2440     if (dbus_error_is_set(&error))
2441         dbus_error_free(&error);
2442
2443     avahi_free(server);
2444     server = NULL;
2445     return -1;
2446 }
2447
2448 void dbus_protocol_shutdown(void) {
2449
2450     if (server) {
2451
2452         while (server->clients)
2453             client_free(server->clients);
2454
2455         assert(server->n_clients == 0);
2456
2457         if (server->bus) {
2458             dbus_connection_disconnect(server->bus);
2459             dbus_connection_unref(server->bus);
2460         }
2461
2462         avahi_free(server);
2463         server = NULL;
2464     }
2465 }