react-native-zeroconf 0.13.8 → 0.14.0

package/android/src/main/jni/mdnsresponder/mDNSShared/dnssd_clientstub.c

@@ -0,0 +1,1988 @@
+/* -*- Mode: C; tab-width: 4 -*-
+ *
+ * Copyright (c) 2003-2004, Apple Computer, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of its
+ *     contributors may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+
+#include "dnssd_ipc.h"
+
+static int gDaemonErr = kDNSServiceErr_NoError;
+
+#if defined(_WIN32)
+
+	#define _SSIZE_T
+	#include <CommonServices.h>
+	#include <DebugServices.h>
+	#include <winsock2.h>
+	#include <ws2tcpip.h>
+	#include <windows.h>
+	#include <stdarg.h>
+	
+	#define sockaddr_mdns sockaddr_in
+	#define AF_MDNS AF_INET
+	
+	// Disable warning: "'type cast' : from data pointer 'void *' to function pointer"
+	#pragma warning(disable:4055)
+	
+	// Disable warning: "nonstandard extension, function/data pointer conversion in expression"
+	#pragma warning(disable:4152)
+	
+	extern BOOL IsSystemServiceDisabled();
+	
+	#define sleep(X) Sleep((X) * 1000)
+	
+	static int g_initWinsock = 0;
+	#define LOG_WARNING kDebugLevelWarning
+	#define LOG_INFO kDebugLevelInfo
+	static void syslog( int priority, const char * message, ...)
+		{
+		va_list args;
+		int len;
+		char * buffer;
+		DWORD err = WSAGetLastError();
+		(void) priority;
+		va_start( args, message );
+		len = _vscprintf( message, args ) + 1;
+		buffer = malloc( len * sizeof(char) );
+		if ( buffer ) { vsprintf( buffer, message, args ); OutputDebugString( buffer ); free( buffer ); }
+		WSASetLastError( err );
+		}
+#else
+
+#ifndef __ANDROID__
+	#include <sys/fcntl.h>		// For O_RDWR etc.
+#else
+	#include <fcntl.h>
+	#define LOG_TAG "libmdns"
+#endif  // !__ANDROID__
+	#include <sys/time.h>
+	#include <sys/socket.h>
+	#include <syslog.h>
+	
+	#define sockaddr_mdns sockaddr_un
+	#define AF_MDNS AF_LOCAL
+
+#endif
+
+// <rdar://problem/4096913> Specifies how many times we'll try and connect to the server.
+
+#define DNSSD_CLIENT_MAXTRIES 4
+
+// Uncomment the line below to use the old error return mechanism of creating a temporary named socket (e.g. in /var/tmp)
+//#define USE_NAMED_ERROR_RETURN_SOCKET 1
+
+#define DNSSD_CLIENT_TIMEOUT 10  // In seconds
+
+#ifndef CTL_PATH_PREFIX
+#define CTL_PATH_PREFIX "/var/tmp/dnssd_result_socket."
+#endif
+
+typedef struct
+	{
+	ipc_msg_hdr         ipc_hdr;
+	DNSServiceFlags     cb_flags;
+	uint32_t            cb_interface;
+	DNSServiceErrorType cb_err;
+	} CallbackHeader;
+
+typedef struct _DNSServiceRef_t DNSServiceOp;
+typedef struct _DNSRecordRef_t DNSRecord;
+
+// client stub callback to process message from server and deliver results to client application
+typedef void (*ProcessReplyFn)(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *msg, const char *const end);
+
+#define ValidatorBits 0x12345678
+#define DNSServiceRefValid(X) (dnssd_SocketValid((X)->sockfd) && (((X)->sockfd ^ (X)->validator) == ValidatorBits))
+
+// When using kDNSServiceFlagsShareConnection, there is one primary _DNSServiceOp_t, and zero or more subordinates
+// For the primary, the 'next' field points to the first subordinate, and its 'next' field points to the next, and so on.
+// For the primary, the 'primary' field is NULL; for subordinates the 'primary' field points back to the associated primary
+//
+// _DNS_SD_LIBDISPATCH is defined where libdispatch/GCD is available. This does not mean that the application will use the
+// DNSServiceSetDispatchQueue API. Hence any new code guarded with _DNS_SD_LIBDISPATCH should still be backwards compatible.
+struct _DNSServiceRef_t
+	{
+	DNSServiceOp     *next;				// For shared connection
+	DNSServiceOp     *primary;			// For shared connection
+	dnssd_sock_t      sockfd;			// Connected socket between client and daemon
+	dnssd_sock_t      validator;		// Used to detect memory corruption, double disposals, etc.
+	client_context_t  uid;				// For shared connection requests, each subordinate DNSServiceRef has its own ID,
+										// unique within the scope of the same shared parent DNSServiceRef
+	uint32_t          op;				// request_op_t or reply_op_t
+	uint32_t          max_index;		// Largest assigned record index - 0 if no additional records registered
+	uint32_t          logcounter;		// Counter used to control number of syslog messages we write
+	int              *moreptr;			// Set while DNSServiceProcessResult working on this particular DNSServiceRef
+	ProcessReplyFn    ProcessReply;		// Function pointer to the code to handle received messages
+	void             *AppCallback;		// Client callback function and context
+	void             *AppContext;
+	DNSRecord        *rec;
+#if _DNS_SD_LIBDISPATCH
+	dispatch_source_t disp_source;
+	dispatch_queue_t  disp_queue;
+#endif
+	};
+
+struct _DNSRecordRef_t
+	{
+	DNSRecord		*recnext;
+	void *AppContext;
+	DNSServiceRegisterRecordReply AppCallback;
+	DNSRecordRef recref;
+	uint32_t record_index;  // index is unique to the ServiceDiscoveryRef
+	DNSServiceOp *sdr;
+	};
+
+// Write len bytes. Return 0 on success, -1 on error
+static int write_all(dnssd_sock_t sd, char *buf, size_t len)
+	{
+	// Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; use an explicit while() loop instead.
+	//if (send(sd, buf, len, MSG_WAITALL) != len) return -1;
+	while (len)
+		{
+		ssize_t num_written = send(sd, buf, (long)len, 0);
+		if (num_written < 0 || (size_t)num_written > len)
+			{
+			// Should never happen. If it does, it indicates some OS bug,
+			// or that the mDNSResponder daemon crashed (which should never happen).
+			#if !defined(__ppc__) && defined(SO_ISDEFUNCT)
+			int defunct;
+			socklen_t dlen = sizeof (defunct);
+			if (getsockopt(sd, SOL_SOCKET, SO_ISDEFUNCT, &defunct, &dlen) < 0)
+				syslog(LOG_WARNING, "dnssd_clientstub write_all: SO_ISDEFUNCT failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
+			if (!defunct)
+				syslog(LOG_WARNING, "dnssd_clientstub write_all(%d) failed %ld/%ld %d %s", sd,
+					(long)num_written, (long)len,
+					(num_written < 0) ? dnssd_errno                 : 0,
+					(num_written < 0) ? dnssd_strerror(dnssd_errno) : "");
+			else
+				syslog(LOG_INFO, "dnssd_clientstub write_all(%d) DEFUNCT", sd);
+			#else
+			syslog(LOG_WARNING, "dnssd_clientstub write_all(%d) failed %ld/%ld %d %s", sd,
+				(long)num_written, (long)len,
+				(num_written < 0) ? dnssd_errno                 : 0,
+				(num_written < 0) ? dnssd_strerror(dnssd_errno) : "");
+			#endif
+			return -1;
+			}
+		buf += num_written;
+		len -= num_written;
+		}
+	return 0;
+	}
+
+enum { read_all_success = 0, read_all_fail = -1, read_all_wouldblock = -2 };
+
+// Read len bytes. Return 0 on success, read_all_fail on error, or read_all_wouldblock for
+static int read_all(dnssd_sock_t sd, char *buf, int len)
+	{
+	// Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; use an explicit while() loop instead.
+	//if (recv(sd, buf, len, MSG_WAITALL) != len) return -1;
+
+	while (len)
+		{
+		ssize_t num_read = recv(sd, buf, len, 0);
+		// It is valid to get an interrupted system call error e.g., somebody attaching
+		// in a debugger, retry without failing
+		if ((num_read < 0) && (errno == EINTR)) { syslog(LOG_INFO, "dnssd_clientstub read_all: EINTR continue"); continue; }
+		if ((num_read == 0) || (num_read < 0) || (num_read > len))
+			{
+			int printWarn = 0;
+			int defunct = 0;
+			// Should never happen. If it does, it indicates some OS bug,
+			// or that the mDNSResponder daemon crashed (which should never happen).
+#if defined(WIN32)
+			// <rdar://problem/7481776> Suppress logs for "A non-blocking socket operation
+			//                          could not be completed immediately"
+			if (WSAGetLastError() != WSAEWOULDBLOCK)
+				printWarn = 1;
+#endif
+#if !defined(__ppc__) && defined(SO_ISDEFUNCT)
+			{
+			socklen_t dlen = sizeof (defunct);
+			if (getsockopt(sd, SOL_SOCKET, SO_ISDEFUNCT, &defunct, &dlen) < 0)
+				syslog(LOG_WARNING, "dnssd_clientstub read_all: SO_ISDEFUNCT failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
+			}
+			if (!defunct)
+				printWarn = 1;
+#endif
+			if (printWarn)
+				syslog(LOG_WARNING, "dnssd_clientstub read_all(%d) failed %ld/%ld %d %s", sd,
+					(long)num_read, (long)len,
+					(num_read < 0) ? dnssd_errno                 : 0,
+					(num_read < 0) ? dnssd_strerror(dnssd_errno) : "");
+			else if (defunct)
+				syslog(LOG_INFO, "dnssd_clientstub read_all(%d) DEFUNCT", sd);
+			return (num_read < 0 && dnssd_errno == dnssd_EWOULDBLOCK) ? read_all_wouldblock : read_all_fail;
+			}
+		buf += num_read;
+		len -= num_read;
+		}
+	return read_all_success;
+	}
+
+// Returns 1 if more bytes remain to be read on socket descriptor sd, 0 otherwise
+static int more_bytes(dnssd_sock_t sd)
+	{
+	struct timeval tv = { 0, 0 };
+	fd_set readfds;
+	fd_set *fs;
+	int ret;
+
+	if (sd < FD_SETSIZE)
+		{
+		fs = &readfds;
+		FD_ZERO(fs);
+		}
+	else 
+		{
+		// Compute the number of integers needed for storing "sd". Internally fd_set is stored
+		// as an array of ints with one bit for each fd and hence we need to compute
+		// the number of ints needed rather than the number of bytes. If "sd" is 32, we need
+		// two ints and not just one.
+		int nfdbits = sizeof (int) * 8;
+		int nints = (sd/nfdbits) + 1;
+		fs = (fd_set *)calloc(nints, sizeof(int));
+		if (fs == NULL) { syslog(LOG_WARNING, "dnssd_clientstub more_bytes: malloc failed"); return 0; }
+		}
+	FD_SET(sd, fs);
+	ret = select((int)sd+1, fs, (fd_set*)NULL, (fd_set*)NULL, &tv);
+	if (fs != &readfds) free(fs);
+	return (ret > 0);
+	}
+
+// Wait for daemon to write to socket
+static int wait_for_daemon(dnssd_sock_t sock, int timeout)
+	{
+#ifndef WIN32
+	// At this point the next operation (accept() or read()) on this socket may block for a few milliseconds waiting
+	// for the daemon to respond, but that's okay -- the daemon is a trusted service and we know if won't take more
+	// than a few milliseconds to respond.  So we'll forego checking for readability of the socket.
+	(void) sock;
+	(void) timeout;
+#else
+	// Windows on the other hand suffers from 3rd party software (primarily 3rd party firewall software) that
+	// interferes with proper functioning of the TCP protocol stack. Because of this and because we depend on TCP
+	// to communicate with the system service, we want to make sure that the next operation on this socket (accept() or
+	// read()) doesn't block indefinitely.
+	if (!gDaemonErr)
+		{
+		struct timeval tv;
+		fd_set set;
+
+		FD_ZERO(&set);
+		FD_SET(sock, &set);
+		tv.tv_sec = timeout;
+		tv.tv_usec = 0;
+		if (!select((int)(sock + 1), &set, NULL, NULL, &tv))
+			{
+				syslog(LOG_WARNING, "dnssd_clientstub wait_for_daemon timed out");
+				gDaemonErr = kDNSServiceErr_Timeout;
+			}
+		}
+#endif
+	return gDaemonErr;
+	}
+
+/* create_hdr
+ *
+ * allocate and initialize an ipc message header. Value of len should initially be the
+ * length of the data, and is set to the value of the data plus the header. data_start
+ * is set to point to the beginning of the data section. SeparateReturnSocket should be
+ * non-zero for calls that can't receive an immediate error return value on their primary
+ * socket, and therefore require a separate return path for the error code result.
+ * if zero, the path to a control socket is appended at the beginning of the message buffer.
+ * data_start is set past this string.
+ */
+static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int SeparateReturnSocket, DNSServiceOp *ref)
+	{
+	char *msg = NULL;
+	ipc_msg_hdr *hdr;
+	int datalen;
+#if !defined(USE_TCP_LOOPBACK)
+	char ctrl_path[64] = "";	// "/var/tmp/dnssd_result_socket.xxxxxxxxxx-xxx-xxxxxx"
+#endif
+
+	if (SeparateReturnSocket)
+		{
+#if defined(USE_TCP_LOOPBACK)
+		*len += 2;  // Allocate space for two-byte port number
+#elif defined(USE_NAMED_ERROR_RETURN_SOCKET)
+		struct timeval tv;
+		if (gettimeofday(&tv, NULL) < 0)
+			{ syslog(LOG_WARNING, "dnssd_clientstub create_hdr: gettimeofday failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno)); return NULL; }
+		sprintf(ctrl_path, "%s%d-%.3lx-%.6lu", CTL_PATH_PREFIX, (int)getpid(),
+			(unsigned long)(tv.tv_sec & 0xFFF), (unsigned long)(tv.tv_usec));
+		*len += strlen(ctrl_path) + 1;
+#else
+		*len += 1;		// Allocate space for single zero byte (empty C string)
+#endif
+		}
+
+	datalen = (int) *len;
+	*len += sizeof(ipc_msg_hdr);
+
+	// Write message to buffer
+	msg = malloc(*len);
+	if (!msg) { syslog(LOG_WARNING, "dnssd_clientstub create_hdr: malloc failed"); return NULL; }
+
+	memset(msg, 0, *len);
+	hdr = (ipc_msg_hdr *)msg;
+	hdr->version                = VERSION;
+	hdr->datalen                = datalen;
+	hdr->ipc_flags              = 0;
+	hdr->op                     = op;
+	hdr->client_context         = ref->uid;
+	hdr->reg_index              = 0;
+	*data_start = msg + sizeof(ipc_msg_hdr);
+#if defined(USE_TCP_LOOPBACK)
+	// Put dummy data in for the port, since we don't know what it is yet.
+	// The data will get filled in before we send the message. This happens in deliver_request().
+	if (SeparateReturnSocket) put_uint16(0, data_start);
+#else
+	if (SeparateReturnSocket) put_string(ctrl_path, data_start);
+#endif
+	return hdr;
+	}
+
+static void FreeDNSRecords(DNSServiceOp *sdRef)
+	{
+	DNSRecord *rec = sdRef->rec;
+	while (rec)
+		{
+		DNSRecord *next = rec->recnext;
+		free(rec);
+		rec = next;
+		}
+	}
+
+static void FreeDNSServiceOp(DNSServiceOp *x)
+	{
+	// We don't use our DNSServiceRefValid macro here because if we're cleaning up after a socket() call failed
+	// then sockfd could legitimately contain a failing value (e.g. dnssd_InvalidSocket)
+	if ((x->sockfd ^ x->validator) != ValidatorBits)
+		syslog(LOG_WARNING, "dnssd_clientstub attempt to dispose invalid DNSServiceRef %p %08X %08X", x, x->sockfd, x->validator);
+	else
+		{
+		x->next         = NULL;
+		x->primary      = NULL;
+		x->sockfd       = dnssd_InvalidSocket;
+		x->validator    = 0xDDDDDDDD;
+		x->op           = request_op_none;
+		x->max_index    = 0;
+		x->logcounter   = 0;
+		x->moreptr      = NULL;
+		x->ProcessReply = NULL;
+		x->AppCallback  = NULL;
+		x->AppContext   = NULL;
+#if _DNS_SD_LIBDISPATCH
+		if (x->disp_source)	dispatch_release(x->disp_source);
+		x->disp_source  = NULL;
+		x->disp_queue   = NULL;
+#endif
+		// DNSRecords may have been added to subordinate sdRef e.g., DNSServiceRegister/DNSServiceAddRecord
+		// or on the main sdRef e.g., DNSServiceCreateConnection/DNSServiveRegisterRecord. DNSRecords may have
+		// been freed if the application called DNSRemoveRecord
+		FreeDNSRecords(x);
+		free(x);
+		}
+	}
+
+// Return a connected service ref (deallocate with DNSServiceRefDeallocate)
+static DNSServiceErrorType ConnectToServer(DNSServiceRef *ref, DNSServiceFlags flags, uint32_t op, ProcessReplyFn ProcessReply, void *AppCallback, void *AppContext)
+	{
+	#if APPLE_OSX_mDNSResponder
+	int NumTries = DNSSD_CLIENT_MAXTRIES;
+	#else
+	int NumTries = 0;
+	#endif
+
+	dnssd_sockaddr_t saddr;
+	DNSServiceOp *sdr;
+
+	if (!ref) { syslog(LOG_WARNING, "dnssd_clientstub DNSService operation with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
+
+	if (flags & kDNSServiceFlagsShareConnection)
+		{
+		if (!*ref)
+			{
+			syslog(LOG_WARNING, "dnssd_clientstub kDNSServiceFlagsShareConnection used with NULL DNSServiceRef");
+			return kDNSServiceErr_BadParam;
+			}
+		if (!DNSServiceRefValid(*ref) || (*ref)->op != connection_request || (*ref)->primary)
+			{
+			syslog(LOG_WARNING, "dnssd_clientstub kDNSServiceFlagsShareConnection used with invalid DNSServiceRef %p %08X %08X",
+				(*ref), (*ref)->sockfd, (*ref)->validator);
+			*ref = NULL;
+			return kDNSServiceErr_BadReference;
+			}
+		}
+
+	#if defined(_WIN32)
+	if (!g_initWinsock)
+		{
+		WSADATA wsaData;
+		g_initWinsock = 1;
+		if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) { *ref = NULL; return kDNSServiceErr_ServiceNotRunning; }
+		}
+	// <rdar://problem/4096913> If the system service is disabled, we only want to try to connect once
+	if (IsSystemServiceDisabled()) NumTries = DNSSD_CLIENT_MAXTRIES;
+	#endif
+
+	sdr = malloc(sizeof(DNSServiceOp));
+	if (!sdr) { syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: malloc failed"); *ref = NULL; return kDNSServiceErr_NoMemory; }
+	sdr->next          = NULL;
+	sdr->primary       = NULL;
+	sdr->sockfd        = dnssd_InvalidSocket;
+	sdr->validator     = sdr->sockfd ^ ValidatorBits;
+	sdr->op            = op;
+	sdr->max_index     = 0;
+	sdr->logcounter    = 0;
+	sdr->moreptr       = NULL;
+	sdr->uid.u32[0]    = 0;
+	sdr->uid.u32[1]    = 0;
+	sdr->ProcessReply  = ProcessReply;
+	sdr->AppCallback   = AppCallback;
+	sdr->AppContext    = AppContext;
+	sdr->rec           = NULL;
+#if _DNS_SD_LIBDISPATCH
+	sdr->disp_source   = NULL;
+	sdr->disp_queue    = NULL;
+#endif
+
+	if (flags & kDNSServiceFlagsShareConnection)
+		{
+		DNSServiceOp **p = &(*ref)->next;		// Append ourselves to end of primary's list
+		while (*p) p = &(*p)->next;
+		*p = sdr;
+		// Preincrement counter before we use it -- it helps with debugging if we know the all-zeroes ID should never appear
+		if (++(*ref)->uid.u32[0] == 0) ++(*ref)->uid.u32[1];	// In parent DNSServiceOp increment UID counter
+		sdr->primary    = *ref;					// Set our primary pointer
+		sdr->sockfd     = (*ref)->sockfd;		// Inherit primary's socket
+		sdr->validator  = (*ref)->validator;
+		sdr->uid        = (*ref)->uid;
+		//printf("ConnectToServer sharing socket %d\n", sdr->sockfd);
+		}
+	else
+		{
+		#ifdef SO_NOSIGPIPE
+		const unsigned long optval = 1;
+		#endif
+		*ref = NULL;
+		sdr->sockfd    = socket(AF_DNSSD, SOCK_STREAM, 0);
+		sdr->validator = sdr->sockfd ^ ValidatorBits;
+		if (!dnssd_SocketValid(sdr->sockfd))
+			{
+			syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: socket failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
+			FreeDNSServiceOp(sdr);
+			return kDNSServiceErr_NoMemory;
+			}
+		#ifdef SO_NOSIGPIPE
+		// Some environments (e.g. OS X) support turning off SIGPIPE for a socket
+		if (setsockopt(sdr->sockfd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)
+			syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_NOSIGPIPE failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
+		#endif
+		#if defined(USE_TCP_LOOPBACK)
+		saddr.sin_family      = AF_INET;
+		saddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
+		saddr.sin_port        = htons(MDNS_TCP_SERVERPORT);
+		#else
+		saddr.sun_family      = AF_LOCAL;
+		strcpy(saddr.sun_path, MDNS_UDS_SERVERPATH);
+		#if !defined(__ppc__) && defined(SO_DEFUNCTOK)
+		{
+		int defunct = 1;
+		if (setsockopt(sdr->sockfd, SOL_SOCKET, SO_DEFUNCTOK, &defunct, sizeof(defunct)) < 0)
+			syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_DEFUNCTOK failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
+		}
+		#endif	
+		#endif
+	
+		while (1)
+			{
+			int err = connect(sdr->sockfd, (struct sockaddr *) &saddr, sizeof(saddr));
+			if (!err) break; // If we succeeded, return sdr
+			// If we failed, then it may be because the daemon is still launching.
+			// This can happen for processes that launch early in the boot process, while the
+			// daemon is still coming up. Rather than fail here, we'll wait a bit and try again.
+			// If, after four seconds, we still can't connect to the daemon,
+			// then we give up and return a failure code.
+			if (++NumTries < DNSSD_CLIENT_MAXTRIES) sleep(1); // Sleep a bit, then try again
+			else { dnssd_close(sdr->sockfd); FreeDNSServiceOp(sdr); return kDNSServiceErr_ServiceNotRunning; }
+			}
+		//printf("ConnectToServer opened socket %d\n", sdr->sockfd);
+		}
+
+	*ref = sdr;
+	return kDNSServiceErr_NoError;
+	}
+
+#define deliver_request_bailout(MSG) \
+	do { syslog(LOG_WARNING, "dnssd_clientstub deliver_request: %s failed %d (%s)", (MSG), dnssd_errno, dnssd_strerror(dnssd_errno)); goto cleanup; } while(0)
+
+static DNSServiceErrorType deliver_request(ipc_msg_hdr *hdr, DNSServiceOp *sdr)
+	{
+	uint32_t datalen = hdr->datalen;	// We take a copy here because we're going to convert hdr->datalen to network byte order
+	#if defined(USE_TCP_LOOPBACK) || defined(USE_NAMED_ERROR_RETURN_SOCKET)
+	char *const data = (char *)hdr + sizeof(ipc_msg_hdr);
+	#endif
+	dnssd_sock_t listenfd = dnssd_InvalidSocket, errsd = dnssd_InvalidSocket;
+	DNSServiceErrorType err = kDNSServiceErr_Unknown;	// Default for the "goto cleanup" cases
+	int MakeSeparateReturnSocket = 0;
+
+	// Note: need to check hdr->op, not sdr->op.
+	// hdr->op contains the code for the specific operation we're currently doing, whereas sdr->op
+	// contains the original parent DNSServiceOp (e.g. for an add_record_request, hdr->op will be
+	// add_record_request but the parent sdr->op will be connection_request or reg_service_request)
+	if (sdr->primary ||
+		hdr->op == reg_record_request || hdr->op == add_record_request || hdr->op == update_record_request || hdr->op == remove_record_request)
+		MakeSeparateReturnSocket = 1;
+
+	if (!DNSServiceRefValid(sdr))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub deliver_request: invalid DNSServiceRef %p %08X %08X", sdr, sdr->sockfd, sdr->validator);
+		return kDNSServiceErr_BadReference;
+		}
+
+	if (!hdr) { syslog(LOG_WARNING, "dnssd_clientstub deliver_request: !hdr"); return kDNSServiceErr_Unknown; }
+
+	if (MakeSeparateReturnSocket)
+		{
+		#if defined(USE_TCP_LOOPBACK)
+			{
+			union { uint16_t s; u_char b[2]; } port;
+			dnssd_sockaddr_t caddr;
+			dnssd_socklen_t len = (dnssd_socklen_t) sizeof(caddr);
+			listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
+			if (!dnssd_SocketValid(listenfd)) deliver_request_bailout("TCP socket");
+
+			caddr.sin_family      = AF_INET;
+			caddr.sin_port        = 0;
+			caddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
+			if (bind(listenfd, (struct sockaddr*) &caddr, sizeof(caddr)) < 0) deliver_request_bailout("TCP bind");
+			if (getsockname(listenfd, (struct sockaddr*) &caddr, &len)   < 0) deliver_request_bailout("TCP getsockname");
+			if (listen(listenfd, 1)                                      < 0) deliver_request_bailout("TCP listen");
+			port.s = caddr.sin_port;
+			data[0] = port.b[0];  // don't switch the byte order, as the
+			data[1] = port.b[1];  // daemon expects it in network byte order
+			}
+		#elif defined(USE_NAMED_ERROR_RETURN_SOCKET)
+			{
+			mode_t mask;
+			int bindresult;
+			dnssd_sockaddr_t caddr;
+			listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
+			if (!dnssd_SocketValid(listenfd)) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET socket");
+
+			caddr.sun_family = AF_LOCAL;
+			// According to Stevens (section 3.2), there is no portable way to
+			// determine whether sa_len is defined on a particular platform.
+			#ifndef NOT_HAVE_SA_LEN
+			caddr.sun_len = sizeof(struct sockaddr_un);
+			#endif
+			strcpy(caddr.sun_path, data);
+			mask = umask(0);
+			bindresult = bind(listenfd, (struct sockaddr *)&caddr, sizeof(caddr));
+			umask(mask);
+			if (bindresult          < 0) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET bind");
+			if (listen(listenfd, 1) < 0) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET listen");
+			}
+		#else
+			{
+			dnssd_sock_t sp[2];
+			if (socketpair(AF_DNSSD, SOCK_STREAM, 0, sp) < 0) deliver_request_bailout("socketpair");
+			else
+				{
+				errsd    = sp[0];	// We'll read our four-byte error code from sp[0]
+				listenfd = sp[1];	// We'll send sp[1] to the daemon
+				#if !defined(__ppc__) && defined(SO_DEFUNCTOK)
+				{
+				int defunct = 1;
+				if (setsockopt(errsd, SOL_SOCKET, SO_DEFUNCTOK, &defunct, sizeof(defunct)) < 0)
+					syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_DEFUNCTOK failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
+				}
+				#endif	
+				}
+			}
+		#endif
+		}
+
+#if !defined(USE_TCP_LOOPBACK) && !defined(USE_NAMED_ERROR_RETURN_SOCKET)
+	// If we're going to make a separate error return socket, and pass it to the daemon
+	// using sendmsg, then we'll hold back one data byte to go with it.
+	// On some versions of Unix (including Leopard) sending a control message without
+	// any associated data does not work reliably -- e.g. one particular issue we ran
+	// into is that if the receiving program is in a kqueue loop waiting to be notified
+	// of the received message, it doesn't get woken up when the control message arrives.
+	if (MakeSeparateReturnSocket || sdr->op == send_bpf) datalen--;		// Okay to use sdr->op when checking for op == send_bpf
+#endif
+
+	// At this point, our listening socket is set up and waiting, if necessary, for the daemon to connect back to
+	ConvertHeaderBytes(hdr);
+	//syslog(LOG_WARNING, "dnssd_clientstub deliver_request writing %lu bytes", (unsigned long)(datalen + sizeof(ipc_msg_hdr)));
+	//if (MakeSeparateReturnSocket) syslog(LOG_WARNING, "dnssd_clientstub deliver_request name is %s", data);
+#if TEST_SENDING_ONE_BYTE_AT_A_TIME
+	unsigned int i;
+	for (i=0; i<datalen + sizeof(ipc_msg_hdr); i++)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub deliver_request writing %d", i);
+		if (write_all(sdr->sockfd, ((char *)hdr)+i, 1) < 0)
+			{ syslog(LOG_WARNING, "write_all (byte %u) failed", i); goto cleanup; }
+		usleep(10000);
+		}
+#else
+	if (write_all(sdr->sockfd, (char *)hdr, datalen + sizeof(ipc_msg_hdr)) < 0)
+		{
+		// write_all already prints an error message if there is an error writing to
+		// the socket except for DEFUNCT. Logging here is unnecessary and also wrong
+		// in the case of DEFUNCT sockets
+		syslog(LOG_INFO, "dnssd_clientstub deliver_request ERROR: write_all(%d, %lu bytes) failed",
+			sdr->sockfd, (unsigned long)(datalen + sizeof(ipc_msg_hdr)));
+		goto cleanup;
+		}
+#endif
+
+	if (!MakeSeparateReturnSocket) errsd = sdr->sockfd;
+	if (MakeSeparateReturnSocket || sdr->op == send_bpf)	// Okay to use sdr->op when checking for op == send_bpf
+		{
+#if defined(USE_TCP_LOOPBACK) || defined(USE_NAMED_ERROR_RETURN_SOCKET)
+		// At this point we may block in accept for a few milliseconds waiting for the daemon to connect back to us,
+		// but that's okay -- the daemon is a trusted service and we know if won't take more than a few milliseconds to respond.
+		dnssd_sockaddr_t daddr;
+		dnssd_socklen_t len = sizeof(daddr);
+		if ((err = wait_for_daemon(listenfd, DNSSD_CLIENT_TIMEOUT)) != kDNSServiceErr_NoError) goto cleanup;
+		errsd = accept(listenfd, (struct sockaddr *)&daddr, &len);
+		if (!dnssd_SocketValid(errsd)) deliver_request_bailout("accept");
+#else
+
+#if APPLE_OSX_mDNSResponder
+// On Leopard, the stock definitions of the CMSG_* macros in /usr/include/sys/socket.h,
+// while arguably correct in theory, nonetheless in practice produce code that doesn't work on 64-bit machines
+// For details see <rdar://problem/5565787> Bonjour API broken for 64-bit apps (SCM_RIGHTS sendmsg fails)
+#undef  CMSG_DATA
+#define CMSG_DATA(cmsg) ((unsigned char *)(cmsg) + (sizeof(struct cmsghdr)))
+#undef  CMSG_SPACE
+#define CMSG_SPACE(l)   ((sizeof(struct cmsghdr)) + (l))
+#undef  CMSG_LEN
+#define CMSG_LEN(l)     ((sizeof(struct cmsghdr)) + (l))
+#endif
+
+		struct iovec vec = { ((char *)hdr) + sizeof(ipc_msg_hdr) + datalen, 1 }; // Send the last byte along with the SCM_RIGHTS
+		struct msghdr msg;
+		struct cmsghdr *cmsg;
+		char cbuf[CMSG_SPACE(sizeof(dnssd_sock_t))];
+
+		if (sdr->op == send_bpf)	// Okay to use sdr->op when checking for op == send_bpf
+			{
+			int i;
+			char p[12];		// Room for "/dev/bpf999" with terminating null
+			for (i=0; i<100; i++)
+				{
+				snprintf(p, sizeof(p), "/dev/bpf%d", i);
+				listenfd = open(p, O_RDWR, 0);
+				//if (dnssd_SocketValid(listenfd)) syslog(LOG_WARNING, "Sending fd %d for %s", listenfd, p);
+				if (!dnssd_SocketValid(listenfd) && dnssd_errno != EBUSY)
+					syslog(LOG_WARNING, "Error opening %s %d (%s)", p, dnssd_errno, dnssd_strerror(dnssd_errno));
+				if (dnssd_SocketValid(listenfd) || dnssd_errno != EBUSY) break;
+				}
+			}
+
+		msg.msg_name       = 0;
+		msg.msg_namelen    = 0;
+		msg.msg_iov        = &vec;
+		msg.msg_iovlen     = 1;
+		msg.msg_control    = cbuf;
+		msg.msg_controllen = CMSG_LEN(sizeof(dnssd_sock_t));
+		msg.msg_flags      = 0;
+		cmsg = CMSG_FIRSTHDR(&msg);
+		cmsg->cmsg_len     = CMSG_LEN(sizeof(dnssd_sock_t));
+		cmsg->cmsg_level   = SOL_SOCKET;
+		cmsg->cmsg_type    = SCM_RIGHTS;
+		*((dnssd_sock_t *)CMSG_DATA(cmsg)) = listenfd;
+
+#if TEST_KQUEUE_CONTROL_MESSAGE_BUG
+		sleep(1);
+#endif
+
+#if DEBUG_64BIT_SCM_RIGHTS
+		syslog(LOG_WARNING, "dnssd_clientstub sendmsg read sd=%d write sd=%d %ld %ld %ld/%ld/%ld/%ld",
+			errsd, listenfd, sizeof(dnssd_sock_t), sizeof(void*),
+			sizeof(struct cmsghdr) + sizeof(dnssd_sock_t),
+			CMSG_LEN(sizeof(dnssd_sock_t)), (long)CMSG_SPACE(sizeof(dnssd_sock_t)),
+			(long)((char*)CMSG_DATA(cmsg) + 4 - cbuf));
+#endif // DEBUG_64BIT_SCM_RIGHTS
+
+		if (sendmsg(sdr->sockfd, &msg, 0) < 0)
+			{
+			syslog(LOG_WARNING, "dnssd_clientstub deliver_request ERROR: sendmsg failed read sd=%d write sd=%d errno %d (%s)",
+				errsd, listenfd, dnssd_errno, dnssd_strerror(dnssd_errno));
+			err = kDNSServiceErr_Incompatible;
+			goto cleanup;
+			}
+
+#if DEBUG_64BIT_SCM_RIGHTS
+		syslog(LOG_WARNING, "dnssd_clientstub sendmsg read sd=%d write sd=%d okay", errsd, listenfd);
+#endif // DEBUG_64BIT_SCM_RIGHTS
+
+#endif
+		// Close our end of the socketpair *before* blocking in read_all to get the four-byte error code.
+		// Otherwise, if the daemon closes our socket (or crashes), we block in read_all() forever
+		// because the socket is not closed (we still have an open reference to it ourselves).
+		dnssd_close(listenfd);
+		listenfd = dnssd_InvalidSocket;		// Make sure we don't close it a second time in the cleanup handling below
+		}
+
+	// At this point we may block in read_all for a few milliseconds waiting for the daemon to send us the error code,
+	// but that's okay -- the daemon is a trusted service and we know if won't take more than a few milliseconds to respond.
+	if (sdr->op == send_bpf)	// Okay to use sdr->op when checking for op == send_bpf
+		err = kDNSServiceErr_NoError;
+	else if ((err = wait_for_daemon(errsd, DNSSD_CLIENT_TIMEOUT)) == kDNSServiceErr_NoError)
+		{
+		if (read_all(errsd, (char*)&err, (int)sizeof(err)) < 0)
+			err = kDNSServiceErr_ServiceNotRunning; // On failure read_all will have written a message to syslog for us
+		else
+			err = ntohl(err);
+		}
+
+	//syslog(LOG_WARNING, "dnssd_clientstub deliver_request: retrieved error code %d", err);
+
+cleanup:
+	if (MakeSeparateReturnSocket)
+		{
+		if (dnssd_SocketValid(listenfd)) dnssd_close(listenfd);
+		if (dnssd_SocketValid(errsd))    dnssd_close(errsd);
+#if defined(USE_NAMED_ERROR_RETURN_SOCKET)
+		// syslog(LOG_WARNING, "dnssd_clientstub deliver_request: removing UDS: %s", data);
+		if (unlink(data) != 0)
+			syslog(LOG_WARNING, "dnssd_clientstub WARNING: unlink(\"%s\") failed errno %d (%s)", data, dnssd_errno, dnssd_strerror(dnssd_errno));
+		// else syslog(LOG_WARNING, "dnssd_clientstub deliver_request: removed UDS: %s", data);
+#endif
+		}
+
+	free(hdr);
+	return err;
+	}
+
+int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdRef)
+	{
+	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD called with NULL DNSServiceRef"); return dnssd_InvalidSocket; }
+
+	if (!DNSServiceRefValid(sdRef))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD called with invalid DNSServiceRef %p %08X %08X",
+			sdRef, sdRef->sockfd, sdRef->validator);
+		return dnssd_InvalidSocket;
+		}
+
+	if (sdRef->primary)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD undefined for kDNSServiceFlagsShareConnection subordinate DNSServiceRef %p", sdRef);
+		return dnssd_InvalidSocket;
+		}
+
+	return (int) sdRef->sockfd;
+	}
+
+#if _DNS_SD_LIBDISPATCH
+static void CallbackWithError(DNSServiceRef sdRef, DNSServiceErrorType error)
+	{
+	DNSServiceOp *sdr = sdRef;
+	DNSServiceOp *sdrNext;
+	DNSRecord *rec;
+	DNSRecord *recnext;
+	int morebytes;
+	
+	while (sdr)
+		{
+		// We can't touch the sdr after the callback as it can be deallocated in the callback
+		sdrNext = sdr->next;
+		morebytes = 1;
+		sdr->moreptr = &morebytes;
+		switch (sdr->op)
+			{
+			case resolve_request:
+				if (sdr->AppCallback)((DNSServiceResolveReply)    sdr->AppCallback)(sdr, 0, 0, error, NULL, 0, 0, 0, NULL,    sdr->AppContext);
+				break;
+			case query_request:
+				if (sdr->AppCallback)((DNSServiceQueryRecordReply)sdr->AppCallback)(sdr, 0, 0, error, NULL, 0, 0, 0, NULL, 0, sdr->AppContext);
+				break;
+			case addrinfo_request:
+				if (sdr->AppCallback)((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, 0, 0, error, NULL, NULL, 0,          sdr->AppContext);
+				break;
+			case browse_request:
+				if (sdr->AppCallback)((DNSServiceBrowseReply)     sdr->AppCallback)(sdr, 0, 0, error, NULL, 0, NULL,          sdr->AppContext);
+				break;
+			case reg_service_request:
+				if (sdr->AppCallback)((DNSServiceRegisterReply)   sdr->AppCallback)(sdr, 0,    error, NULL, 0, NULL,          sdr->AppContext);
+				break;
+			case enumeration_request:
+				if (sdr->AppCallback)((DNSServiceDomainEnumReply) sdr->AppCallback)(sdr, 0, 0, error, NULL,                   sdr->AppContext);
+				break;
+			case sethost_request:
+				if (sdr->AppCallback)((DNSServiceSetHostReply)    sdr->AppCallback)(sdr, 0,    error, NULL,                   sdr->AppContext);
+				break;
+			case connection_request:
+				// This means Register Record, walk the list of DNSRecords to do the callback
+				rec = sdr->rec;
+				while (rec)
+					{
+					recnext = rec->recnext;
+					if (rec->AppCallback) ((DNSServiceRegisterRecordReply)rec->AppCallback)(sdr, 0, 0, error, rec->AppContext);
+					// The Callback can call DNSServiceRefDeallocate which in turn frees sdr and all the records.
+					// Detect that and return early
+					if (!morebytes){syslog(LOG_WARNING, "dnssdclientstub:Record: CallbackwithError morebytes zero"); return;}
+					rec = recnext;
+					}
+				break;
+			case port_mapping_request:
+				if (sdr->AppCallback)((DNSServiceNATPortMappingReply)sdr->AppCallback)(sdr, 0, 0, error, 0, 0, 0, 0, 0, sdr->AppContext);
+				break;
+			default:
+				syslog(LOG_WARNING, "dnssd_clientstub CallbackWithError called with bad op %d", sdr->op);
+			}
+		// If DNSServiceRefDeallocate was called in the callback, morebytes will be zero. It means
+		// all other sdrefs have been freed. This happens for shared connections where the
+		// DNSServiceRefDeallocate on the first sdRef frees all other sdrefs.
+		if (!morebytes){syslog(LOG_WARNING, "dnssdclientstub:sdRef: CallbackwithError morebytes zero"); return;}
+		sdr = sdrNext;
+		}
+	}
+#endif // _DNS_SD_LIBDISPATCH
+
+// Handle reply from server, calling application client callback. If there is no reply
+// from the daemon on the socket contained in sdRef, the call will block.
+DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdRef)
+	{
+	int morebytes = 0;
+
+	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
+
+	if (!DNSServiceRefValid(sdRef))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
+		return kDNSServiceErr_BadReference;
+		}
+
+	if (sdRef->primary)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult undefined for kDNSServiceFlagsShareConnection subordinate DNSServiceRef %p", sdRef);
+		return kDNSServiceErr_BadReference;
+		}
+
+	if (!sdRef->ProcessReply)
+		{
+		static int num_logs = 0;
+		if (num_logs < 10) syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with DNSServiceRef with no ProcessReply function");
+		if (num_logs < 1000) num_logs++; else sleep(1);
+		return kDNSServiceErr_BadReference;
+		}
+
+	do
+		{
+		CallbackHeader cbh;
+		char *data;
+	
+		// return NoError on EWOULDBLOCK. This will handle the case
+		// where a non-blocking socket is told there is data, but it was a false positive.
+		// On error, read_all will write a message to syslog for us, so don't need to duplicate that here
+		// Note: If we want to properly support using non-blocking sockets in the future
+		int result = read_all(sdRef->sockfd, (void *)&cbh.ipc_hdr, sizeof(cbh.ipc_hdr));
+		if (result == read_all_fail)
+			{
+			// Set the ProcessReply to NULL before callback as the sdRef can get deallocated
+			// in the callback.
+			sdRef->ProcessReply = NULL;
+#if _DNS_SD_LIBDISPATCH
+			// Call the callbacks with an error if using the dispatch API, as DNSServiceProcessResult
+			// is not called by the application and hence need to communicate the error. Cancel the
+			// source so that we don't get any more events
+			if (sdRef->disp_source)
+				{
+				dispatch_source_cancel(sdRef->disp_source);
+				dispatch_release(sdRef->disp_source);
+				sdRef->disp_source = NULL;
+				CallbackWithError(sdRef, kDNSServiceErr_ServiceNotRunning);
+				}
+#endif
+			// Don't touch sdRef anymore as it might have been deallocated
+			return kDNSServiceErr_ServiceNotRunning;
+			}
+		else if (result == read_all_wouldblock)
+			{
+			if (morebytes && sdRef->logcounter < 100)
+				{
+				sdRef->logcounter++;
+				syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult error: select indicated data was waiting but read_all returned EWOULDBLOCK");
+				}
+			return kDNSServiceErr_NoError;
+			}
+	
+		ConvertHeaderBytes(&cbh.ipc_hdr);
+		if (cbh.ipc_hdr.version != VERSION)
+			{
+			syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult daemon version %d does not match client version %d", cbh.ipc_hdr.version, VERSION);
+			sdRef->ProcessReply = NULL;
+			return kDNSServiceErr_Incompatible;
+			}
+	
+		data = malloc(cbh.ipc_hdr.datalen);
+		if (!data) return kDNSServiceErr_NoMemory;
+		if (read_all(sdRef->sockfd, data, cbh.ipc_hdr.datalen) < 0) // On error, read_all will write a message to syslog for us
+			{
+			// Set the ProcessReply to NULL before callback as the sdRef can get deallocated
+			// in the callback.
+			sdRef->ProcessReply = NULL;
+#if _DNS_SD_LIBDISPATCH
+			// Call the callbacks with an error if using the dispatch API, as DNSServiceProcessResult
+			// is not called by the application and hence need to communicate the error. Cancel the
+			// source so that we don't get any more events
+			if (sdRef->disp_source)
+				{
+				dispatch_source_cancel(sdRef->disp_source);
+				dispatch_release(sdRef->disp_source);
+				sdRef->disp_source = NULL;
+				CallbackWithError(sdRef, kDNSServiceErr_ServiceNotRunning);
+				}
+#endif
+			// Don't touch sdRef anymore as it might have been deallocated
+			free(data);
+			return kDNSServiceErr_ServiceNotRunning;
+			}
+		else
+			{
+			const char *ptr = data;
+			cbh.cb_flags     = get_flags     (&ptr, data + cbh.ipc_hdr.datalen);
+			cbh.cb_interface = get_uint32    (&ptr, data + cbh.ipc_hdr.datalen);
+			cbh.cb_err       = get_error_code(&ptr, data + cbh.ipc_hdr.datalen);
+
+			// CAUTION: We have to handle the case where the client calls DNSServiceRefDeallocate from within the callback function.
+			// To do this we set moreptr to point to morebytes. If the client does call DNSServiceRefDeallocate(),
+			// then that routine will clear morebytes for us, and cause us to exit our loop.
+			morebytes = more_bytes(sdRef->sockfd);
+			if (morebytes)
+				{
+				cbh.cb_flags |= kDNSServiceFlagsMoreComing;
+				sdRef->moreptr = &morebytes;
+				}
+			if (ptr) sdRef->ProcessReply(sdRef, &cbh, ptr, data + cbh.ipc_hdr.datalen);
+			// Careful code here:
+			// If morebytes is non-zero, that means we set sdRef->moreptr above, and the operation was not
+			// cancelled out from under us, so now we need to clear sdRef->moreptr so we don't leave a stray
+			// dangling pointer pointing to a long-gone stack variable.
+			// If morebytes is zero, then one of two thing happened:
+			// (a) morebytes was 0 above, so we didn't set sdRef->moreptr, so we don't need to clear it
+			// (b) morebytes was 1 above, and we set sdRef->moreptr, but the operation was cancelled (with DNSServiceRefDeallocate()),
+			//     so we MUST NOT try to dereference our stale sdRef pointer.
+			if (morebytes) sdRef->moreptr = NULL;
+			}
+		free(data);
+		} while (morebytes);
+
+	return kDNSServiceErr_NoError;
+	}
+
+void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdRef)
+	{
+	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefDeallocate called with NULL DNSServiceRef"); return; }
+
+	if (!DNSServiceRefValid(sdRef))		// Also verifies dnssd_SocketValid(sdRef->sockfd) for us too
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefDeallocate called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
+		return;
+		}
+
+	// If we're in the middle of a DNSServiceProcessResult() invocation for this DNSServiceRef, clear its morebytes flag to break it out of its while loop
+	if (sdRef->moreptr) *(sdRef->moreptr) = 0;
+
+	if (sdRef->primary)		// If this is a subordinate DNSServiceOp, just send a 'stop' command
+		{
+		DNSServiceOp **p = &sdRef->primary->next;
+		while (*p && *p != sdRef) p = &(*p)->next;
+		if (*p)
+			{
+			char *ptr;
+			size_t len = 0;
+			ipc_msg_hdr *hdr = create_hdr(cancel_request, &len, &ptr, 0, sdRef);
+			if (hdr)
+				{
+				ConvertHeaderBytes(hdr);
+				write_all(sdRef->sockfd, (char *)hdr, len);
+				free(hdr);
+				}
+			*p = sdRef->next;
+			FreeDNSServiceOp(sdRef);
+			}
+		}
+	else					// else, make sure to terminate all subordinates as well
+		{
+#if _DNS_SD_LIBDISPATCH
+		// The cancel handler will close the fd if a dispatch source has been set
+		if (sdRef->disp_source)
+			{
+			// By setting the ProcessReply to NULL, we make sure that we never call
+			// the application callbacks ever, after returning from this function. We
+			// assume that DNSServiceRefDeallocate is called from the serial queue
+			// that was passed to DNSServiceSetDispatchQueue. Hence, dispatch_source_cancel
+			// should cancel all the blocks on the queue and hence there should be no more
+			// callbacks when we return from this function. Setting ProcessReply to NULL
+			// provides extra protection.
+			sdRef->ProcessReply = NULL;
+			dispatch_source_cancel(sdRef->disp_source);
+			dispatch_release(sdRef->disp_source);
+			sdRef->disp_source = NULL;
+			}
+			// if disp_queue is set, it means it used the DNSServiceSetDispatchQueue API. In that case,
+			// when the source was cancelled, the fd was closed in the handler. Currently the source
+			// is cancelled only when the mDNSResponder daemon dies
+		else if (!sdRef->disp_queue) dnssd_close(sdRef->sockfd);
+#else
+		dnssd_close(sdRef->sockfd);
+#endif
+		// Free DNSRecords added in DNSRegisterRecord if they have not
+		// been freed in DNSRemoveRecord
+		while (sdRef)
+			{
+			DNSServiceOp *p = sdRef;
+			sdRef = sdRef->next;
+			FreeDNSServiceOp(p);
+			}
+		}
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceGetProperty(const char *property, void *result, uint32_t *size)
+	{
+	char *ptr;
+	size_t len = strlen(property) + 1;
+	ipc_msg_hdr *hdr;
+	DNSServiceOp *tmp;
+	uint32_t actualsize;
+
+	DNSServiceErrorType err = ConnectToServer(&tmp, 0, getproperty_request, NULL, NULL, NULL);
+	if (err) return err;
+
+	hdr = create_hdr(getproperty_request, &len, &ptr, 0, tmp);
+	if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
+
+	put_string(property, &ptr);
+	err = deliver_request(hdr, tmp);		// Will free hdr for us
+	if (read_all(tmp->sockfd, (char*)&actualsize, (int)sizeof(actualsize)) < 0)
+		{ DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
+
+	actualsize = ntohl(actualsize);
+	if (read_all(tmp->sockfd, (char*)result, actualsize < *size ? actualsize : *size) < 0)
+		{ DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
+	DNSServiceRefDeallocate(tmp);
+
+	// Swap version result back to local process byte order
+	if (!strcmp(property, kDNSServiceProperty_DaemonVersion) && *size >= 4)
+		*(uint32_t*)result = ntohl(*(uint32_t*)result);
+
+	*size = actualsize;
+	return kDNSServiceErr_NoError;
+	}
+
+static void handle_resolve_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *end)
+	{
+	char fullname[kDNSServiceMaxDomainName];
+	char target[kDNSServiceMaxDomainName];
+	uint16_t txtlen;
+	union { uint16_t s; u_char b[2]; } port;
+	unsigned char *txtrecord;
+
+	get_string(&data, end, fullname, kDNSServiceMaxDomainName);
+	get_string(&data, end, target,   kDNSServiceMaxDomainName);
+	if (!data || data + 2 > end) goto fail;
+
+	port.b[0] = *data++;
+	port.b[1] = *data++;
+	txtlen = get_uint16(&data, end);
+	txtrecord = (unsigned char *)get_rdata(&data, end, txtlen);
+
+	if (!data) goto fail;
+	((DNSServiceResolveReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, fullname, target, port.s, txtlen, txtrecord, sdr->AppContext);
+	return;
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+fail:
+	syslog(LOG_WARNING, "dnssd_clientstub handle_resolve_response: error reading result from daemon");
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceResolve
+	(
+	DNSServiceRef                 *sdRef,
+	DNSServiceFlags               flags,
+	uint32_t                      interfaceIndex,
+	const char                    *name,
+	const char                    *regtype,
+	const char                    *domain,
+	DNSServiceResolveReply        callBack,
+	void                          *context
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err;
+
+	if (!name || !regtype || !domain || !callBack) return kDNSServiceErr_BadParam;
+
+	// Need a real InterfaceID for WakeOnResolve
+	if ((flags & kDNSServiceFlagsWakeOnResolve) != 0 &&
+		((interfaceIndex == kDNSServiceInterfaceIndexAny) ||
+		(interfaceIndex == kDNSServiceInterfaceIndexLocalOnly) ||
+		(interfaceIndex == kDNSServiceInterfaceIndexUnicast) ||
+		(interfaceIndex == kDNSServiceInterfaceIndexP2P)))
+		{
+		return kDNSServiceErr_BadParam;
+		}
+		
+	err = ConnectToServer(sdRef, flags, resolve_request, handle_resolve_response, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	// Calculate total message length
+	len = sizeof(flags);
+	len += sizeof(interfaceIndex);
+	len += strlen(name) + 1;
+	len += strlen(regtype) + 1;
+	len += strlen(domain) + 1;
+
+	hdr = create_hdr(resolve_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_string(name, &ptr);
+	put_string(regtype, &ptr);
+	put_string(domain, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+static void handle_query_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
+	{
+	uint32_t ttl;
+	char name[kDNSServiceMaxDomainName];
+	uint16_t rrtype, rrclass, rdlen;
+	const char *rdata;
+
+	get_string(&data, end, name, kDNSServiceMaxDomainName);
+	rrtype  = get_uint16(&data, end);
+	rrclass = get_uint16(&data, end);
+	rdlen   = get_uint16(&data, end);
+	rdata   = get_rdata(&data, end, rdlen);
+	ttl     = get_uint32(&data, end);
+
+	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_query_response: error reading result from daemon");
+	else ((DNSServiceQueryRecordReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, name, rrtype, rrclass, rdlen, rdata, ttl, sdr->AppContext);
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceQueryRecord
+	(
+	DNSServiceRef              *sdRef,
+	DNSServiceFlags             flags,
+	uint32_t                    interfaceIndex,
+	const char                 *name,
+	uint16_t                    rrtype,
+	uint16_t                    rrclass,
+	DNSServiceQueryRecordReply  callBack,
+	void                       *context
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err = ConnectToServer(sdRef, flags, query_request, handle_query_response, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	if (!name) name = "\0";
+
+	// Calculate total message length
+	len = sizeof(flags);
+	len += sizeof(uint32_t);  // interfaceIndex
+	len += strlen(name) + 1;
+	len += 2 * sizeof(uint16_t);  // rrtype, rrclass
+
+	hdr = create_hdr(query_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_string(name, &ptr);
+	put_uint16(rrtype, &ptr);
+	put_uint16(rrclass, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+static void handle_addrinfo_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
+	{
+	char hostname[kDNSServiceMaxDomainName];
+	uint16_t rrtype, rrclass, rdlen;
+	const char *rdata;
+	uint32_t ttl;
+
+	get_string(&data, end, hostname, kDNSServiceMaxDomainName);
+	rrtype  = get_uint16(&data, end);
+	rrclass = get_uint16(&data, end);
+	rdlen   = get_uint16(&data, end);
+	rdata   = get_rdata (&data, end, rdlen);
+	ttl     = get_uint32(&data, end);
+
+	// We only generate client callbacks for A and AAAA results (including NXDOMAIN results for
+	// those types, if the client has requested those with the kDNSServiceFlagsReturnIntermediates).
+	// Other result types, specifically CNAME referrals, are not communicated to the client, because
+	// the DNSServiceGetAddrInfoReply interface doesn't have any meaningful way to communiate CNAME referrals.
+	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_addrinfo_response: error reading result from daemon");
+	else if (rrtype == kDNSServiceType_A || rrtype == kDNSServiceType_AAAA)
+		{
+		struct sockaddr_in  sa4;
+		struct sockaddr_in6 sa6;
+		const struct sockaddr *const sa = (rrtype == kDNSServiceType_A) ? (struct sockaddr*)&sa4 : (struct sockaddr*)&sa6;
+		if (rrtype == kDNSServiceType_A)
+			{
+			memset(&sa4, 0, sizeof(sa4));
+			#ifndef NOT_HAVE_SA_LEN
+			sa4.sin_len = sizeof(struct sockaddr_in);
+			#endif
+			sa4.sin_family = AF_INET;
+			//  sin_port   = 0;
+			if (!cbh->cb_err) memcpy(&sa4.sin_addr, rdata, rdlen);
+			}
+		else
+			{
+			memset(&sa6, 0, sizeof(sa6));
+			#ifndef NOT_HAVE_SA_LEN
+			sa6.sin6_len = sizeof(struct sockaddr_in6);
+			#endif
+			sa6.sin6_family     = AF_INET6;
+			//  sin6_port     = 0;
+			//  sin6_flowinfo = 0;
+			//  sin6_scope_id = 0;
+			if (!cbh->cb_err)
+				{
+				memcpy(&sa6.sin6_addr, rdata, rdlen);
+				if (IN6_IS_ADDR_LINKLOCAL(&sa6.sin6_addr)) sa6.sin6_scope_id = cbh->cb_interface;
+				}
+			}
+		((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, hostname, sa, ttl, sdr->AppContext);
+		// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+		}
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceGetAddrInfo
+	(
+	DNSServiceRef                    *sdRef,
+	DNSServiceFlags                  flags,
+	uint32_t                         interfaceIndex,
+	uint32_t                         protocol,
+	const char                       *hostname,
+	DNSServiceGetAddrInfoReply       callBack,
+	void                             *context          /* may be NULL */
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err;
+
+	if (!hostname) return kDNSServiceErr_BadParam;
+
+	err = ConnectToServer(sdRef, flags, addrinfo_request, handle_addrinfo_response, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	// Calculate total message length
+	len = sizeof(flags);
+	len += sizeof(uint32_t);      // interfaceIndex
+	len += sizeof(uint32_t);      // protocol
+	len += strlen(hostname) + 1;
+
+	hdr = create_hdr(addrinfo_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_uint32(protocol, &ptr);
+	put_string(hostname, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+	
+static void handle_browse_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
+	{
+	char replyName[256], replyType[kDNSServiceMaxDomainName], replyDomain[kDNSServiceMaxDomainName];
+	get_string(&data, end, replyName, 256);
+	get_string(&data, end, replyType, kDNSServiceMaxDomainName);
+	get_string(&data, end, replyDomain, kDNSServiceMaxDomainName);
+	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_browse_response: error reading result from daemon");
+	else ((DNSServiceBrowseReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, replyName, replyType, replyDomain, sdr->AppContext);
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceBrowse
+	(
+	DNSServiceRef         *sdRef,
+	DNSServiceFlags        flags,
+	uint32_t               interfaceIndex,
+	const char            *regtype,
+	const char            *domain,
+	DNSServiceBrowseReply  callBack,
+	void                  *context
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err = ConnectToServer(sdRef, flags, browse_request, handle_browse_response, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	if (!domain) domain = "";
+	len = sizeof(flags);
+	len += sizeof(interfaceIndex);
+	len += strlen(regtype) + 1;
+	len += strlen(domain) + 1;
+
+	hdr = create_hdr(browse_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_string(regtype, &ptr);
+	put_string(domain, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+static void handle_hostname_changed_response(
+	DNSServiceOp         *const sdr,
+	const CallbackHeader *const cbh, 
+	const char           *data, 
+	const char           *const end)
+{
+	char replyHostname[256];
+	get_string(&data, end, replyHostname, sizeof(replyHostname));
+	if (!data) syslog(LOG_WARNING,
+		"dnssd_clientstub handle_hostname_changed_response: error reading result from daemon");
+	else ((DNSHostnameChangedReply)sdr->AppCallback)(
+		sdr, cbh->cb_flags, cbh->cb_err, replyHostname, sdr->AppContext);
+}
+
+DNSServiceErrorType DNSSD_API DNSSetHostname
+(
+	DNSServiceRef           *sdRef,
+	DNSServiceFlags         flags,
+	const char              *hostname,
+	DNSHostnameChangedReply callBack,
+	void                    *context
+)
+{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err = ConnectToServer(sdRef, flags, sethost_request,
+		handle_hostname_changed_response, callBack, context);
+	if (err) return err;
+	len = sizeof(flags);
+	len += strlen(hostname) + 1;
+	hdr = create_hdr(sethost_request, &len, &ptr,
+		(*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr)
+ 	{
+		DNSServiceRefDeallocate(*sdRef);
+		*sdRef = NULL;
+		return kDNSServiceErr_NoMemory;
+	}
+	put_flags(flags, &ptr);
+	put_string(hostname, &ptr);
+	err = deliver_request(hdr, *sdRef);
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+}
+
+DNSServiceErrorType DNSSD_API DNSServiceSetDefaultDomainForUser(DNSServiceFlags flags, const char *domain);
+DNSServiceErrorType DNSSD_API DNSServiceSetDefaultDomainForUser(DNSServiceFlags flags, const char *domain)
+	{
+	DNSServiceOp *tmp;
+	char *ptr;
+	size_t len = sizeof(flags) + strlen(domain) + 1;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err = ConnectToServer(&tmp, 0, setdomain_request, NULL, NULL, NULL);
+	if (err) return err;
+
+	hdr = create_hdr(setdomain_request, &len, &ptr, 0, tmp);
+	if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_string(domain, &ptr);
+	err = deliver_request(hdr, tmp);		// Will free hdr for us
+	DNSServiceRefDeallocate(tmp);
+	return err;
+	}
+
+static void handle_regservice_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
+	{
+	char name[256], regtype[kDNSServiceMaxDomainName], domain[kDNSServiceMaxDomainName];
+	get_string(&data, end, name, 256);
+	get_string(&data, end, regtype, kDNSServiceMaxDomainName);
+	get_string(&data, end, domain,  kDNSServiceMaxDomainName);
+	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_regservice_response: error reading result from daemon");
+	else ((DNSServiceRegisterReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_err, name, regtype, domain, sdr->AppContext);
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceRegister
+	(
+	DNSServiceRef                       *sdRef,
+	DNSServiceFlags                     flags,
+	uint32_t                            interfaceIndex,
+	const char                          *name,
+	const char                          *regtype,
+	const char                          *domain,
+	const char                          *host,
+	uint16_t                            PortInNetworkByteOrder,
+	uint16_t                            txtLen,
+	const void                          *txtRecord,
+	DNSServiceRegisterReply             callBack,
+	void                                *context
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err;
+	union { uint16_t s; u_char b[2]; } port = { PortInNetworkByteOrder };
+
+	if (!name) name = "";
+	if (!regtype) return kDNSServiceErr_BadParam;
+	if (!domain) domain = "";
+	if (!host) host = "";
+	if (!txtRecord) txtRecord = (void*)"";
+
+	// No callback must have auto-rename
+	if (!callBack && (flags & kDNSServiceFlagsNoAutoRename)) return kDNSServiceErr_BadParam;
+
+	err = ConnectToServer(sdRef, flags, reg_service_request, callBack ? handle_regservice_response : NULL, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	len = sizeof(DNSServiceFlags);
+	len += sizeof(uint32_t);  // interfaceIndex
+	len += strlen(name) + strlen(regtype) + strlen(domain) + strlen(host) + 4;
+	len += 2 * sizeof(uint16_t);  // port, txtLen
+	len += txtLen;
+
+	hdr = create_hdr(reg_service_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+	if (!callBack) hdr->ipc_flags |= IPC_FLAGS_NOREPLY;
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_string(name, &ptr);
+	put_string(regtype, &ptr);
+	put_string(domain, &ptr);
+	put_string(host, &ptr);
+	*ptr++ = port.b[0];
+	*ptr++ = port.b[1];
+	put_uint16(txtLen, &ptr);
+	put_rdata(txtLen, txtRecord, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+static void handle_enumeration_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
+	{
+	char domain[kDNSServiceMaxDomainName];
+	get_string(&data, end, domain, kDNSServiceMaxDomainName);
+	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_enumeration_response: error reading result from daemon");
+	else ((DNSServiceDomainEnumReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, domain, sdr->AppContext);
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains
+	(
+	DNSServiceRef             *sdRef,
+	DNSServiceFlags            flags,
+	uint32_t                   interfaceIndex,
+	DNSServiceDomainEnumReply  callBack,
+	void                      *context
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err;
+
+	int f1 = (flags & kDNSServiceFlagsBrowseDomains) != 0;
+	int f2 = (flags & kDNSServiceFlagsRegistrationDomains) != 0;
+	if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
+
+	err = ConnectToServer(sdRef, flags, enumeration_request, handle_enumeration_response, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	len = sizeof(DNSServiceFlags);
+	len += sizeof(uint32_t);
+
+	hdr = create_hdr(enumeration_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+static void ConnectionResponse(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *const data, const char *const end)
+	{
+	DNSRecordRef rref = cbh->ipc_hdr.client_context.context;
+	(void)data; // Unused
+
+	//printf("ConnectionResponse got %d\n", cbh->ipc_hdr.op);
+	if (cbh->ipc_hdr.op != reg_record_reply_op)
+		{
+		// When using kDNSServiceFlagsShareConnection, need to search the list of associated DNSServiceOps
+		// to find the one this response is intended for, and then call through to its ProcessReply handler.
+		// We start with our first subordinate DNSServiceRef -- don't want to accidentally match the parent DNSServiceRef.
+		DNSServiceOp *op = sdr->next;
+		while (op && (op->uid.u32[0] != cbh->ipc_hdr.client_context.u32[0] || op->uid.u32[1] != cbh->ipc_hdr.client_context.u32[1]))
+			op = op->next;
+		// Note: We may sometimes not find a matching DNSServiceOp, in the case where the client has
+		// cancelled the subordinate DNSServiceOp, but there are still messages in the pipeline from the daemon
+		if (op && op->ProcessReply) op->ProcessReply(op, cbh, data, end);
+		// WARNING: Don't touch op or sdr after this -- client may have called DNSServiceRefDeallocate
+		return;
+		}
+
+	if (sdr->op == connection_request)
+		rref->AppCallback(rref->sdr, rref, cbh->cb_flags, cbh->cb_err, rref->AppContext);
+	else
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub ConnectionResponse: sdr->op != connection_request");
+		rref->AppCallback(rref->sdr, rref, 0, kDNSServiceErr_Unknown, rref->AppContext);
+		}
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceCreateConnection(DNSServiceRef *sdRef)
+	{
+	char *ptr;
+	size_t len = 0;
+	ipc_msg_hdr *hdr;
+	DNSServiceErrorType err = ConnectToServer(sdRef, 0, connection_request, ConnectionResponse, NULL, NULL);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+	
+	hdr = create_hdr(connection_request, &len, &ptr, 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceRegisterRecord
+	(
+	DNSServiceRef                  sdRef,
+	DNSRecordRef                  *RecordRef,
+	DNSServiceFlags                flags,
+	uint32_t                       interfaceIndex,
+	const char                    *fullname,
+	uint16_t                       rrtype,
+	uint16_t                       rrclass,
+	uint16_t                       rdlen,
+	const void                    *rdata,
+	uint32_t                       ttl,
+	DNSServiceRegisterRecordReply  callBack,
+	void                          *context
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr = NULL;
+	DNSRecordRef rref = NULL;
+	DNSRecord **p;
+	int f1 = (flags & kDNSServiceFlagsShared) != 0;
+	int f2 = (flags & kDNSServiceFlagsUnique) != 0;
+	if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
+
+	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
+
+	if (!DNSServiceRefValid(sdRef))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
+		return kDNSServiceErr_BadReference;
+		}
+
+	if (sdRef->op != connection_request)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with non-DNSServiceCreateConnection DNSServiceRef %p %d", sdRef, sdRef->op);
+		return kDNSServiceErr_BadReference;
+		}
+
+	*RecordRef = NULL;
+
+	len = sizeof(DNSServiceFlags);
+	len += 2 * sizeof(uint32_t);  // interfaceIndex, ttl
+	len += 3 * sizeof(uint16_t);  // rrtype, rrclass, rdlen
+	len += strlen(fullname) + 1;
+	len += rdlen;
+
+	hdr = create_hdr(reg_record_request, &len, &ptr, 1, sdRef);
+	if (!hdr) return kDNSServiceErr_NoMemory;
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_string(fullname, &ptr);
+	put_uint16(rrtype, &ptr);
+	put_uint16(rrclass, &ptr);
+	put_uint16(rdlen, &ptr);
+	put_rdata(rdlen, rdata, &ptr);
+	put_uint32(ttl, &ptr);
+
+	rref = malloc(sizeof(DNSRecord));
+	if (!rref) { free(hdr); return kDNSServiceErr_NoMemory; }
+	rref->AppContext = context;
+	rref->AppCallback = callBack;
+	rref->record_index = sdRef->max_index++;
+	rref->sdr = sdRef;
+	rref->recnext = NULL;
+	*RecordRef = rref;
+	hdr->client_context.context = rref;
+	hdr->reg_index = rref->record_index;
+
+	p = &(sdRef)->rec;
+	while (*p) p = &(*p)->recnext;
+	*p = rref;
+
+	return deliver_request(hdr, sdRef);		// Will free hdr for us
+	}
+
+// sdRef returned by DNSServiceRegister()
+DNSServiceErrorType DNSSD_API DNSServiceAddRecord
+	(
+	DNSServiceRef    sdRef,
+	DNSRecordRef    *RecordRef,
+	DNSServiceFlags  flags,
+	uint16_t         rrtype,
+	uint16_t         rdlen,
+	const void      *rdata,
+	uint32_t         ttl
+	)
+	{
+	ipc_msg_hdr *hdr;
+	size_t len = 0;
+	char *ptr;
+	DNSRecordRef rref;
+	DNSRecord **p;
+
+	if (!sdRef)     { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with NULL DNSServiceRef");        return kDNSServiceErr_BadParam; }
+	if (!RecordRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with NULL DNSRecordRef pointer"); return kDNSServiceErr_BadParam; }
+	if (sdRef->op != reg_service_request)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with non-DNSServiceRegister DNSServiceRef %p %d", sdRef, sdRef->op);
+		return kDNSServiceErr_BadReference;
+		}
+
+	if (!DNSServiceRefValid(sdRef))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
+		return kDNSServiceErr_BadReference;
+		}
+
+	*RecordRef = NULL;
+
+	len += 2 * sizeof(uint16_t);  // rrtype, rdlen
+	len += rdlen;
+	len += sizeof(uint32_t);
+	len += sizeof(DNSServiceFlags);
+
+	hdr = create_hdr(add_record_request, &len, &ptr, 1, sdRef);
+	if (!hdr) return kDNSServiceErr_NoMemory;
+	put_flags(flags, &ptr);
+	put_uint16(rrtype, &ptr);
+	put_uint16(rdlen, &ptr);
+	put_rdata(rdlen, rdata, &ptr);
+	put_uint32(ttl, &ptr);
+
+	rref = malloc(sizeof(DNSRecord));
+	if (!rref) { free(hdr); return kDNSServiceErr_NoMemory; }
+	rref->AppContext = NULL;
+	rref->AppCallback = NULL;
+	rref->record_index = sdRef->max_index++;
+	rref->sdr = sdRef;
+	rref->recnext = NULL;
+	*RecordRef = rref;
+	hdr->reg_index = rref->record_index;
+
+	p = &(sdRef)->rec;
+	while (*p) p = &(*p)->recnext;
+	*p = rref;
+
+	return deliver_request(hdr, sdRef);		// Will free hdr for us
+	}
+
+// DNSRecordRef returned by DNSServiceRegisterRecord or DNSServiceAddRecord
+DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord
+	(
+	DNSServiceRef    sdRef,
+	DNSRecordRef     RecordRef,
+	DNSServiceFlags  flags,
+	uint16_t         rdlen,
+	const void      *rdata,
+	uint32_t         ttl
+	)
+	{
+	ipc_msg_hdr *hdr;
+	size_t len = 0;
+	char *ptr;
+
+	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceUpdateRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
+
+	if (!DNSServiceRefValid(sdRef))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceUpdateRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
+		return kDNSServiceErr_BadReference;
+		}
+
+	// Note: RecordRef is allowed to be NULL
+
+	len += sizeof(uint16_t);
+	len += rdlen;
+	len += sizeof(uint32_t);
+	len += sizeof(DNSServiceFlags);
+
+	hdr = create_hdr(update_record_request, &len, &ptr, 1, sdRef);
+	if (!hdr) return kDNSServiceErr_NoMemory;
+	hdr->reg_index = RecordRef ? RecordRef->record_index : TXT_RECORD_INDEX;
+	put_flags(flags, &ptr);
+	put_uint16(rdlen, &ptr);
+	put_rdata(rdlen, rdata, &ptr);
+	put_uint32(ttl, &ptr);
+	return deliver_request(hdr, sdRef);		// Will free hdr for us
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceRemoveRecord
+	(
+	DNSServiceRef    sdRef,
+	DNSRecordRef     RecordRef,
+	DNSServiceFlags  flags
+	)
+	{
+	ipc_msg_hdr *hdr;
+	size_t len = 0;
+	char *ptr;
+	DNSServiceErrorType err;
+
+	if (!sdRef)            { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
+	if (!RecordRef)        { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with NULL DNSRecordRef");  return kDNSServiceErr_BadParam; }
+	if (!sdRef->max_index) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with bad DNSServiceRef");  return kDNSServiceErr_BadReference; }
+
+	if (!DNSServiceRefValid(sdRef))
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
+		return kDNSServiceErr_BadReference;
+		}
+
+	len += sizeof(flags);
+	hdr = create_hdr(remove_record_request, &len, &ptr, 1, sdRef);
+	if (!hdr) return kDNSServiceErr_NoMemory;
+	hdr->reg_index = RecordRef->record_index;
+	put_flags(flags, &ptr);
+	err = deliver_request(hdr, sdRef);		// Will free hdr for us
+	if (!err)
+		{
+		// This RecordRef could have been allocated in DNSServiceRegisterRecord or DNSServiceAddRecord.
+		// If so, delink from the list before freeing
+		DNSRecord **p = &sdRef->rec;
+		while (*p && *p != RecordRef) p = &(*p)->recnext;
+		if (*p) *p = RecordRef->recnext;
+		free(RecordRef);
+		}
+	return err;
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord
+	(
+	DNSServiceFlags  flags,
+	uint32_t         interfaceIndex,
+	const char      *fullname,
+	uint16_t         rrtype,
+	uint16_t         rrclass,
+	uint16_t         rdlen,
+	const void      *rdata
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	DNSServiceOp *tmp;
+
+	DNSServiceErrorType err = ConnectToServer(&tmp, flags, reconfirm_record_request, NULL, NULL, NULL);
+	if (err) return err;
+
+	len = sizeof(DNSServiceFlags);
+	len += sizeof(uint32_t);
+	len += strlen(fullname) + 1;
+	len += 3 * sizeof(uint16_t);
+	len += rdlen;
+	hdr = create_hdr(reconfirm_record_request, &len, &ptr, 0, tmp);
+	if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_string(fullname, &ptr);
+	put_uint16(rrtype, &ptr);
+	put_uint16(rrclass, &ptr);
+	put_uint16(rdlen, &ptr);
+	put_rdata(rdlen, rdata, &ptr);
+
+	err = deliver_request(hdr, tmp);		// Will free hdr for us
+	DNSServiceRefDeallocate(tmp);
+	return err;
+	}
+
+static void handle_port_mapping_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
+	{
+	union { uint32_t l; u_char b[4]; } addr;
+	uint8_t protocol;
+	union { uint16_t s; u_char b[2]; } internalPort;
+	union { uint16_t s; u_char b[2]; } externalPort;
+	uint32_t ttl;
+
+	if (!data || data + 13 > end) goto fail;
+
+	addr        .b[0] = *data++;
+	addr        .b[1] = *data++;
+	addr        .b[2] = *data++;
+	addr        .b[3] = *data++;
+	protocol          = *data++;
+	internalPort.b[0] = *data++;
+	internalPort.b[1] = *data++;
+	externalPort.b[0] = *data++;
+	externalPort.b[1] = *data++;
+	ttl               = get_uint32(&data, end);
+	if (!data) goto fail;
+
+	((DNSServiceNATPortMappingReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, addr.l, protocol, internalPort.s, externalPort.s, ttl, sdr->AppContext);
+	return;
+	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
+
+fail:
+	syslog(LOG_WARNING, "dnssd_clientstub handle_port_mapping_response: error reading result from daemon");
+	}
+
+DNSServiceErrorType DNSSD_API DNSServiceNATPortMappingCreate
+	(
+	DNSServiceRef                       *sdRef,
+	DNSServiceFlags                     flags,
+	uint32_t                            interfaceIndex,
+	uint32_t                            protocol,     /* TCP and/or UDP */
+	uint16_t                            internalPortInNetworkByteOrder,
+	uint16_t                            externalPortInNetworkByteOrder,
+	uint32_t                            ttl,          /* time to live in seconds */
+	DNSServiceNATPortMappingReply       callBack,
+	void                                *context      /* may be NULL */
+	)
+	{
+	char *ptr;
+	size_t len;
+	ipc_msg_hdr *hdr;
+	union { uint16_t s; u_char b[2]; } internalPort = { internalPortInNetworkByteOrder };
+	union { uint16_t s; u_char b[2]; } externalPort = { externalPortInNetworkByteOrder };
+
+	DNSServiceErrorType err = ConnectToServer(sdRef, flags, port_mapping_request, handle_port_mapping_response, callBack, context);
+	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
+
+	len = sizeof(flags);
+	len += sizeof(interfaceIndex);
+	len += sizeof(protocol);
+	len += sizeof(internalPort);
+	len += sizeof(externalPort);
+	len += sizeof(ttl);
+
+	hdr = create_hdr(port_mapping_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
+	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
+
+	put_flags(flags, &ptr);
+	put_uint32(interfaceIndex, &ptr);
+	put_uint32(protocol, &ptr);
+	*ptr++ = internalPort.b[0];
+	*ptr++ = internalPort.b[1];
+	*ptr++ = externalPort.b[0];
+	*ptr++ = externalPort.b[1];
+	put_uint32(ttl, &ptr);
+
+	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
+	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
+	return err;
+	}
+
+#if _DNS_SD_LIBDISPATCH
+DNSServiceErrorType DNSSD_API DNSServiceSetDispatchQueue
+	(
+	DNSServiceRef service,
+	dispatch_queue_t queue
+	)
+	{
+	int dnssd_fd  = DNSServiceRefSockFD(service);
+	if (dnssd_fd == dnssd_InvalidSocket) return kDNSServiceErr_BadParam;
+	if (!queue)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub: DNSServiceSetDispatchQueue dispatch queue NULL");
+		return kDNSServiceErr_BadParam;
+		}
+	if (service->disp_queue)
+		{
+		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceSetDispatchQueue dispatch queue set already");
+		return kDNSServiceErr_BadParam;
+		}
+	if (service->disp_source)
+		{
+		syslog(LOG_WARNING, "DNSServiceSetDispatchQueue dispatch source set already");
+		return kDNSServiceErr_BadParam;
+		}
+	service->disp_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, dnssd_fd, 0, queue);
+	if (!service->disp_source)
+		{
+		syslog(LOG_WARNING, "DNSServiceSetDispatchQueue dispatch_source_create failed");
+		return kDNSServiceErr_NoMemory;
+		}
+	service->disp_queue = queue;
+	dispatch_source_set_event_handler(service->disp_source, ^{DNSServiceProcessResult(service);});
+	dispatch_source_set_cancel_handler(service->disp_source, ^{dnssd_close(dnssd_fd);});
+	dispatch_resume(service->disp_source);
+	return kDNSServiceErr_NoError;
+	}
+#endif // _DNS_SD_LIBDISPATCH