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