2 * Copyright (c) 2008-2009 Apple Inc. All rights reserved.
4 * @APPLE_LICENSE_HEADER_START@
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
21 * @APPLE_LICENSE_HEADER_END@
24 * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
26 * Permission to use, copy, modify, and distribute this software for any
27 * purpose with or without fee is hereby granted, provided that the above
28 * copyright notice and this permission notice appear in all copies.
30 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
31 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
32 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
33 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
34 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
35 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
36 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
40 * Copyright (c) 1988, 1993
41 * The Regents of the University of California. All rights reserved.
43 * Redistribution and use in source and binary forms, with or without
44 * modification, are permitted provided that the following conditions
46 * 1. Redistributions of source code must retain the above copyright
47 * notice, this list of conditions and the following disclaimer.
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 * 4. Neither the name of the University nor the names of its contributors
52 * may be used to endorse or promote products derived from this software
53 * without specific prior written permission.
55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
70 * Permission to use, copy, modify, and distribute this software for any
71 * purpose with or without fee is hereby granted, provided that the above
72 * copyright notice and this permission notice appear in all copies, and that
73 * the name of Digital Equipment Corporation not be used in advertising or
74 * publicity pertaining to distribution of the document or software without
75 * specific, written prior permission.
77 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
78 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
79 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
80 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
81 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
82 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
83 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
89 #include "si_module.h"
92 #include <arpa/inet.h>
93 #include <arpa/nameser.h>
94 #include <arpa/nameser_compat.h>
95 #include <libkern/OSAtomic.h>
96 #include <netinet/in.h>
108 #include <sys/event.h>
109 #include <sys/param.h>
110 #include <sys/time.h>
111 #include <sys/types.h>
112 #include <sys/socket.h>
118 #include <dns_util.h>
119 #include <TargetConditionals.h>
121 /* from dns_util.c */
122 #define DNS_MAX_RECEIVE_SIZE 65536
124 #define INET_NTOP_AF_INET_OFFSET 4
125 #define INET_NTOP_AF_INET6_OFFSET 8
127 #define IPPROTO_UNSPEC 0
129 static int _mdns_debug
= 0;
131 // mutex protects DNSServiceProcessResult and DNSServiceRefDeallocate
132 static pthread_mutex_t _mdns_mutex
= PTHREAD_MUTEX_INITIALIZER
;
135 // Options: timeout:n total_timeout attempts
137 /* _dns_config_token: notify token indicating dns config needs refresh
139 static int _dns_config_token
= -1;
144 dns_resolver_t
*primary
;
146 dns_resolver_t
**defaults
;
158 typedef struct mdns_srv_t mdns_srv_t
;
178 DNSServiceRef _mdns_sdref
;
179 DNSServiceRef _mdns_old_sdref
;
181 static int _mdns_query_mDNSResponder(const char *name
, int class, int type
,
182 const char *interface
, DNSServiceFlags flags
,
183 uint8_t *answer
, uint32_t *anslen
,
184 mdns_reply_t
*reply
, uint32_t timeout
);
186 static int _mdns_resolver_get_option(dns_resolver_t
*resolver
, const char* option
);
187 static void _mdns_hostent_clear(mdns_hostent_t
*h
);
188 static void _mdns_reply_clear(mdns_reply_t
*r
);
190 static const char hexchar
[] = "0123456789abcdef";
192 #define BILLION 1000000000
194 /* length of a reverse DNS IPv6 address query name, e.g. "9.4.a.f.c.e.e.f.e.e.1.5.4.1.4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa" */
195 #define IPv6_REVERSE_LEN 72
197 /* index of the trailing char that must be "8", "9", "A", "a", "b", or "B" */
198 #define IPv6_REVERSE_LINK_LOCAL_TRAILING_CHAR 58
200 /* index of low-order nibble of embedded scope id */
201 #define IPv6_REVERSE_LINK_LOCAL_SCOPE_ID_LOW 48
203 const static uint8_t hexval
[128] = {
204 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 15 */
205 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16 - 31 */
206 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 32 - 47 */
207 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 48 - 63 */
208 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 64 - 79 */
209 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 95 */
210 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 96 - 111 */
211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 112 - 127 */
215 * _mdns_create_search_list
216 * Creates a NULL terminated array of strings from the specied resolver's
217 * search list, or from the components of the specified resolver's domain
218 * if search list is empty.
219 * Free the list and elements with free(3) when done.
222 _mdns_create_search_list(dns_resolver_t
*resolver
)
228 if (resolver
== NULL
) return NULL
;
230 // return the search list if present
231 if (resolver
->n_search
> 0) {
232 list
= (char **)calloc(resolver
->n_search
+1, sizeof(char *));
233 if (list
== NULL
) return NULL
;
234 for (n
= 0; n
< resolver
->n_search
; ++n
) {
235 list
[n
] = strdup(resolver
->search
[n
]);
240 if (resolver
->domain
== NULL
) return NULL
;
241 domain
= strdup(resolver
->domain
);
242 if (domain
== NULL
) return NULL
;
246 for (p
= domain
; *p
!= '\0'; p
++) {
250 // trim trailing dots
251 for (p
--; (p
>= domain
) && (*p
== '.'); p
--) {
256 // make sure the resulting string is not empty
262 // dots are separators, so number of components is one larger
266 list
= (char **)calloc(n
+1, sizeof(char *));
267 if (list
== NULL
) return NULL
;
268 // first item in list is domain itself
271 // include parent domains with at least LOCALDOMAINPARTS components
273 while (n
> LOCALDOMAINPARTS
) {
274 // find next component
275 while ((*p
!= '.') && (*p
!= '\0')) p
++;
276 if (*p
== '\0') break;
280 list
[m
++] = strdup(p
);
285 /* _mdns_resolver_get_option
286 * Determines whether the specified option is present in the resolver.
289 _mdns_resolver_get_option(dns_resolver_t
*resolver
, const char* option
)
291 if (resolver
== NULL
) return 0;
292 int len
= strlen(option
);
293 char *options
= resolver
->options
;
294 if (options
== NULL
) return 0;
295 // look for "(^| )option( |:|$)"
296 char *ptr
= strstr(options
, option
);
298 if (ptr
== options
|| ptr
[-1] == ' ') {
299 if (ptr
[len
] == ' ' || ptr
[len
] == 0) {
301 } else if (ptr
[len
] == ':') {
302 return strtol(&ptr
[len
+1], NULL
, 10);
305 ptr
= strstr(ptr
, option
);
310 /* _mdns_compare_resolvers
311 * Compares two dns_resolver_t pointers by search order ascending.
314 _mdns_compare_resolvers(const void *a
, const void *b
)
316 dns_resolver_t
**x
= (dns_resolver_t
**)a
, **y
= (dns_resolver_t
**)b
;
317 return ((*x
)->search_order
- (*y
)->search_order
);
320 /* _mdns_create_default_resolvers_list
321 * Returns an array of dns_resolver_t containing only default resolvers.
322 * A resolver is a default resolver if it is the primary resolver or if it
323 * contains the "default" configuration option.
326 _mdns_config_init_default_resolvers(mdns_config_t
*config
)
328 uint32_t count
= config
->dns
->n_resolver
;
329 if (count
== 0) return;
330 config
->defaults
= calloc(count
, sizeof(dns_resolver_t
*));
331 if (config
->defaults
== NULL
) return;
333 if (config
->primary
) config
->defaults
[m
++] = config
->primary
;
334 // iterate the resolvers, add any default resolvers that are not
335 // already in the list.
336 for (i
= 0; i
< count
; ++i
) {
337 dns_resolver_t
*resolver
= config
->dns
->resolver
[i
];
338 if (_mdns_resolver_get_option(resolver
, "default")) {
340 for (j
= 0; j
< m
; ++j
) {
341 if (config
->defaults
[j
] == resolver
) {
347 config
->defaults
[m
++] = resolver
;
351 config
->n_defaults
= m
;
352 // sort list by search order ascending
353 qsort(config
->defaults
, config
->n_defaults
, sizeof(dns_resolver_t
*), _mdns_compare_resolvers
);
358 _mdns_print_dns_resolver(dns_resolver_t
*resolver
)
360 printf("resolver = {\n");
361 printf("\tdomain = %s\n", resolver
->domain
);
363 for (j
= 0; j
< resolver
->n_nameserver
; ++j
) {
365 char host
[255], serv
[255];
366 res
= getnameinfo(resolver
->nameserver
[j
], resolver
->nameserver
[j
]->sa_len
, host
, sizeof(host
), serv
, sizeof(serv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
368 printf("\tnameserver[%d] = %s:%s\n", j
, host
, serv
);
370 printf("\tnameserver[%d] = %s\n", j
, gai_strerror(res
));
373 printf("\tport = %d\n", resolver
->port
);
374 for (j
= 0; j
< resolver
->n_search
; ++j
) {
375 printf("\tsearch[%d] = %s\n", j
, resolver
->search
[j
]);
378 printf("\tn_sortaddr = %d\n", resolver
->n_sortaddr
);
380 printf("\toptions = %s\n", resolver
->options
);
381 printf("\ttimeout = %d\n", resolver
->timeout
);
382 printf("\tsearch_order = %d\n", resolver
->search_order
);
387 _mdns_print_dns_config(dns_config_t
*config
)
390 dns_resolver_t
**list
= _mdns_create_sorted_resolver_list(config
);
391 dns_resolver_t
**ptr
= list
;
393 _mdns_print_dns_resolver(*ptr
);
400 _mdns_print_hostent(mdns_hostent_t
* h
)
402 if (h
== NULL
) return;
403 printf("hostent[%p] = {\n", h
);
404 printf("\thost = {\n");
405 printf("\t\th_name = %s\n", h
->host
.h_name
);
406 printf("\t\th_length = %d\n", h
->host
.h_length
);
407 printf("\t\th_addrtype = %d\n", h
->host
.h_addrtype
);
408 char **alias
= h
->host
.h_aliases
;
409 while (alias
&& *alias
) {
410 printf("\t\th_aliases = %s\n", *alias
++);
412 char **addr
= h
->host
.h_addr_list
;
413 while (addr
&& *addr
) {
414 printf("\t\th_addr_list = %x\n", ntohl(*(uint32_t*)*addr
++));
417 printf("\talias_count = %d\n", h
->alias_count
);
418 printf("\taddr_count = %d\n", h
->addr_count
);
424 /* _mdns_config_retain
425 * Retain the mdns configuration.
427 static mdns_config_t
*
428 _mdns_config_retain(mdns_config_t
*config
)
432 if (config
== NULL
) return NULL
;
433 rc
= OSAtomicIncrement32Barrier(&config
->rc
);
438 /* _mdns_config_release
439 * Releases the mdns configuration structure and
440 * frees the data if no references remain.
443 _mdns_config_release(mdns_config_t
*config
)
447 if (config
== NULL
) return;
448 rc
= OSAtomicDecrement32Barrier(&config
->rc
);
451 if (config
->dns
) dns_configuration_free(config
->dns
);
452 free(config
->defaults
);
453 char **p
= config
->search_list
;
454 while (p
&& *p
) { free(*p
++); }
455 free(config
->search_list
);
460 /* _mdns_copy_system_config
461 * Retrieves DNS configuration from SystemConfiguration.framework.
462 * Checks notify notification to determine whether configuration is in need
465 static mdns_config_t
*
466 _mdns_copy_system_config(void)
468 // first call needs refresh
469 static mdns_config_t
*current_config
;
470 mdns_config_t
*config
= NULL
;
474 pthread_mutex_lock(&_mdns_mutex
);
476 // check whether the global configuration has changed
477 if (_dns_config_token
== -1) {
478 res
= notify_register_check(dns_configuration_notify_key(), &_dns_config_token
);
479 if (res
!= NOTIFY_STATUS_OK
) _dns_config_token
= -1;
482 if (_dns_config_token
!= -1) {
483 res
= notify_check(_dns_config_token
, &refresh
);
484 if (res
!= NOTIFY_STATUS_OK
) refresh
= 1;
487 // return the current configuration if still valid
489 mdns_config_t
*config
= _mdns_config_retain(current_config
);
490 pthread_mutex_unlock(&_mdns_mutex
);
494 // need to allocate a new configuration
496 config
= calloc(1, sizeof(mdns_config_t
));
497 if (config
!= NULL
) config
->dns
= dns_configuration_copy();
499 // failed to get new config, return previous config
500 if (config
== NULL
|| config
->dns
== NULL
) {
502 config
= _mdns_config_retain(current_config
);
503 pthread_mutex_unlock(&_mdns_mutex
);
508 if (config
->dns
->n_resolver
> 0) {
509 // primary resolver is always index 0 and contains the
511 config
->primary
= config
->dns
->resolver
[0];
512 config
->search_list
= _mdns_create_search_list(config
->primary
);
513 _mdns_config_init_default_resolvers(config
);
515 config
->ndots
= _mdns_resolver_get_option(config
->primary
, "ndots");
517 // promote the new configuration to current
518 _mdns_config_release(current_config
);
519 current_config
= config
;
521 // return the new configuration
522 config
= _mdns_config_retain(config
);
523 pthread_mutex_unlock(&_mdns_mutex
);
527 /* _mdns_timeout_for_name
528 * Returns the appropriate timeout for the specified name based on the
529 * sum of the timeouts of all resolvers that match the name.
532 _mdns_timeout_for_name(mdns_config_t
*config
, const char *name
)
535 uint32_t timeout
= 0;
537 if (name
== NULL
) return 0;
539 // use strncasecmp to ignore a trailing '.' in name
540 int len
= strlen(name
);
541 if ((len
- 1) >= 0 && name
[len
-1] == '.') --len
;
543 const char *p
= name
;
545 uint32_t count
= config
->dns
->n_resolver
;
546 for (i
= 0; i
< count
; ++i
) {
547 dns_resolver_t
*resolver
= config
->dns
->resolver
[i
];
548 if (resolver
->domain
== NULL
) continue;
549 if (strncasecmp(resolver
->domain
, p
, len
) == 0) {
550 timeout
+= resolver
->timeout
;
553 // discard the current label
557 if (p
[-1] == '.') break;
563 /* _mdns_query_unqualified
564 * Performs a query for the name as an unqualified name (appends each
565 * of the default resolver's domains).
568 _mdns_query_unqualified(mdns_config_t
*config
, const char *name
, uint32_t class, uint32_t type
, const char *interface
, DNSServiceFlags flags
, uint8_t *buf
, uint32_t *len
, mdns_reply_t
*reply
)
572 for (i
= 0; i
< config
->n_defaults
; ++i
) {
573 dns_resolver_t
*resolver
= config
->defaults
[i
];
576 asprintf(&qname
, "%s.%s", name
, resolver
->domain ? resolver
->domain
: "");
577 res
= _mdns_query_mDNSResponder(qname
, class, type
, interface
, flags
, buf
, len
, reply
, resolver
->timeout
);
581 else _mdns_reply_clear(reply
);
586 /* _mdns_query_absolute
587 * Performs a query for the name as an absolute name (does not qualify with any
588 * additional domains).
591 _mdns_query_absolute(mdns_config_t
*config
, const char *name
, uint32_t class, uint32_t type
, const char *interface
, DNSServiceFlags flags
, uint32_t fqdn
, uint8_t *buf
, uint32_t *len
, mdns_reply_t
*reply
)
594 char *qname
= (char *)name
;
596 uint32_t timeout
= _mdns_timeout_for_name(config
, name
);
598 if (fqdn
== 0) asprintf(&qname
, "%s.", name
);
599 res
= _mdns_query_mDNSResponder(qname
, class, type
, interface
, flags
, buf
, len
, reply
, timeout
);
600 if (fqdn
== 0) free(qname
);
601 if (res
!= 0) _mdns_reply_clear(reply
);
606 _mdns_search(const char *name
, uint32_t class, uint32_t type
, const char *interface
, DNSServiceFlags flags
, uint32_t fqdn
, uint32_t recurse
, uint8_t *buf
, uint32_t *len
, mdns_reply_t
*reply
)
612 if (name
== NULL
) return -1;
614 mdns_config_t
*config
= _mdns_copy_system_config();
615 if (config
== NULL
) return -1;
617 // NDOTS is the threshold for trying a qualified name "as is"
618 ndots
= config
->ndots
;
619 if (ndots
== 0) ndots
= 1;
621 // count the dots, and remember position of the last one
624 for (i
= 0; name
[i
] != '\0'; i
++) {
625 if (name
[i
] == '.') {
627 dot
= (char *)(name
+ i
);
630 // FQDN has dot for last character
631 if (fqdn
== 0 && dot
!= NULL
&& dot
[1] == '\0') fqdn
= 1;
633 // if the name has at least ndots, try first as an absolute query.
634 // FQDN and PTR queries are always absolute.
635 if (n
>= ndots
|| fqdn
== 1 || type
== ns_t_ptr
) {
636 res
= _mdns_query_absolute(config
, name
, class, type
, interface
, flags
, fqdn
, buf
, len
, reply
);
638 _mdns_config_release(config
);
643 // stop if FQDN, PTR, or no recursion requested
644 if (fqdn
== 1 || type
== ns_t_ptr
|| recurse
== 0) {
645 _mdns_config_release(config
);
649 // Qualify the name with each of the search domains looking for a match.
650 char **search
= config
->search_list
;
651 if (search
!= NULL
) {
653 for (i
= 0; i
< MAXDNSRCH
&& search
[i
] != NULL
; ++i
) {
655 asprintf(&qname
, "%s.%s", name
, search
[i
]);
656 res
= _mdns_search(qname
, class, type
, interface
, flags
, 0, 0, buf
, len
, reply
);
661 // The name is not fully qualified and there is no search list.
662 // Try each default resolver, qualifying the name with that
663 // resolver's domain.
664 res
= _mdns_query_unqualified(config
, name
, class, type
, interface
, flags
, buf
, len
, reply
);
666 _mdns_config_release(config
);
671 _mdns_reverse_ipv4(const char *addr
)
680 if (addr
== NULL
) return NULL
;
682 memcpy(&(ab
.a
), addr
, 4);
684 asprintf(&p
, "%u.%u.%u.%u.in-addr.arpa.", ab
.b
[3], ab
.b
[2], ab
.b
[1], ab
.b
[0]);
689 _mdns_reverse_ipv6(const char *addr
)
695 if (addr
== NULL
) return NULL
;
699 for (i
= 0; i
< 16; i
++)
705 x
[j
--] = hexchar
[hi
];
707 x
[j
--] = hexchar
[lo
];
710 asprintf(&p
, "%sip6.arpa.", x
);
715 /* _mdns_canonicalize
716 * Canonicalize the domain name by converting to lower case and removing the
717 * trailing '.' if present.
720 _mdns_canonicalize(const char *s
)
724 if (s
== NULL
) return NULL
;
726 if (t
== NULL
) return NULL
;
727 if (t
[0] == '\0') return t
;
728 for (i
= 0; t
[i
] != '\0'; i
++) {
729 if (t
[i
] >= 'A' && t
[i
] <= 'Z') t
[i
] += 32;
731 if (t
[i
-1] == '.') t
[i
-1] = '\0';
735 /* _mdns_hostent_append_alias
736 * Appends an alias to the mdns_hostent_t structure.
739 _mdns_hostent_append_alias(mdns_hostent_t
*h
, const char *alias
)
743 if (h
== NULL
|| alias
== NULL
) return 0;
744 name
= _mdns_canonicalize(alias
);
745 if (name
== NULL
) return -1;
747 // don't add the name if it matches an existing name
748 if (h
->host
.h_name
&& string_equal(h
->host
.h_name
, name
)) {
752 for (i
= 0; i
< h
->alias_count
; ++i
) {
753 if (string_equal(h
->host
.h_aliases
[i
], name
)) {
759 // add the alias and NULL terminate the list
760 h
->host
.h_aliases
= (char **)reallocf(h
->host
.h_aliases
, (h
->alias_count
+2) * sizeof(char *));
761 if (h
->host
.h_aliases
== NULL
) {
766 h
->host
.h_aliases
[h
->alias_count
] = name
;
768 h
->host
.h_aliases
[h
->alias_count
] = NULL
;
772 /* _mdns_hostent_append_addr
773 * Appends an alias to the mdns_hostent_t structure.
776 _mdns_hostent_append_addr(mdns_hostent_t
*h
, const uint8_t *addr
, uint32_t len
)
778 if (h
== NULL
|| addr
== NULL
|| len
== 0) return 0;
780 // copy the address buffer
781 uint8_t *buf
= malloc(len
);
782 if (buf
== NULL
) return -1;
783 memcpy(buf
, addr
, len
);
785 // add the address and NULL terminate the list
786 h
->host
.h_addr_list
= (char **)reallocf(h
->host
.h_addr_list
, (h
->addr_count
+2) * sizeof(char *));
787 if (h
->host
.h_addr_list
== NULL
) {
791 h
->host
.h_addr_list
[h
->addr_count
] = (char*)buf
;
793 h
->host
.h_addr_list
[h
->addr_count
] = NULL
;
798 _mdns_hostent_clear(mdns_hostent_t
*h
)
800 if (h
== NULL
) return;
801 free(h
->host
.h_name
);
802 h
->host
.h_name
= NULL
;
804 char **aliases
= h
->host
.h_aliases
;
805 while (aliases
&& *aliases
) {
808 free(h
->host
.h_aliases
);
809 h
->host
.h_aliases
= NULL
;
812 char **addrs
= h
->host
.h_addr_list
;
813 while (addrs
&& *addrs
) {
816 free(h
->host
.h_addr_list
);
817 h
->host
.h_addr_list
= NULL
;
823 _mdns_reply_clear(mdns_reply_t
*r
)
825 if (r
== NULL
) return;
827 _mdns_hostent_clear(r
->h4
);
828 _mdns_hostent_clear(r
->h6
);
829 mdns_srv_t
*srv
= r
->srv
;
832 mdns_srv_t
*next
= srv
->next
;
833 free(srv
->srv
.target
);
840 _mdns_hostbyname(si_mod_t
*si
, const char *name
, int af
, const char *interface
, uint32_t *err
)
845 si_item_t
*out
= NULL
;
848 DNSServiceFlags flags
= 0;
850 if (err
!= NULL
) *err
= SI_STATUS_NO_ERROR
;
853 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
857 memset(&h
, 0, sizeof(h
));
858 memset(&reply
, 0, sizeof(reply
));
868 h
.host
.h_length
= 16;
872 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
875 h
.host
.h_addrtype
= af
;
877 status
= _mdns_search(name
, ns_c_in
, type
, interface
, flags
, 0, 1, NULL
, NULL
, &reply
);
878 if (status
!= 0 || h
.addr_count
== 0) {
879 _mdns_reply_clear(&reply
);
880 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_HOST_NOT_FOUND
;
884 bb
= reply
.ttl
+ time(NULL
);
888 out
= (si_item_t
*)LI_ils_create("L4488s*44a", (unsigned long)si
, CATEGORY_HOST_IPV4
, 1, bb
, 0LL, h
.host
.h_name
, h
.host
.h_aliases
, h
.host
.h_addrtype
, h
.host
.h_length
, h
.host
.h_addr_list
);
891 out
= (si_item_t
*)LI_ils_create("L4488s*44c", (unsigned long)si
, CATEGORY_HOST_IPV6
, 1, bb
, 0LL, h
.host
.h_name
, h
.host
.h_aliases
, h
.host
.h_addrtype
, h
.host
.h_length
, h
.host
.h_addr_list
);
895 _mdns_reply_clear(&reply
);
897 if (out
== NULL
&& err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
903 _mdns_hostbyaddr(si_mod_t
*si
, const void *addr
, int af
, const char *interface
, uint32_t *err
)
912 DNSServiceFlags flags
= 0;
914 if (err
!= NULL
) *err
= SI_STATUS_NO_ERROR
;
916 if (addr
== NULL
|| si
== NULL
) {
917 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
921 memset(&h
, 0, sizeof(h
));
922 memset(&reply
, 0, sizeof(reply
));
928 name
= _mdns_reverse_ipv4(addr
);
929 cat
= CATEGORY_HOST_IPV4
;
932 h
.host
.h_length
= 16;
934 name
= _mdns_reverse_ipv6(addr
);
935 cat
= CATEGORY_HOST_IPV6
;
938 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
941 h
.host
.h_addrtype
= af
;
943 status
= _mdns_search(name
, ns_c_in
, ns_t_ptr
, interface
, flags
, 0, 1, NULL
, NULL
, &reply
);
946 _mdns_reply_clear(&reply
);
947 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_HOST_NOT_FOUND
;
951 status
= _mdns_hostent_append_addr(&h
, addr
, h
.host
.h_length
);
953 _mdns_hostent_clear(&h
);
954 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
958 bb
= reply
.ttl
+ time(NULL
);
959 out
= (si_item_t
*)LI_ils_create("L4488s*44a", (unsigned long)si
, cat
, 1, bb
, 0LL, h
.host
.h_name
, h
.host
.h_aliases
, h
.host
.h_addrtype
, h
.host
.h_length
, h
.host
.h_addr_list
);
961 _mdns_hostent_clear(&h
);
963 if (out
== NULL
&& err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
968 _mdns_addrinfo(si_mod_t
*si
, const void *node
, const void *serv
, uint32_t family
, uint32_t socktype
, uint32_t proto
, uint32_t flags
, const char *interface
, uint32_t *err
)
972 if (family
== AF_INET6
) wantv4
= 0;
973 else if (family
== AF_INET
) wantv6
= 0;
974 else if (family
!= AF_UNSPEC
) return NULL
;
984 if (err
!= NULL
) *err
= SI_STATUS_NO_ERROR
;
986 si_list_t
*out
= NULL
;
988 memset(&h4
, 0, sizeof(h4
));
989 memset(&h6
, 0, sizeof(h6
));
990 memset(&reply
, 0, sizeof(reply
));
992 h4
.host
.h_addrtype
= AF_INET
;
993 h4
.host
.h_length
= 4;
994 h6
.host
.h_addrtype
= AF_INET6
;
995 h6
.host
.h_length
= 16;
997 if (wantv4
&& wantv6
) {
1001 } else if (wantv4
) {
1004 } else if (wantv6
) {
1008 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
1013 if ((flags
& AI_NUMERICSERV
) != 0) {
1014 port
= *(uint16_t *)serv
;
1016 if (_gai_serv_to_port(serv
, proto
, &port
) != 0) {
1017 if (err
) *err
= SI_STATUS_EAI_NONAME
;
1023 if ((flags
& AI_NUMERICHOST
) != 0) {
1025 struct in_addr
*p4
= NULL
;
1026 struct in6_addr
*p6
= NULL
;
1027 if (family
== AF_INET
) {
1029 memcpy(p4
, node
, sizeof(a4
));
1030 } else if (family
== AF_INET6
) {
1032 memcpy(p6
, node
, sizeof(a6
));
1034 out
= si_addrinfo_list(si
, socktype
, proto
, p4
, p6
, port
, 0, cname
, cname
);
1036 DNSServiceFlags dns_flags
= 0;
1037 if (flags
& AI_ADDRCONFIG
) {
1038 dns_flags
|= kDNSServiceFlagsSuppressUnusable
;
1041 res
= _mdns_search(node
, ns_c_in
, type
, interface
, dns_flags
, 0, 1, NULL
, NULL
, &reply
);
1042 if (res
== 0 && (h4
.addr_count
> 0 || h6
.addr_count
> 0)) {
1043 out
= si_addrinfo_list_from_hostent(si
, socktype
, proto
,
1045 (wantv4 ?
&h4
.host
: NULL
),
1046 (wantv6 ?
&h6
.host
: NULL
));
1047 } else if (err
!= NULL
) {
1048 *err
= SI_STATUS_EAI_NONAME
;
1050 _mdns_reply_clear(&reply
);
1056 _mdns_srv_byname(si_mod_t
* si
, const char *qname
, const char *interface
, uint32_t *err
)
1058 si_list_t
*out
= NULL
;
1062 const uint64_t unused
= 0;
1063 DNSServiceFlags flags
= 0;
1065 if (err
!= NULL
) *err
= SI_STATUS_NO_ERROR
;
1067 memset(&reply
, 0, sizeof(reply
));
1068 res
= _mdns_search(qname
, ns_c_in
, ns_t_srv
, interface
, flags
, 0, 1, NULL
, NULL
, &reply
);
1073 item
= (si_item_t
*)LI_ils_create("L4488222s", (unsigned long)si
, CATEGORY_SRV
, 1, unused
, unused
, srv
->srv
.priority
, srv
->srv
.weight
, srv
->srv
.port
, srv
->srv
.target
);
1074 out
= si_list_add(out
, item
);
1075 si_item_release(item
);
1079 _mdns_reply_clear(&reply
);
1084 * We support dns_async_start / cancel / handle_reply using dns_item_call
1087 _mdns_item_call(si_mod_t
*si
, int call
, const char *name
, const char *ignored
, const char *interface
, uint32_t class, uint32_t type
, uint32_t *err
)
1090 uint8_t buf
[DNS_MAX_RECEIVE_SIZE
];
1091 uint32_t len
= sizeof(buf
);
1097 DNSServiceFlags flags
= 0;
1099 if (err
!= NULL
) *err
= SI_STATUS_NO_ERROR
;
1102 case SI_CALL_DNS_QUERY
:
1105 case SI_CALL_DNS_SEARCH
:
1108 if (err
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
1114 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
1118 memset(&h4
, 0, sizeof(h4
));
1119 memset(&h6
, 0, sizeof(h6
));
1120 memset(&reply
, 0, sizeof(reply
));
1122 h4
.host
.h_addrtype
= AF_INET
;
1123 h4
.host
.h_length
= 4;
1124 h6
.host
.h_addrtype
= AF_INET6
;
1125 h6
.host
.h_length
= 16;
1129 res
= _mdns_search(name
, class, type
, interface
, flags
, norecurse
, 1, buf
, &len
, &reply
);
1130 if (res
!= 0 || len
<= 0 || len
> DNS_MAX_RECEIVE_SIZE
) {
1131 _mdns_reply_clear(&reply
);
1132 if (err
!= NULL
) *err
= SI_STATUS_H_ERRNO_HOST_NOT_FOUND
;
1136 struct sockaddr_in6 from
;
1137 uint32_t fromlen
= sizeof(from
);
1138 memset(&from
, 0, fromlen
);
1139 from
.sin6_len
= fromlen
;
1140 from
.sin6_family
= AF_INET6
;
1141 from
.sin6_addr
.__u6_addr
.__u6_addr8
[15] = 1;
1142 if (reply
.ifnum
!= 0) {
1143 from
.sin6_addr
.__u6_addr
.__u6_addr16
[0] = htons(0xfe80);
1144 from
.sin6_scope_id
= reply
.ifnum
;
1147 out
= (si_item_t
*)LI_ils_create("L4488@@", (unsigned long)si
, CATEGORY_DNSPACKET
, 1, 0LL, 0LL, len
, buf
, fromlen
, &from
);
1148 if (out
== NULL
&& err
!= NULL
) *err
= SI_STATUS_H_ERRNO_NO_RECOVERY
;
1150 _mdns_reply_clear(&reply
);
1156 _mdns_is_valid(si_mod_t
*si
, si_item_t
*item
)
1162 _mdns_close(si_mod_t
*si
)
1164 if (_dns_config_token
!= -1) notify_cancel(_dns_config_token
);
1169 _mdns_atfork_prepare(void)
1171 // acquire our lock so that we know all other threads have "drained"
1172 pthread_mutex_lock(&_mdns_mutex
);
1176 _mdns_atfork_parent(void)
1178 // parent can simply resume
1179 pthread_mutex_unlock(&_mdns_mutex
);
1183 _mdns_atfork_child(void)
1185 // child needs to force re-initialization
1186 _mdns_old_sdref
= _mdns_sdref
; // for later deallocation
1188 _dns_config_token
= -1;
1189 pthread_mutex_unlock(&_mdns_mutex
);
1192 __private_extern__ si_mod_t
*
1193 si_module_static_mdns(void)
1195 si_mod_t
*out
= (si_mod_t
*)calloc(1, sizeof(si_mod_t
));
1196 char *outname
= strdup("mdns");
1198 if ((out
== NULL
) || (outname
== NULL
))
1205 out
->name
= outname
;
1208 out
->private = NULL
;
1210 out
->sim_close
= _mdns_close
;
1211 out
->sim_is_valid
= _mdns_is_valid
;
1212 out
->sim_host_byname
= _mdns_hostbyname
;
1213 out
->sim_host_byaddr
= _mdns_hostbyaddr
;
1214 out
->sim_item_call
= _mdns_item_call
;
1215 out
->sim_addrinfo
= _mdns_addrinfo
;
1216 out
->sim_srv_byname
= _mdns_srv_byname
;
1220 res
= notify_register_check(dns_configuration_notify_key(), &_dns_config_token
);
1221 if (res
!= NOTIFY_STATUS_OK
) _dns_config_token
= -1;
1223 pthread_atfork(_mdns_atfork_prepare
, _mdns_atfork_parent
, _mdns_atfork_child
);
1225 _mdns_debug
= getenv("RES_DEBUG") != NULL
;
1231 * _mdns_parse_domain_name
1232 * Combine DNS labels to form a string.
1233 * DNSService API does not return compressed names.
1236 _mdns_parse_domain_name(const uint8_t *data
, uint32_t datalen
)
1240 uint32_t domainlen
= 0;
1241 char *domain
= NULL
;
1243 // i: index into input data
1244 // j: index into output string
1245 while (datalen
-- > 0) {
1247 domainlen
+= (len
+ 1);
1248 domain
= reallocf(domain
, domainlen
);
1249 if (domain
== NULL
) return NULL
;
1250 if (len
== 0) break; // DNS root (NUL)
1252 domain
[j
++] = datalen ?
'.' : '\0';
1255 while ((len
-- > 0) && (datalen
--)) {
1256 if (data
[i
] == '.') {
1257 // special case: escape the '.' with a '\'
1258 domain
= reallocf(domain
, ++domainlen
);
1259 if (domain
== NULL
) return NULL
;
1262 domain
[j
++] = data
[i
++];
1271 * _mdns_pack_domain_name
1272 * Format the string as packed DNS labels.
1273 * Only used for one string at a time, therefore no need for compression.
1276 _mdns_pack_domain_name(const char* str
, uint8_t *buf
, size_t buflen
) {
1278 while (i
< buflen
) {
1280 // calculate length to next '.' or '\0'
1281 char *dot
= strchr(str
, '.');
1282 if (dot
== NULL
) dot
= strchr(str
, '\0');
1284 if (len
> NS_MAXLABEL
) return -1;
1285 // copy data for label
1290 // skip past '.', break if '\0'
1291 if (*str
++ == '\0') break;
1293 if (i
>= buflen
) return -1;
1299 _is_rev_link_local(const char *name
)
1303 if (name
== NULL
) return 0;
1306 if (len
== 0) return 0;
1308 /* check for trailing '.' */
1309 if (name
[len
- 1] == '.') len
--;
1311 if (len
!= IPv6_REVERSE_LEN
) return 0;
1313 i
= IPv6_REVERSE_LINK_LOCAL_TRAILING_CHAR
;
1314 if ((name
[i
] != '8') && (name
[i
] != '9') && (name
[i
] != 'A') && (name
[i
] != 'a') && (name
[i
] != 'B') && (name
[i
] != 'b')) return 0;
1316 i
= IPv6_REVERSE_LINK_LOCAL_TRAILING_CHAR
+ 1;
1317 if (strncasecmp(name
+ i
, ".e.f.ip6.arpa", 13)) return 0;
1319 for (i
= 0; i
< IPv6_REVERSE_LINK_LOCAL_TRAILING_CHAR
; i
+= 2)
1321 if (name
[i
] < '0') return 0;
1322 if ((name
[i
] > '9') && (name
[i
] < 'A')) return 0;
1323 if ((name
[i
] > 'F') && (name
[i
] < 'a')) return 0;
1324 if (name
[i
] > 'f') return 0;
1325 if (name
[i
+ 1] != '.') return 0;
1331 /* _mdns_ipv6_extract_scope_id
1332 * If the input string is a link local IPv6 address with an encoded scope id,
1333 * the scope id is extracted and a new string is constructed with the scope id removed.
1336 _mdns_ipv6_extract_scope_id(const char *name
, uint32_t *out_ifnum
)
1343 if (out_ifnum
!= NULL
) *out_ifnum
= 0;
1345 /* examine the address, extract the scope id if present */
1346 if ((name
!= NULL
) && (_is_rev_link_local(name
)))
1348 /* _is_rev_link_local rejects chars > 127 so it's safe to index into hexval */
1349 i
= IPv6_REVERSE_LINK_LOCAL_SCOPE_ID_LOW
;
1350 nibble
= hexval
[(uint32_t)name
[i
]];
1354 nibble
= hexval
[(uint32_t)name
[i
]];
1355 iface
+= (nibble
<< 4);
1358 nibble
= hexval
[(uint32_t)name
[i
]];
1359 iface
+= (nibble
<< 8);
1362 nibble
= hexval
[(uint32_t)name
[i
]];
1363 iface
+= (nibble
<< 12);
1367 qname
= strdup(name
);
1368 if (qname
== NULL
) return NULL
;
1370 i
= IPv6_REVERSE_LINK_LOCAL_SCOPE_ID_LOW
;
1376 if (out_ifnum
) *out_ifnum
= iface
;
1384 _mdns_make_query(const char* name
, int class, int type
, uint8_t *buf
, uint32_t buflen
)
1388 if (buf
== NULL
|| buflen
< (NS_HFIXEDSZ
+ NS_QFIXEDSZ
)) return -1;
1389 memset(buf
, 0, NS_HFIXEDSZ
);
1390 HEADER
*hp
= (HEADER
*)buf
;
1393 hp
->id
= arc4random();
1395 hp
->opcode
= ns_o_query
;
1397 hp
->rcode
= ns_r_noerror
;
1398 hp
->qdcount
= htons(1);
1400 int n
= _mdns_pack_domain_name(name
, &buf
[len
], buflen
- len
);
1401 if (n
< 0) return -1;
1406 memcpy(&buf
[len
], &word
, sizeof(word
));
1407 len
+= sizeof(word
);
1408 word
= htons(class);
1409 memcpy(&buf
[len
], &word
, sizeof(word
));
1410 len
+= sizeof(word
);
1415 mdns_reply_t
*reply
;
1416 mdns_hostent_t
*host
;
1417 uint8_t *answer
; // DNS packet buffer
1418 size_t anslen
; // DNS packet buffer current length
1419 size_t ansmaxlen
; // DNS packet buffer maximum length
1420 int type
; // type of query: A, AAAA, PTR, SRV...
1421 uint16_t last_type
; // last type received
1423 DNSServiceFlags flags
;
1424 DNSServiceErrorType error
;
1425 int kq
; // kqueue to notify when callback received
1426 } mdns_query_context_t
;
1429 _mdns_query_callback(DNSServiceRef
, DNSServiceFlags
, uint32_t, DNSServiceErrorType
, const char *, uint16_t, uint16_t, uint16_t, const void *, uint32_t, void *);
1431 /* _mdns_query_start
1432 * initializes the context and starts a DNS-SD query.
1434 static DNSServiceErrorType
1435 _mdns_query_start(mdns_query_context_t
*ctx
, mdns_reply_t
*reply
, uint8_t *answer
, uint32_t *anslen
, const char* name
, int class, int type
, const char *interface
, DNSServiceFlags flags
, int kq
)
1437 DNSServiceErrorType status
;
1439 flags
|= kDNSServiceFlagsShareConnection
;
1440 flags
|= kDNSServiceFlagsReturnIntermediates
;
1442 memset(ctx
, 0, sizeof(mdns_query_context_t
));
1444 if (answer
&& anslen
) {
1445 // build a dummy DNS header to return to the caller
1446 ctx
->answer
= answer
;
1447 ctx
->ansmaxlen
= *anslen
;
1448 ctx
->anslen
= _mdns_make_query(name
, class, type
, answer
, ctx
->ansmaxlen
);
1449 if (ctx
->anslen
<= 0) return -1;
1453 ctx
->sd
= _mdns_sdref
;
1457 if (type
== ns_t_a
) ctx
->host
= reply
->h4
;
1458 else if (type
== ns_t_aaaa
) ctx
->host
= reply
->h6
;
1459 else if (type
== ns_t_ptr
&& reply
->h4
) ctx
->host
= reply
->h4
;
1460 else if (type
== ns_t_ptr
&& reply
->h6
) ctx
->host
= reply
->h6
;
1461 else if (type
!= ns_t_srv
&& type
!= ns_t_cname
) abort();
1465 char *qname
= _mdns_ipv6_extract_scope_id(name
, &iface
);
1466 if (qname
== NULL
) qname
= (char *)name
;
1468 if (interface
!= NULL
)
1470 /* get interface number from name */
1471 int iface2
= if_nametoindex(interface
);
1473 /* balk if interface name lookup failed */
1474 if (iface2
== 0) return -1;
1476 /* balk if scope id is set AND interface is given AND they don't match */
1477 if ((iface
!= 0) && (iface2
!= 0) && (iface
!= iface2
)) return -1;
1478 if (iface2
!= 0) iface
= iface2
;
1481 if (_mdns_debug
) printf(";; mdns query %s %d %d\n", qname
, type
, class);
1482 status
= DNSServiceQueryRecord(&ctx
->sd
, flags
, iface
, qname
, type
, class, _mdns_query_callback
, ctx
);
1483 if (qname
!= name
) free(qname
);
1487 /* _mdns_query_is_complete
1488 * Determines whether the specified query has sufficient information to be
1489 * considered complete.
1492 _mdns_query_is_complete(mdns_query_context_t
*ctx
)
1494 if (ctx
== NULL
) return 1;
1495 //if (ctx->flags & kDNSServiceFlagsMoreComing) return 0;
1496 if (ctx
->last_type
!= ctx
->type
) return 0;
1497 switch (ctx
->type
) {
1500 if (ctx
->host
!= NULL
&& ctx
->host
->addr_count
> 0) {
1505 if (ctx
->host
!= NULL
&& ctx
->host
->host
.h_name
!= NULL
) {
1510 if (ctx
->reply
!= NULL
&& ctx
->reply
->srv
!= NULL
) {
1520 /* _mdns_query_clear
1521 * Clear out the temporary fields of the context, and clear any result
1522 * structures that are incomplete. Retrns 1 if the query was complete.
1525 _mdns_query_clear(mdns_query_context_t
*ctx
)
1527 int complete
= _mdns_query_is_complete(ctx
);
1528 if (ctx
== NULL
) return complete
;
1530 if (ctx
->sd
!= NULL
) {
1531 DNSServiceRefDeallocate(ctx
->sd
);
1538 _mdns_hostent_clear(ctx
->host
);
1545 _mdns_query_callback(DNSServiceRef sdRef
, DNSServiceFlags flags
, uint32_t ifIndex
, DNSServiceErrorType errorCode
, const char *fullname
, uint16_t rrtype
, uint16_t rrclass
, uint16_t rdlen
, const void *rdata
, uint32_t ttl
, void *ctx
)
1547 mdns_query_context_t
*context
;
1550 context
= (mdns_query_context_t
*)ctx
;
1552 context
->flags
= flags
;
1553 context
->error
= errorCode
;
1554 context
->last_type
= rrtype
;
1556 if (errorCode
!= kDNSServiceErr_NoError
) {
1557 if (_mdns_debug
) printf(";; [%s %hu %hu]: error %d\n", fullname
, rrtype
, rrclass
, errorCode
);
1561 // embed the scope ID into link-local IPv6 addresses
1562 if (rrtype
== ns_t_aaaa
&& rdlen
== sizeof(struct in6_addr
) &&
1563 IN6_IS_ADDR_LINKLOCAL((struct in6_addr
*)rdata
)) {
1564 memcpy(&a6
, rdata
, rdlen
);
1565 a6
.__u6_addr
.__u6_addr16
[1] = htons(ifIndex
);
1569 if (context
->reply
) {
1572 mdns_reply_t
*reply
= context
->reply
;
1574 if (reply
->ifnum
== 0) {
1575 reply
->ifnum
= ifIndex
;
1578 _mdns_hostent_append_alias(context
->host
, fullname
);
1579 if (reply
->ttl
== 0 || ttl
< reply
->ttl
) reply
->ttl
= ttl
;
1584 if (((rrtype
== ns_t_a
&& context
->host
->host
.h_addrtype
== AF_INET
) ||
1585 (rrtype
== ns_t_aaaa
&& context
->host
->host
.h_addrtype
== AF_INET6
)) &&
1586 rdlen
>= context
->host
->host
.h_length
) {
1587 if (context
->host
->host
.h_name
== NULL
) {
1589 mdns_hostent_t
*h
= context
->host
;
1590 char *h_name
= _mdns_canonicalize(fullname
);
1591 context
->host
->host
.h_name
= h_name
;
1593 // 6863416 remove h_name from h_aliases
1594 for (i
= 0; i
< h
->alias_count
; ++i
) {
1595 if (h_name
== NULL
) break;
1596 if (string_equal(h
->host
.h_aliases
[i
], h_name
)) {
1597 // includes trailing NULL pointer
1598 int sz
= sizeof(char *) * (h
->alias_count
- i
);
1599 free(h
->host
.h_aliases
[i
]);
1600 memmove(&h
->host
.h_aliases
[i
], &h
->host
.h_aliases
[i
+1], sz
);
1601 h
->alias_count
-= 1;
1606 _mdns_hostent_append_addr(context
->host
, rdata
, context
->host
->host
.h_length
);
1612 name
= _mdns_parse_domain_name(rdata
, rdlen
);
1613 if (!name
) malformed
= 1;
1614 _mdns_hostent_append_alias(context
->host
, name
);
1618 name
= _mdns_parse_domain_name(rdata
, rdlen
);
1619 if (!name
) malformed
= 1;
1620 if (context
->host
&& context
->host
->host
.h_name
== NULL
) {
1621 context
->host
->host
.h_name
= _mdns_canonicalize(name
);
1623 _mdns_hostent_append_alias(context
->host
, name
);
1627 mdns_rr_srv_t
*p
= (mdns_rr_srv_t
*)rdata
;
1628 mdns_srv_t
*srv
= calloc(1, sizeof(mdns_srv_t
));
1629 if (srv
== NULL
) break;
1630 if (rdlen
< sizeof(mdns_rr_srv_t
)) {
1634 srv
->srv
.priority
= ntohs(p
->priority
);
1635 srv
->srv
.weight
= ntohs(p
->weight
);
1636 srv
->srv
.port
= ntohs(p
->port
);
1637 srv
->srv
.target
= _mdns_parse_domain_name(&p
->target
[0], rdlen
- 3*sizeof(uint16_t));
1638 if (srv
->srv
.target
== NULL
) {
1642 // append to the end of the list
1643 if (reply
->srv
== NULL
) {
1646 mdns_srv_t
*iter
= reply
->srv
;
1647 while (iter
->next
) iter
= iter
->next
;
1653 malformed
= _mdns_debug
;
1656 if (malformed
&& _mdns_debug
) {
1657 printf(";; [%s %hu %hu]: malformed reply\n", fullname
, rrtype
, rrclass
);
1662 if (context
->answer
) {
1666 size_t buflen
= context
->ansmaxlen
- context
->anslen
;
1667 if (buflen
< NS_HFIXEDSZ
)
1669 if (_mdns_debug
) printf(";; [%s %hu %hu]: malformed reply\n", fullname
, rrtype
, rrclass
);
1673 cp
= context
->answer
+ context
->anslen
;
1675 n
= _mdns_pack_domain_name(fullname
, cp
, buflen
);
1677 if (_mdns_debug
) printf(";; [%s %hu %hu]: name mismatch\n", fullname
, rrtype
, rrclass
);
1681 // check that there is enough space in the buffer for the
1682 // resource name (n), the resource record data (rdlen) and
1683 // the resource record header (10).
1684 if (buflen
< n
+ rdlen
+ 10) {
1685 if (_mdns_debug
) printf(";; [%s %hu %hu]: insufficient buffer space for reply\n", fullname
, rrtype
, rrclass
);
1695 word
= htons(rrtype
);
1696 memcpy(cp
, &word
, sizeof(word
));
1699 word
= htons(rrclass
);
1700 memcpy(cp
, &word
, sizeof(word
));
1703 longword
= htonl(ttl
);
1704 memcpy(cp
, &longword
, sizeof(longword
));
1705 cp
+= sizeof(longword
);
1707 word
= htons(rdlen
);
1708 memcpy(cp
, &word
, sizeof(word
));
1711 memcpy(cp
, rdata
, rdlen
);
1714 ans
= (HEADER
*)context
->answer
;
1715 ans
->ancount
= htons(ntohs(ans
->ancount
) + 1);
1717 context
->anslen
= (size_t)(cp
- context
->answer
);
1720 if (_mdns_debug
) printf(";; [%s %hu %hu]\n", fullname
, rrtype
, rrclass
);
1723 // Ping the waiting thread in case this callback was invoked on another
1724 if (context
->kq
!= -1) {
1726 EV_SET(&ev
, 1, EVFILT_USER
, 0, NOTE_TRIGGER
, 0, 0);
1727 int res
= kevent(context
->kq
, &ev
, 1, NULL
, 0, NULL
);
1728 if (res
&& _mdns_debug
) printf(";; kevent EV_TRIGGER: %s\n", strerror(errno
));
1733 _mdns_now(struct timespec
*now
) {
1735 gettimeofday(&tv
, NULL
);
1736 now
->tv_sec
= tv
.tv_sec
;
1737 now
->tv_nsec
= tv
.tv_usec
* 1000;
1741 _mdns_add_time(struct timespec
*sum
, const struct timespec
*a
, const struct timespec
*b
)
1743 sum
->tv_sec
= a
->tv_sec
+ b
->tv_sec
;
1744 sum
->tv_nsec
= a
->tv_nsec
+ b
->tv_nsec
;
1745 if (sum
->tv_nsec
> 1000000000) {
1746 sum
->tv_sec
+= (sum
->tv_nsec
/ 1000000000);
1747 sum
->tv_nsec
%= 1000000000;
1751 // calculate a deadline from the current time based on the desired timeout
1753 _mdns_deadline(struct timespec
*deadline
, const struct timespec
*delta
)
1755 struct timespec now
;
1757 _mdns_add_time(deadline
, &now
, delta
);
1761 _mdns_sub_time(struct timespec
*delta
, const struct timespec
*a
, const struct timespec
*b
)
1763 delta
->tv_sec
= a
->tv_sec
- b
->tv_sec
;
1764 delta
->tv_nsec
= a
->tv_nsec
- b
->tv_nsec
;
1765 if (delta
->tv_nsec
< 0) {
1766 delta
->tv_nsec
+= 1000000000;
1771 // calculate a timeout remaining before the given deadline
1773 _mdns_timeout(struct timespec
*timeout
, const struct timespec
*deadline
)
1775 struct timespec now
;
1777 _mdns_sub_time(timeout
, deadline
, &now
);
1781 _mdns_query_mDNSResponder(const char *name
, int class, int type
, const char *interface
, DNSServiceFlags flags
, uint8_t *answer
, uint32_t *anslen
, mdns_reply_t
*reply
, uint32_t timeout_sec
)
1783 DNSServiceErrorType err
= 0;
1784 int kq
, n
, wait
= 1;
1786 struct timespec start
, finish
, delta
, timeout
;
1788 int i
, complete
, got_response
= 0;
1791 // 2 for A and AAAA parallel queries
1793 mdns_query_context_t ctx
[2];
1795 if (name
== NULL
) return -1;
1797 #if TARGET_OS_EMBEDDED
1798 // log a warning for queries from the main thread
1799 if (pthread_main_np()) asl_log(NULL
, NULL
, ASL_LEVEL_WARNING
, "Warning: Libinfo call to mDNSResponder on main thread");
1800 #endif // TARGET_OS_EMBEDDED
1803 // The kevent(2) API timeout parameter is used to enforce the total
1804 // timeout of the DNS query. Each iteraion recalculates the relative
1805 // timeout based on the desired end time (total timeout from origin).
1807 // In order to workaround some DNS configurations that do not return
1808 // responses for AAAA queries, parallel queries modify the total
1809 // timeout upon receipt of the first response. The new total timeout is
1810 // set to an effective value of 2N where N is the time taken to receive
1811 // the A response (the original total timeout is preserved if 2N would
1812 // have exceeded it). However, since mDNSResponder caches values, a
1813 // minimum value of 50ms for N is enforced in order to give some time
1814 // for the receipt of a AAAA response.
1816 // determine the maximum time to wait for a result
1817 if (timeout_sec
== 0) timeout_sec
= RES_MAXRETRANS
;
1818 delta
.tv_sec
= timeout_sec
;
1820 _mdns_deadline(&finish
, &delta
);
1824 // set up the kqueue
1826 EV_SET(&ev
, 1, EVFILT_USER
, EV_ADD
| EV_CLEAR
, 0, 0, 0);
1827 n
= kevent(kq
, &ev
, 1, NULL
, 0, NULL
);
1828 if (n
!= 0) wait
= 0;
1833 pthread_mutex_lock(&_mdns_mutex
);
1834 // clear any stale contexts
1835 for (i
= 0; i
< n_ctx
; ++i
) {
1836 _mdns_query_clear(&ctx
[i
]);
1840 if (_mdns_sdref
== NULL
) {
1841 if (_mdns_old_sdref
!= NULL
) {
1842 DNSServiceRefDeallocate(_mdns_old_sdref
);
1843 _mdns_old_sdref
= NULL
;
1845 // (re)initialize the shared connection
1846 err
= DNSServiceCreateConnection(&_mdns_sdref
);
1849 pthread_mutex_unlock(&_mdns_mutex
);
1854 // issue (or reissue) the queries
1855 // unspecified type: do parallel A and AAAA
1857 err
= _mdns_query_start(&ctx
[n_ctx
++], reply
,
1860 (type
== 0) ? ns_t_a
: type
, interface
, flags
, kq
);
1862 if (err
== 0 && type
== 0) {
1863 err
= _mdns_query_start(&ctx
[n_ctx
++], reply
,
1865 name
, class, ns_t_aaaa
, interface
, flags
, kq
);
1867 if (err
&& _mdns_debug
) printf(";; initialization error %d\n", err
);
1868 // try to reinitialize
1869 if (err
== kDNSServiceErr_Unknown
||
1870 err
== kDNSServiceErr_ServiceNotRunning
||
1871 err
== kDNSServiceErr_BadReference
) {
1873 DNSServiceRefDeallocate(_mdns_sdref
);
1878 pthread_mutex_unlock(&_mdns_mutex
);
1880 } else if (err
!= 0) {
1881 pthread_mutex_unlock(&_mdns_mutex
);
1885 // (re)register the fd with kqueue
1886 int fd
= DNSServiceRefSockFD(_mdns_sdref
);
1887 EV_SET(&ev
, fd
, EVFILT_READ
, EV_ADD
, 0, 0, 0);
1888 n
= kevent(kq
, &ev
, 1, NULL
, 0, NULL
);
1889 pthread_mutex_unlock(&_mdns_mutex
);
1890 if (err
!= 0 || n
!= 0) break;
1893 if (_mdns_debug
) printf(";; kevent timeout %ld.%ld\n", timeout
.tv_sec
, timeout
.tv_nsec
);
1894 n
= kevent(kq
, NULL
, 0, &ev
, 1, &timeout
);
1895 if (n
< 0 && errno
!= EINTR
) {
1900 pthread_mutex_lock(&_mdns_mutex
);
1901 // DNSServiceProcessResult() is a blocking API
1902 // confirm that there is still data on the socket
1903 const struct timespec notimeout
= { 0, 0 };
1904 int m
= kevent(kq
, NULL
, 0, &ev
, 1, ¬imeout
);
1905 if (_mdns_sdref
== NULL
) {
1907 } else if (m
> 0 && ev
.filter
== EVFILT_READ
) {
1908 err
= DNSServiceProcessResult(_mdns_sdref
);
1909 if (err
== kDNSServiceErr_ServiceNotRunning
||
1910 err
== kDNSServiceErr_BadReference
) {
1911 if (_mdns_debug
) printf(";; DNSServiceProcessResult status %d\n", err
);
1913 // re-initialize the shared connection
1914 DNSServiceRefDeallocate(_mdns_sdref
);
1920 // Check if all queries are complete (including errors)
1922 for (i
= 0; i
< n_ctx
; ++i
) {
1923 if (_mdns_query_is_complete(&ctx
[i
]) || ctx
[i
].error
!= 0) {
1924 if (ctx
[i
].type
== ns_t_a
) {
1931 pthread_mutex_unlock(&_mdns_mutex
);
1934 if (_mdns_debug
) printf(";; DNSServiceProcessResult status %d\n", err
);
1936 } else if (complete
== 1) {
1937 if (_mdns_debug
) printf(";; done\n");
1939 } else if (got_response
== 1) {
1940 // got A, adjust deadline for AAAA
1941 struct timespec now
, tn
, ms100
;
1943 // delta = now - start
1945 _mdns_sub_time(&delta
, &now
, &start
);
1948 _mdns_add_time(&tn
, &delta
, &delta
);
1950 // delta = tn + 100ms
1952 ms100
.tv_nsec
= 100000000;
1953 _mdns_add_time(&delta
, &tn
, &ms100
);
1955 // check that delta doesn't exceed our total timeout
1956 _mdns_sub_time(&tn
, &timeout
, &delta
);
1957 if (tn
.tv_sec
>= 0) {
1958 if (_mdns_debug
) printf(";; new timeout (waiting for AAAA) %ld.%ld\n", delta
.tv_sec
, delta
.tv_nsec
);
1959 _mdns_deadline(&finish
, &delta
);
1963 // calculate remaining timeout
1964 _mdns_timeout(&timeout
, &finish
);
1966 // check for time remaining
1967 if (timeout
.tv_sec
< 0) {
1968 if (_mdns_debug
) printf(";; timeout\n");
1974 pthread_mutex_lock(&_mdns_mutex
);
1975 for (i
= 0; i
< n_ctx
; ++i
) {
1976 if (err
== 0) err
= ctx
[i
].error
;
1977 // Only clears hostents if result is incomplete.
1978 complete
= _mdns_query_clear(&ctx
[i
]) || complete
;
1980 pthread_mutex_unlock(&_mdns_mutex
);
1981 // Everything should be done with the kq by now.
1984 // Return error if everything is incomplete
1985 if (complete
== 0) {
1989 if (anslen
) *anslen
= ctx
[0].anslen
;