react-native-zeroconf 0.13.8 → 0.14.0

package/android/src/main/jni/mdnsresponder/mDNSPosix/nss_mdns.c

@@ -0,0 +1,2723 @@
+/*
+NICTA Public Software Licence
+Version 1.0
+
+Copyright © 2004 National ICT Australia Ltd
+
+All rights reserved.
+
+By this licence, National ICT Australia Ltd (NICTA) grants permission,
+free of charge, to any person who obtains a copy of this software
+and any associated documentation files ("the Software") to use and
+deal with the Software in source code and binary forms without
+restriction, with or without modification, and to permit persons
+to whom the Software is furnished to do so, provided that the
+following conditions are met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimers.
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimers in
+  the documentation and/or other materials provided with the
+  distribution.
+- The name of NICTA may not be used to endorse or promote products
+  derived from this Software without specific prior written permission.
+
+EXCEPT AS EXPRESSLY STATED IN THIS LICENCE AND TO THE FULL EXTENT
+PERMITTED BY APPLICABLE LAW, THE SOFTWARE IS PROVIDED "AS-IS" AND
+NICTA MAKES NO REPRESENTATIONS, WARRANTIES OR CONDITIONS OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY
+REPRESENTATIONS, WARRANTIES OR CONDITIONS REGARDING THE CONTENTS
+OR ACCURACY OF THE SOFTWARE, OR OF TITLE, MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, THE ABSENCE OF LATENT
+OR OTHER DEFECTS, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR
+NOT DISCOVERABLE.
+
+TO THE FULL EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL
+NICTA BE LIABLE ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+NEGLIGENCE) FOR ANY LOSS OR DAMAGE WHATSOEVER, INCLUDING (WITHOUT
+LIMITATION) LOSS OF PRODUCTION OR OPERATION TIME, LOSS, DAMAGE OR
+CORRUPTION OF DATA OR RECORDS; OR LOSS OF ANTICIPATED SAVINGS,
+OPPORTUNITY, REVENUE, PROFIT OR GOODWILL, OR OTHER ECONOMIC LOSS;
+OR ANY SPECIAL, INCIDENTAL, INDIRECT, CONSEQUENTIAL, PUNITIVE OR
+EXEMPLARY DAMAGES ARISING OUT OF OR IN CONNECTION WITH THIS LICENCE,
+THE SOFTWARE OR THE USE OF THE SOFTWARE, EVEN IF NICTA HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+If applicable legislation implies warranties or conditions, or
+imposes obligations or liability on NICTA in respect of the Software
+that cannot be wholly or partly excluded, restricted or modified,
+NICTA's liability is limited, to the full extent permitted by the
+applicable legislation, at its option, to:
+
+a. in the case of goods, any one or more of the following:
+  i.   the replacement of the goods or the supply of equivalent goods;
+  ii.  the repair of the goods;
+  iii. the payment of the cost of replacing the goods or of acquiring
+       equivalent goods;
+  iv.  the payment of the cost of having the goods repaired; or
+b. in the case of services:
+  i.   the supplying of the services again; or 
+  ii.  the payment of the cost of having the services supplied
+       again.
+ */
+
+/*
+	NSSwitch Implementation of mDNS interface.
+	
+	Andrew White (Andrew.White@nicta.com.au)
+	May 2004
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <syslog.h>
+#include <pthread.h>
+#include <ctype.h>
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+
+#include <arpa/inet.h>
+#define BIND_8_COMPAT 1
+#include <arpa/nameser.h>
+
+#include <dns_sd.h>
+
+
+//----------
+// Public functions
+
+/*
+	Count the number of dots in a name string.
+ */
+int
+count_dots (const char * name);
+
+
+/*
+	Test whether a domain name is local.
+
+	Returns
+		1 if name ends with ".local" or ".local."
+		0 otherwise
+ */
+int
+islocal (const char * name);
+
+
+/*
+	Format an address structure as a string appropriate for DNS reverse (PTR)
+	lookup, based on address type.
+	
+	Parameters
+		prefixlen
+			Prefix length, in bits.  When formatting, this will be rounded up
+			to the nearest appropriate size.  If -1, assume maximum.
+		buf
+			Output buffer.  Must be long enough to hold largest possible
+			output.
+	Returns
+		Pointer to (first character of) output buffer,
+		or NULL on error.
+ */
+char *
+format_reverse_addr (int af, const void * addr, int prefixlen, char * buf);
+
+
+/*
+	Format an address structure as a string appropriate for DNS reverse (PTR)
+	lookup for AF_INET.  Output is in .in-addr.arpa domain.
+	
+	Parameters
+		prefixlen
+			Prefix length, in bits.  When formatting, this will be rounded up
+			to the nearest byte (8).  If -1, assume 32.
+		buf
+			Output buffer.  Must be long enough to hold largest possible
+			output.  For AF_INET, this is 29 characters (including null).
+	Returns
+		Pointer to (first character of) output buffer,
+		or NULL on error.
+ */
+char *
+format_reverse_addr_in (
+	const struct in_addr * addr,
+	int prefixlen,
+	char * buf
+);
+#define DNS_PTR_AF_INET_SIZE 29
+
+/*
+	Format an address structure as a string appropriate for DNS reverse (PTR)
+	lookup for AF_INET6.  Output is in .ip6.arpa domain.
+	
+	Parameters
+		prefixlen
+			Prefix length, in bits.  When formatting, this will be rounded up
+			to the nearest nibble (4).  If -1, assume 128.
+		buf
+			Output buffer.  Must be long enough to hold largest possible
+			output.  For AF_INET6, this is 72 characters (including null).
+	Returns
+		Pointer to (first character of) output buffer,
+		or NULL on error.
+ */
+char *
+format_reverse_addr_in6 (
+	const struct in6_addr * addr,
+	int prefixlen,
+	char * buf
+);
+#define DNS_PTR_AF_INET6_SIZE 72
+
+
+/*
+	Compare whether the given dns name has the given domain suffix.
+	A single leading '.' on the name or leading or trailing '.' on the
+	domain is ignored for the purposes of the comparison.
+	Multiple leading or trailing '.'s are an error.  Other DNS syntax
+	errors are not checked for.  The comparison is case insensitive.
+	
+	Returns
+		1 on success (match)
+		0 on failure (no match)
+		< 0 on error
+ */
+int
+cmp_dns_suffix (const char * name, const char * domain);
+enum
+{
+	CMP_DNS_SUFFIX_SUCCESS = 1,
+	CMP_DNS_SUFFIX_FAILURE = 0,
+	CMP_DNS_SUFFIX_BAD_NAME = 1,
+	CMP_DNS_SUFFIX_BAD_DOMAIN = -2
+};
+
+typedef int ns_type_t;
+typedef int ns_class_t;
+
+/*
+	Convert a DNS resource record (RR) code to an address family (AF) code.
+	
+	Parameters
+		rrtype
+			resource record type (from nameser.h)
+
+	Returns
+		Appropriate AF code (from socket.h), or AF_UNSPEC if an appropriate
+		mapping couldn't be determined
+ */
+int
+rr_to_af (ns_type_t rrtype);
+
+
+/*
+	Convert an address family (AF) code to a DNS resource record (RR) code.
+	
+	Parameters
+		int
+			address family code (from socket.h)
+	Returns
+		Appropriate RR code (from nameser.h), or ns_t_invalid if an appropriate
+		mapping couldn't be determined
+ */
+ns_type_t
+af_to_rr (int af);
+
+
+/*
+	Convert a string to an address family (case insensitive).
+
+	Returns
+		Matching AF code, or AF_UNSPEC if no match found.
+ */
+int
+str_to_af (const char * str);
+
+
+/*
+	Convert a string to an ns_class_t (case insensitive).
+
+	Returns
+		Matching ns_class_t, or ns_c_invalid if no match found.
+ */
+ns_class_t
+str_to_ns_class (const char * str);
+
+
+/*
+	Convert a string to an ns_type_t (case insensitive).
+
+	Returns
+		Matching ns_type_t, or ns_t_invalid if no match found.
+ */
+ns_type_t
+str_to_ns_type (const char * str);
+
+
+/*
+	Convert an address family code to a string.
+
+	Returns
+		String representation of AF,
+		or NULL if address family unrecognised or invalid.
+ */
+const char *
+af_to_str (int in);
+
+
+/*
+	Convert an ns_class_t code to a string.
+
+	Returns
+		String representation of ns_class_t,
+		or NULL if ns_class_t unrecognised or invalid.
+ */
+const char *
+ns_class_to_str (ns_class_t in);
+
+
+/*
+	Convert an ns_type_t code to a string.
+
+	Returns
+		String representation of ns_type_t,
+		or NULL if ns_type_t unrecognised or invalid.
+ */
+const char *
+ns_type_to_str (ns_type_t in);
+
+
+/*
+	Convert DNS rdata in label format (RFC1034, RFC1035) to a name.
+	
+	On error, partial data is written to name (as much as was successfully
+	processed) and an error code is returned.  Errors include a name too
+	long for the buffer and a pointer in the label (which cannot be
+	resolved).
+	
+	Parameters
+		rdata
+			Rdata formatted as series of labels.
+		rdlen
+			Length of rdata buffer.
+		name
+			Buffer to store fully qualified result in.
+			By RFC1034 section 3.1, a 255 character buffer (256 characters
+			including null) is long enough for any legal name.
+		name_len
+			Number of characters available in name buffer, not including
+			trailing null.
+	
+	Returns
+		Length of name buffer (not including trailing null).
+		< 0 on error.
+		A return of 0 implies the empty domain.
+ */
+int
+dns_rdata_to_name (const char * rdata, int rdlen, char * name, int name_len);
+enum
+{
+	DNS_RDATA_TO_NAME_BAD_FORMAT = -1,
+		// Format is broken.  Usually because we ran out of data
+		// (according to rdata) before the labels said we should.
+	DNS_RDATA_TO_NAME_TOO_LONG = -2,
+		// The converted rdata is longer than the name buffer.
+	DNS_RDATA_TO_NAME_PTR = -3,
+		// The rdata contains a pointer.
+};
+
+#define DNS_LABEL_MAXLEN 63
+	// Maximum length of a single DNS label
+#define DNS_NAME_MAXLEN 256
+	// Maximum length of a DNS name
+
+//----------
+// Public types
+
+typedef int errcode_t;
+	// Used for 0 = success, non-zero = error code functions
+
+
+//----------
+// Public functions
+
+/*
+	Test whether a domain name is in a domain covered by nss_mdns.
+	The name is assumed to be fully qualified (trailing dot optional);
+	unqualified names will be processed but may return unusual results
+	if the unqualified prefix happens to match a domain suffix.
+	
+	Returns
+		 1 success
+		 0 failure
+		-1 error, check errno
+ */
+int
+config_is_mdns_suffix (const char * name);
+
+
+/*
+	Loads all relevant data from configuration file.  Other code should
+	rarely need to call this function, since all other public configuration
+	functions do so implicitly.  Once loaded, configuration info doesn't
+	change.
+	
+	Returns
+		0 configuration ready
+		non-zero configuration error code
+ */
+errcode_t
+init_config ();
+
+#define ENTNAME  hostent
+#define DATABASE "hosts"
+
+#include <nss.h>
+	// For nss_status
+#include <netdb.h>
+	// For hostent
+#include <sys/types.h>
+	// For size_t
+
+typedef enum nss_status nss_status;
+typedef struct hostent hostent;
+
+/*
+gethostbyname implementation
+
+	name:
+		name to look up
+	result_buf:
+		resulting entry
+	buf:
+		auxillary buffer
+	buflen:
+		length of auxillary buffer
+	errnop:
+		pointer to errno
+	h_errnop:
+		pointer to h_errno
+ */
+nss_status
+_nss_mdns_gethostbyname_r (
+	const char *name,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+);
+
+
+/*
+gethostbyname2 implementation
+
+	name:
+		name to look up
+	af:
+		address family
+	result_buf:
+		resulting entry
+	buf:
+		auxillary buffer
+	buflen:
+		length of auxillary buffer
+	errnop:
+		pointer to errno
+	h_errnop:
+		pointer to h_errno
+ */
+nss_status
+_nss_mdns_gethostbyname2_r (
+	const char *name,
+	int af,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+);
+
+
+/*
+gethostbyaddr implementation
+
+	addr:
+		address structure to look up
+	len:
+		length of address structure
+	af:
+		address family
+	result_buf:
+		resulting entry
+	buf:
+		auxillary buffer
+	buflen:
+		length of auxillary buffer
+	errnop:
+		pointer to errno
+	h_errnop:
+		pointer to h_errno
+ */
+nss_status
+_nss_mdns_gethostbyaddr_r (
+	const void *addr,
+	socklen_t len,
+	int af,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+);
+
+
+//----------
+// Types and Constants
+
+const int MDNS_VERBOSE = 0;
+	// This enables verbose syslog messages
+	// If zero, only "imporant" messages will appear in syslog
+
+#define k_hostname_maxlen 256
+	// As per RFC1034 and RFC1035
+#define k_aliases_max 15
+#define k_addrs_max 15
+
+typedef struct buf_header
+{
+	char hostname [k_hostname_maxlen + 1];
+	char * aliases [k_aliases_max + 1];
+	char * addrs [k_addrs_max + 1];
+} buf_header_t;
+
+typedef struct result_map
+{
+	int done;
+	nss_status status;
+	hostent * hostent;
+	buf_header_t * header;
+	int aliases_count;
+	int addrs_count;
+	char * buffer;
+	int addr_idx;
+		// Index for addresses - grow from low end
+		// Index points to first empty space
+	int alias_idx;
+		// Index for aliases - grow from high end
+		// Index points to lowest entry
+	int r_errno;
+	int r_h_errno;
+} result_map_t;
+
+static const struct timeval
+	k_select_time = { 0, 500000 };
+		// 0 seconds, 500 milliseconds
+
+//----------
+// Local prototypes
+
+static nss_status
+mdns_gethostbyname2 (
+	const char *name,
+	int af,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+);
+
+
+/*
+	Lookup name using mDNS server
+ */
+static nss_status
+mdns_lookup_name (
+	const char * fullname,
+	int af,
+	result_map_t * result
+);
+
+/*
+	Lookup address using mDNS server
+ */
+static nss_status
+mdns_lookup_addr (
+	const void * addr,
+	socklen_t len,
+	int af,
+	const char * addr_str,
+	result_map_t * result
+);
+
+
+/*
+	Handle incoming MDNS events
+ */
+static nss_status
+handle_events (DNSServiceRef sdref, result_map_t * result, const char * str);
+
+
+// Callback for mdns_lookup operations
+//DNSServiceQueryRecordReply mdns_lookup_callback;
+typedef void
+mdns_lookup_callback_t
+(
+	DNSServiceRef		sdref,
+	DNSServiceFlags		flags,
+	uint32_t			interface_index,
+	DNSServiceErrorType	error_code,
+	const char			*fullname,	  
+	uint16_t			rrtype,
+	uint16_t			rrclass,
+	uint16_t			rdlen,
+	const void			*rdata,
+	uint32_t			ttl,
+	void				*context
+);
+
+mdns_lookup_callback_t mdns_lookup_callback;
+
+
+static int
+init_result (
+	result_map_t * result,
+	hostent * result_buf,
+	char * buf,
+	size_t buflen
+);
+
+static int
+callback_body_ptr (
+	const char * fullname,
+	result_map_t * result,
+	int rdlen,
+	const void * rdata
+);
+
+static void *
+add_address_to_buffer (result_map_t * result, const void * data, int len);
+static char *
+add_alias_to_buffer (result_map_t * result, const char * data, int len);
+static char *
+add_hostname_len (result_map_t * result, const char * fullname, int len);
+static char *
+add_hostname_or_alias (result_map_t * result, const char * data, int len);
+
+static void *
+contains_address (result_map_t * result, const void * data, int len);
+static char *
+contains_alias (result_map_t * result, const char * data);
+
+
+static const char *
+is_applicable_name (
+	result_map_t * result,
+	const char * name,
+	char * lookup_name
+);
+
+static const char *
+is_applicable_addr (
+	result_map_t * result,
+	const void * addr,
+	int af,
+	char * addr_str
+);
+
+
+// Error code functions
+
+static nss_status
+set_err (result_map_t * result, nss_status status, int err, int herr);
+
+static nss_status set_err_notfound (result_map_t * result);
+static nss_status set_err_bad_hostname (result_map_t * result);
+static nss_status set_err_buf_too_small (result_map_t * result);
+static nss_status set_err_internal_resource_full (result_map_t * result);
+static nss_status set_err_system (result_map_t * result);
+static nss_status set_err_mdns_failed (result_map_t * result);
+static nss_status set_err_success (result_map_t * result);
+
+
+//----------
+// Global variables
+
+
+//----------
+// NSS functions
+
+nss_status
+_nss_mdns_gethostbyname_r (
+	const char *name,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+)
+{
+	if (MDNS_VERBOSE)
+		syslog (LOG_DEBUG,
+			"mdns: Called nss_mdns_gethostbyname with %s",
+			name
+		);
+
+	return
+		mdns_gethostbyname2 (
+			name, AF_INET, result_buf, buf, buflen, errnop, h_errnop
+		);
+}
+
+
+nss_status
+_nss_mdns_gethostbyname2_r (
+	const char *name,
+	int af,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+)
+{
+	if (MDNS_VERBOSE)
+		syslog (LOG_DEBUG,
+			"mdns: Called nss_mdns_gethostbyname2 with %s",
+			name
+		);
+
+	return
+		mdns_gethostbyname2 (
+			name, af, result_buf, buf, buflen, errnop, h_errnop
+		);
+}
+
+
+nss_status
+_nss_mdns_gethostbyaddr_r (
+	const void *addr,
+	socklen_t len,
+	int af,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+)
+{
+	char addr_str [NI_MAXHOST + 1];
+	result_map_t result;
+	int err_status;
+	
+	if (inet_ntop (af, addr, addr_str, NI_MAXHOST) == NULL)
+	{
+		const char * family = af_to_str (af);
+		if (family == NULL)
+		{
+			family = "Unknown";
+		}
+
+		syslog (LOG_WARNING,
+			"mdns: Couldn't covert address, family %d (%s) in nss_mdns_gethostbyaddr: %s",
+			af,
+			family,
+			strerror (errno)
+		);
+
+		// This address family never applicable to us, so return NOT_FOUND
+
+		*errnop = ENOENT;
+		*h_errnop = HOST_NOT_FOUND;
+		return NSS_STATUS_NOTFOUND;
+	}
+	if (MDNS_VERBOSE)
+	{
+		syslog (LOG_DEBUG,
+			"mdns: Called nss_mdns_gethostbyaddr with %s",
+			addr_str
+		);
+	}
+
+	// Initialise result
+	err_status = init_result (&result, result_buf, buf, buflen);
+	if (err_status)
+	{
+		*errnop = err_status;
+		*h_errnop = NETDB_INTERNAL;
+		return NSS_STATUS_TRYAGAIN;
+	}
+		
+	if (is_applicable_addr (&result, addr, af, addr_str))
+	{
+		nss_status rv;
+
+		rv = mdns_lookup_addr (addr, len, af, addr_str, &result);
+		if (rv == NSS_STATUS_SUCCESS)
+		{
+			return rv;
+		}
+	}
+
+	// Return current error status (defaults to NOT_FOUND)
+	
+	*errnop = result.r_errno;
+	*h_errnop = result.r_h_errno;
+	return result.status;
+}
+
+
+//----------
+// Local functions
+
+nss_status
+mdns_gethostbyname2 (
+	const char *name,
+	int af,
+	hostent * result_buf,
+	char *buf,
+	size_t buflen,
+	int *errnop,
+	int *h_errnop
+)
+{
+	char lookup_name [k_hostname_maxlen + 1];
+	result_map_t result;
+	int err_status;
+	
+	// Initialise result
+	err_status = init_result (&result, result_buf, buf, buflen);
+	if (err_status)
+	{
+		*errnop = err_status;
+		*h_errnop = NETDB_INTERNAL;
+		return NSS_STATUS_TRYAGAIN;
+	}
+		
+	if (is_applicable_name (&result, name, lookup_name))
+	{
+		// Try using mdns
+		nss_status rv;
+
+		if (MDNS_VERBOSE)
+			syslog (LOG_DEBUG,
+				"mdns: Local name: %s",
+				name
+			);
+
+		rv = mdns_lookup_name (name, af, &result);
+		if (rv == NSS_STATUS_SUCCESS)
+		{
+			return rv;
+		}
+	}
+
+	// Return current error status (defaults to NOT_FOUND)
+	
+	*errnop = result.r_errno;
+	*h_errnop = result.r_h_errno;
+	return result.status;
+}
+
+
+/*
+	Lookup a fully qualified hostname using the default record type
+	for the specified address family.
+	
+	Parameters
+		fullname
+			Fully qualified hostname.  If not fully qualified the code will
+			still 'work', but the lookup is unlikely to succeed.
+		af
+			Either AF_INET or AF_INET6.  Other families are not supported.
+		result
+			Initialised 'result' data structure.
+ */
+static nss_status
+mdns_lookup_name (
+	const char * fullname,
+	int af,
+	result_map_t * result
+)
+{
+	// Lookup using mDNS.
+	DNSServiceErrorType errcode;
+	DNSServiceRef sdref;
+	ns_type_t rrtype;
+	nss_status status;
+	
+	if (MDNS_VERBOSE)
+		syslog (LOG_DEBUG,
+			"mdns: Attempting lookup of %s",
+			fullname
+		);
+	
+	switch (af)
+	{
+	  case AF_INET:
+		rrtype = kDNSServiceType_A;
+		result->hostent->h_length = 4;
+			// Length of an A record
+		break;
+	
+	  case AF_INET6:
+		rrtype = kDNSServiceType_AAAA;
+		result->hostent->h_length = 16;
+			// Length of an AAAA record
+		break;
+	
+	  default:
+		syslog (LOG_WARNING,
+			"mdns: Unsupported address family %d",
+			af
+		);
+		return set_err_bad_hostname (result);
+	}
+	result->hostent->h_addrtype = af;
+	
+	errcode =
+		DNSServiceQueryRecord (
+			&sdref,
+			kDNSServiceFlagsForceMulticast,		// force multicast query
+			kDNSServiceInterfaceIndexAny,	// all interfaces
+			fullname,	// full name to query for
+			rrtype,		// resource record type
+			kDNSServiceClass_IN,	// internet class records
+			mdns_lookup_callback,	// callback
+			result		// Context - result buffer
+		);
+	
+	if (errcode)
+	{
+		syslog (LOG_WARNING,
+			"mdns: Failed to initialise lookup, error %d",
+			errcode
+		);
+		return set_err_mdns_failed (result);
+	}
+
+	status = handle_events (sdref, result, fullname);
+	DNSServiceRefDeallocate (sdref);
+	return status;
+}
+
+
+/*
+	Reverse (PTR) lookup for the specified address.
+	
+	Parameters
+		addr
+			Either a struct in_addr or a struct in6_addr
+		addr_len
+			size of the address
+		af
+			Either AF_INET or AF_INET6.  Other families are not supported.
+			Must match addr
+		addr_str
+			Address in format suitable for PTR lookup.
+			AF_INET: a.b.c.d -> d.c.b.a.in-addr.arpa
+			AF_INET6: reverse nibble format, x.x.x...x.ip6.arpa
+		result
+			Initialised 'result' data structure.
+ */
+static nss_status
+mdns_lookup_addr (
+	const void * addr,
+	socklen_t addr_len,
+	int af,
+	const char * addr_str,
+	result_map_t * result
+)
+{
+	DNSServiceErrorType errcode;
+	DNSServiceRef sdref;
+	nss_status status;
+	
+	if (MDNS_VERBOSE)
+		syslog (LOG_DEBUG,
+			"mdns: Attempting lookup of %s",
+			addr_str
+		);
+		
+	result->hostent->h_addrtype = af;
+	result->hostent->h_length = addr_len;
+
+	// Query address becomes "address" in result.
+	if (! add_address_to_buffer (result, addr, addr_len))
+	{
+		return result->status;
+	}
+	
+	result->hostent->h_name [0] = 0;
+	
+	errcode =
+		DNSServiceQueryRecord (
+			&sdref,
+			kDNSServiceFlagsForceMulticast,		// force multicast query
+			kDNSServiceInterfaceIndexAny,	// all interfaces
+			addr_str,	// address string to query for
+			kDNSServiceType_PTR,	// pointer RRs
+			kDNSServiceClass_IN,	// internet class records
+			mdns_lookup_callback,	// callback
+			result		// Context - result buffer
+		);
+	
+	if (errcode)
+	{
+		syslog (LOG_WARNING,
+			"mdns: Failed to initialise mdns lookup, error %d",
+			errcode
+		);
+		return set_err_mdns_failed (result);
+	}
+
+	status = handle_events (sdref, result, addr_str);
+	DNSServiceRefDeallocate (sdref);
+	return status;
+}
+
+
+/*
+	Wait on result of callback, and process it when it arrives.
+	
+	Parameters
+		sdref
+			dns-sd reference
+		result
+			Initialised 'result' data structure.
+		str
+			lookup string, used for status/error reporting.
+ */
+static nss_status
+handle_events (DNSServiceRef sdref, result_map_t * result, const char * str)
+{
+	int dns_sd_fd = DNSServiceRefSockFD(sdref);
+	int nfds = dns_sd_fd + 1;
+	fd_set readfds;
+	struct timeval tv;
+	int select_result;
+
+	while (! result->done)
+	{
+		FD_ZERO(&readfds);
+		FD_SET(dns_sd_fd, &readfds);
+
+		tv = k_select_time;
+		
+		select_result =
+			select (nfds, &readfds, (fd_set*)NULL, (fd_set*)NULL, &tv);
+		if (select_result > 0)
+		{
+			if (FD_ISSET(dns_sd_fd, &readfds))
+			{
+				if (MDNS_VERBOSE)
+					syslog (LOG_DEBUG,
+						"mdns: Reply received for %s",
+						str
+					);
+				DNSServiceProcessResult(sdref);
+			}
+			else
+			{
+				syslog (LOG_WARNING,
+					"mdns: Unexpected return from select on lookup of %s",
+					str
+				);
+			}
+		}
+		else
+		{
+			// Terminate loop due to timer expiry
+			if (MDNS_VERBOSE)
+				syslog (LOG_DEBUG,
+					"mdns: %s not found - timer expired",
+					str
+				);
+			set_err_notfound (result);
+			break;
+		}
+	}
+	
+	return result->status;
+}
+
+
+/*
+	Examine incoming data and add to relevant fields in result structure.
+	This routine is called from DNSServiceProcessResult where appropriate.
+ */
+void
+mdns_lookup_callback
+(
+	DNSServiceRef		sdref,
+	DNSServiceFlags		flags,
+	uint32_t			interface_index,
+	DNSServiceErrorType	error_code,
+	const char			*fullname,	  
+	uint16_t			rrtype,
+	uint16_t			rrclass,
+	uint16_t			rdlen,
+	const void			*rdata,
+	uint32_t			ttl,
+	void				*context
+)
+{
+	// A single record is received
+
+	result_map_t * result = (result_map_t *) context;
+
+	(void)sdref; // Unused
+	(void)interface_index; // Unused
+	(void)ttl; // Unused
+	
+	if (! (flags & kDNSServiceFlagsMoreComing) )
+	{
+		result->done = 1;
+	}
+
+	if (error_code == kDNSServiceErr_NoError)
+	{
+		ns_type_t expected_rr_type =
+			af_to_rr (result->hostent->h_addrtype);
+
+		// Idiot check class
+		if (rrclass != C_IN)
+		{
+			syslog (LOG_WARNING,
+				"mdns: Received bad RR class: expected %d (%s),"
+				" got %d (%s), RR type %d (%s)",
+				C_IN,
+				ns_class_to_str (C_IN),
+				rrclass,
+				ns_class_to_str (rrclass),
+				rrtype,
+				ns_type_to_str (rrtype)
+			);
+			return;
+		}
+		
+		// If a PTR
+		if (rrtype == kDNSServiceType_PTR)
+		{
+			if (callback_body_ptr (fullname, result, rdlen, rdata) < 0)
+				return;
+		}
+		else if (rrtype == expected_rr_type)
+		{
+			if (!
+				add_hostname_or_alias (
+					result,
+					fullname,
+					strlen (fullname)
+				)
+			)
+			{
+				result->done = 1;
+				return;
+					// Abort on error
+			}
+
+			if (! add_address_to_buffer (result, rdata, rdlen) )
+			{
+				result->done = 1;
+				return;
+					// Abort on error
+			}
+		}
+		else
+		{
+			syslog (LOG_WARNING,
+				"mdns: Received bad RR type: expected %d (%s),"
+				" got %d (%s)",
+				expected_rr_type,
+				ns_type_to_str (expected_rr_type),
+				rrtype,
+				ns_type_to_str (rrtype)
+			);
+			return;
+		}
+		
+		if (result->status != NSS_STATUS_SUCCESS)
+			set_err_success (result);
+	}
+	else
+	{
+		// For now, dump message to syslog and continue
+		syslog (LOG_WARNING,
+			"mdns: callback returned error %d",
+			error_code
+		);
+	}
+}
+
+static int
+callback_body_ptr (
+	const char * fullname,
+	result_map_t * result,
+	int rdlen,
+	const void * rdata
+)
+{
+	char result_name [k_hostname_maxlen + 1];
+	int rv;
+	
+	// Fullname should be .in-addr.arpa or equivalent, which we're
+	// not interested in.  Ignore it.
+	
+	rv = dns_rdata_to_name (rdata, rdlen, result_name, k_hostname_maxlen);
+	if (rv < 0)
+	{
+		const char * errmsg;
+		
+		switch (rv)
+		{
+		  case DNS_RDATA_TO_NAME_BAD_FORMAT:
+			errmsg = "mdns: PTR '%s' result badly formatted ('%s...')";
+			break;
+		
+		  case DNS_RDATA_TO_NAME_TOO_LONG:
+			errmsg = "mdns: PTR '%s' result too long ('%s...')";
+			break;
+		
+		  case DNS_RDATA_TO_NAME_PTR:
+			errmsg = "mdns: PTR '%s' result contained pointer ('%s...')";
+			break;
+		
+		  default:
+			errmsg = "mdns: PTR '%s' result conversion failed ('%s...')";
+		}
+
+		syslog (LOG_WARNING,
+			errmsg,
+			fullname,
+			result_name
+		);
+		
+		return -1;
+	}
+	
+	if (MDNS_VERBOSE)
+	{
+		syslog (LOG_DEBUG,
+			"mdns: PTR '%s' resolved to '%s'",
+			fullname,
+			result_name
+		);
+	}
+	
+	// Data should be a hostname
+	if (!
+		add_hostname_or_alias (
+			result,
+			result_name,
+			rv
+		)
+	)
+	{
+		result->done = 1;
+		return -1;
+	}
+	
+	return 0;
+}
+
+
+/*
+	Add an address to the buffer.
+	
+	Parameter
+		result
+			Result structure to write to
+		data
+			Incoming address data buffer
+			Must be 'int' aligned
+		len
+			Length of data buffer (in bytes)
+			Must match data alignment
+	
+	Result
+		Pointer to start of newly written data,
+		or NULL on error.
+		If address already exists in buffer, returns pointer to that instead.
+ */
+static void *
+add_address_to_buffer (result_map_t * result, const void * data, int len)
+{
+	int new_addr;
+	void * start;
+	void * temp;
+	
+	if ((temp = contains_address (result, data, len)))
+	{
+		return temp;
+	}
+	
+	if (result->addrs_count >= k_addrs_max)
+	{
+		// Not enough addr slots
+		set_err_internal_resource_full (result);
+		syslog (LOG_ERR,
+			"mdns: Internal address buffer full; increase size"
+		);
+		return NULL;
+	}
+	
+	// Idiot check
+	if (len != result->hostent->h_length)
+	{
+		syslog (LOG_WARNING,
+			"mdns: Unexpected rdata length for address.  Expected %d, got %d",
+			result->hostent->h_length,
+			len
+		);
+		// XXX And continue for now.
+	}
+
+	new_addr = result->addr_idx + len;
+	
+	if (new_addr > result->alias_idx)
+	{
+		// Not enough room
+		set_err_buf_too_small (result);
+		if (MDNS_VERBOSE)
+			syslog (LOG_DEBUG,
+				"mdns: Ran out of buffer when adding address %d",
+				result->addrs_count + 1
+			);
+		return NULL;
+	}
+
+	start = result->buffer + result->addr_idx;
+	memcpy (start, data, len);
+	result->addr_idx = new_addr;
+	result->header->addrs [result->addrs_count] = start;
+	result->addrs_count ++;
+	result->header->addrs [result->addrs_count] = NULL;
+
+	return start;
+}
+
+
+static void *
+contains_address (result_map_t * result, const void * data, int len)
+{
+	int i;
+	
+	// Idiot check
+	if (len != result->hostent->h_length)
+	{
+		syslog (LOG_WARNING,
+			"mdns: Unexpected rdata length for address.  Expected %d, got %d",
+			result->hostent->h_length,
+			len
+		);
+		// XXX And continue for now.
+	}
+
+	for (i = 0; result->header->addrs [i]; i++)
+	{
+		if (memcmp (result->header->addrs [i], data, len) == 0)
+		{
+			return result->header->addrs [i];
+		}
+	}
+	
+	return NULL;
+}
+
+
+/*
+	Add an alias to the buffer.
+	
+	Parameter
+		result
+			Result structure to write to
+		data
+			Incoming alias (null terminated)
+		len
+			Length of data buffer (in bytes), including trailing null
+	
+	Result
+		Pointer to start of newly written data,
+		or NULL on error
+		If alias already exists in buffer, returns pointer to that instead.
+ */
+static char *
+add_alias_to_buffer (result_map_t * result, const char * data, int len)
+{
+	int new_alias;
+	char * start;
+	char * temp;
+	
+	if ((temp = contains_alias (result, data)))
+	{
+		return temp;
+	}
+	
+	if (result->aliases_count >= k_aliases_max)
+	{
+		// Not enough alias slots
+		set_err_internal_resource_full (result);
+		syslog (LOG_ERR,
+			"mdns: Internal alias buffer full; increase size"
+		);
+		return NULL;
+	}
+
+	new_alias = result->alias_idx - len;
+	
+	if (new_alias < result->addr_idx)
+	{
+		// Not enough room
+		set_err_buf_too_small (result);
+		if (MDNS_VERBOSE)
+			syslog (LOG_DEBUG,
+				"mdns: Ran out of buffer when adding alias %d",
+				result->aliases_count + 1
+			);
+		return NULL;
+	}
+
+	start = result->buffer + new_alias;
+	memcpy (start, data, len);
+	result->alias_idx = new_alias;
+	result->header->aliases [result->aliases_count] = start;
+	result->aliases_count ++;
+	result->header->aliases [result->aliases_count] = NULL;
+
+	return start;
+}
+
+
+static char *
+contains_alias (result_map_t * result, const char * alias)
+{
+	int i;
+	
+	for (i = 0; result->header->aliases [i]; i++)
+	{
+		if (strcmp (result->header->aliases [i], alias) == 0)
+		{
+			return result->header->aliases [i];
+		}
+	}
+	
+	return NULL;
+}
+
+
+/*
+	Add fully qualified hostname to result.
+	
+	Parameter
+		result
+			Result structure to write to
+		fullname
+			Fully qualified hostname
+	
+	Result
+		Pointer to start of hostname buffer,
+		or NULL on error (usually hostname too long)
+ */
+
+static char *
+add_hostname_len (result_map_t * result, const char * fullname, int len)
+{
+	if (len >= k_hostname_maxlen)
+	{
+		set_err_bad_hostname (result);
+		syslog (LOG_WARNING,
+			"mdns: Hostname too long '%.*s': len %d, max %d",
+			len,
+			fullname,
+			len,
+			k_hostname_maxlen
+		);
+		return NULL;
+	}
+	
+	result->hostent->h_name =
+		strcpy (result->header->hostname, fullname);
+	
+	return result->header->hostname;
+}
+
+
+/*
+	Add fully qualified name as hostname or alias.
+	
+	If hostname is not fully qualified this is not an error, but the data
+	returned may be not what the application wanted.
+
+	Parameter
+		result
+			Result structure to write to
+		data
+			Incoming alias (null terminated)
+		len
+			Length of data buffer (in bytes), including trailing null
+	
+	Result
+		Pointer to start of newly written data,
+		or NULL on error
+		If alias or hostname already exists, returns pointer to that instead.
+ */
+static char *
+add_hostname_or_alias (result_map_t * result, const char * data, int len)
+{
+	char * hostname = result->hostent->h_name;
+
+	if (*hostname)
+	{
+		if (strcmp (hostname, data) == 0)
+		{
+			return hostname;
+		}
+		else
+		{
+			return add_alias_to_buffer (result, data, len);
+		}
+	}
+	else
+	{
+		return add_hostname_len (result, data, len);
+	}
+}
+
+
+static int
+init_result (
+	result_map_t * result,
+	hostent * result_buf,
+	char * buf,
+	size_t buflen
+)
+{
+	if (buflen < sizeof (buf_header_t))
+	{
+		return ERANGE;
+	}
+
+	result->hostent = result_buf;
+	result->header = (buf_header_t *) buf;
+	result->header->hostname[0] = 0;
+	result->aliases_count = 0;
+	result->header->aliases[0] = NULL;
+	result->addrs_count = 0;
+	result->header->addrs[0] = NULL;
+	result->buffer = buf + sizeof (buf_header_t);
+	result->addr_idx = 0;
+	result->alias_idx = buflen - sizeof (buf_header_t);
+	result->done = 0;
+	set_err_notfound (result);
+
+	// Point hostent to the right buffers
+	result->hostent->h_name = result->header->hostname;
+	result->hostent->h_aliases = result->header->aliases;
+	result->hostent->h_addr_list = result->header->addrs;
+	
+	return 0;
+}
+
+/*
+	Set the status in the result.
+	
+	Parameters
+		result
+			Result structure to update
+		status
+			New nss_status value
+		err
+			New errno value
+		herr
+			New h_errno value
+	
+	Returns
+		New status value
+ */
+static nss_status
+set_err (result_map_t * result, nss_status status, int err, int herr)
+{
+	result->status = status;
+	result->r_errno = err;
+	result->r_h_errno = herr;
+	
+	return status;
+}
+
+static nss_status
+set_err_notfound (result_map_t * result)
+{
+	return set_err (result, NSS_STATUS_NOTFOUND, ENOENT, HOST_NOT_FOUND);
+}
+
+static nss_status
+set_err_bad_hostname (result_map_t * result)
+{
+	return set_err (result, NSS_STATUS_TRYAGAIN, ENOENT, NO_RECOVERY);
+}
+
+static nss_status
+set_err_buf_too_small (result_map_t * result)
+{
+	return set_err (result, NSS_STATUS_TRYAGAIN, ERANGE, NETDB_INTERNAL);
+}
+
+static nss_status
+set_err_internal_resource_full (result_map_t * result)
+{
+	return set_err (result, NSS_STATUS_RETURN, ERANGE, NO_RECOVERY);
+}
+
+static nss_status
+set_err_system (result_map_t * result)
+{
+	return set_err (result, NSS_STATUS_UNAVAIL, errno, NETDB_INTERNAL);
+}
+
+static nss_status
+set_err_mdns_failed (result_map_t * result)
+{
+	return set_err (result, NSS_STATUS_TRYAGAIN, EAGAIN, TRY_AGAIN);
+}
+
+static nss_status
+set_err_success (result_map_t * result)
+{
+	result->status = NSS_STATUS_SUCCESS;
+	return result->status;
+}
+
+
+/*
+	Test whether name is applicable for mdns to process, and if so copy into
+	lookup_name buffer (if non-NULL).
+	
+	Returns
+		Pointer to name to lookup up, if applicable, or NULL otherwise.
+ */
+static const char *
+is_applicable_name (
+	result_map_t * result,
+	const char * name,
+	char * lookup_name
+)
+{
+	int match = config_is_mdns_suffix (name);
+	if (match > 0)
+	{
+		if (lookup_name)
+		{
+			strncpy (lookup_name, name, k_hostname_maxlen + 1);
+			return lookup_name;
+		}
+		else
+		{
+			return name;
+		}
+	}
+	else
+	{
+		if (match < 0)
+		{
+			set_err_system (result);
+		}
+		return NULL;
+	}
+}
+
+/*
+	Test whether address is applicable for mdns to process, and if so copy into
+	addr_str buffer as an address suitable for ptr lookup.
+	
+	Returns
+		Pointer to name to lookup up, if applicable, or NULL otherwise.
+ */
+static const char *
+is_applicable_addr (
+	result_map_t * result,
+	const void * addr,
+	int af,
+	char * addr_str
+)
+{
+	int match;
+	
+	if (! format_reverse_addr (af, addr, -1, addr_str))
+	{
+		if (MDNS_VERBOSE)
+			syslog (LOG_DEBUG,
+				"mdns: Failed to create reverse address"
+			);
+		return NULL;
+	}
+
+	if (MDNS_VERBOSE)
+		syslog (LOG_DEBUG,
+			"mdns: Reverse address: %s",
+			addr_str
+		);
+
+	match = config_is_mdns_suffix (addr_str);
+	if (match > 0)
+	{
+		return addr_str;
+	}
+	else
+	{
+		if (match < 0)
+		{
+			set_err_system (result);
+		}
+		return NULL;
+	}
+}
+
+//----------
+// Types and Constants
+
+const char * k_conf_file = "/etc/nss_mdns.conf";
+#define CONF_LINE_SIZE 1024
+
+const char k_comment_char = '#';
+
+const char * k_keyword_domain = "domain";
+
+const char * k_default_domains [] =
+	{
+		"local",
+		"254.169.in-addr.arpa",
+		"8.e.f.ip6.int",
+		"8.e.f.ip6.arpa",
+		"9.e.f.ip6.int",
+		"9.e.f.ip6.arpa",
+		"a.e.f.ip6.int",
+		"a.e.f.ip6.arpa",
+		"b.e.f.ip6.int",
+		"b.e.f.ip6.arpa",
+		NULL
+			// Always null terminated
+	};
+
+// Linked list of domains
+typedef struct domain_entry
+{
+	char * domain;
+	struct domain_entry * next;
+} domain_entry_t;
+
+
+// Config
+typedef struct
+{
+	domain_entry_t * domains;
+} config_t;
+
+const config_t k_empty_config =
+	{
+		NULL
+	};
+
+
+// Context - tracks position in config file, used for error reporting
+typedef struct
+{
+	const char * filename;
+	int linenum;
+} config_file_context_t;
+
+
+//----------
+// Local prototypes
+
+static errcode_t
+load_config (config_t * conf);
+
+static errcode_t
+process_config_line (
+	config_t * conf,
+	char * line,
+	config_file_context_t * context
+);
+
+static char *
+get_next_word (char * input, char **next);
+
+static errcode_t
+default_config (config_t * conf);
+
+static errcode_t
+add_domain (config_t * conf, const char * domain);
+
+static int
+contains_domain (const config_t * conf, const char * domain);
+
+static int
+contains_domain_suffix (const config_t * conf, const char * addr);
+
+
+//----------
+// Global variables
+
+static config_t * g_config = NULL;
+	// Configuration info
+
+pthread_mutex_t g_config_mutex =
+#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+	PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
+#else
+	PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+
+//----------
+// Configuration functions
+
+
+/*
+	Initialise the configuration from the config file.
+	
+	Returns
+		0 success
+		non-zero error code on failure
+ */
+errcode_t
+init_config ()
+{
+	if (g_config)
+	{
+		/*
+			Safe to test outside mutex.
+			If non-zero, initialisation is complete and g_config can be
+			safely used read-only.  If zero, then we do proper mutex
+			testing before initialisation.
+		 */
+		return 0;
+	}
+	else
+	{
+		int errcode = -1;
+		int presult;
+		config_t * temp_config;
+		
+		// Acquire mutex
+		presult = pthread_mutex_lock (&g_config_mutex);
+		if (presult)
+		{
+			syslog (LOG_ERR,
+				"mdns: Fatal mutex lock error in nss_mdns:init_config, %s:%d: %d: %s",
+				__FILE__, __LINE__, presult, strerror (presult)
+			);
+			return presult;
+		}
+		
+		// Test again now we have mutex, in case initialisation occurred while
+		// we were waiting
+		if (! g_config)
+		{
+			temp_config = (config_t *) malloc (sizeof (config_t));
+			if (temp_config)
+			{
+				// Note: This code will leak memory if initialisation fails
+				// repeatedly.  This should only happen in the case of a memory
+				// error, so I'm not sure if it's a meaningful problem. - AW
+				*temp_config = k_empty_config;
+				errcode = load_config (temp_config);
+	
+				if (! errcode)
+				{
+					g_config = temp_config;
+				}
+			}
+			else
+			{
+				syslog (LOG_ERR,
+					"mdns: Can't allocate memory in nss_mdns:init_config, %s:%d",
+					__FILE__, __LINE__
+				);
+				errcode = errno;
+			}
+		}
+		
+		presult = pthread_mutex_unlock (&g_config_mutex);
+		if (presult)
+		{
+			syslog (LOG_ERR,
+				"mdns: Fatal mutex unlock error in nss_mdns:init_config, %s:%d: %d: %s",
+				__FILE__, __LINE__, presult, strerror (presult)
+			);
+			errcode = presult;
+		}
+
+		return errcode;
+	}
+}
+
+
+int
+config_is_mdns_suffix (const char * name)
+{
+	int errcode = init_config ();
+	if (! errcode)
+	{
+		return contains_domain_suffix (g_config, name);
+	}
+	else
+	{
+		errno = errcode;
+		return -1;
+	}
+}
+
+
+//----------
+// Local functions
+
+static errcode_t
+load_config (config_t * conf)
+{
+	FILE * cf;
+	char line [CONF_LINE_SIZE];
+	config_file_context_t context;
+
+	context.filename = k_conf_file;
+	context.linenum = 0;
+	
+	
+	cf = fopen (context.filename, "r");
+	if (! cf)
+	{
+		syslog (LOG_INFO,
+			"mdns: Couldn't open nss_mdns configuration file %s, using default.",
+			context.filename
+		);
+		return default_config (conf);
+	}
+	
+	while (fgets (line, CONF_LINE_SIZE, cf))
+	{
+		int errcode;
+		context.linenum++;
+		errcode = process_config_line (conf, line, &context);
+		if (errcode)
+		{
+			// Critical error, give up
+			fclose(cf);
+			return errcode;
+		}
+	}
+	
+	fclose (cf);
+	
+	return 0;
+}
+
+
+/*
+	Parse a line of the configuration file.
+	For each keyword recognised, perform appropriate handling.
+	If the keyword is not recognised, print a message to syslog
+	and continue.
+	
+	Returns
+		0 success, or recoverable config file error
+		non-zero serious system error, processing aborted
+ */
+static errcode_t
+process_config_line (
+	config_t * conf,
+	char * line,
+	config_file_context_t * context
+)
+{
+	char * curr = line;
+	char * word;
+	
+	word = get_next_word (curr, &curr);
+	if (! word || word [0] == k_comment_char)
+	{
+		// Nothing interesting on this line
+		return 0;
+	}
+	
+	if (strcmp (word, k_keyword_domain) == 0)
+	{
+		word = get_next_word (curr, &curr);
+		if (word)
+		{
+			int errcode = add_domain (conf, word);
+			if (errcode)
+			{
+				// something badly wrong, bail
+				return errcode;
+			}
+			
+			if (get_next_word (curr, NULL))
+			{
+				syslog (LOG_WARNING,
+					"%s, line %d: ignored extra text found after domain",
+					context->filename,
+					context->linenum
+				);
+			}
+		}
+		else
+		{
+			syslog (LOG_WARNING,
+				"%s, line %d: no domain specified",
+				context->filename,
+				context->linenum
+			);
+		}
+	}
+	else
+	{
+		syslog (LOG_WARNING,
+			"%s, line %d: unknown keyword %s - skipping",
+			context->filename,
+			context->linenum,
+			word
+		);
+	}
+	
+	return 0;
+}
+
+
+/*
+	Get next word (whitespace separated) from input string.
+	A null character is written into the first whitespace character following
+	the word.
+	
+	Parameters
+		input
+			Input string.  This string is modified by get_next_word.
+		next
+			If non-NULL and the result is non-NULL, a pointer to the
+			character following the end of the word (after the null)
+			is written to 'next'.
+			If no word is found, the original value is unchanged.
+			If the word extended to the end of the string, 'next' points
+			to the trailling NULL.
+			It is safe to pass 'str' as 'input' and '&str' as 'next'.
+	Returns
+		Pointer to the first non-whitespace character (and thus word) found.
+		if no word is found, returns NULL.
+ */
+static char *
+get_next_word (char * input, char **next)
+{
+	char * curr = input;
+	char * result;
+	
+	while (isspace (*curr))
+	{
+		curr ++;
+	}
+	
+	if (*curr == 0)
+	{
+		return NULL;
+	}
+	
+	result = curr;
+	while (*curr && ! isspace (*curr))
+	{
+		curr++;
+	}
+	if (*curr)
+	{
+		*curr = 0;
+		if (next)
+		{
+			*next = curr+1;
+		}
+	}
+	else
+	{
+		if (next)
+		{
+			*next = curr;
+		}
+	}
+	
+	return result;
+}
+
+
+static errcode_t
+default_config (config_t * conf)
+{
+	int i;
+	for (i = 0; k_default_domains [i]; i++)
+	{
+		int errcode =
+			add_domain (conf, k_default_domains [i]);
+		if (errcode)
+		{
+			// Something has gone (badly) wrong - let's bail
+			return errcode;
+		}
+	}
+	
+	return 0;
+}
+
+
+static errcode_t
+add_domain (config_t * conf, const char * domain)
+{
+	if (! contains_domain (conf, domain))
+	{
+		domain_entry_t * d =
+			(domain_entry_t *) malloc (sizeof (domain_entry_t));
+		if (! d)
+		{
+			syslog (LOG_ERR,
+				"mdns: Can't allocate memory in nss_mdns:init_config, %s:%d",
+				__FILE__, __LINE__
+			);
+			return ENOMEM;
+		}
+
+		d->domain = strdup (domain);
+		if (! d->domain)
+		{
+			syslog (LOG_ERR,
+				"mdns: Can't allocate memory in nss_mdns:init_config, %s:%d",
+				__FILE__, __LINE__
+			);
+			free (d);
+			return ENOMEM;
+		}
+		d->next = conf->domains;
+		conf->domains = d;
+	}
+	
+	return 0;
+}
+
+
+static int
+contains_domain (const config_t * conf, const char * domain)
+{
+	const domain_entry_t * curr = conf->domains;
+	
+	while (curr != NULL)
+	{
+		if (strcasecmp (curr->domain, domain) == 0)
+		{
+			return 1;
+		}
+		
+		curr = curr->next;
+	}
+	
+	return 0;
+}
+
+
+static int
+contains_domain_suffix (const config_t * conf, const char * addr)
+{
+	const domain_entry_t * curr = conf->domains;
+	
+	while (curr != NULL)
+	{
+		if (cmp_dns_suffix (addr, curr->domain) > 0)
+		{
+			return 1;
+		}
+		
+		curr = curr->next;
+	}
+	
+	return 0;
+}
+
+//----------
+// Types and Constants
+
+static const char * k_local_suffix = "local";
+static const char k_dns_separator = '.';
+
+static const int k_label_maxlen = DNS_LABEL_MAXLEN;
+	// Label entries longer than this are actually pointers.
+
+typedef struct
+{
+	int value;
+	const char * name;
+	const char * comment;
+} table_entry_t;
+
+static const table_entry_t k_table_af [] =
+	{
+		{ AF_UNSPEC, NULL, NULL },
+		{ AF_LOCAL, "LOCAL", NULL },
+		{ AF_UNIX, "UNIX", NULL },
+		{ AF_INET, "INET", NULL },
+		{ AF_INET6, "INET6", NULL }
+	};
+static const int k_table_af_size =
+	sizeof (k_table_af) / sizeof (* k_table_af);
+
+static const char * k_table_ns_class [] =
+	{
+		NULL,
+		"IN"
+	};
+static const int k_table_ns_class_size =
+	sizeof (k_table_ns_class) / sizeof (* k_table_ns_class);
+
+static const char * k_table_ns_type [] =
+	{
+		NULL,
+		"A",
+		"NS",
+		"MD",
+		"MF",
+		"CNAME",
+		"SOA",
+		"MB",
+		"MG",
+		"MR",
+		"NULL",
+		"WKS",
+		"PTR",
+		"HINFO",
+		"MINFO",
+		"MX",
+		"TXT",
+		"RP",
+		"AFSDB",
+		"X25",
+		"ISDN",
+		"RT",
+		"NSAP",
+		NULL,
+		"SIG",
+		"KEY",
+		"PX",
+		"GPOS",
+		"AAAA",
+		"LOC",
+		"NXT",
+		"EID",
+		"NIMLOC",
+		"SRV",
+		"ATMA",
+		"NAPTR",
+		"KX",
+		"CERT",
+		"A6",
+		"DNAME",
+		"SINK",
+		"OPT"
+	};
+static const int k_table_ns_type_size =
+	sizeof (k_table_ns_type) / sizeof (* k_table_ns_type);
+
+
+//----------
+// Local prototypes
+
+static int
+simple_table_index (const char * table [], int size, const char * str);
+
+static int
+table_index_name (const table_entry_t table [], int size, const char * str);
+
+static int
+table_index_value (const table_entry_t table [], int size, int n);
+
+
+//----------
+// Global variables
+
+
+//----------
+// Util functions
+
+int
+count_dots (const char * name)
+{
+	int count = 0;
+	int i;
+	for (i = 0; name[i]; i++)
+	{
+		if (name [i] == k_dns_separator)
+			count++;
+	}
+	
+	return count;
+}
+
+
+int
+islocal (const char * name)
+{
+	return cmp_dns_suffix (name, k_local_suffix) > 0;
+}
+
+
+int
+rr_to_af (ns_type_t rrtype)
+{
+	switch (rrtype)
+	{
+	  case kDNSServiceType_A:
+		return AF_INET;
+	
+	  case kDNSServiceType_AAAA:
+		return AF_INET6;
+	
+	  default:
+		return AF_UNSPEC;
+	}
+}
+
+
+ns_type_t
+af_to_rr (int af)
+{
+	switch (af)
+	{
+	  case AF_INET:
+		return kDNSServiceType_A;
+	
+	  case AF_INET6:
+		return kDNSServiceType_AAAA;
+	
+	  default:
+		//return ns_t_invalid;
+		return 0;
+	}
+}
+
+
+int
+str_to_af (const char * str)
+{
+	int result =
+		table_index_name (k_table_af, k_table_af_size, str);
+	if (result < 0)
+		result = 0;
+
+	return k_table_af [result].value;
+}
+
+
+ns_class_t
+str_to_ns_class (const char * str)
+{
+	return (ns_class_t)
+		simple_table_index (k_table_ns_class, k_table_ns_class_size, str);
+}
+
+
+ns_type_t
+str_to_ns_type (const char * str)
+{
+	return (ns_type_t)
+		simple_table_index (k_table_ns_type, k_table_ns_type_size, str);
+}
+
+
+const char *
+af_to_str (int in)
+{
+	int result =
+		table_index_value (k_table_af, k_table_af_size, in);
+	if (result < 0)
+		result = 0;
+
+	return k_table_af [result].name;
+}
+
+
+const char *
+ns_class_to_str (ns_class_t in)
+{
+	if (in < k_table_ns_class_size)
+		return k_table_ns_class [in];
+	else
+		return NULL;
+}
+
+
+const char *
+ns_type_to_str (ns_type_t in)
+{
+	if (in < k_table_ns_type_size)
+		return k_table_ns_type [in];
+	else
+		return NULL;
+}
+
+
+char *
+format_reverse_addr_in (
+	const struct in_addr * addr,
+	int prefixlen,
+	char * buf
+)
+{
+	char * curr = buf;
+	int i;
+	
+	const uint8_t * in_addr_a = (uint8_t *) addr;
+	
+	if (prefixlen > 32)
+		return NULL;
+	if (prefixlen < 0)
+		prefixlen = 32;
+
+	i = (prefixlen + 7) / 8;
+		// divide prefixlen into bytes, rounding up
+	
+	while (i > 0)
+	{
+		i--;
+		curr += sprintf (curr, "%d.", in_addr_a [i]);
+	}
+	sprintf (curr, "in-addr.arpa");
+	
+	return buf;
+}
+
+
+char *
+format_reverse_addr_in6 (
+	const struct in6_addr * addr,
+	int prefixlen,
+	char * buf
+)
+{
+	char * curr = buf;
+	int i;
+
+	const uint8_t * in_addr_a = (uint8_t *) addr;
+
+	if (prefixlen > 128)
+		return NULL;
+	if (prefixlen < 0)
+		prefixlen = 128;
+	
+	i = (prefixlen + 3) / 4;
+		// divide prefixlen into nibbles, rounding up
+
+	// Special handling for first
+	if (i % 2)
+	{
+		curr += sprintf (curr, "%d.", (in_addr_a [i/2] >> 4) & 0x0F);
+	}
+	i >>= 1;
+		// Convert i to bytes (divide by 2)
+	
+	while (i > 0)
+	{
+		uint8_t val;
+		
+		i--;
+		val = in_addr_a [i];
+		curr += sprintf (curr, "%x.%x.", val & 0x0F, (val >> 4) & 0x0F);
+	}
+	sprintf (curr, "ip6.arpa");
+	
+	return buf;
+}
+
+
+char *
+format_reverse_addr (
+	int af,
+	const void * addr,
+	int prefixlen,
+	char * buf
+)
+{
+	switch (af)
+	{
+	  case AF_INET:
+		return
+			format_reverse_addr_in (
+				(struct in_addr *) addr, prefixlen, buf
+			);
+		break;
+	
+	  case AF_INET6:
+		return
+			format_reverse_addr_in6 (
+				(struct in6_addr *) addr, prefixlen, buf
+			);
+		break;
+	
+	  default:
+		return NULL;
+	}
+}
+
+
+int
+cmp_dns_suffix (const char * name, const char * domain)
+{
+	const char * nametail;
+	const char * domaintail;
+
+	// Idiot checks
+	if (*name == 0 || *name == k_dns_separator)
+	{
+		// Name can't be empty or start with separator
+		return CMP_DNS_SUFFIX_BAD_NAME;
+	}
+	
+	if (*domain == 0)
+	{
+		return CMP_DNS_SUFFIX_SUCCESS;
+			// trivially true
+	}
+	
+	if (*domain == k_dns_separator)
+	{
+		// drop leading separator from domain
+		domain++;
+		if (*domain == k_dns_separator)
+		{
+			return CMP_DNS_SUFFIX_BAD_DOMAIN;
+		}
+	}
+
+	// Find ends of strings
+	for (nametail = name; *nametail; nametail++)
+		;
+	for (domaintail = domain; *domaintail; domaintail++)
+		;
+	
+	// Shuffle back to last real character, and drop any trailing '.'
+	// while we're at it.
+	nametail --;
+	if (*nametail == k_dns_separator)
+	{
+		nametail --;
+		if (*nametail == k_dns_separator)
+		{
+			return CMP_DNS_SUFFIX_BAD_NAME;
+		}
+	}
+	domaintail --;
+	if (*domaintail == k_dns_separator)
+	{
+		domaintail --;
+		if (*domaintail == k_dns_separator)
+		{
+			return CMP_DNS_SUFFIX_BAD_DOMAIN;
+		}
+	}
+	
+	// Compare.
+	while (
+		nametail >= name
+		&& domaintail >= domain
+		&& tolower(*nametail) == tolower(*domaintail))
+	{
+		nametail--;
+		domaintail--;
+	}
+	
+	/* A successful finish will be one of the following:
+		(leading and trailing . ignored)
+		
+		name  :  domain2.domain1
+		domain:  domain2.domain1
+		        ^
+		
+		name  : domain3.domain2.domain1
+		domain:         domain2.domain1
+		               ^
+	 */
+	if (
+		domaintail < domain
+		&& (nametail < name || *nametail == k_dns_separator)
+	)
+	{
+		return CMP_DNS_SUFFIX_SUCCESS;
+	}
+	else
+	{
+		return CMP_DNS_SUFFIX_FAILURE;
+	}
+}
+
+
+int
+dns_rdata_to_name (const char * rdata, int rdlen, char * name, int name_len)
+{
+	int i = 0;
+		// Index into 'name'
+	const char * rdata_curr = rdata;
+	
+	if (rdlen == 0) return DNS_RDATA_TO_NAME_BAD_FORMAT;
+	
+	/*
+		In RDATA, a DNS name is stored as a series of labels.
+		Each label consists of a length octet (max value 63)
+		followed by the data for that label.
+		The series is terminated with a length 0 octet.
+		A length octet beginning with bits 11 is a pointer to
+		somewhere else in the payload, but we don't support these
+		since we don't have access to the entire payload.
+	
+		See RFC1034 section 3.1 and RFC1035 section 3.1.
+	 */
+	while (1)
+	{
+		int term_len = *rdata_curr;
+		rdata_curr++;
+
+		if (term_len == 0)
+		{
+			break;
+				// 0 length record terminates label
+		}
+		else if (term_len > k_label_maxlen)
+		{
+			name [i] = 0;
+			return DNS_RDATA_TO_NAME_PTR;
+		}
+		else if (rdata_curr + term_len > rdata + rdlen)
+		{
+			name [i] = 0;
+			return DNS_RDATA_TO_NAME_BAD_FORMAT;
+		}
+		
+		if (name_len < i + term_len + 1)
+			// +1 is separator
+		{
+			name [i] = 0;
+			return DNS_RDATA_TO_NAME_TOO_LONG;
+		}
+		
+		memcpy (name + i, rdata_curr, term_len);
+		
+		i += term_len;
+		rdata_curr += term_len;
+		
+		name [i] = k_dns_separator;
+		i++;
+	}
+	
+	name [i] = 0;
+	return i;
+}
+
+
+//----------
+// Local functions
+
+/*
+	Find the index of an string entry in a table.  A case insenitive match
+	is performed.  If no entry is found, 0 is returned.
+	
+	Parameters
+		table
+			Lookup table
+			Table entries may be NULL.  NULL entries will never match.
+		size
+			number of entries in table
+		str
+			lookup string
+
+	Result
+		index of first matching entry, or 0 if no matches
+ */
+static int
+simple_table_index (const char * table [], int size, const char * str)
+{
+	int i;
+	for (i = 0; i < size; i++)
+	{
+		if (
+			table [i]
+			&& (strcasecmp (table [i], str) == 0)
+		)
+		{
+			return i;
+		}
+	}
+	
+	return 0;
+}
+
+
+/*
+	Find the index of a name in a table.
+	
+	Parameters
+		table
+			array of table_entry_t records.  The name field is compared
+			(ignoring case) to the input string.
+		size
+			number of entries in table
+		str
+			lookup string
+
+	Result
+		index of first matching entry, or -1 if no matches
+ */
+static int
+table_index_name (const table_entry_t table [], int size, const char * str)
+{
+	int i;
+	for (i = 0; i < size; i++)
+	{
+		if (
+			table [i].name
+			&& (strcasecmp (table [i].name, str) == 0)
+		)
+		{
+			return i;
+		}
+	}
+	
+	return -1;
+}
+
+
+/*
+	Find the index of a value a table.
+	
+	Parameters
+		table
+			array of table_entry_t records.  The value field is compared to
+			the input value
+		size
+			number of entries in table
+		n
+			lookup value
+
+	Result
+		index of first matching entry, or -1 if no matches
+ */
+static int
+table_index_value (const table_entry_t table [], int size, int n)
+{
+	int i;
+	for (i = 0; i < size; i++)
+	{
+		if (table [i].value == n)
+		{
+			return i;
+		}
+	}
+	
+	return -1;
+}