git.meshlink.io Git - catta/blob - avahi-compat-libdns_sd/compat.c

   1 /***
   2   This file is part of avahi.
   3
   4   avahi is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU Lesser General Public License as
   6   published by the Free Software Foundation; either version 2.1 of the
   7   License, or (at your option) any later version.
   8
   9   avahi is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  12   Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public
  15   License along with avahi; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  17   USA.
  18 ***/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <pthread.h>
  25 #include <assert.h>
  26 #include <unistd.h>
  27 #include <stdio.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <signal.h>
  31 #include <netinet/in.h>
  32 #include <fcntl.h>
  33
  34 #include <sys/types.h>
  35 #include <sys/socket.h>
  36
  37 #include <avahi-common/simple-watch.h>
  38 #include <avahi-common/malloc.h>
  39 #include <avahi-common/error.h>
  40 #include <avahi-common/domain.h>
  41 #include <avahi-common/alternative.h>
  42
  43 #include <avahi-client/client.h>
  44 #include <avahi-client/publish.h>
  45 #include <avahi-client/lookup.h>
  46
  47 #include "warn.h"
  48 #include "dns_sd.h"
  49
  50 enum {
  51     COMMAND_POLL = 'p',
  52     COMMAND_QUIT = 'q',
  53     COMMAND_POLL_DONE = 'P',
  54     COMMAND_POLL_FAILED = 'F'
  55 };
  56
  57 struct type_info {
  58     char *type;
  59     AvahiStringList *subtypes;
  60     int n_subtypes;
  61 };
  62
  63 struct _DNSServiceRef_t {
  64     int n_ref;
  65
  66     AvahiSimplePoll *simple_poll;
  67
  68     int thread_fd, main_fd;
  69
  70     pthread_t thread;
  71     int thread_running;
  72
  73     pthread_mutex_t mutex;
  74
  75     void *context;
  76     DNSServiceBrowseReply service_browser_callback;
  77     DNSServiceResolveReply service_resolver_callback;
  78     DNSServiceDomainEnumReply domain_browser_callback;
  79     DNSServiceRegisterReply service_register_callback;
  80
  81     AvahiClient *client;
  82     AvahiServiceBrowser *service_browser;
  83     AvahiServiceResolver *service_resolver;
  84     AvahiDomainBrowser *domain_browser;
  85
  86     struct type_info type_info;
  87     char *service_name, *service_name_chosen, *service_domain, *service_host;
  88     uint16_t service_port;
  89     AvahiIfIndex service_interface;
  90     AvahiStringList *service_txt;
  91
  92     AvahiEntryGroup *entry_group;
  93 };
  94
  95 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }
  96
  97 static DNSServiceErrorType map_error(int error) {
  98     switch (error) {
  99         case AVAHI_OK :
 100             return kDNSServiceErr_NoError;
 101
 102         case AVAHI_ERR_BAD_STATE :
 103             return kDNSServiceErr_BadState;
 104
 105         case AVAHI_ERR_INVALID_HOST_NAME:
 106         case AVAHI_ERR_INVALID_DOMAIN_NAME:
 107         case AVAHI_ERR_INVALID_TTL:
 108         case AVAHI_ERR_IS_PATTERN:
 109         case AVAHI_ERR_INVALID_RECORD:
 110         case AVAHI_ERR_INVALID_SERVICE_NAME:
 111         case AVAHI_ERR_INVALID_SERVICE_TYPE:
 112         case AVAHI_ERR_INVALID_PORT:
 113         case AVAHI_ERR_INVALID_KEY:
 114         case AVAHI_ERR_INVALID_ADDRESS:
 115         case AVAHI_ERR_INVALID_SERVICE_SUBTYPE:
 116             return kDNSServiceErr_BadParam;
 117
 118
 119         case AVAHI_ERR_COLLISION:
 120             return kDNSServiceErr_NameConflict;
 121
 122         case AVAHI_ERR_TOO_MANY_CLIENTS:
 123         case AVAHI_ERR_TOO_MANY_OBJECTS:
 124         case AVAHI_ERR_TOO_MANY_ENTRIES:
 125         case AVAHI_ERR_ACCESS_DENIED:
 126             return kDNSServiceErr_Refused;
 127
 128         case AVAHI_ERR_INVALID_OPERATION:
 129         case AVAHI_ERR_INVALID_OBJECT:
 130             return kDNSServiceErr_Invalid;
 131
 132         case AVAHI_ERR_NO_MEMORY:
 133             return kDNSServiceErr_NoMemory;
 134
 135         case AVAHI_ERR_INVALID_INTERFACE:
 136         case AVAHI_ERR_INVALID_PROTOCOL:
 137             return kDNSServiceErr_BadInterfaceIndex;
 138
 139         case AVAHI_ERR_INVALID_FLAGS:
 140             return kDNSServiceErr_BadFlags;
 141
 142         case AVAHI_ERR_NOT_FOUND:
 143             return kDNSServiceErr_NoSuchName;
 144
 145         case AVAHI_ERR_VERSION_MISMATCH:
 146             return kDNSServiceErr_Incompatible;
 147
 148         case AVAHI_ERR_NO_NETWORK:
 149         case AVAHI_ERR_OS:
 150         case AVAHI_ERR_INVALID_CONFIG:
 151         case AVAHI_ERR_TIMEOUT:
 152         case AVAHI_ERR_DBUS_ERROR:
 153         case AVAHI_ERR_DISCONNECTED:
 154         case AVAHI_ERR_NO_DAEMON:
 155             break;
 156
 157     }
 158
 159     return kDNSServiceErr_Unknown;
 160 }
 161
 162 static void type_info_init(struct type_info *i) {
 163     assert(i);
 164     i->type = NULL;
 165     i->subtypes = NULL;
 166     i->n_subtypes = 0;
 167 }
 168
 169 static void type_info_free(struct type_info *i) {
 170     assert(i);
 171
 172     avahi_free(i->type);
 173     avahi_string_list_free(i->subtypes);
 174
 175     type_info_init(i);
 176 }
 177
 178 static int type_info_parse(struct type_info *i, const char *t) {
 179     char *token = NULL;
 180
 181     assert(i);
 182     assert(t);
 183
 184     type_info_init(i);
 185
 186     for (;;) {
 187         size_t l;
 188
 189         if (*t == 0)
 190             break;
 191
 192         l = strcspn(t, ",");
 193
 194         if (l <= 0)
 195             goto fail;
 196
 197         token = avahi_strndup(t, l);
 198
 199         if (!token)
 200             goto fail;
 201
 202         if (!i->type) {
 203             /* This is the first token, hence the main type */
 204
 205             if (!avahi_is_valid_service_type_strict(token))
 206                 goto fail;
 207
 208             i->type = token;
 209             token = NULL;
 210         } else {
 211             char *fst;
 212
 213             /* This is not the first token, hence a subtype */
 214
 215             if (!(fst = avahi_strdup_printf("%s._sub.%s", token, i->type)))
 216                 goto fail;
 217
 218             if (!avahi_is_valid_service_subtype(fst)) {
 219                 avahi_free(fst);
 220                 goto fail;
 221             }
 222
 223             i->subtypes = avahi_string_list_add(i->subtypes, fst);
 224             avahi_free(fst);
 225
 226             avahi_free(token);
 227             token = NULL;
 228
 229             i->n_subtypes++;
 230         }
 231
 232         t += l;
 233
 234         if (*t == ',')
 235             t++;
 236     }
 237
 238     if (i->type)
 239         return 0;
 240
 241 fail:
 242     type_info_free(i);
 243     avahi_free(token);
 244     return -1;
 245 }
 246
 247 static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
 248     if (!s)
 249         return NULL;
 250
 251     if (*s == 0)
 252         return s;
 253
 254     if (s[strlen(s)-1] == '.')
 255         return s;
 256
 257     snprintf(buf, buf_len, "%s.", s);
 258     return buf;
 259 }
 260
 261 static int read_command(int fd) {
 262     ssize_t r;
 263     char command;
 264
 265     assert(fd >= 0);
 266
 267     if ((r = read(fd, &command, 1)) != 1) {
 268         fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
 269         return -1;
 270     }
 271
 272     return command;
 273 }
 274
 275 static int write_command(int fd, char reply) {
 276     assert(fd >= 0);
 277
 278     if (write(fd, &reply, 1) != 1) {
 279         fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
 280         return -1;
 281     }
 282
 283     return 0;
 284 }
 285
 286 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
 287     DNSServiceRef sdref = userdata;
 288     int ret;
 289
 290     assert(sdref);
 291
 292     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 293
 294 /*     fprintf(stderr, "pre-syscall\n"); */
 295     ret = poll(ufds, nfds, timeout);
 296 /*     fprintf(stderr, "post-syscall\n"); */
 297
 298     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 299
 300     return ret;
 301 }
 302
 303 static void * thread_func(void *data) {
 304     DNSServiceRef sdref = data;
 305     sigset_t mask;
 306
 307     sigfillset(&mask);
 308     pthread_sigmask(SIG_BLOCK, &mask, NULL);
 309
 310     sdref->thread = pthread_self();
 311     sdref->thread_running = 1;
 312
 313     for (;;) {
 314         char command;
 315
 316         if ((command = read_command(sdref->thread_fd)) < 0)
 317             break;
 318
 319 /*         fprintf(stderr, "Command: %c\n", command); */
 320
 321         switch (command) {
 322
 323             case COMMAND_POLL: {
 324                 int ret;
 325
 326                 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 327
 328                 for (;;) {
 329                     errno = 0;
 330
 331                     if ((ret = avahi_simple_poll_run(sdref->simple_poll)) < 0) {
 332
 333                         if (errno == EINTR)
 334                             continue;
 335
 336                         fprintf(stderr, __FILE__": avahi_simple_poll_run() failed: %s\n", strerror(errno));
 337                     }
 338
 339                     break;
 340                 }
 341
 342                 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 343
 344                 if (write_command(sdref->thread_fd, ret < 0 ? COMMAND_POLL_FAILED : COMMAND_POLL_DONE) < 0)
 345                     break;
 346
 347                 break;
 348             }
 349
 350             case COMMAND_QUIT:
 351                 return NULL;
 352         }
 353
 354     }
 355
 356     return NULL;
 357 }
 358
 359 static DNSServiceRef sdref_new(void) {
 360     int fd[2] = { -1, -1 };
 361     DNSServiceRef sdref = NULL;
 362     pthread_mutexattr_t mutex_attr;
 363
 364     if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
 365         goto fail;
 366
 367     if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
 368         goto fail;
 369
 370     sdref->n_ref = 1;
 371     sdref->thread_fd = fd[0];
 372     sdref->main_fd = fd[1];
 373
 374     sdref->client = NULL;
 375     sdref->service_browser = NULL;
 376     sdref->service_resolver = NULL;
 377     sdref->domain_browser = NULL;
 378     sdref->entry_group = NULL;
 379
 380     sdref->service_name = sdref->service_name_chosen = sdref->service_domain = sdref->service_host = NULL;
 381     sdref->service_txt = NULL;
 382
 383     type_info_init(&sdref->type_info);
 384
 385     ASSERT_SUCCESS(pthread_mutexattr_init(&mutex_attr));
 386     pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
 387     ASSERT_SUCCESS(pthread_mutex_init(&sdref->mutex, &mutex_attr));
 388
 389     sdref->thread_running = 0;
 390
 391     if (!(sdref->simple_poll = avahi_simple_poll_new()))
 392         goto fail;
 393
 394     avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);
 395
 396     /* Start simple poll */
 397     if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
 398         goto fail;
 399
 400     /* Queue an initial POLL command for the thread */
 401     if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
 402         goto fail;
 403
 404     if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
 405         goto fail;
 406
 407     sdref->thread_running = 1;
 408
 409     return sdref;
 410
 411 fail:
 412
 413     if (sdref)
 414         DNSServiceRefDeallocate(sdref);
 415
 416     return NULL;
 417 }
 418
 419 static void sdref_free(DNSServiceRef sdref) {
 420     assert(sdref);
 421
 422     if (sdref->thread_running) {
 423         ASSERT_SUCCESS(write_command(sdref->main_fd, COMMAND_QUIT));
 424         avahi_simple_poll_wakeup(sdref->simple_poll);
 425         ASSERT_SUCCESS(pthread_join(sdref->thread, NULL));
 426     }
 427
 428     if (sdref->client)
 429         avahi_client_free(sdref->client);
 430
 431     if (sdref->simple_poll)
 432         avahi_simple_poll_free(sdref->simple_poll);
 433
 434     if (sdref->thread_fd >= 0)
 435         close(sdref->thread_fd);
 436
 437     if (sdref->main_fd >= 0)
 438         close(sdref->main_fd);
 439
 440     ASSERT_SUCCESS(pthread_mutex_destroy(&sdref->mutex));
 441
 442     avahi_free(sdref->service_name);
 443     avahi_free(sdref->service_name_chosen);
 444     avahi_free(sdref->service_domain);
 445     avahi_free(sdref->service_host);
 446
 447     type_info_free(&sdref->type_info);
 448
 449     avahi_string_list_free(sdref->service_txt);
 450
 451     avahi_free(sdref);
 452 }
 453
 454 static void sdref_ref(DNSServiceRef sdref) {
 455     assert(sdref);
 456     assert(sdref->n_ref >= 1);
 457
 458     sdref->n_ref++;
 459 }
 460
 461 static void sdref_unref(DNSServiceRef sdref) {
 462     assert(sdref);
 463     assert(sdref->n_ref >= 1);
 464
 465     if (--(sdref->n_ref) <= 0)
 466         sdref_free(sdref);
 467 }
 468
 469 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {
 470
 471     AVAHI_WARN_LINKAGE;
 472
 473     if (!sdref || sdref->n_ref <= 0)
 474         return -1;
 475
 476     return sdref->main_fd;
 477 }
 478
 479 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
 480     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 481
 482     AVAHI_WARN_LINKAGE;
 483
 484     if (!sdref || sdref->n_ref <= 0)
 485         return kDNSServiceErr_BadParam;
 486
 487     sdref_ref(sdref);
 488
 489     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 490
 491     /* Cleanup notification socket */
 492     if (read_command(sdref->main_fd) != COMMAND_POLL_DONE)
 493         goto finish;
 494
 495     if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
 496         goto finish;
 497
 498     if (sdref->n_ref > 1) /* Perhaps we should die */
 499
 500         /* Dispatch events */
 501         if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
 502             goto finish;
 503
 504     if (sdref->n_ref > 1)
 505
 506         /* Request the poll */
 507         if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
 508             goto finish;
 509
 510     ret = kDNSServiceErr_NoError;
 511
 512 finish:
 513
 514     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 515
 516     sdref_unref(sdref);
 517
 518     return ret;
 519 }
 520
 521 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
 522     AVAHI_WARN_LINKAGE;
 523
 524     if (sdref)
 525         sdref_unref(sdref);
 526 }
 527
 528 static void service_browser_callback(
 529     AvahiServiceBrowser *b,
 530     AvahiIfIndex interface,
 531     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 532     AvahiBrowserEvent event,
 533     const char *name,
 534     const char *type,
 535     const char *domain,
 536     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 537     void *userdata) {
 538
 539     DNSServiceRef sdref = userdata;
 540     char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 541     assert(b);
 542     assert(sdref);
 543     assert(sdref->n_ref >= 1);
 544
 545     type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
 546     domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
 547
 548     switch (event) {
 549         case AVAHI_BROWSER_NEW:
 550             sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
 551             break;
 552
 553         case AVAHI_BROWSER_REMOVE:
 554             sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
 555             break;
 556
 557         case AVAHI_BROWSER_FAILURE:
 558             sdref->service_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, NULL, sdref->context);
 559             break;
 560
 561         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 562         case AVAHI_BROWSER_ALL_FOR_NOW:
 563             break;
 564     }
 565 }
 566
 567 static void generic_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
 568     DNSServiceRef sdref = userdata;
 569     int error = kDNSServiceErr_Unknown;
 570
 571     assert(s);
 572     assert(sdref);
 573     assert(sdref->n_ref >= 1);
 574
 575     switch (state) {
 576
 577         case AVAHI_CLIENT_FAILURE:
 578
 579             if (sdref->service_browser_callback)
 580                 sdref->service_browser_callback(sdref, 0, 0, error, NULL, NULL, NULL, sdref->context);
 581             else if (sdref->service_resolver_callback)
 582                 sdref->service_resolver_callback(sdref, 0, 0, error, NULL, NULL, 0, 0, NULL, sdref->context);
 583             else if (sdref->domain_browser_callback)
 584                 sdref->domain_browser_callback(sdref, 0, 0, error, NULL, sdref->context);
 585
 586             break;
 587
 588         case AVAHI_CLIENT_S_RUNNING:
 589         case AVAHI_CLIENT_S_COLLISION:
 590         case AVAHI_CLIENT_S_REGISTERING:
 591         case AVAHI_CLIENT_CONNECTING:
 592             break;
 593     }
 594 }
 595
 596 DNSServiceErrorType DNSSD_API DNSServiceBrowse(
 597         DNSServiceRef *ret_sdref,
 598         DNSServiceFlags flags,
 599         uint32_t interface,
 600         const char *regtype,
 601         const char *domain,
 602         DNSServiceBrowseReply callback,
 603         void *context) {
 604
 605     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 606     int error;
 607     DNSServiceRef sdref = NULL;
 608     AvahiIfIndex ifindex;
 609     struct type_info type_info;
 610
 611     AVAHI_WARN_LINKAGE;
 612
 613     if (!ret_sdref || !regtype)
 614         return kDNSServiceErr_BadParam;
 615     *ret_sdref = NULL;
 616
 617     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
 618         AVAHI_WARN_UNSUPPORTED;
 619         return kDNSServiceErr_Unsupported;
 620     }
 621
 622     type_info_init(&type_info);
 623
 624     if (type_info_parse(&type_info, regtype) < 0 || type_info.n_subtypes > 1) {
 625         type_info_free(&type_info);
 626
 627         if (!avahi_is_valid_service_type_generic(regtype))
 628             return kDNSServiceErr_Unsupported;
 629     } else
 630         regtype = type_info.subtypes ? (char*) type_info.subtypes->text : type_info.type;
 631
 632     if (!(sdref = sdref_new())) {
 633         type_info_free(&type_info);
 634         return kDNSServiceErr_Unknown;
 635     }
 636
 637     sdref->context = context;
 638     sdref->service_browser_callback = callback;
 639
 640     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 641
 642     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
 643         ret =  map_error(error);
 644         goto finish;
 645     }
 646
 647     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 648
 649     if (!(sdref->service_browser = avahi_service_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, regtype, domain, 0, service_browser_callback, sdref))) {
 650         ret = map_error(avahi_client_errno(sdref->client));
 651         goto finish;
 652     }
 653
 654     ret = kDNSServiceErr_NoError;
 655     *ret_sdref = sdref;
 656
 657 finish:
 658
 659     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 660
 661     if (ret != kDNSServiceErr_NoError)
 662         DNSServiceRefDeallocate(sdref);
 663
 664     type_info_free(&type_info);
 665
 666     return ret;
 667 }
 668
 669 static void service_resolver_callback(
 670     AvahiServiceResolver *r,
 671     AvahiIfIndex interface,
 672     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 673     AvahiResolverEvent event,
 674     const char *name,
 675     const char *type,
 676     const char *domain,
 677     const char *host_name,
 678     AVAHI_GCC_UNUSED const AvahiAddress *a,
 679     uint16_t port,
 680     AvahiStringList *txt,
 681     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 682     void *userdata) {
 683
 684     DNSServiceRef sdref = userdata;
 685
 686     assert(r);
 687     assert(sdref);
 688     assert(sdref->n_ref >= 1);
 689
 690     switch (event) {
 691         case AVAHI_RESOLVER_FOUND: {
 692
 693             char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
 694             char full_name[AVAHI_DOMAIN_NAME_MAX];
 695             int ret;
 696             char *p = NULL;
 697             size_t l = 0;
 698
 699             host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));
 700
 701             if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
 702                 avahi_string_list_serialize(txt, p, l);
 703
 704             ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
 705             assert(ret == AVAHI_OK);
 706
 707             strcat(full_name, ".");
 708
 709             sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, (unsigned char*) p, sdref->context);
 710
 711             avahi_free(p);
 712             break;
 713         }
 714
 715         case AVAHI_RESOLVER_FAILURE:
 716             sdref->service_resolver_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, 0, 0, NULL, sdref->context);
 717             break;
 718     }
 719 }
 720
 721 DNSServiceErrorType DNSSD_API DNSServiceResolve(
 722     DNSServiceRef *ret_sdref,
 723     DNSServiceFlags flags,
 724     uint32_t interface,
 725     const char *name,
 726     const char *regtype,
 727     const char *domain,
 728     DNSServiceResolveReply callback,
 729     void *context) {
 730
 731     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 732     int error;
 733     DNSServiceRef sdref = NULL;
 734     AvahiIfIndex ifindex;
 735
 736     AVAHI_WARN_LINKAGE;
 737
 738     if (!ret_sdref || !name || !regtype || !domain || !callback)
 739         return kDNSServiceErr_BadParam;
 740     *ret_sdref = NULL;
 741
 742     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
 743         AVAHI_WARN_UNSUPPORTED;
 744         return kDNSServiceErr_Unsupported;
 745     }
 746
 747     if (!(sdref = sdref_new()))
 748         return kDNSServiceErr_Unknown;
 749
 750     sdref->context = context;
 751     sdref->service_resolver_callback = callback;
 752
 753     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 754
 755     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
 756         ret =  map_error(error);
 757         goto finish;
 758     }
 759
 760     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 761
 762     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))) {
 763         ret = map_error(avahi_client_errno(sdref->client));
 764         goto finish;
 765     }
 766
 767
 768     ret = kDNSServiceErr_NoError;
 769     *ret_sdref = sdref;
 770
 771 finish:
 772
 773     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 774
 775     if (ret != kDNSServiceErr_NoError)
 776         DNSServiceRefDeallocate(sdref);
 777
 778     return ret;
 779 }
 780
 781 int DNSSD_API DNSServiceConstructFullName (
 782     char *fullName,
 783     const char *service,
 784     const char *regtype,
 785     const char *domain) {
 786
 787     AVAHI_WARN_LINKAGE;
 788
 789     if (!fullName || !regtype || !domain)
 790         return -1;
 791
 792     if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
 793         return -1;
 794
 795     return 0;
 796 }
 797
 798 static void domain_browser_callback(
 799     AvahiDomainBrowser *b,
 800     AvahiIfIndex interface,
 801     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 802     AvahiBrowserEvent event,
 803     const char *domain,
 804     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 805     void *userdata) {
 806
 807     DNSServiceRef sdref = userdata;
 808     static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 809
 810     assert(b);
 811     assert(sdref);
 812     assert(sdref->n_ref >= 1);
 813
 814     domain  = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
 815
 816     switch (event) {
 817         case AVAHI_BROWSER_NEW:
 818             sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
 819             break;
 820
 821         case AVAHI_BROWSER_REMOVE:
 822             sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, domain, sdref->context);
 823             break;
 824
 825         case AVAHI_BROWSER_FAILURE:
 826             sdref->domain_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), domain, sdref->context);
 827             break;
 828
 829         case AVAHI_BROWSER_CACHE_EXHAUSTED:
 830         case AVAHI_BROWSER_ALL_FOR_NOW:
 831             break;
 832     }
 833 }
 834
 835 DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
 836     DNSServiceRef *ret_sdref,
 837     DNSServiceFlags flags,
 838     uint32_t interface,
 839     DNSServiceDomainEnumReply callback,
 840     void *context) {
 841
 842     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
 843     int error;
 844     DNSServiceRef sdref = NULL;
 845     AvahiIfIndex ifindex;
 846
 847     AVAHI_WARN_LINKAGE;
 848
 849     if (!ret_sdref || !callback)
 850         return kDNSServiceErr_BadParam;
 851     *ret_sdref = NULL;
 852
 853     if (interface == kDNSServiceInterfaceIndexLocalOnly ||
 854         (flags != kDNSServiceFlagsBrowseDomains &&  flags != kDNSServiceFlagsRegistrationDomains)) {
 855         AVAHI_WARN_UNSUPPORTED;
 856         return kDNSServiceErr_Unsupported;
 857     }
 858
 859     if (!(sdref = sdref_new()))
 860         return kDNSServiceErr_Unknown;
 861
 862     sdref->context = context;
 863     sdref->domain_browser_callback = callback;
 864
 865     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
 866
 867     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
 868         ret =  map_error(error);
 869         goto finish;
 870     }
 871
 872     ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
 873
 874     if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, "local",
 875                                                            flags == kDNSServiceFlagsRegistrationDomains ? AVAHI_DOMAIN_BROWSER_REGISTER : AVAHI_DOMAIN_BROWSER_BROWSE,
 876                                                            0, domain_browser_callback, sdref))) {
 877         ret = map_error(avahi_client_errno(sdref->client));
 878         goto finish;
 879     }
 880
 881     ret = kDNSServiceErr_NoError;
 882     *ret_sdref = sdref;
 883
 884 finish:
 885
 886     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
 887
 888     if (ret != kDNSServiceErr_NoError)
 889         DNSServiceRefDeallocate(sdref);
 890
 891     return ret;
 892 }
 893
 894 static void reg_report_error(DNSServiceRef sdref, DNSServiceErrorType error) {
 895     char regtype_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
 896     const char *regtype, *domain;
 897     assert(sdref);
 898     assert(sdref->n_ref >= 1);
 899
 900     if (!sdref->service_register_callback)
 901         return;
 902
 903     regtype = add_trailing_dot(sdref->type_info.type, regtype_fixed, sizeof(regtype_fixed));
 904     domain = add_trailing_dot(sdref->service_domain, domain_fixed, sizeof(domain_fixed));
 905
 906     sdref->service_register_callback(
 907         sdref, 0, error,
 908         sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
 909         regtype,
 910         domain,
 911         sdref->context);
 912 }
 913
 914 static int reg_create_service(DNSServiceRef sdref) {
 915     int ret;
 916     AvahiStringList *l;
 917
 918     assert(sdref);
 919     assert(sdref->n_ref >= 1);
 920
 921     if ((ret = avahi_entry_group_add_service_strlst(
 922         sdref->entry_group,
 923         sdref->service_interface,
 924         AVAHI_PROTO_UNSPEC,
 925         0,
 926         sdref->service_name_chosen,
 927         sdref->type_info.type,
 928         sdref->service_domain,
 929         sdref->service_host,
 930         sdref->service_port,
 931         sdref->service_txt)) < 0)
 932         return ret;
 933
 934     for (l = sdref->type_info.subtypes; l; l = l->next) {
 935         /* Create a subtype entry */
 936
 937         if (avahi_entry_group_add_service_subtype(
 938                 sdref->entry_group,
 939                 sdref->service_interface,
 940                 AVAHI_PROTO_UNSPEC,
 941                 0,
 942                 sdref->service_name_chosen,
 943                 sdref->type_info.type,
 944                 sdref->service_domain,
 945                 (const char*) l->text) < 0)
 946             return ret;
 947     }
 948
 949     if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
 950         return ret;
 951
 952     return 0;
 953 }
 954
 955 static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
 956     DNSServiceRef sdref = userdata;
 957
 958     assert(s);
 959     assert(sdref);
 960     assert(sdref->n_ref >= 1);
 961
 962     /* We've not been setup completely */
 963     if (!sdref->entry_group)
 964         return;
 965
 966     switch (state) {
 967         case AVAHI_CLIENT_FAILURE:
 968             reg_report_error(sdref, kDNSServiceErr_Unknown);
 969             break;
 970
 971         case AVAHI_CLIENT_S_RUNNING: {
 972             int ret;
 973
 974             if (!sdref->service_name) {
 975                 const char *n;
 976                 /* If the service name is taken from the host name, copy that */
 977
 978                 avahi_free(sdref->service_name_chosen);
 979                 sdref->service_name_chosen = NULL;
 980
 981                 if (!(n = avahi_client_get_host_name(sdref->client))) {
 982                     reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
 983                     return;
 984                 }
 985
 986                 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
 987                     reg_report_error(sdref, kDNSServiceErr_NoMemory);
 988                     return;
 989                 }
 990             }
 991
 992             if (!sdref->service_name_chosen) {
 993
 994                 assert(sdref->service_name);
 995
 996                 if (!(sdref->service_name_chosen = avahi_strdup(sdref->service_name))) {
 997                     reg_report_error(sdref, kDNSServiceErr_NoMemory);
 998                     return;
 999                 }
1000             }
1001
1002             /* Register the service */
1003
1004             if ((ret = reg_create_service(sdref)) < 0) {
1005                 reg_report_error(sdref, map_error(ret));
1006                 return;
1007             }
1008
1009             break;
1010         }
1011
1012         case AVAHI_CLIENT_S_COLLISION:
1013         case AVAHI_CLIENT_S_REGISTERING:
1014
1015             /* Remove our entry */
1016             avahi_entry_group_reset(sdref->entry_group);
1017
1018             break;
1019
1020         case AVAHI_CLIENT_CONNECTING:
1021             /* Ignore */
1022             break;
1023     }
1024
1025 }
1026
1027 static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
1028     DNSServiceRef sdref = userdata;
1029
1030     assert(g);
1031
1032     switch (state) {
1033         case AVAHI_ENTRY_GROUP_ESTABLISHED:
1034
1035             /* Inform the user */
1036             reg_report_error(sdref, kDNSServiceErr_NoError);
1037
1038             break;
1039
1040         case AVAHI_ENTRY_GROUP_COLLISION: {
1041             char *n;
1042             int ret;
1043
1044             /* Remove our entry */
1045             avahi_entry_group_reset(sdref->entry_group);
1046
1047             assert(sdref->service_name_chosen);
1048
1049             /* Pick a new name */
1050             if (!(n = avahi_alternative_service_name(sdref->service_name_chosen))) {
1051                 reg_report_error(sdref, kDNSServiceErr_NoMemory);
1052                 return;
1053             }
1054             avahi_free(sdref->service_name_chosen);
1055             sdref->service_name_chosen = n;
1056
1057             /* Register the service with that new name */
1058             if ((ret = reg_create_service(sdref)) < 0) {
1059                 reg_report_error(sdref, map_error(ret));
1060                 return;
1061             }
1062
1063             break;
1064         }
1065
1066         case AVAHI_ENTRY_GROUP_REGISTERING:
1067         case AVAHI_ENTRY_GROUP_UNCOMMITED:
1068             /* Ignore */
1069             break;
1070
1071         case AVAHI_ENTRY_GROUP_FAILURE:
1072             /* Inform the user */
1073             reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
1074             break;
1075
1076     }
1077 }
1078
1079 DNSServiceErrorType DNSSD_API DNSServiceRegister (
1080         DNSServiceRef *ret_sdref,
1081         DNSServiceFlags flags,
1082         uint32_t interface,
1083         const char *name,
1084         const char *regtype,
1085         const char *domain,
1086         const char *host,
1087         uint16_t port,
1088         uint16_t txtLen,
1089         const void *txtRecord,
1090         DNSServiceRegisterReply callback,
1091         void *context) {
1092
1093     DNSServiceErrorType ret = kDNSServiceErr_Unknown;
1094     int error;
1095     DNSServiceRef sdref = NULL;
1096     AvahiStringList *txt = NULL;
1097     struct type_info type_info;
1098
1099     AVAHI_WARN_LINKAGE;
1100
1101     if (!ret_sdref || !regtype)
1102         return kDNSServiceErr_BadParam;
1103     *ret_sdref = NULL;
1104
1105     if (!txtRecord) {
1106         txtLen = 1;
1107         txtRecord = "";
1108     }
1109
1110     if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
1111         AVAHI_WARN_UNSUPPORTED;
1112         return kDNSServiceErr_Unsupported;
1113     }
1114
1115     if (txtLen > 0)
1116         if (avahi_string_list_parse(txtRecord, txtLen, &txt) < 0)
1117             return kDNSServiceErr_Invalid;
1118
1119     if (type_info_parse(&type_info, regtype) < 0) {
1120         avahi_string_list_free(txt);
1121         return kDNSServiceErr_Invalid;
1122     }
1123
1124     if (!(sdref = sdref_new())) {
1125         avahi_string_list_free(txt);
1126         type_info_free(&type_info);
1127         return kDNSServiceErr_Unknown;
1128     }
1129
1130     sdref->context = context;
1131     sdref->service_register_callback = callback;
1132
1133     sdref->type_info = type_info;
1134     sdref->service_name = avahi_strdup(name);
1135     sdref->service_domain = domain ? avahi_normalize_name_strdup(domain) : NULL;
1136     sdref->service_host = host ? avahi_normalize_name_strdup(host) : NULL;
1137     sdref->service_interface = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
1138     sdref->service_port = ntohs(port);
1139     sdref->service_txt = txt;
1140
1141     /* Some OOM checking would be cool here */
1142
1143     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
1144
1145     if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, reg_client_callback, sdref, &error))) {
1146         ret =  map_error(error);
1147         goto finish;
1148     }
1149
1150     if (!sdref->service_domain) {
1151         const char *d;
1152
1153         if (!(d = avahi_client_get_domain_name(sdref->client))) {
1154             ret = map_error(avahi_client_errno(sdref->client));
1155             goto finish;
1156         }
1157
1158         if (!(sdref->service_domain = avahi_strdup(d))) {
1159             ret = kDNSServiceErr_NoMemory;
1160             goto finish;
1161         }
1162     }
1163
1164     if (!(sdref->entry_group = avahi_entry_group_new(sdref->client, reg_entry_group_callback, sdref))) {
1165         ret = map_error(avahi_client_errno(sdref->client));
1166         goto finish;
1167     }
1168
1169     if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING) {
1170         const char *n;
1171
1172         if (sdref->service_name)
1173             n = sdref->service_name;
1174         else {
1175             if (!(n = avahi_client_get_host_name(sdref->client))) {
1176                 ret = map_error(avahi_client_errno(sdref->client));
1177                 goto finish;
1178             }
1179         }
1180
1181         if (!(sdref->service_name_chosen = avahi_strdup(n))) {
1182             ret = kDNSServiceErr_NoMemory;
1183             goto finish;
1184         }
1185
1186
1187         if ((error = reg_create_service(sdref)) < 0) {
1188             ret = map_error(error);
1189             goto finish;
1190         }
1191     }
1192
1193     ret = kDNSServiceErr_NoError;
1194     *ret_sdref = sdref;
1195
1196 finish:
1197
1198     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
1199
1200     if (ret != kDNSServiceErr_NoError)
1201         DNSServiceRefDeallocate(sdref);
1202
1203     return ret;
1204 }
1205
1206 DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord(
1207          DNSServiceRef sdref,
1208          DNSRecordRef rref,
1209          DNSServiceFlags flags,
1210          uint16_t rdlen,
1211          const void *rdata,
1212          AVAHI_GCC_UNUSED uint32_t ttl) {
1213
1214     int ret = kDNSServiceErr_Unknown;
1215     AvahiStringList *txt = NULL;
1216
1217     AVAHI_WARN_LINKAGE;
1218
1219     if (!sdref || sdref->n_ref <= 0)
1220         return kDNSServiceErr_BadParam;
1221
1222     if (flags || rref) {
1223         AVAHI_WARN_UNSUPPORTED;
1224         return kDNSServiceErr_Unsupported;
1225     }
1226
1227     if (rdlen > 0)
1228         if (avahi_string_list_parse(rdata, rdlen, &txt) < 0)
1229             return kDNSServiceErr_Invalid;
1230
1231     ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
1232
1233     if (!avahi_string_list_equal(txt, sdref->service_txt)) {
1234
1235         avahi_string_list_free(sdref->service_txt);
1236         sdref->service_txt = txt;
1237
1238         if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING &&
1239             sdref->entry_group &&
1240             (avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_ESTABLISHED ||
1241             avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING))
1242
1243             if (avahi_entry_group_update_service_txt_strlst(
1244                         sdref->entry_group,
1245                         sdref->service_interface,
1246                         AVAHI_PROTO_UNSPEC,
1247                         0,
1248                         sdref->service_name_chosen,
1249                         sdref->type_info.type,
1250                         sdref->service_domain,
1251                         sdref->service_txt) < 0) {
1252
1253                 ret = map_error(avahi_client_errno(sdref->client));
1254                 goto finish;
1255             }
1256
1257     } else
1258         avahi_string_list_free(txt);
1259
1260     ret = kDNSServiceErr_NoError;
1261
1262 finish:
1263     ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
1264
1265     return ret;
1266 }
1267