git.meshlink.io Git - catta/blob - avahi-compat-libdns_sd/compat.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 <pthread.h>
  27 #include <assert.h>
  28 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <signal.h>
  33 #include <netinet/in.h>
  34
  35 #include <avahi-common/simple-watch.h>
  36 #include <avahi-common/malloc.h>
  37 #include <avahi-common/error.h>
  38 #include <avahi-common/domain.h>
  39 #include <avahi-common/alternative.h>
  40 #include <avahi-client/client.h>
  41
  42 #include "warn.h"
  43 #include "dns_sd.h"
  44
  45 enum {
  46     COMMAND_POLL = 'P',
  47     COMMAND_QUIT = 'Q',
  48     COMMAND_POLLED = 'D'
  49 };
  50
  51 struct _DNSServiceRef_t {
  52     int n_ref;
  53
  54     AvahiSimplePoll *simple_poll;
  55
  56     int thread_fd, main_fd;
  57
  58     pthread_t thread;
  59     int thread_running;
  60
  61     pthread_mutex_t mutex;
  62
  63     void *context;
  64     DNSServiceBrowseReply service_browser_callback;
  65     DNSServiceResolveReply service_resolver_callback;
  66     DNSServiceDomainEnumReply domain_browser_callback;
  67     DNSServiceRegisterReply service_register_callback;
  68
  69     AvahiClient *client;
  70     AvahiServiceBrowser *service_browser;
  71     AvahiServiceResolver *service_resolver;
  72     AvahiDomainBrowser *domain_browser;
  73
  74     char *service_name, *service_name_chosen, *service_regtype, *service_domain, *service_host;
  75     uint16_t service_port;
  76     AvahiIfIndex service_interface;
  77     AvahiStringList *service_txt;
  78
  79     AvahiEntryGroup *entry_group;
  80 };
  81
  82 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }
  83
  84 static DNSServiceErrorType map_error(int error) {
  85     switch (error) {
  86         case AVAHI_OK :
  87             return kDNSServiceErr_NoError;
  88
  89         case AVAHI_ERR_BAD_STATE :
  90             return kDNSServiceErr_BadState;
  91
  92         case AVAHI_ERR_INVALID_HOST_NAME:
  93         case AVAHI_ERR_INVALID_DOMAIN_NAME:
  94         case AVAHI_ERR_INVALID_TTL:
  95         case AVAHI_ERR_IS_PATTERN:
  96         case AVAHI_ERR_INVALID_RECORD:
  97         case AVAHI_ERR_INVALID_SERVICE_NAME:
  98         case AVAHI_ERR_INVALID_SERVICE_TYPE:
  99         case AVAHI_ERR_INVALID_PORT:
 100         case AVAHI_ERR_INVALID_KEY:
 101         case AVAHI_ERR_INVALID_ADDRESS:
 102             return kDNSServiceErr_BadParam;
 103
 104
 105         case AVAHI_ERR_LOCAL_COLLISION:
 106             return kDNSServiceErr_NameConflict;
 107
 108         case AVAHI_ERR_TOO_MANY_CLIENTS:
 109         case AVAHI_ERR_TOO_MANY_OBJECTS:
 110         case AVAHI_ERR_TOO_MANY_ENTRIES:
 111         case AVAHI_ERR_ACCESS_DENIED:
 112             return kDNSServiceErr_Refused;
 113
 114         case AVAHI_ERR_INVALID_OPERATION:
 115         case AVAHI_ERR_INVALID_OBJECT:
 116             return kDNSServiceErr_Invalid;
 117
 118         case AVAHI_ERR_NO_MEMORY:
 119             return kDNSServiceErr_NoMemory;
 120
 121         case AVAHI_ERR_INVALID_INTERFACE:
 122         case AVAHI_ERR_INVALID_PROTOCOL:
 123             return kDNSServiceErr_BadInterfaceIndex;
 124
 125         case AVAHI_ERR_INVALID_FLAGS:
 126             return kDNSServiceErr_BadFlags;
 127
 128         case AVAHI_ERR_NOT_FOUND:
 129             return kDNSServiceErr_NoSuchName;
 130
 131         case AVAHI_ERR_VERSION_MISMATCH:
 132             return kDNSServiceErr_Incompatible;
 133
 134         case AVAHI_ERR_NO_NETWORK:
 135         case AVAHI_ERR_OS:
 136         case AVAHI_ERR_INVALID_CONFIG:
 137         case AVAHI_ERR_TIMEOUT:
 138         case AVAHI_ERR_DBUS_ERROR:
 139         case AVAHI_ERR_NOT_CONNECTED:
 140         case AVAHI_ERR_NO_DAEMON:
 141             break;
 142
 143     }
 144
 145     return kDNSServiceErr_Unknown;
 146 }
 147
 148 static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
 149     if (!s)
 150         return NULL;
 151
 152     if (*s == 0)
 153         return s;
 154
 155     if (s[strlen(s)-1] == '.')
 156         return s;
 157
 158     snprintf(buf, buf_len, "%s.", s);
 159     return buf;
 160 }
 161
 162 static int read_command(int fd) {
 163     ssize_t r;
 164     char command;
 165
 166     assert(fd >= 0);
 167
 168     if ((r = read(fd, &command, 1)) != 1) {
 169         fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
 170         return -1;
 171     }
 172
 173     return command;
 174 }
 175
 176 static int write_command(int fd, char reply) {
 177     assert(fd >= 0);
 178
 179     if (write(fd, &reply, 1) != 1) {
 180         fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
 181         return -1;
 182     }
 183
 184     return 0;
 185 }
 186
 187 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
 188     DNSServiceRef sdref = userdata;
 189     int ret;
 190
 191     assert(sdref);
 192
 193     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 194
 195 /*     fprintf(stderr, "pre-syscall\n"); */
 196     ret = poll(ufds, nfds, timeout);
 197 /*     fprintf(stderr, "post-syscall\n"); */
 198
 199     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 200
 201     return ret;
 202 }
 203
 204 static void * thread_func(void *data) {
 205     DNSServiceRef sdref = data;
 206     sigset_t mask;
 207
 208     sigfillset(&mask);
 209     pthread_sigmask(SIG_BLOCK, &mask, NULL);
 210
 211     sdref->thread = pthread_self();
 212     sdref->thread_running = 1;
 213
 214     for (;;) {
 215         char command;
 216
 217         if ((command = read_command(sdref->thread_fd)) < 0)
 218             break;
 219
 220 /*         fprintf(stderr, "Command: %c\n", command); */
 221
 222         switch (command) {
 223
 224             case COMMAND_POLL:
 225
 226                 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 227
 228
 229                 if (avahi_simple_poll_run(sdref->simple_poll) < 0) {
 230                     fprintf(stderr, __FILE__": avahi_simple_poll_run() failed.\n");
 231                     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 232                     break;
 233                 }
 234
 235                 if (write_command(sdref->thread_fd, COMMAND_POLLED) < 0) {
 236                     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 237                     break;
 238                 }
 239
 240                 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 241
 242                 break;
 243
 244             case COMMAND_QUIT:
 245                 return NULL;
 246         }
 247
 248     }
 249
 250     return NULL;
 251 }
 252
 253 static DNSServiceRef sdref_new(void) {
 254     int fd[2] = { -1, -1 };
 255     DNSServiceRef sdref = NULL;
 256     pthread_mutexattr_t mutex_attr;
 257
 258     if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
 259         goto fail;
 260
 261     if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
 262         goto fail;
 263
 264     sdref->n_ref = 1;
 265     sdref->thread_fd = fd[0];
 266     sdref->main_fd = fd[1];
 267
 268     sdref->client = NULL;
 269     sdref->service_browser = NULL;
 270     sdref->service_resolver = NULL;
 271     sdref->domain_browser = NULL;
 272     sdref->entry_group = NULL;
 273
 274     sdref->service_name = sdref->service_name_chosen = sdref->service_regtype = sdref->service_domain = sdref->service_host = NULL;
 275     sdref->service_txt = NULL;
 276
 277     ASSERT_SUCCESS(pthread_mutexattr_init(&mutex_attr));
 278     pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
 279     ASSERT_SUCCESS(pthread_mutex_init(&sdref->mutex, NULL));
 280
 281     sdref->thread_running = 0;
 282
 283     if (!(sdref->simple_poll = avahi_simple_poll_new()))
 284         goto fail;
 285
 286     avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);
 287
 288     /* Start simple poll */
 289     if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
 290         goto fail;
 291
 292     /* Queue a initiall POLL command for the thread */
 293     if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
 294         goto fail;
 295
 296     if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
 297         goto fail;
 298
 299     sdref->thread_running = 1;
 300
 301     return sdref;
 302
 303 fail:
 304
 305     if (sdref)
 306         DNSServiceRefDeallocate(sdref);
 307
 308     return NULL;
 309 }
 310
 311 static void sdref_free(DNSServiceRef sdref) {
 312     assert(sdref);
 313
 314     if (sdref->thread_running) {
 315         write_command(sdref->main_fd, COMMAND_QUIT);
 316         avahi_simple_poll_wakeup(sdref->simple_poll);
 317         pthread_join(sdref->thread, NULL);
 318     }
 319
 320     if (sdref->client)
 321         avahi_client_free(sdref->client);
 322
 323     if (sdref->thread_fd >= 0)
 324         close(sdref->thread_fd);
 325
 326     if (sdref->main_fd >= 0)
 327         close(sdref->main_fd);
 328
 329     if (sdref->simple_poll)
 330         avahi_simple_poll_free(sdref->simple_poll);
 331
 332     pthread_mutex_destroy(&sdref->mutex);
 333
 334     avahi_free(sdref->service_name);
 335     avahi_free(sdref->service_name_chosen);
 336     avahi_free(sdref->service_regtype);
 337     avahi_free(sdref->service_domain);
 338     avahi_free(sdref->service_host);
 339
 340     avahi_string_list_free(sdref->service_txt);
 341
 342     avahi_free(sdref);
 343 }
 344
 345 static void sdref_ref(DNSServiceRef sdref) {
 346     assert(sdref);
 347     assert(sdref->n_ref >= 1);
 348
 349     sdref->n_ref++;
 350 }
 351
 352 static void sdref_unref(DNSServiceRef sdref) {
 353     assert(sdref);
 354     assert(sdref->n_ref >= 1);
 355
 356     if (--(sdref->n_ref) <= 0)
 357         sdref_free(sdref);
 358 }
 359
 360 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {
 361     assert(sdref);
 362     assert(sdref->n_ref >= 1);
 363
 364     AVAHI_WARN_LINKAGE;
 365
 366     return sdref->main_fd;
 367 }
 368
 369 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
 370     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 371
 372     assert(sdref);
 373     assert(sdref->n_ref >= 1);
 374
 375     AVAHI_WARN_LINKAGE;
 376
 377     sdref_ref(sdref);
 378
 379     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 380
 381     /* Cleanup notification socket */
 382     if (read_command(sdref->main_fd) != COMMAND_POLLED)
 383         goto finish;
 384
 385     if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
 386         goto finish;
 387
 388     if (sdref->n_ref > 1) /* Perhaps we should die */
 389
 390         /* Dispatch events */
 391         if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
 392             goto finish;
 393
 394     if (sdref->n_ref > 1)
 395
 396         /* Request the poll */
 397         if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
 398             goto finish;
 399
 400     ret = kDNSServiceErr_NoError;
 401
 402 finish:
 403
 404     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 405
 406     sdref_unref(sdref);
 407
 408     return ret;
 409 }
 410
 411 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
 412     assert(sdref);
 413     assert(sdref->n_ref >= 1);
 414
 415     AVAHI_WARN_LINKAGE;
 416
 417     sdref_unref(sdref);
 418 }
 419
 420 static void service_browser_callback(
 421     AvahiServiceBrowser *b,
 422     AvahiIfIndex interface,
 423     AvahiProtocol protocol,
 424     AvahiBrowserEvent event,
 425     const char *name,
 426     const char *type,
 427     const char *domain,
 428     AvahiLookupResultFlags flags,
 429     void *userdata) {
 430
 431     DNSServiceRef sdref = userdata;
 432     char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 433     assert(b);
 434     assert(sdref);
 435     assert(sdref->n_ref >= 1);
 436
 437     type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
 438     domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
 439
 440     switch (event) {
 441         case AVAHI_BROWSER_NEW:
 442             sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
 443             break;
 444
 445         case AVAHI_BROWSER_REMOVE:
 446             sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
 447             break;
 448
 449         case AVAHI_BROWSER_FAILURE:
 450             sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_Unknown, NULL, NULL, NULL, sdref->context);
 451             break;
 452
 453         case AVAHI_BROWSER_NOT_FOUND:
 454             sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, NULL, NULL, NULL, sdref->context);
 455             break;
 456
 457         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 458         case AVAHI_BROWSER_ALL_FOR_NOW:
 459             break;
 460     }
 461 }
 462
 463 static void generic_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
 464     DNSServiceRef sdref = userdata;
 465
 466     assert(s);
 467     assert(sdref);
 468     assert(sdref->n_ref >= 1);
 469
 470     switch (state) {
 471         case AVAHI_CLIENT_DISCONNECTED: {
 472
 473             if (sdref->service_browser_callback)
 474                 sdref->service_browser_callback(sdref, 0, 0, kDNSServiceErr_Unknown, NULL, NULL, NULL, sdref->context);
 475             else if (sdref->service_resolver_callback)
 476                 sdref->service_resolver_callback(sdref, 0, 0, kDNSServiceErr_Unknown, NULL, NULL, 0, 0, NULL, sdref->context);
 477             else if (sdref->domain_browser_callback)
 478                 sdref->domain_browser_callback(sdref, 0, 0, kDNSServiceErr_Unknown, NULL, sdref->context);
 479
 480             break;
 481         }
 482
 483         case AVAHI_CLIENT_S_RUNNING:
 484         case AVAHI_CLIENT_S_COLLISION:
 485         case AVAHI_CLIENT_S_INVALID:
 486         case AVAHI_CLIENT_S_REGISTERING:
 487             break;
 488     }
 489 }
 490
 491 DNSServiceErrorType DNSSD_API DNSServiceBrowse(
 492     DNSServiceRef *ret_sdref,
 493     DNSServiceFlags flags,
 494     uint32_t interface,
 495     const char *regtype,
 496     const char *domain,
 497     DNSServiceBrowseReply callback,
 498     void *context) {
 499
 500     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 501     int error;
 502     DNSServiceRef sdref = NULL;
 503     AvahiIfIndex ifindex;
 504
 505     AVAHI_WARN_LINKAGE;
 506
 507     assert(ret_sdref);
 508     assert(regtype);
 509     assert(domain);
 510     assert(callback);
 511
 512     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
 513         AVAHI_WARN_UNSUPPORTED;
 514         return kDNSServiceErr_Unsupported;
 515     }
 516
 517     if (!(sdref = sdref_new()))
 518         return kDNSServiceErr_Unknown;
 519
 520     sdref->context = context;
 521     sdref->service_browser_callback = callback;
 522
 523     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 524
 525     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), generic_client_callback, sdref, &error))) {
 526         ret =  map_error(error);
 527         goto finish;
 528     }
 529
 530     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 531
 532     if (!(sdref->service_browser = avahi_service_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, regtype, domain, 0, service_browser_callback, sdref))) {
 533         ret = map_error(avahi_client_errno(sdref->client));
 534         goto finish;
 535     }
 536
 537     ret = kDNSServiceErr_NoError;
 538     *ret_sdref = sdref;
 539
 540 finish:
 541
 542     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 543
 544     if (ret != kDNSServiceErr_NoError)
 545         DNSServiceRefDeallocate(sdref);
 546
 547     return ret;
 548 }
 549
 550 static void service_resolver_callback(
 551     AvahiServiceResolver *r,
 552     AvahiIfIndex interface,
 553     AvahiProtocol protocol,
 554     AvahiResolverEvent event,
 555     const char *name,
 556     const char *type,
 557     const char *domain,
 558     const char *host_name,
 559     const AvahiAddress *a,
 560     uint16_t port,
 561     AvahiStringList *txt,
 562     AvahiLookupResultFlags flags,
 563     void *userdata) {
 564
 565     DNSServiceRef sdref = userdata;
 566     char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
 567
 568     assert(r);
 569     assert(sdref);
 570     assert(sdref->n_ref >= 1);
 571
 572     host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));
 573
 574     switch (event) {
 575         case AVAHI_RESOLVER_FOUND: {
 576
 577             char full_name[AVAHI_DOMAIN_NAME_MAX];
 578             int ret;
 579             char *p = NULL;
 580             size_t l = 0;
 581
 582             if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
 583                 avahi_string_list_serialize(txt, p, l);
 584
 585             ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
 586             assert(ret == AVAHI_OK);
 587
 588             strcat(full_name, ".");
 589
 590             sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, p, sdref->context);
 591
 592             avahi_free(p);
 593             break;
 594         }
 595
 596         case AVAHI_RESOLVER_TIMEOUT:
 597         case AVAHI_RESOLVER_NOT_FOUND:
 598             sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, NULL, NULL, 0, 0, NULL, sdref->context);
 599             break;
 600
 601         case AVAHI_RESOLVER_FAILURE:
 602             sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_Unknown, NULL, NULL, 0, 0, NULL, sdref->context);
 603
 604     }
 605 }
 606
 607 DNSServiceErrorType DNSSD_API DNSServiceResolve(
 608     DNSServiceRef *ret_sdref,
 609     DNSServiceFlags flags,
 610     uint32_t interface,
 611     const char *name,
 612     const char *regtype,
 613     const char *domain,
 614     DNSServiceResolveReply callback,
 615     void *context) {
 616
 617     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 618     int error;
 619     DNSServiceRef sdref = NULL;
 620     AvahiIfIndex ifindex;
 621
 622     AVAHI_WARN_LINKAGE;
 623
 624     assert(ret_sdref);
 625     assert(name);
 626     assert(regtype);
 627     assert(domain);
 628     assert(callback);
 629
 630     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
 631         AVAHI_WARN_UNSUPPORTED;
 632         return kDNSServiceErr_Unsupported;
 633     }
 634
 635     if (!(sdref = sdref_new()))
 636         return kDNSServiceErr_Unknown;
 637
 638     sdref->context = context;
 639     sdref->service_resolver_callback = callback;
 640
 641     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 642
 643     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), generic_client_callback, sdref, &error))) {
 644         ret =  map_error(error);
 645         goto finish;
 646     }
 647
 648     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 649
 650     if (!(sdref->service_resolver = avahi_service_resolver_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, name, regtype, domain, AVAHI_PROTO_UNSPEC, 0, service_resolver_callback, sdref))) {
 651         ret = map_error(avahi_client_errno(sdref->client));
 652         goto finish;
 653     }
 654
 655
 656     ret = kDNSServiceErr_NoError;
 657     *ret_sdref = sdref;
 658
 659 finish:
 660
 661     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 662
 663     if (ret != kDNSServiceErr_NoError)
 664         DNSServiceRefDeallocate(sdref);
 665
 666     return ret;
 667 }
 668
 669 int DNSSD_API DNSServiceConstructFullName (
 670     char *fullName,
 671     const char *service,
 672     const char *regtype,
 673     const char *domain) {
 674
 675     AVAHI_WARN_LINKAGE;
 676
 677     assert(fullName);
 678     assert(regtype);
 679     assert(domain);
 680
 681     if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
 682         return -1;
 683
 684     return 0;
 685 }
 686
 687 static void domain_browser_callback(
 688     AvahiDomainBrowser *b,
 689     AvahiIfIndex interface,
 690     AvahiProtocol protocol,
 691     AvahiBrowserEvent event,
 692     const char *domain,
 693     AvahiLookupResultFlags flags,
 694     void *userdata) {
 695
 696     DNSServiceRef sdref = userdata;
 697     static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 698
 699     assert(b);
 700     assert(sdref);
 701     assert(sdref->n_ref >= 1);
 702
 703     domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
 704
 705     switch (event) {
 706         case AVAHI_BROWSER_NEW:
 707             sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
 708             break;
 709
 710         case AVAHI_BROWSER_REMOVE:
 711             sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, domain, sdref->context);
 712             break;
 713
 714         case AVAHI_BROWSER_FAILURE:
 715             sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_Unknown, domain, sdref->context);
 716             break;
 717
 718         case AVAHI_BROWSER_NOT_FOUND:
 719             sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoSuchName, domain, sdref->context);
 720             break;
 721
 722         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 723         case AVAHI_BROWSER_ALL_FOR_NOW:
 724             break;
 725     }
 726 }
 727
 728 DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
 729     DNSServiceRef *ret_sdref,
 730     DNSServiceFlags flags,
 731     uint32_t interface,
 732     DNSServiceDomainEnumReply callback,
 733     void *context) {
 734
 735     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 736     int error;
 737     DNSServiceRef sdref = NULL;
 738     AvahiIfIndex ifindex;
 739
 740     AVAHI_WARN_LINKAGE;
 741
 742     assert(ret_sdref);
 743     assert(callback);
 744
 745     if (interface == kDNSServiceInterfaceIndexLocalOnly ||
 746         (flags != kDNSServiceFlagsBrowseDomains &&  flags != kDNSServiceFlagsRegistrationDomains)) {
 747         AVAHI_WARN_UNSUPPORTED;
 748         return kDNSServiceErr_Unsupported;
 749     }
 750
 751     if (!(sdref = sdref_new()))
 752         return kDNSServiceErr_Unknown;
 753
 754     sdref->context = context;
 755     sdref->domain_browser_callback = callback;
 756
 757     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 758
 759     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), generic_client_callback, sdref, &error))) {
 760         ret =  map_error(error);
 761         goto finish;
 762     }
 763
 764     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 765
 766     if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, "local",
 767                                                            flags == kDNSServiceFlagsRegistrationDomains ? AVAHI_DOMAIN_BROWSER_REGISTER : AVAHI_DOMAIN_BROWSER_BROWSE,
 768                                                            0, domain_browser_callback, sdref))) {
 769         ret = map_error(avahi_client_errno(sdref->client));
 770         goto finish;
 771     }
 772
 773     ret = kDNSServiceErr_NoError;
 774     *ret_sdref = sdref;
 775
 776 finish:
 777
 778     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 779
 780     if (ret != kDNSServiceErr_NoError)
 781         DNSServiceRefDeallocate(sdref);
 782
 783     return ret;
 784 }
 785
 786 static void reg_report_error(DNSServiceRef sdref, DNSServiceErrorType error) {
 787     char regtype_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 788     const char *regtype, *domain;
 789     assert(sdref);
 790     assert(sdref->n_ref >= 1);
 791
 792     assert(sdref->service_register_callback);
 793
 794     regtype = add_trailing_dot(sdref->service_regtype, regtype_fixed, sizeof(regtype_fixed));
 795     domain = add_trailing_dot(sdref->service_domain, domain_fixed, sizeof(domain_fixed));
 796
 797     sdref->service_register_callback(
 798         sdref, 0, error,
 799         sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
 800         regtype,
 801         domain,
 802         sdref->context);
 803 }
 804
 805 static int reg_create_service(DNSServiceRef sdref) {
 806     int ret;
 807     assert(sdref);
 808     assert(sdref->n_ref >= 1);
 809
 810     if ((ret = avahi_entry_group_add_service_strlst(
 811         sdref->entry_group,
 812         sdref->service_interface,
 813         AVAHI_PROTO_UNSPEC,
 814         0,
 815         sdref->service_name_chosen,
 816         sdref->service_regtype,
 817         sdref->service_domain,
 818         sdref->service_host,
 819         sdref->service_port,
 820         sdref->service_txt)) < 0)
 821         return ret;
 822
 823     if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
 824         return ret;
 825
 826     return 0;
 827 }
 828
 829 static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
 830     DNSServiceRef sdref = userdata;
 831
 832     assert(s);
 833     assert(sdref);
 834     assert(sdref->n_ref >= 1);
 835
 836     /* We've not been setup completely */
 837     if (!sdref->entry_group)
 838         return;
 839
 840     switch (state) {
 841         case AVAHI_CLIENT_DISCONNECTED: {
 842
 843             reg_report_error(sdref, kDNSServiceErr_NoError);
 844             break;
 845         }
 846
 847         case AVAHI_CLIENT_S_RUNNING: {
 848             int ret;
 849
 850             if (!sdref->service_name) {
 851                 const char *n;
 852                 /* If the service name is taken from the host name, copy that */
 853
 854                 avahi_free(sdref->service_name_chosen);
 855
 856                 if (!(n = avahi_client_get_host_name(sdref->client))) {
 857                     reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
 858                     return;
 859                 }
 860
 861                 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
 862                     reg_report_error(sdref, kDNSServiceErr_NoMemory);
 863                     return;
 864                 }
 865             }
 866
 867             /* Register the service */
 868
 869             if ((ret = reg_create_service(sdref)) < 0) {
 870                 reg_report_error(sdref, map_error(ret));
 871                 return;
 872             }
 873
 874             break;
 875         }
 876
 877         case AVAHI_CLIENT_S_COLLISION:
 878
 879             /* Remove our entry */
 880             avahi_entry_group_reset(sdref->entry_group);
 881
 882             break;
 883
 884         case AVAHI_CLIENT_S_INVALID:
 885         case AVAHI_CLIENT_S_REGISTERING:
 886             /* Ignore */
 887             break;
 888     }
 889
 890 }
 891
 892 static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
 893     DNSServiceRef sdref = userdata;
 894
 895     assert(g);
 896
 897     switch (state) {
 898         case AVAHI_ENTRY_GROUP_ESTABLISHED:
 899             /* Inform the user */
 900             reg_report_error(sdref, kDNSServiceErr_NoError);
 901
 902             break;
 903
 904         case AVAHI_ENTRY_GROUP_COLLISION: {
 905             char *n;
 906             int ret;
 907
 908             /* Remove our entry */
 909             avahi_entry_group_reset(sdref->entry_group);
 910
 911             assert(sdref->service_name_chosen);
 912
 913             /* Pick a new name */
 914             if (!(n = avahi_alternative_service_name(sdref->service_name_chosen))) {
 915                 reg_report_error(sdref, kDNSServiceErr_NoMemory);
 916                 return;
 917             }
 918             avahi_free(sdref->service_name_chosen);
 919             sdref->service_name_chosen = n;
 920
 921             /* Register the service with that new name */
 922             if ((ret = reg_create_service(sdref)) < 0) {
 923                 reg_report_error(sdref, map_error(ret));
 924                 return;
 925             }
 926
 927             break;
 928         }
 929
 930         case AVAHI_ENTRY_GROUP_REGISTERING:
 931         case AVAHI_ENTRY_GROUP_UNCOMMITED:
 932             /* Ignore */
 933             break;
 934     }
 935 }
 936
 937 DNSServiceErrorType DNSSD_API DNSServiceRegister (
 938     DNSServiceRef *ret_sdref,
 939     DNSServiceFlags flags,
 940     uint32_t interface,
 941     const char *name,
 942     const char *regtype,
 943     const char *domain,
 944     const char *host,
 945     uint16_t port,
 946     uint16_t txtLen,
 947     const void *txtRecord,
 948     DNSServiceRegisterReply callback,
 949     void *context) {
 950
 951     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 952     int error;
 953     DNSServiceRef sdref = NULL;
 954
 955     AVAHI_WARN_LINKAGE;
 956
 957     assert(ret_sdref);
 958     assert(callback);
 959     assert(regtype);
 960
 961     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
 962         AVAHI_WARN_UNSUPPORTED;
 963         return kDNSServiceErr_Unsupported;
 964     }
 965
 966     if (!(sdref = sdref_new()))
 967         return kDNSServiceErr_Unknown;
 968
 969     sdref->context = context;
 970     sdref->service_register_callback = callback;
 971
 972     sdref->service_name = avahi_strdup(name);
 973     sdref->service_regtype = regtype ? avahi_normalize_name_strdup(regtype) : NULL;
 974     sdref->service_domain = domain ? avahi_normalize_name_strdup(domain) : NULL;
 975     sdref->service_host = host ? avahi_normalize_name_strdup(host) : NULL;
 976     sdref->service_interface = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 977     sdref->service_port = ntohs(port);
 978     sdref->service_txt = txtRecord ? avahi_string_list_parse(txtRecord, txtLen) : NULL;
 979
 980     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 981
 982     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), reg_client_callback, sdref, &error))) {
 983         ret =  map_error(error);
 984         goto finish;
 985     }
 986
 987     if (!sdref->service_domain) {
 988         const char *d;
 989
 990         if (!(d = avahi_client_get_domain_name(sdref->client))) {
 991             ret = map_error(avahi_client_errno(sdref->client));
 992             goto finish;
 993         }
 994
 995         if (!(sdref->service_domain = avahi_strdup(d))) {
 996             ret = kDNSServiceErr_NoMemory;
 997             goto finish;
 998         }
 999     }
1000
1001     if (!(sdref->entry_group = avahi_entry_group_new(sdref->client, reg_entry_group_callback, sdref))) {
1002         ret = map_error(avahi_client_errno(sdref->client));
1003         goto finish;
1004     }
1005
1006     if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING) {
1007         const char *n;
1008
1009         if (sdref->service_name)
1010             n = sdref->service_name;
1011         else {
1012             if (!(n = avahi_client_get_host_name(sdref->client))) {
1013                 ret = map_error(avahi_client_errno(sdref->client));
1014                 goto finish;
1015             }
1016         }
1017
1018         if (!(sdref->service_name_chosen = avahi_strdup(n))) {
1019             ret = kDNSServiceErr_NoMemory;
1020             goto finish;
1021         }
1022
1023
1024         if ((error = reg_create_service(sdref)) < 0) {
1025             ret = map_error(error);
1026             goto finish;
1027         }
1028     }
1029
1030     ret = kDNSServiceErr_NoError;
1031     *ret_sdref = sdref;
1032
1033 finish:
1034
1035     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
1036
1037     if (ret != kDNSServiceErr_NoError)
1038         DNSServiceRefDeallocate(sdref);
1039
1040     return ret;
1041 }
1042