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