4 This file is part of avahi.
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.
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.
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
33 #include <netinet/in.h>
36 #include <sys/types.h>
37 #include <sys/socket.h>
39 #include <avahi-common/simple-watch.h>
40 #include <avahi-common/malloc.h>
41 #include <avahi-common/error.h>
42 #include <avahi-common/domain.h>
43 #include <avahi-common/alternative.h>
45 #include <avahi-client/client.h>
46 #include <avahi-client/publish.h>
47 #include <avahi-client/lookup.h>
55 COMMAND_POLL_DONE = 'P',
56 COMMAND_POLL_FAILED = 'F'
61 AvahiStringList *subtypes;
65 struct _DNSServiceRef_t {
68 AvahiSimplePoll *simple_poll;
70 int thread_fd, main_fd;
75 pthread_mutex_t mutex;
78 DNSServiceBrowseReply service_browser_callback;
79 DNSServiceResolveReply service_resolver_callback;
80 DNSServiceDomainEnumReply domain_browser_callback;
81 DNSServiceRegisterReply service_register_callback;
84 AvahiServiceBrowser *service_browser;
85 AvahiServiceResolver *service_resolver;
86 AvahiDomainBrowser *domain_browser;
88 struct type_info type_info;
89 char *service_name, *service_name_chosen, *service_domain, *service_host;
90 uint16_t service_port;
91 AvahiIfIndex service_interface;
92 AvahiStringList *service_txt;
94 AvahiEntryGroup *entry_group;
97 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }
99 static DNSServiceErrorType map_error(int error) {
102 return kDNSServiceErr_NoError;
104 case AVAHI_ERR_BAD_STATE :
105 return kDNSServiceErr_BadState;
107 case AVAHI_ERR_INVALID_HOST_NAME:
108 case AVAHI_ERR_INVALID_DOMAIN_NAME:
109 case AVAHI_ERR_INVALID_TTL:
110 case AVAHI_ERR_IS_PATTERN:
111 case AVAHI_ERR_INVALID_RECORD:
112 case AVAHI_ERR_INVALID_SERVICE_NAME:
113 case AVAHI_ERR_INVALID_SERVICE_TYPE:
114 case AVAHI_ERR_INVALID_PORT:
115 case AVAHI_ERR_INVALID_KEY:
116 case AVAHI_ERR_INVALID_ADDRESS:
117 case AVAHI_ERR_INVALID_SERVICE_SUBTYPE:
118 return kDNSServiceErr_BadParam;
121 case AVAHI_ERR_COLLISION:
122 return kDNSServiceErr_NameConflict;
124 case AVAHI_ERR_TOO_MANY_CLIENTS:
125 case AVAHI_ERR_TOO_MANY_OBJECTS:
126 case AVAHI_ERR_TOO_MANY_ENTRIES:
127 case AVAHI_ERR_ACCESS_DENIED:
128 return kDNSServiceErr_Refused;
130 case AVAHI_ERR_INVALID_OPERATION:
131 case AVAHI_ERR_INVALID_OBJECT:
132 return kDNSServiceErr_Invalid;
134 case AVAHI_ERR_NO_MEMORY:
135 return kDNSServiceErr_NoMemory;
137 case AVAHI_ERR_INVALID_INTERFACE:
138 case AVAHI_ERR_INVALID_PROTOCOL:
139 return kDNSServiceErr_BadInterfaceIndex;
141 case AVAHI_ERR_INVALID_FLAGS:
142 return kDNSServiceErr_BadFlags;
144 case AVAHI_ERR_NOT_FOUND:
145 return kDNSServiceErr_NoSuchName;
147 case AVAHI_ERR_VERSION_MISMATCH:
148 return kDNSServiceErr_Incompatible;
150 case AVAHI_ERR_NO_NETWORK:
152 case AVAHI_ERR_INVALID_CONFIG:
153 case AVAHI_ERR_TIMEOUT:
154 case AVAHI_ERR_DBUS_ERROR:
155 case AVAHI_ERR_DISCONNECTED:
156 case AVAHI_ERR_NO_DAEMON:
161 return kDNSServiceErr_Unknown;
164 static void type_info_init(struct type_info *i) {
171 static void type_info_free(struct type_info *i) {
175 avahi_string_list_free(i->subtypes);
180 static int type_info_parse(struct type_info *i, const char *t) {
199 token = avahi_strndup(t, l);
205 /* This is the first token, hence the main type */
207 if (!avahi_is_valid_service_type_strict(token))
215 /* This is not the first token, hence a subtype */
217 if (!(fst = avahi_strdup_printf("%s._sub.%s", token, i->type)))
220 if (!avahi_is_valid_service_subtype(fst)) {
225 i->subtypes = avahi_string_list_add(i->subtypes, fst);
249 static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
256 if (s[strlen(s)-1] == '.')
259 snprintf(buf, buf_len, "%s.", s);
263 static int read_command(int fd) {
269 if ((r = read(fd, &command, 1)) != 1) {
270 fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
277 static int write_command(int fd, char reply) {
280 if (write(fd, &reply, 1) != 1) {
281 fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
288 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
289 DNSServiceRef sdref = userdata;
294 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
296 /* fprintf(stderr, "pre-syscall\n"); */
297 ret = poll(ufds, nfds, timeout);
298 /* fprintf(stderr, "post-syscall\n"); */
300 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
305 static void * thread_func(void *data) {
306 DNSServiceRef sdref = data;
310 pthread_sigmask(SIG_BLOCK, &mask, NULL);
312 sdref->thread = pthread_self();
313 sdref->thread_running = 1;
318 if ((command = read_command(sdref->thread_fd)) < 0)
321 /* fprintf(stderr, "Command: %c\n", command); */
328 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
333 if ((ret = avahi_simple_poll_run(sdref->simple_poll)) < 0) {
338 fprintf(stderr, __FILE__": avahi_simple_poll_run() failed: %s\n", strerror(errno));
344 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
346 if (write_command(sdref->thread_fd, ret < 0 ? COMMAND_POLL_FAILED : COMMAND_POLL_DONE) < 0)
361 static DNSServiceRef sdref_new(void) {
362 int fd[2] = { -1, -1 };
363 DNSServiceRef sdref = NULL;
364 pthread_mutexattr_t mutex_attr;
366 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
369 if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
373 sdref->thread_fd = fd[0];
374 sdref->main_fd = fd[1];
376 sdref->client = NULL;
377 sdref->service_browser = NULL;
378 sdref->service_resolver = NULL;
379 sdref->domain_browser = NULL;
380 sdref->entry_group = NULL;
382 sdref->service_name = sdref->service_name_chosen = sdref->service_domain = sdref->service_host = NULL;
383 sdref->service_txt = NULL;
385 type_info_init(&sdref->type_info);
387 ASSERT_SUCCESS(pthread_mutexattr_init(&mutex_attr));
388 pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
389 ASSERT_SUCCESS(pthread_mutex_init(&sdref->mutex, &mutex_attr));
391 sdref->thread_running = 0;
393 if (!(sdref->simple_poll = avahi_simple_poll_new()))
396 avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);
398 /* Start simple poll */
399 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
402 /* Queue an initial POLL command for the thread */
403 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
406 if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
409 sdref->thread_running = 1;
416 DNSServiceRefDeallocate(sdref);
421 static void sdref_free(DNSServiceRef sdref) {
424 if (sdref->thread_running) {
425 ASSERT_SUCCESS(write_command(sdref->main_fd, COMMAND_QUIT));
426 avahi_simple_poll_wakeup(sdref->simple_poll);
427 ASSERT_SUCCESS(pthread_join(sdref->thread, NULL));
431 avahi_client_free(sdref->client);
433 if (sdref->simple_poll)
434 avahi_simple_poll_free(sdref->simple_poll);
436 if (sdref->thread_fd >= 0)
437 close(sdref->thread_fd);
439 if (sdref->main_fd >= 0)
440 close(sdref->main_fd);
442 ASSERT_SUCCESS(pthread_mutex_destroy(&sdref->mutex));
444 avahi_free(sdref->service_name);
445 avahi_free(sdref->service_name_chosen);
446 avahi_free(sdref->service_domain);
447 avahi_free(sdref->service_host);
449 type_info_free(&sdref->type_info);
451 avahi_string_list_free(sdref->service_txt);
456 static void sdref_ref(DNSServiceRef sdref) {
458 assert(sdref->n_ref >= 1);
463 static void sdref_unref(DNSServiceRef sdref) {
465 assert(sdref->n_ref >= 1);
467 if (--(sdref->n_ref) <= 0)
471 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {
472 if (!sdref || sdref->n_ref <= 0)
477 return sdref->main_fd;
480 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
481 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
484 assert(sdref->n_ref >= 1);
488 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
492 /* Cleanup notification socket */
493 if (read_command(sdref->main_fd) != COMMAND_POLL_DONE)
496 if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
499 if (sdref->n_ref > 1) /* Perhaps we should die */
501 /* Dispatch events */
502 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
505 if (sdref->n_ref > 1)
507 /* Request the poll */
508 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
511 ret = kDNSServiceErr_NoError;
517 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
522 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
529 static void service_browser_callback(
530 AvahiServiceBrowser *b,
531 AvahiIfIndex interface,
532 AVAHI_GCC_UNUSED AvahiProtocol protocol,
533 AvahiBrowserEvent event,
537 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
540 DNSServiceRef sdref = userdata;
541 char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
544 assert(sdref->n_ref >= 1);
546 type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
547 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
550 case AVAHI_BROWSER_NEW:
551 sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
554 case AVAHI_BROWSER_REMOVE:
555 sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
558 case AVAHI_BROWSER_FAILURE:
559 sdref->service_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, NULL, sdref->context);
562 case AVAHI_BROWSER_CACHE_EXHAUSTED:
563 case AVAHI_BROWSER_ALL_FOR_NOW:
568 static void generic_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
569 DNSServiceRef sdref = userdata;
570 int error = kDNSServiceErr_Unknown;
574 assert(sdref->n_ref >= 1);
578 case AVAHI_CLIENT_FAILURE:
580 if (sdref->service_browser_callback)
581 sdref->service_browser_callback(sdref, 0, 0, error, NULL, NULL, NULL, sdref->context);
582 else if (sdref->service_resolver_callback)
583 sdref->service_resolver_callback(sdref, 0, 0, error, NULL, NULL, 0, 0, NULL, sdref->context);
584 else if (sdref->domain_browser_callback)
585 sdref->domain_browser_callback(sdref, 0, 0, error, NULL, sdref->context);
589 case AVAHI_CLIENT_S_RUNNING:
590 case AVAHI_CLIENT_S_COLLISION:
591 case AVAHI_CLIENT_S_REGISTERING:
592 case AVAHI_CLIENT_CONNECTING:
597 DNSServiceErrorType DNSSD_API DNSServiceBrowse(
598 DNSServiceRef *ret_sdref,
599 DNSServiceFlags flags,
603 DNSServiceBrowseReply callback,
606 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
608 DNSServiceRef sdref = NULL;
609 AvahiIfIndex ifindex;
610 struct type_info type_info;
615 return kDNSServiceErr_BadParam;
621 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
622 AVAHI_WARN_UNSUPPORTED;
623 return kDNSServiceErr_Unsupported;
626 type_info_init(&type_info);
628 if (type_info_parse(&type_info, regtype) < 0 || type_info.n_subtypes > 1) {
629 type_info_free(&type_info);
631 if (!avahi_is_valid_service_type_generic(regtype))
632 return kDNSServiceErr_Unsupported;
634 regtype = type_info.subtypes ? (char*) type_info.subtypes->text : type_info.type;
636 if (!(sdref = sdref_new())) {
637 type_info_free(&type_info);
638 return kDNSServiceErr_Unknown;
641 sdref->context = context;
642 sdref->service_browser_callback = callback;
644 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
646 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
647 ret = map_error(error);
651 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
653 if (!(sdref->service_browser = avahi_service_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, regtype, domain, 0, service_browser_callback, sdref))) {
654 ret = map_error(avahi_client_errno(sdref->client));
658 ret = kDNSServiceErr_NoError;
663 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
665 if (ret != kDNSServiceErr_NoError)
666 DNSServiceRefDeallocate(sdref);
668 type_info_free(&type_info);
673 static void service_resolver_callback(
674 AvahiServiceResolver *r,
675 AvahiIfIndex interface,
676 AVAHI_GCC_UNUSED AvahiProtocol protocol,
677 AvahiResolverEvent event,
681 const char *host_name,
682 AVAHI_GCC_UNUSED const AvahiAddress *a,
684 AvahiStringList *txt,
685 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
688 DNSServiceRef sdref = userdata;
692 assert(sdref->n_ref >= 1);
695 case AVAHI_RESOLVER_FOUND: {
697 char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
698 char full_name[AVAHI_DOMAIN_NAME_MAX];
703 host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));
705 if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
706 avahi_string_list_serialize(txt, p, l);
708 ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
709 assert(ret == AVAHI_OK);
711 strcat(full_name, ".");
713 sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, (unsigned char*) p, sdref->context);
719 case AVAHI_RESOLVER_FAILURE:
720 sdref->service_resolver_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, 0, 0, NULL, sdref->context);
725 DNSServiceErrorType DNSSD_API DNSServiceResolve(
726 DNSServiceRef *ret_sdref,
727 DNSServiceFlags flags,
732 DNSServiceResolveReply callback,
735 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
737 DNSServiceRef sdref = NULL;
738 AvahiIfIndex ifindex;
748 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
749 AVAHI_WARN_UNSUPPORTED;
750 return kDNSServiceErr_Unsupported;
753 if (!(sdref = sdref_new()))
754 return kDNSServiceErr_Unknown;
756 sdref->context = context;
757 sdref->service_resolver_callback = callback;
759 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
761 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
762 ret = map_error(error);
766 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
768 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))) {
769 ret = map_error(avahi_client_errno(sdref->client));
774 ret = kDNSServiceErr_NoError;
779 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
781 if (ret != kDNSServiceErr_NoError)
782 DNSServiceRefDeallocate(sdref);
787 int DNSSD_API DNSServiceConstructFullName (
791 const char *domain) {
799 if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
805 static void domain_browser_callback(
806 AvahiDomainBrowser *b,
807 AvahiIfIndex interface,
808 AVAHI_GCC_UNUSED AvahiProtocol protocol,
809 AvahiBrowserEvent event,
811 AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
814 DNSServiceRef sdref = userdata;
815 static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];
819 assert(sdref->n_ref >= 1);
821 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
824 case AVAHI_BROWSER_NEW:
825 sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
828 case AVAHI_BROWSER_REMOVE:
829 sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, domain, sdref->context);
832 case AVAHI_BROWSER_FAILURE:
833 sdref->domain_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), domain, sdref->context);
836 case AVAHI_BROWSER_CACHE_EXHAUSTED:
837 case AVAHI_BROWSER_ALL_FOR_NOW:
842 DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
843 DNSServiceRef *ret_sdref,
844 DNSServiceFlags flags,
846 DNSServiceDomainEnumReply callback,
849 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
851 DNSServiceRef sdref = NULL;
852 AvahiIfIndex ifindex;
859 if (interface == kDNSServiceInterfaceIndexLocalOnly ||
860 (flags != kDNSServiceFlagsBrowseDomains && flags != kDNSServiceFlagsRegistrationDomains)) {
861 AVAHI_WARN_UNSUPPORTED;
862 return kDNSServiceErr_Unsupported;
865 if (!(sdref = sdref_new()))
866 return kDNSServiceErr_Unknown;
868 sdref->context = context;
869 sdref->domain_browser_callback = callback;
871 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
873 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, generic_client_callback, sdref, &error))) {
874 ret = map_error(error);
878 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
880 if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, "local",
881 flags == kDNSServiceFlagsRegistrationDomains ? AVAHI_DOMAIN_BROWSER_REGISTER : AVAHI_DOMAIN_BROWSER_BROWSE,
882 0, domain_browser_callback, sdref))) {
883 ret = map_error(avahi_client_errno(sdref->client));
887 ret = kDNSServiceErr_NoError;
892 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
894 if (ret != kDNSServiceErr_NoError)
895 DNSServiceRefDeallocate(sdref);
900 static void reg_report_error(DNSServiceRef sdref, DNSServiceErrorType error) {
901 char regtype_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
902 const char *regtype, *domain;
904 assert(sdref->n_ref >= 1);
906 if (!sdref->service_register_callback)
909 regtype = add_trailing_dot(sdref->type_info.type, regtype_fixed, sizeof(regtype_fixed));
910 domain = add_trailing_dot(sdref->service_domain, domain_fixed, sizeof(domain_fixed));
912 sdref->service_register_callback(
914 sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
920 static int reg_create_service(DNSServiceRef sdref) {
925 assert(sdref->n_ref >= 1);
927 if ((ret = avahi_entry_group_add_service_strlst(
929 sdref->service_interface,
932 sdref->service_name_chosen,
933 sdref->type_info.type,
934 sdref->service_domain,
937 sdref->service_txt)) < 0)
940 for (l = sdref->type_info.subtypes; l; l = l->next) {
941 /* Create a subtype entry */
943 if (avahi_entry_group_add_service_subtype(
945 sdref->service_interface,
948 sdref->service_name_chosen,
949 sdref->type_info.type,
950 sdref->service_domain,
951 (const char*) l->text) < 0)
955 if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
961 static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
962 DNSServiceRef sdref = userdata;
966 assert(sdref->n_ref >= 1);
968 /* We've not been setup completely */
969 if (!sdref->entry_group)
973 case AVAHI_CLIENT_FAILURE:
974 reg_report_error(sdref, kDNSServiceErr_Unknown);
977 case AVAHI_CLIENT_S_RUNNING: {
980 if (!sdref->service_name) {
982 /* If the service name is taken from the host name, copy that */
984 avahi_free(sdref->service_name_chosen);
985 sdref->service_name_chosen = NULL;
987 if (!(n = avahi_client_get_host_name(sdref->client))) {
988 reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
992 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
993 reg_report_error(sdref, kDNSServiceErr_NoMemory);
998 /* Register the service */
1000 if ((ret = reg_create_service(sdref)) < 0) {
1001 reg_report_error(sdref, map_error(ret));
1008 case AVAHI_CLIENT_S_COLLISION:
1009 case AVAHI_CLIENT_S_REGISTERING:
1011 /* Remove our entry */
1012 avahi_entry_group_reset(sdref->entry_group);
1016 case AVAHI_CLIENT_CONNECTING:
1023 static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
1024 DNSServiceRef sdref = userdata;
1029 case AVAHI_ENTRY_GROUP_ESTABLISHED:
1031 /* Inform the user */
1032 reg_report_error(sdref, kDNSServiceErr_NoError);
1036 case AVAHI_ENTRY_GROUP_COLLISION: {
1040 /* Remove our entry */
1041 avahi_entry_group_reset(sdref->entry_group);
1043 assert(sdref->service_name_chosen);
1045 /* Pick a new name */
1046 if (!(n = avahi_alternative_service_name(sdref->service_name_chosen))) {
1047 reg_report_error(sdref, kDNSServiceErr_NoMemory);
1050 avahi_free(sdref->service_name_chosen);
1051 sdref->service_name_chosen = n;
1053 /* Register the service with that new name */
1054 if ((ret = reg_create_service(sdref)) < 0) {
1055 reg_report_error(sdref, map_error(ret));
1062 case AVAHI_ENTRY_GROUP_REGISTERING:
1063 case AVAHI_ENTRY_GROUP_UNCOMMITED:
1067 case AVAHI_ENTRY_GROUP_FAILURE:
1068 /* Inform the user */
1069 reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
1075 DNSServiceErrorType DNSSD_API DNSServiceRegister (
1076 DNSServiceRef *ret_sdref,
1077 DNSServiceFlags flags,
1080 const char *regtype,
1085 const void *txtRecord,
1086 DNSServiceRegisterReply callback,
1089 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
1091 DNSServiceRef sdref = NULL;
1092 AvahiStringList *txt = NULL;
1093 struct type_info type_info;
1098 return kDNSServiceErr_BadParam;
1103 return kDNSServiceErr_BadParam;
1105 assert(txtRecord || txtLen == 0);
1107 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
1108 AVAHI_WARN_UNSUPPORTED;
1109 return kDNSServiceErr_Unsupported;
1113 if (avahi_string_list_parse(txtRecord, txtLen, &txt) < 0)
1114 return kDNSServiceErr_Invalid;
1116 if (type_info_parse(&type_info, regtype) < 0) {
1117 avahi_string_list_free(txt);
1118 return kDNSServiceErr_Invalid;
1121 if (!(sdref = sdref_new())) {
1122 avahi_string_list_free(txt);
1123 type_info_free(&type_info);
1124 return kDNSServiceErr_Unknown;
1127 sdref->context = context;
1128 sdref->service_register_callback = callback;
1130 sdref->type_info = type_info;
1131 sdref->service_name = avahi_strdup(name);
1132 sdref->service_domain = domain ? avahi_normalize_name_strdup(domain) : NULL;
1133 sdref->service_host = host ? avahi_normalize_name_strdup(host) : NULL;
1134 sdref->service_interface = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
1135 sdref->service_port = ntohs(port);
1136 sdref->service_txt = txt;
1138 /* Some OOM checking would be cool here */
1140 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
1142 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), 0, reg_client_callback, sdref, &error))) {
1143 ret = map_error(error);
1147 if (!sdref->service_domain) {
1150 if (!(d = avahi_client_get_domain_name(sdref->client))) {
1151 ret = map_error(avahi_client_errno(sdref->client));
1155 if (!(sdref->service_domain = avahi_strdup(d))) {
1156 ret = kDNSServiceErr_NoMemory;
1161 if (!(sdref->entry_group = avahi_entry_group_new(sdref->client, reg_entry_group_callback, sdref))) {
1162 ret = map_error(avahi_client_errno(sdref->client));
1166 if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING) {
1169 if (sdref->service_name)
1170 n = sdref->service_name;
1172 if (!(n = avahi_client_get_host_name(sdref->client))) {
1173 ret = map_error(avahi_client_errno(sdref->client));
1178 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
1179 ret = kDNSServiceErr_NoMemory;
1184 if ((error = reg_create_service(sdref)) < 0) {
1185 ret = map_error(error);
1190 ret = kDNSServiceErr_NoError;
1195 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
1197 if (ret != kDNSServiceErr_NoError)
1198 DNSServiceRefDeallocate(sdref);
1203 DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord(
1204 DNSServiceRef sdref,
1206 DNSServiceFlags flags,
1209 AVAHI_GCC_UNUSED uint32_t ttl) {
1211 int ret = kDNSServiceErr_Unknown;
1212 AvahiStringList *txt = NULL;
1217 if (flags || rref) {
1218 AVAHI_WARN_UNSUPPORTED;
1219 return kDNSServiceErr_Unsupported;
1223 if (avahi_string_list_parse(rdata, rdlen, &txt) < 0)
1224 return kDNSServiceErr_Invalid;
1226 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
1228 if (!avahi_string_list_equal(txt, sdref->service_txt)) {
1230 avahi_string_list_free(sdref->service_txt);
1231 sdref->service_txt = txt;
1233 if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING &&
1234 sdref->entry_group &&
1235 (avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_ESTABLISHED ||
1236 avahi_entry_group_get_state(sdref->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING))
1238 if (avahi_entry_group_update_service_txt_strlst(
1240 sdref->service_interface,
1243 sdref->service_name_chosen,
1244 sdref->type_info.type,
1245 sdref->service_domain,
1246 sdref->service_txt) < 0) {
1248 ret = map_error(avahi_client_errno(sdref->client));
1253 avahi_string_list_free(txt);
1255 ret = kDNSServiceErr_NoError;
1258 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));