2 This file is part of avahi.
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.
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.
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
31 #include <netinet/in.h>
34 #include <sys/types.h>
35 #include <sys/socket.h>
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>
43 #include <avahi-client/client.h>
44 #include <avahi-client/publish.h>
45 #include <avahi-client/lookup.h>
53 COMMAND_POLL_DONE = 'P',
54 COMMAND_POLL_FAILED = 'F'
59 AvahiStringList *subtypes;
63 struct _DNSServiceRef_t {
66 AvahiSimplePoll *simple_poll;
68 int thread_fd, main_fd;
73 pthread_mutex_t mutex;
76 DNSServiceBrowseReply service_browser_callback;
77 DNSServiceResolveReply service_resolver_callback;
78 DNSServiceDomainEnumReply domain_browser_callback;
79 DNSServiceRegisterReply service_register_callback;
82 AvahiServiceBrowser *service_browser;
83 AvahiServiceResolver *service_resolver;
84 AvahiDomainBrowser *domain_browser;
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;
92 AvahiEntryGroup *entry_group;
95 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }
97 static DNSServiceErrorType map_error(int error) {
100 return kDNSServiceErr_NoError;
102 case AVAHI_ERR_BAD_STATE :
103 return kDNSServiceErr_BadState;
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;
119 case AVAHI_ERR_COLLISION:
120 return kDNSServiceErr_NameConflict;
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;
128 case AVAHI_ERR_INVALID_OPERATION:
129 case AVAHI_ERR_INVALID_OBJECT:
130 return kDNSServiceErr_Invalid;
132 case AVAHI_ERR_NO_MEMORY:
133 return kDNSServiceErr_NoMemory;
135 case AVAHI_ERR_INVALID_INTERFACE:
136 case AVAHI_ERR_INVALID_PROTOCOL:
137 return kDNSServiceErr_BadInterfaceIndex;
139 case AVAHI_ERR_INVALID_FLAGS:
140 return kDNSServiceErr_BadFlags;
142 case AVAHI_ERR_NOT_FOUND:
143 return kDNSServiceErr_NoSuchName;
145 case AVAHI_ERR_VERSION_MISMATCH:
146 return kDNSServiceErr_Incompatible;
148 case AVAHI_ERR_NO_NETWORK:
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:
159 return kDNSServiceErr_Unknown;
162 static void type_info_init(struct type_info *i) {
169 static void type_info_free(struct type_info *i) {
173 avahi_string_list_free(i->subtypes);
178 static int type_info_parse(struct type_info *i, const char *t) {
197 token = avahi_strndup(t, l);
203 /* This is the first token, hence the main type */
205 if (!avahi_is_valid_service_type_strict(token))
213 /* This is not the first token, hence a subtype */
215 if (!(fst = avahi_strdup_printf("%s._sub.%s", token, i->type)))
218 if (!avahi_is_valid_service_subtype(fst)) {
223 i->subtypes = avahi_string_list_add(i->subtypes, fst);
247 static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
254 if (s[strlen(s)-1] == '.')
257 snprintf(buf, buf_len, "%s.", s);
261 static int read_command(int fd) {
267 if ((r = read(fd, &command, 1)) != 1) {
268 fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
275 static int write_command(int fd, char reply) {
278 if (write(fd, &reply, 1) != 1) {
279 fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
286 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
287 DNSServiceRef sdref = userdata;
292 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
294 /* fprintf(stderr, "pre-syscall\n"); */
295 ret = poll(ufds, nfds, timeout);
296 /* fprintf(stderr, "post-syscall\n"); */
298 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
303 static void * thread_func(void *data) {
304 DNSServiceRef sdref = data;
308 pthread_sigmask(SIG_BLOCK, &mask, NULL);
310 sdref->thread = pthread_self();
311 sdref->thread_running = 1;
316 if ((command = read_command(sdref->thread_fd)) < 0)
319 /* fprintf(stderr, "Command: %c\n", command); */
326 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
331 if ((ret = avahi_simple_poll_run(sdref->simple_poll)) < 0) {
336 fprintf(stderr, __FILE__": avahi_simple_poll_run() failed: %s\n", strerror(errno));
342 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
344 if (write_command(sdref->thread_fd, ret < 0 ? COMMAND_POLL_FAILED : COMMAND_POLL_DONE) < 0)
359 static DNSServiceRef sdref_new(void) {
360 int fd[2] = { -1, -1 };
361 DNSServiceRef sdref = NULL;
362 pthread_mutexattr_t mutex_attr;
364 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
367 if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
371 sdref->thread_fd = fd[0];
372 sdref->main_fd = fd[1];
374 sdref->client = NULL;
375 sdref->service_browser = NULL;
376 sdref->service_resolver = NULL;
377 sdref->domain_browser = NULL;
378 sdref->entry_group = NULL;
380 sdref->service_name = sdref->service_name_chosen = sdref->service_domain = sdref->service_host = NULL;
381 sdref->service_txt = NULL;
383 type_info_init(&sdref->type_info);
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));
389 sdref->thread_running = 0;
391 if (!(sdref->simple_poll = avahi_simple_poll_new()))
394 avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);
396 /* Start simple poll */
397 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
400 /* Queue an initial POLL command for the thread */
401 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
404 if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
407 sdref->thread_running = 1;
414 DNSServiceRefDeallocate(sdref);
419 static void sdref_free(DNSServiceRef sdref) {
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));
429 avahi_client_free(sdref->client);
431 if (sdref->simple_poll)
432 avahi_simple_poll_free(sdref->simple_poll);
434 if (sdref->thread_fd >= 0)
435 close(sdref->thread_fd);
437 if (sdref->main_fd >= 0)
438 close(sdref->main_fd);
440 ASSERT_SUCCESS(pthread_mutex_destroy(&sdref->mutex));
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);
447 type_info_free(&sdref->type_info);
449 avahi_string_list_free(sdref->service_txt);
454 static void sdref_ref(DNSServiceRef sdref) {
456 assert(sdref->n_ref >= 1);
461 static void sdref_unref(DNSServiceRef sdref) {
463 assert(sdref->n_ref >= 1);
465 if (--(sdref->n_ref) <= 0)
469 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {
473 if (!sdref || sdref->n_ref <= 0)
476 return sdref->main_fd;
479 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
480 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
484 if (!sdref || sdref->n_ref <= 0)
485 return kDNSServiceErr_BadParam;
489 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
491 /* Cleanup notification socket */
492 if (read_command(sdref->main_fd) != COMMAND_POLL_DONE)
495 if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
498 if (sdref->n_ref > 1) /* Perhaps we should die */
500 /* Dispatch events */
501 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
504 if (sdref->n_ref > 1)
506 /* Request the poll */
507 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
510 ret = kDNSServiceErr_NoError;
514 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
521 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
528 static void service_browser_callback(
529 AvahiServiceBrowser *b,
530 AvahiIfIndex interface,
531 AVAHI_GCC_UNUSED AvahiProtocol protocol,
532 AvahiBrowserEvent event,
536 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
539 DNSServiceRef sdref = userdata;
540 char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
543 assert(sdref->n_ref >= 1);
545 type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
546 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
549 case AVAHI_BROWSER_NEW:
550 sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
553 case AVAHI_BROWSER_REMOVE:
554 sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
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);
561 case AVAHI_BROWSER_CACHE_EXHAUSTED:
562 case AVAHI_BROWSER_ALL_FOR_NOW:
567 static void generic_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
568 DNSServiceRef sdref = userdata;
569 int error = kDNSServiceErr_Unknown;
573 assert(sdref->n_ref >= 1);
577 case AVAHI_CLIENT_FAILURE:
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);
588 case AVAHI_CLIENT_S_RUNNING:
589 case AVAHI_CLIENT_S_COLLISION:
590 case AVAHI_CLIENT_S_REGISTERING:
591 case AVAHI_CLIENT_CONNECTING:
596 DNSServiceErrorType DNSSD_API DNSServiceBrowse(
597 DNSServiceRef *ret_sdref,
598 DNSServiceFlags flags,
602 DNSServiceBrowseReply callback,
605 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
607 DNSServiceRef sdref = NULL;
608 AvahiIfIndex ifindex;
609 struct type_info type_info;
613 if (!ret_sdref || !regtype)
614 return kDNSServiceErr_BadParam;
617 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
618 AVAHI_WARN_UNSUPPORTED;
619 return kDNSServiceErr_Unsupported;
622 type_info_init(&type_info);
624 if (type_info_parse(&type_info, regtype) < 0 || type_info.n_subtypes > 1) {
625 type_info_free(&type_info);
627 if (!avahi_is_valid_service_type_generic(regtype))
628 return kDNSServiceErr_Unsupported;
630 regtype = type_info.subtypes ? (char*) type_info.subtypes->text : type_info.type;
632 if (!(sdref = sdref_new())) {
633 type_info_free(&type_info);
634 return kDNSServiceErr_Unknown;
637 sdref->context = context;
638 sdref->service_browser_callback = callback;
640 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
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);
647 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
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));
654 ret = kDNSServiceErr_NoError;
659 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
661 if (ret != kDNSServiceErr_NoError)
662 DNSServiceRefDeallocate(sdref);
664 type_info_free(&type_info);
669 static void service_resolver_callback(
670 AvahiServiceResolver *r,
671 AvahiIfIndex interface,
672 AVAHI_GCC_UNUSED AvahiProtocol protocol,
673 AvahiResolverEvent event,
677 const char *host_name,
678 AVAHI_GCC_UNUSED const AvahiAddress *a,
680 AvahiStringList *txt,
681 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
684 DNSServiceRef sdref = userdata;
688 assert(sdref->n_ref >= 1);
691 case AVAHI_RESOLVER_FOUND: {
693 char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
694 char full_name[AVAHI_DOMAIN_NAME_MAX];
699 host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));
701 if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
702 avahi_string_list_serialize(txt, p, l);
704 ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
705 assert(ret == AVAHI_OK);
707 strcat(full_name, ".");
709 sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, (unsigned char*) p, sdref->context);
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);
721 DNSServiceErrorType DNSSD_API DNSServiceResolve(
722 DNSServiceRef *ret_sdref,
723 DNSServiceFlags flags,
728 DNSServiceResolveReply callback,
731 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
733 DNSServiceRef sdref = NULL;
734 AvahiIfIndex ifindex;
738 if (!ret_sdref || !name || !regtype || !domain || !callback)
739 return kDNSServiceErr_BadParam;
742 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
743 AVAHI_WARN_UNSUPPORTED;
744 return kDNSServiceErr_Unsupported;
747 if (!(sdref = sdref_new()))
748 return kDNSServiceErr_Unknown;
750 sdref->context = context;
751 sdref->service_resolver_callback = callback;
753 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
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);
760 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
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));
768 ret = kDNSServiceErr_NoError;
773 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
775 if (ret != kDNSServiceErr_NoError)
776 DNSServiceRefDeallocate(sdref);
781 int DNSSD_API DNSServiceConstructFullName (
785 const char *domain) {
789 if (!fullName || !regtype || !domain)
792 if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
798 static void domain_browser_callback(
799 AvahiDomainBrowser *b,
800 AvahiIfIndex interface,
801 AVAHI_GCC_UNUSED AvahiProtocol protocol,
802 AvahiBrowserEvent event,
804 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
807 DNSServiceRef sdref = userdata;
808 static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];
812 assert(sdref->n_ref >= 1);
814 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
817 case AVAHI_BROWSER_NEW:
818 sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
821 case AVAHI_BROWSER_REMOVE:
822 sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, domain, sdref->context);
825 case AVAHI_BROWSER_FAILURE:
826 sdref->domain_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), domain, sdref->context);
829 case AVAHI_BROWSER_CACHE_EXHAUSTED:
830 case AVAHI_BROWSER_ALL_FOR_NOW:
835 DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
836 DNSServiceRef *ret_sdref,
837 DNSServiceFlags flags,
839 DNSServiceDomainEnumReply callback,
842 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
844 DNSServiceRef sdref = NULL;
845 AvahiIfIndex ifindex;
849 if (!ret_sdref || !callback)
850 return kDNSServiceErr_BadParam;
853 if (interface == kDNSServiceInterfaceIndexLocalOnly ||
854 (flags != kDNSServiceFlagsBrowseDomains && flags != kDNSServiceFlagsRegistrationDomains)) {
855 AVAHI_WARN_UNSUPPORTED;
856 return kDNSServiceErr_Unsupported;
859 if (!(sdref = sdref_new()))
860 return kDNSServiceErr_Unknown;
862 sdref->context = context;
863 sdref->domain_browser_callback = callback;
865 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
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);
872 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
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));
881 ret = kDNSServiceErr_NoError;
886 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
888 if (ret != kDNSServiceErr_NoError)
889 DNSServiceRefDeallocate(sdref);
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;
898 assert(sdref->n_ref >= 1);
900 if (!sdref->service_register_callback)
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));
906 sdref->service_register_callback(
908 sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
914 static int reg_create_service(DNSServiceRef sdref) {
919 assert(sdref->n_ref >= 1);
921 if ((ret = avahi_entry_group_add_service_strlst(
923 sdref->service_interface,
926 sdref->service_name_chosen,
927 sdref->type_info.type,
928 sdref->service_domain,
931 sdref->service_txt)) < 0)
934 for (l = sdref->type_info.subtypes; l; l = l->next) {
935 /* Create a subtype entry */
937 if (avahi_entry_group_add_service_subtype(
939 sdref->service_interface,
942 sdref->service_name_chosen,
943 sdref->type_info.type,
944 sdref->service_domain,
945 (const char*) l->text) < 0)
949 if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
955 static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
956 DNSServiceRef sdref = userdata;
960 assert(sdref->n_ref >= 1);
962 /* We've not been setup completely */
963 if (!sdref->entry_group)
967 case AVAHI_CLIENT_FAILURE:
968 reg_report_error(sdref, kDNSServiceErr_Unknown);
971 case AVAHI_CLIENT_S_RUNNING: {
974 if (!sdref->service_name) {
976 /* If the service name is taken from the host name, copy that */
978 avahi_free(sdref->service_name_chosen);
979 sdref->service_name_chosen = NULL;
981 if (!(n = avahi_client_get_host_name(sdref->client))) {
982 reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
986 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
987 reg_report_error(sdref, kDNSServiceErr_NoMemory);
992 if (!sdref->service_name_chosen) {
994 assert(sdref->service_name);
996 if (!(sdref->service_name_chosen = avahi_strdup(sdref->service_name))) {
997 reg_report_error(sdref, kDNSServiceErr_NoMemory);
1002 /* Register the service */
1004 if ((ret = reg_create_service(sdref)) < 0) {
1005 reg_report_error(sdref, map_error(ret));
1012 case AVAHI_CLIENT_S_COLLISION:
1013 case AVAHI_CLIENT_S_REGISTERING:
1015 /* Remove our entry */
1016 avahi_entry_group_reset(sdref->entry_group);
1020 case AVAHI_CLIENT_CONNECTING:
1027 static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
1028 DNSServiceRef sdref = userdata;
1033 case AVAHI_ENTRY_GROUP_ESTABLISHED:
1035 /* Inform the user */
1036 reg_report_error(sdref, kDNSServiceErr_NoError);
1040 case AVAHI_ENTRY_GROUP_COLLISION: {
1044 /* Remove our entry */
1045 avahi_entry_group_reset(sdref->entry_group);
1047 assert(sdref->service_name_chosen);
1049 /* Pick a new name */
1050 if (!(n = avahi_alternative_service_name(sdref->service_name_chosen))) {
1051 reg_report_error(sdref, kDNSServiceErr_NoMemory);
1054 avahi_free(sdref->service_name_chosen);
1055 sdref->service_name_chosen = n;
1057 /* Register the service with that new name */
1058 if ((ret = reg_create_service(sdref)) < 0) {
1059 reg_report_error(sdref, map_error(ret));
1066 case AVAHI_ENTRY_GROUP_REGISTERING:
1067 case AVAHI_ENTRY_GROUP_UNCOMMITED:
1071 case AVAHI_ENTRY_GROUP_FAILURE:
1072 /* Inform the user */
1073 reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
1079 DNSServiceErrorType DNSSD_API DNSServiceRegister (
1080 DNSServiceRef *ret_sdref,
1081 DNSServiceFlags flags,
1084 const char *regtype,
1089 const void *txtRecord,
1090 DNSServiceRegisterReply callback,
1093 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
1095 DNSServiceRef sdref = NULL;
1096 AvahiStringList *txt = NULL;
1097 struct type_info type_info;
1101 if (!ret_sdref || !regtype)
1102 return kDNSServiceErr_BadParam;
1110 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
1111 AVAHI_WARN_UNSUPPORTED;
1112 return kDNSServiceErr_Unsupported;
1116 if (avahi_string_list_parse(txtRecord, txtLen, &txt) < 0)
1117 return kDNSServiceErr_Invalid;
1119 if (type_info_parse(&type_info, regtype) < 0) {
1120 avahi_string_list_free(txt);
1121 return kDNSServiceErr_Invalid;
1124 if (!(sdref = sdref_new())) {
1125 avahi_string_list_free(txt);
1126 type_info_free(&type_info);
1127 return kDNSServiceErr_Unknown;
1130 sdref->context = context;
1131 sdref->service_register_callback = callback;
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;
1141 /* Some OOM checking would be cool here */
1143 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
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);
1150 if (!sdref->service_domain) {
1153 if (!(d = avahi_client_get_domain_name(sdref->client))) {
1154 ret = map_error(avahi_client_errno(sdref->client));
1158 if (!(sdref->service_domain = avahi_strdup(d))) {
1159 ret = kDNSServiceErr_NoMemory;
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));
1169 if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING) {
1172 if (sdref->service_name)
1173 n = sdref->service_name;
1175 if (!(n = avahi_client_get_host_name(sdref->client))) {
1176 ret = map_error(avahi_client_errno(sdref->client));
1181 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
1182 ret = kDNSServiceErr_NoMemory;
1187 if ((error = reg_create_service(sdref)) < 0) {
1188 ret = map_error(error);
1193 ret = kDNSServiceErr_NoError;
1198 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
1200 if (ret != kDNSServiceErr_NoError)
1201 DNSServiceRefDeallocate(sdref);
1206 DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord(
1207 DNSServiceRef sdref,
1209 DNSServiceFlags flags,
1212 AVAHI_GCC_UNUSED uint32_t ttl) {
1214 int ret = kDNSServiceErr_Unknown;
1215 AvahiStringList *txt = NULL;
1219 if (!sdref || sdref->n_ref <= 0)
1220 return kDNSServiceErr_BadParam;
1222 if (flags || rref) {
1223 AVAHI_WARN_UNSUPPORTED;
1224 return kDNSServiceErr_Unsupported;
1228 if (avahi_string_list_parse(rdata, rdlen, &txt) < 0)
1229 return kDNSServiceErr_Invalid;
1231 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
1233 if (!avahi_string_list_equal(txt, sdref->service_txt)) {
1235 avahi_string_list_free(sdref->service_txt);
1236 sdref->service_txt = txt;
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))
1243 if (avahi_entry_group_update_service_txt_strlst(
1245 sdref->service_interface,
1248 sdref->service_name_chosen,
1249 sdref->type_info.type,
1250 sdref->service_domain,
1251 sdref->service_txt) < 0) {
1253 ret = map_error(avahi_client_errno(sdref->client));
1258 avahi_string_list_free(txt);
1260 ret = kDNSServiceErr_NoError;
1263 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));