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