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>
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>
48 COMMAND_POLL_DONE = 'P'
51 struct _DNSServiceRef_t {
54 AvahiSimplePoll *simple_poll;
56 int thread_fd, main_fd;
61 pthread_mutex_t mutex;
64 DNSServiceBrowseReply service_browser_callback;
65 DNSServiceResolveReply service_resolver_callback;
66 DNSServiceDomainEnumReply domain_browser_callback;
67 DNSServiceRegisterReply service_register_callback;
70 AvahiServiceBrowser *service_browser;
71 AvahiServiceResolver *service_resolver;
72 AvahiDomainBrowser *domain_browser;
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;
79 AvahiEntryGroup *entry_group;
82 #define ASSERT_SUCCESS(r) { int __ret = (r); assert(__ret == 0); }
84 static DNSServiceErrorType map_error(int error) {
87 return kDNSServiceErr_NoError;
89 case AVAHI_ERR_BAD_STATE :
90 return kDNSServiceErr_BadState;
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;
106 case AVAHI_ERR_LOCAL_COLLISION:
107 return kDNSServiceErr_NameConflict;
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;
115 case AVAHI_ERR_INVALID_OPERATION:
116 case AVAHI_ERR_INVALID_OBJECT:
117 return kDNSServiceErr_Invalid;
119 case AVAHI_ERR_NO_MEMORY:
120 return kDNSServiceErr_NoMemory;
122 case AVAHI_ERR_INVALID_INTERFACE:
123 case AVAHI_ERR_INVALID_PROTOCOL:
124 return kDNSServiceErr_BadInterfaceIndex;
126 case AVAHI_ERR_INVALID_FLAGS:
127 return kDNSServiceErr_BadFlags;
129 case AVAHI_ERR_NOT_FOUND:
130 return kDNSServiceErr_NoSuchName;
132 case AVAHI_ERR_VERSION_MISMATCH:
133 return kDNSServiceErr_Incompatible;
135 case AVAHI_ERR_NO_NETWORK:
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:
146 return kDNSServiceErr_Unknown;
149 static const char *add_trailing_dot(const char *s, char *buf, size_t buf_len) {
156 if (s[strlen(s)-1] == '.')
159 snprintf(buf, buf_len, "%s.", s);
163 static int read_command(int fd) {
169 if ((r = read(fd, &command, 1)) != 1) {
170 fprintf(stderr, __FILE__": read() failed: %s\n", r < 0 ? strerror(errno) : "EOF");
177 static int write_command(int fd, char reply) {
180 if (write(fd, &reply, 1) != 1) {
181 fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
188 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
189 DNSServiceRef sdref = userdata;
194 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
196 /* fprintf(stderr, "pre-syscall\n"); */
197 ret = poll(ufds, nfds, timeout);
198 /* fprintf(stderr, "post-syscall\n"); */
200 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
205 static void * thread_func(void *data) {
206 DNSServiceRef sdref = data;
210 pthread_sigmask(SIG_BLOCK, &mask, NULL);
212 sdref->thread = pthread_self();
213 sdref->thread_running = 1;
218 if ((command = read_command(sdref->thread_fd)) < 0)
221 /* fprintf(stderr, "Command: %c\n", command); */
227 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
229 if (avahi_simple_poll_run(sdref->simple_poll) < 0) {
230 fprintf(stderr, __FILE__": avahi_simple_poll_run() failed.\n");
231 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
235 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
237 if (write_command(sdref->thread_fd, COMMAND_POLL_DONE) < 0)
251 static DNSServiceRef sdref_new(void) {
252 int fd[2] = { -1, -1 };
253 DNSServiceRef sdref = NULL;
254 pthread_mutexattr_t mutex_attr;
256 if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0)
259 if (!(sdref = avahi_new(struct _DNSServiceRef_t, 1)))
263 sdref->thread_fd = fd[0];
264 sdref->main_fd = fd[1];
266 sdref->client = NULL;
267 sdref->service_browser = NULL;
268 sdref->service_resolver = NULL;
269 sdref->domain_browser = NULL;
270 sdref->entry_group = NULL;
272 sdref->service_name = sdref->service_name_chosen = sdref->service_regtype = sdref->service_domain = sdref->service_host = NULL;
273 sdref->service_txt = NULL;
275 ASSERT_SUCCESS(pthread_mutexattr_init(&mutex_attr));
276 pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
277 ASSERT_SUCCESS(pthread_mutex_init(&sdref->mutex, &mutex_attr));
279 sdref->thread_running = 0;
281 if (!(sdref->simple_poll = avahi_simple_poll_new()))
284 avahi_simple_poll_set_func(sdref->simple_poll, poll_func, sdref);
286 /* Start simple poll */
287 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
290 /* Queue an initial POLL command for the thread */
291 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
294 if (pthread_create(&sdref->thread, NULL, thread_func, sdref) != 0)
297 sdref->thread_running = 1;
304 DNSServiceRefDeallocate(sdref);
309 static void sdref_free(DNSServiceRef sdref) {
312 if (sdref->thread_running) {
313 ASSERT_SUCCESS(write_command(sdref->main_fd, COMMAND_QUIT));
314 avahi_simple_poll_wakeup(sdref->simple_poll);
315 ASSERT_SUCCESS(pthread_join(sdref->thread, NULL));
319 avahi_client_free(sdref->client);
321 if (sdref->simple_poll)
322 avahi_simple_poll_free(sdref->simple_poll);
325 if (sdref->thread_fd >= 0)
326 close(sdref->thread_fd);
328 if (sdref->main_fd >= 0)
329 close(sdref->main_fd);
331 ASSERT_SUCCESS(pthread_mutex_destroy(&sdref->mutex));
333 avahi_free(sdref->service_name);
334 avahi_free(sdref->service_name_chosen);
335 avahi_free(sdref->service_regtype);
336 avahi_free(sdref->service_domain);
337 avahi_free(sdref->service_host);
339 avahi_string_list_free(sdref->service_txt);
344 static void sdref_ref(DNSServiceRef sdref) {
346 assert(sdref->n_ref >= 1);
351 static void sdref_unref(DNSServiceRef sdref) {
353 assert(sdref->n_ref >= 1);
355 if (--(sdref->n_ref) <= 0)
359 int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdref) {
361 assert(sdref->n_ref >= 1);
365 return sdref->main_fd;
368 DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdref) {
369 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
372 assert(sdref->n_ref >= 1);
378 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
380 /* Cleanup notification socket */
381 if (read_command(sdref->main_fd) != COMMAND_POLL_DONE)
384 if (avahi_simple_poll_dispatch(sdref->simple_poll) < 0)
387 if (sdref->n_ref > 1) /* Perhaps we should die */
389 /* Dispatch events */
390 if (avahi_simple_poll_prepare(sdref->simple_poll, -1) < 0)
393 if (sdref->n_ref > 1)
395 /* Request the poll */
396 if (write_command(sdref->main_fd, COMMAND_POLL) < 0)
399 ret = kDNSServiceErr_NoError;
403 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
410 void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdref) {
412 assert(sdref->n_ref >= 1);
419 static void service_browser_callback(
420 AvahiServiceBrowser *b,
421 AvahiIfIndex interface,
422 AvahiProtocol protocol,
423 AvahiBrowserEvent event,
427 AvahiLookupResultFlags flags,
430 DNSServiceRef sdref = userdata;
431 char type_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
434 assert(sdref->n_ref >= 1);
436 type = add_trailing_dot(type, type_fixed, sizeof(type_fixed));
437 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
440 case AVAHI_BROWSER_NEW:
441 sdref->service_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
444 case AVAHI_BROWSER_REMOVE:
445 sdref->service_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, name, type, domain, sdref->context);
448 case AVAHI_BROWSER_FAILURE:
449 sdref->service_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, NULL, sdref->context);
452 case AVAHI_BROWSER_CACHE_EXHAUSTED:
453 case AVAHI_BROWSER_ALL_FOR_NOW:
458 static void generic_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
459 DNSServiceRef sdref = userdata;
463 assert(sdref->n_ref >= 1);
466 case AVAHI_CLIENT_DISCONNECTED: {
468 if (sdref->service_browser_callback)
469 sdref->service_browser_callback(sdref, 0, 0, kDNSServiceErr_Unknown, NULL, NULL, NULL, sdref->context);
470 else if (sdref->service_resolver_callback)
471 sdref->service_resolver_callback(sdref, 0, 0, kDNSServiceErr_Unknown, NULL, NULL, 0, 0, NULL, sdref->context);
472 else if (sdref->domain_browser_callback)
473 sdref->domain_browser_callback(sdref, 0, 0, kDNSServiceErr_Unknown, NULL, sdref->context);
478 case AVAHI_CLIENT_S_RUNNING:
479 case AVAHI_CLIENT_S_COLLISION:
480 case AVAHI_CLIENT_S_INVALID:
481 case AVAHI_CLIENT_S_REGISTERING:
486 DNSServiceErrorType DNSSD_API DNSServiceBrowse(
487 DNSServiceRef *ret_sdref,
488 DNSServiceFlags flags,
492 DNSServiceBrowseReply callback,
495 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
497 DNSServiceRef sdref = NULL;
498 AvahiIfIndex ifindex;
507 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
508 AVAHI_WARN_UNSUPPORTED;
509 return kDNSServiceErr_Unsupported;
512 if (!(sdref = sdref_new()))
513 return kDNSServiceErr_Unknown;
515 sdref->context = context;
516 sdref->service_browser_callback = callback;
518 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
520 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), generic_client_callback, sdref, &error))) {
521 ret = map_error(error);
525 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
527 if (!(sdref->service_browser = avahi_service_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, regtype, domain, 0, service_browser_callback, sdref))) {
528 ret = map_error(avahi_client_errno(sdref->client));
532 ret = kDNSServiceErr_NoError;
537 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
539 if (ret != kDNSServiceErr_NoError)
540 DNSServiceRefDeallocate(sdref);
545 static void service_resolver_callback(
546 AvahiServiceResolver *r,
547 AvahiIfIndex interface,
548 AvahiProtocol protocol,
549 AvahiResolverEvent event,
553 const char *host_name,
554 const AvahiAddress *a,
556 AvahiStringList *txt,
557 AvahiLookupResultFlags flags,
560 DNSServiceRef sdref = userdata;
564 assert(sdref->n_ref >= 1);
567 case AVAHI_RESOLVER_FOUND: {
569 char host_name_fixed[AVAHI_DOMAIN_NAME_MAX];
570 char full_name[AVAHI_DOMAIN_NAME_MAX];
575 host_name = add_trailing_dot(host_name, host_name_fixed, sizeof(host_name_fixed));
577 if ((p = avahi_new0(char, (l = avahi_string_list_serialize(txt, NULL, 0))+1)))
578 avahi_string_list_serialize(txt, p, l);
580 ret = avahi_service_name_join(full_name, sizeof(full_name), name, type, domain);
581 assert(ret == AVAHI_OK);
583 strcat(full_name, ".");
585 sdref->service_resolver_callback(sdref, 0, interface, kDNSServiceErr_NoError, full_name, host_name, htons(port), l, p, sdref->context);
591 case AVAHI_RESOLVER_FAILURE:
592 sdref->service_resolver_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), NULL, NULL, 0, 0, NULL, sdref->context);
597 DNSServiceErrorType DNSSD_API DNSServiceResolve(
598 DNSServiceRef *ret_sdref,
599 DNSServiceFlags flags,
604 DNSServiceResolveReply callback,
607 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
609 DNSServiceRef sdref = NULL;
610 AvahiIfIndex ifindex;
620 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags != 0) {
621 AVAHI_WARN_UNSUPPORTED;
622 return kDNSServiceErr_Unsupported;
625 if (!(sdref = sdref_new()))
626 return kDNSServiceErr_Unknown;
628 sdref->context = context;
629 sdref->service_resolver_callback = callback;
631 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
633 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), generic_client_callback, sdref, &error))) {
634 ret = map_error(error);
638 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
640 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))) {
641 ret = map_error(avahi_client_errno(sdref->client));
646 ret = kDNSServiceErr_NoError;
651 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
653 if (ret != kDNSServiceErr_NoError)
654 DNSServiceRefDeallocate(sdref);
659 int DNSSD_API DNSServiceConstructFullName (
663 const char *domain) {
671 if (avahi_service_name_join(fullName, kDNSServiceMaxDomainName, service, regtype, domain) < 0)
677 static void domain_browser_callback(
678 AvahiDomainBrowser *b,
679 AvahiIfIndex interface,
680 AvahiProtocol protocol,
681 AvahiBrowserEvent event,
683 AvahiLookupResultFlags flags,
686 DNSServiceRef sdref = userdata;
687 static char domain_fixed[AVAHI_DOMAIN_NAME_MAX];
691 assert(sdref->n_ref >= 1);
693 domain = add_trailing_dot(domain, domain_fixed, sizeof(domain_fixed));
696 case AVAHI_BROWSER_NEW:
697 sdref->domain_browser_callback(sdref, kDNSServiceFlagsAdd, interface, kDNSServiceErr_NoError, domain, sdref->context);
700 case AVAHI_BROWSER_REMOVE:
701 sdref->domain_browser_callback(sdref, 0, interface, kDNSServiceErr_NoError, domain, sdref->context);
704 case AVAHI_BROWSER_FAILURE:
705 sdref->domain_browser_callback(sdref, 0, interface, map_error(avahi_client_errno(sdref->client)), domain, sdref->context);
708 case AVAHI_BROWSER_CACHE_EXHAUSTED:
709 case AVAHI_BROWSER_ALL_FOR_NOW:
714 DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains(
715 DNSServiceRef *ret_sdref,
716 DNSServiceFlags flags,
718 DNSServiceDomainEnumReply callback,
721 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
723 DNSServiceRef sdref = NULL;
724 AvahiIfIndex ifindex;
731 if (interface == kDNSServiceInterfaceIndexLocalOnly ||
732 (flags != kDNSServiceFlagsBrowseDomains && flags != kDNSServiceFlagsRegistrationDomains)) {
733 AVAHI_WARN_UNSUPPORTED;
734 return kDNSServiceErr_Unsupported;
737 if (!(sdref = sdref_new()))
738 return kDNSServiceErr_Unknown;
740 sdref->context = context;
741 sdref->domain_browser_callback = callback;
743 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
745 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), generic_client_callback, sdref, &error))) {
746 ret = map_error(error);
750 ifindex = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
752 if (!(sdref->domain_browser = avahi_domain_browser_new(sdref->client, ifindex, AVAHI_PROTO_UNSPEC, "local",
753 flags == kDNSServiceFlagsRegistrationDomains ? AVAHI_DOMAIN_BROWSER_REGISTER : AVAHI_DOMAIN_BROWSER_BROWSE,
754 0, domain_browser_callback, sdref))) {
755 ret = map_error(avahi_client_errno(sdref->client));
759 ret = kDNSServiceErr_NoError;
764 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
766 if (ret != kDNSServiceErr_NoError)
767 DNSServiceRefDeallocate(sdref);
772 static void reg_report_error(DNSServiceRef sdref, DNSServiceErrorType error) {
773 char regtype_fixed[AVAHI_DOMAIN_NAME_MAX], domain_fixed[AVAHI_DOMAIN_NAME_MAX];
774 const char *regtype, *domain;
776 assert(sdref->n_ref >= 1);
778 assert(sdref->service_register_callback);
780 regtype = add_trailing_dot(sdref->service_regtype, regtype_fixed, sizeof(regtype_fixed));
781 domain = add_trailing_dot(sdref->service_domain, domain_fixed, sizeof(domain_fixed));
783 sdref->service_register_callback(
785 sdref->service_name_chosen ? sdref->service_name_chosen : sdref->service_name,
791 static int reg_create_service(DNSServiceRef sdref) {
793 const char *real_type;
796 assert(sdref->n_ref >= 1);
798 real_type = avahi_get_type_from_subtype(sdref->service_regtype);
800 if ((ret = avahi_entry_group_add_service_strlst(
802 sdref->service_interface,
805 sdref->service_name_chosen,
806 real_type ? real_type : sdref->service_regtype,
807 sdref->service_domain,
810 sdref->service_txt)) < 0)
815 /* Create a subtype entry */
817 if (avahi_entry_group_add_service_subtype(
819 sdref->service_interface,
822 sdref->service_name_chosen,
824 sdref->service_domain,
825 sdref->service_regtype) < 0)
830 if ((ret = avahi_entry_group_commit(sdref->entry_group)) < 0)
836 static void reg_client_callback(AvahiClient *s, AvahiClientState state, void* userdata) {
837 DNSServiceRef sdref = userdata;
841 assert(sdref->n_ref >= 1);
843 /* We've not been setup completely */
844 if (!sdref->entry_group)
848 case AVAHI_CLIENT_DISCONNECTED:
850 reg_report_error(sdref, kDNSServiceErr_NoError);
853 case AVAHI_CLIENT_S_RUNNING: {
856 if (!sdref->service_name) {
858 /* If the service name is taken from the host name, copy that */
860 avahi_free(sdref->service_name_chosen);
861 sdref->service_name_chosen = NULL;
863 if (!(n = avahi_client_get_host_name(sdref->client))) {
864 reg_report_error(sdref, map_error(avahi_client_errno(sdref->client)));
868 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
869 reg_report_error(sdref, kDNSServiceErr_NoMemory);
874 /* Register the service */
876 if ((ret = reg_create_service(sdref)) < 0) {
877 reg_report_error(sdref, map_error(ret));
884 case AVAHI_CLIENT_S_COLLISION:
886 /* Remove our entry */
887 avahi_entry_group_reset(sdref->entry_group);
891 case AVAHI_CLIENT_S_INVALID:
892 case AVAHI_CLIENT_S_REGISTERING:
899 static void reg_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
900 DNSServiceRef sdref = userdata;
905 case AVAHI_ENTRY_GROUP_ESTABLISHED:
906 /* Inform the user */
907 reg_report_error(sdref, kDNSServiceErr_NoError);
911 case AVAHI_ENTRY_GROUP_COLLISION: {
915 /* Remove our entry */
916 avahi_entry_group_reset(sdref->entry_group);
918 assert(sdref->service_name_chosen);
920 /* Pick a new name */
921 if (!(n = avahi_alternative_service_name(sdref->service_name_chosen))) {
922 reg_report_error(sdref, kDNSServiceErr_NoMemory);
925 avahi_free(sdref->service_name_chosen);
926 sdref->service_name_chosen = n;
928 /* Register the service with that new name */
929 if ((ret = reg_create_service(sdref)) < 0) {
930 reg_report_error(sdref, map_error(ret));
937 case AVAHI_ENTRY_GROUP_REGISTERING:
938 case AVAHI_ENTRY_GROUP_UNCOMMITED:
944 DNSServiceErrorType DNSSD_API DNSServiceRegister (
945 DNSServiceRef *ret_sdref,
946 DNSServiceFlags flags,
954 const void *txtRecord,
955 DNSServiceRegisterReply callback,
958 DNSServiceErrorType ret = kDNSServiceErr_Unknown;
960 DNSServiceRef sdref = NULL;
968 if (interface == kDNSServiceInterfaceIndexLocalOnly || flags) {
969 AVAHI_WARN_UNSUPPORTED;
970 return kDNSServiceErr_Unsupported;
973 if (!(sdref = sdref_new()))
974 return kDNSServiceErr_Unknown;
976 sdref->context = context;
977 sdref->service_register_callback = callback;
979 sdref->service_name = avahi_strdup(name);
980 sdref->service_regtype = regtype ? avahi_normalize_name_strdup(regtype) : NULL;
981 sdref->service_domain = domain ? avahi_normalize_name_strdup(domain) : NULL;
982 sdref->service_host = host ? avahi_normalize_name_strdup(host) : NULL;
983 sdref->service_interface = interface == kDNSServiceInterfaceIndexAny ? AVAHI_IF_UNSPEC : (AvahiIfIndex) interface;
984 sdref->service_port = ntohs(port);
985 sdref->service_txt = txtRecord && txtLen > 0 ? avahi_string_list_parse(txtRecord, txtLen) : NULL;
987 /* Some OOM checking would be cool here */
989 ASSERT_SUCCESS(pthread_mutex_lock(&sdref->mutex));
991 if (!(sdref->client = avahi_client_new(avahi_simple_poll_get(sdref->simple_poll), reg_client_callback, sdref, &error))) {
992 ret = map_error(error);
996 if (!sdref->service_domain) {
999 if (!(d = avahi_client_get_domain_name(sdref->client))) {
1000 ret = map_error(avahi_client_errno(sdref->client));
1004 if (!(sdref->service_domain = avahi_strdup(d))) {
1005 ret = kDNSServiceErr_NoMemory;
1010 if (!(sdref->entry_group = avahi_entry_group_new(sdref->client, reg_entry_group_callback, sdref))) {
1011 ret = map_error(avahi_client_errno(sdref->client));
1015 if (avahi_client_get_state(sdref->client) == AVAHI_CLIENT_S_RUNNING) {
1018 if (sdref->service_name)
1019 n = sdref->service_name;
1021 if (!(n = avahi_client_get_host_name(sdref->client))) {
1022 ret = map_error(avahi_client_errno(sdref->client));
1027 if (!(sdref->service_name_chosen = avahi_strdup(n))) {
1028 ret = kDNSServiceErr_NoMemory;
1033 if ((error = reg_create_service(sdref)) < 0) {
1034 ret = map_error(error);
1039 ret = kDNSServiceErr_NoError;
1044 ASSERT_SUCCESS(pthread_mutex_unlock(&sdref->mutex));
1046 if (ret != kDNSServiceErr_NoError)
1047 DNSServiceRefDeallocate(sdref);