1/* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2003-2004, Apple Computer, Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1.  Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 * 2.  Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of its
14 *     contributors may be used to endorse or promote products derived from this
15 *     software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28	Change History (most recent first):
29
30Log: dnssd_clientstub.c,v $
31Revision 1.134  2009/06/19 23:13:24  cheshire
32<rdar://problem/6990066> Library: crash at handle_resolve_response + 183
33Added check for NULL after calling get_string
34
35Revision 1.133  2009/05/27 22:19:12  cheshire
36Remove questionable uses of errno
37
38Revision 1.132  2009/05/26 21:31:07  herscher
39Fix compile errors on Windows
40
41Revision 1.131  2009/05/26 04:48:19  herscher
42<rdar://problem/6844819> ExplorerPlugin does not work in B4W 2.0
43
44Revision 1.130  2009/05/02 01:29:48  mcguire
45<rdar://problem/6847601> spin calling DNSServiceProcessResult if errno was set to EWOULDBLOCK by an unrelated call
46
47Revision 1.129  2009/05/01 19:18:50  cheshire
48<rdar://problem/6843645> Using duplicate DNSServiceRefs when sharing a connection should return an error
49
50Revision 1.128  2009/04/01 21:09:35  herscher
51<rdar://problem/5925472> Current Bonjour code does not compile on Windows.
52
53Revision 1.127  2009/03/03 21:38:19  cheshire
54Improved "deliver_request ERROR" message
55
56Revision 1.126  2009/02/12 21:02:22  cheshire
57Commented out BPF "Sending fd" debugging message
58
59Revision 1.125  2009/02/12 20:28:32  cheshire
60Added some missing "const" declarations
61
62Revision 1.124  2009/02/10 01:44:39  cheshire
63<rdar://problem/6553729> DNSServiceUpdateRecord fails with kDNSServiceErr_BadReference for otherwise valid reference
64
65Revision 1.123  2009/01/19 00:49:21  mkrochma
66Type cast size_t values to unsigned long
67
68Revision 1.122  2009/01/18 03:51:37  mkrochma
69Fix warning in deliver_request on Linux
70
71Revision 1.121  2009/01/16 23:34:37  cheshire
72<rdar://problem/6504143> Uninitialized error code variable in error handling path in deliver_request
73
74Revision 1.120  2009/01/13 05:31:35  mkrochma
75<rdar://problem/6491367> Replace bzero, bcopy with mDNSPlatformMemZero, mDNSPlatformMemCopy, memset, memcpy
76
77Revision 1.119  2009/01/11 03:45:08  mkrochma
78Stop type casting num_written and num_read to int
79
80Revision 1.118  2009/01/11 03:20:06  mkrochma
81<rdar://problem/5797526> Fixes from Igor Seleznev to get mdnsd working on Solaris
82
83Revision 1.117  2009/01/10 22:03:43  mkrochma
84<rdar://problem/5797507> dnsextd fails to build on Linux
85
86Revision 1.116  2009/01/05 16:55:24  cheshire
87<rdar://problem/6452199> Stuck in "Examining available disks"
88ConnectionResponse handler was accidentally matching the parent DNSServiceRef before
89finding the appropriate subordinate DNSServiceRef for the operation in question.
90
91Revision 1.115  2008/12/18 00:19:11  mcguire
92<rdar://problem/6452199> Stuck in "Examining available disks"
93
94Revision 1.114  2008/12/10 02:11:43  cheshire
95ARMv5 compiler doesn't like uncommented stuff after #endif
96
97Revision 1.113  2008/12/04 03:23:05  cheshire
98Preincrement UID counter before we use it -- it helps with debugging if we know the all-zeroes ID should never appear
99
100Revision 1.112  2008/11/25 22:56:54  cheshire
101<rdar://problem/6377257> Make library code more defensive when client calls DNSServiceProcessResult with bad DNSServiceRef repeatedly
102
103Revision 1.111  2008/10/28 17:58:44  cheshire
104If client code keeps calling DNSServiceProcessResult repeatedly after an error, rate-limit the
105"DNSServiceProcessResult called with DNSServiceRef with no ProcessReply function" log messages
106
107Revision 1.110  2008/10/23 23:38:58  cheshire
108For Windows compatibility, instead of "strerror(errno)" use "dnssd_strerror(dnssd_errno)"
109
110Revision 1.109  2008/10/23 23:06:17  cheshire
111Removed () from dnssd_errno macro definition -- it's not a function and doesn't need any arguments
112
113Revision 1.108  2008/10/23 22:33:24  cheshire
114Changed "NOTE:" to "Note:" so that BBEdit 9 stops putting those comment lines into the funtion popup menu
115
116Revision 1.107  2008/10/20 21:50:11  cheshire
117Improved /dev/bpf error message
118
119Revision 1.106  2008/10/20 15:37:18  cheshire
120Log error message if opening /dev/bpf fails
121
122Revision 1.105  2008/09/27 01:26:34  cheshire
123Added handler to pass back BPF fd when requested
124
125Revision 1.104  2008/09/23 01:36:00  cheshire
126Updated code to use internalPort/externalPort terminology, instead of the old privatePort/publicPort
127terms (which could be misleading, because the word "private" suggests security).
128
129Revision 1.103  2008/07/24 18:51:13  cheshire
130Removed spurious spaces
131
132Revision 1.102  2008/02/25 19:16:19  cheshire
133<rdar://problem/5708953> Problems with DNSServiceGetAddrInfo API
134Was returning a bogus result (NULL pointer) when following a CNAME referral
135
136Revision 1.101  2008/02/20 21:18:21  cheshire
137<rdar://problem/5708953> DNSServiceGetAddrInfo doesn't set the scope ID of returned IPv6 link local addresses
138
139Revision 1.100  2007/11/02 17:56:37  cheshire
140<rdar://problem/5565787> Bonjour API broken for 64-bit apps (SCM_RIGHTS sendmsg fails)
141Wrap hack code in "#if APPLE_OSX_mDNSResponder" since (as far as we know right now)
142we don't want to do this on 64-bit Linux, Solaris, etc.
143
144Revision 1.99  2007/11/02 17:29:40  cheshire
145<rdar://problem/5565787> Bonjour API broken for 64-bit apps (SCM_RIGHTS sendmsg fails)
146To get 64-bit code that works, we need to NOT use the standard CMSG_* macros
147
148Revision 1.98  2007/11/01 19:52:43  cheshire
149Wrap debugging messages in "#if DEBUG_64BIT_SCM_RIGHTS"
150
151Revision 1.97  2007/11/01 19:45:55  cheshire
152Added "DEBUG_64BIT_SCM_RIGHTS" debugging code
153See <rdar://problem/5565787> Bonjour API broken for 64-bit apps (SCM_RIGHTS sendmsg fails)
154
155Revision 1.96  2007/11/01 15:59:33  cheshire
156umask not being set and restored properly in USE_NAMED_ERROR_RETURN_SOCKET code
157(no longer used on OS X, but relevant for other platforms)
158
159Revision 1.95  2007/10/31 20:07:16  cheshire
160<rdar://problem/5541498> Set SO_NOSIGPIPE on client socket
161Refinement: the cleanup code still needs to close listenfd when necesssary
162
163Revision 1.94  2007/10/15 22:34:27  cheshire
164<rdar://problem/5541498> Set SO_NOSIGPIPE on client socket
165
166Revision 1.93  2007/10/10 00:48:54  cheshire
167<rdar://problem/5526379> Daemon spins in an infinite loop when it doesn't get the control message it's expecting
168
169Revision 1.92  2007/10/06 03:44:44  cheshire
170Testing code for <rdar://problem/5526374> kqueue does not get a kevent to wake it up when a control message arrives on a socket
171
172Revision 1.91  2007/10/04 20:53:59  cheshire
173Improved debugging message when sendmsg fails
174
175Revision 1.90  2007/09/30 00:09:27  cheshire
176<rdar://problem/5492315> Pass socket fd via SCM_RIGHTS sendmsg instead of using named UDS in the filesystem
177
178Revision 1.89  2007/09/19 23:53:12  cheshire
179Fixed spelling mistake in comment
180
181Revision 1.88  2007/09/07 23:18:27  cheshire
182<rdar://problem/5467542> Change "client_context" to be an incrementing 64-bit counter
183
184Revision 1.87  2007/09/07 22:50:09  cheshire
185Added comment explaining moreptr field in DNSServiceOp structure
186
187Revision 1.86  2007/09/07 20:21:22  cheshire
188<rdar://problem/5462371> Make DNSSD library more resilient
189Add more comments explaining the moreptr/morebytes logic; don't allow DNSServiceRefSockFD or
190DNSServiceProcessResult for subordinate DNSServiceRefs created using kDNSServiceFlagsShareConnection
191
192Revision 1.85  2007/09/06 21:43:23  cheshire
193<rdar://problem/5462371> Make DNSSD library more resilient
194Allow DNSServiceRefDeallocate from within DNSServiceProcessResult callback
195
196Revision 1.84  2007/09/06 18:31:47  cheshire
197<rdar://problem/5462371> Make DNSSD library more resilient against client programming errors
198
199Revision 1.83  2007/08/28 20:45:45  cheshire
200Typo: ctrl_path needs to be 64 bytes, not 44 bytes
201
202Revision 1.82  2007/08/28 19:53:52  cheshire
203<rdar://problem/5437423> Bonjour failures when /tmp is not writable (e.g. when booted from installer disc)
204
205Revision 1.81  2007/07/27 00:03:20  cheshire
206Fixed compiler warnings that showed up now we're building optimized ("-Os")
207
208Revision 1.80  2007/07/23 22:12:53  cheshire
209<rdar://problem/5352299> Make mDNSResponder more defensive against malicious local clients
210
211Revision 1.79  2007/07/23 19:58:24  cheshire
212<rdar://problem/5351640> Library: Leak in DNSServiceRefDeallocate
213
214Revision 1.78  2007/07/12 20:42:27  cheshire
215<rdar://problem/5280735> If daemon is killed, return kDNSServiceErr_ServiceNotRunning
216to clients instead of kDNSServiceErr_Unknown
217
218Revision 1.77  2007/07/02 23:07:13  cheshire
219<rdar://problem/5308280> Reduce DNS-SD client syslog error messages
220
221Revision 1.76  2007/06/22 20:12:18  cheshire
222<rdar://problem/5277024> Leak in DNSServiceRefDeallocate
223
224Revision 1.75  2007/05/23 18:59:22  cheshire
225Remove unnecessary IPC_FLAGS_REUSE_SOCKET
226
227Revision 1.74  2007/05/22 18:28:38  cheshire
228Fixed compile errors in posix build
229
230Revision 1.73  2007/05/22 01:20:47  cheshire
231To determine current operation, need to check hdr->op, not sdr->op
232
233Revision 1.72  2007/05/22 01:07:42  cheshire
234<rdar://problem/3563675> API: Need a way to get version/feature information
235
236Revision 1.71  2007/05/18 23:55:22  cheshire
237<rdar://problem/4454655> Allow multiple register/browse/resolve operations to share single Unix Domain Socket
238
239Revision 1.70  2007/05/17 20:58:22  cheshire
240<rdar://problem/4647145> DNSServiceQueryRecord should return useful information with NXDOMAIN
241
242Revision 1.69  2007/05/16 16:58:27  cheshire
243<rdar://problem/4471320> Improve reliability of kDNSServiceFlagsMoreComing flag on multiprocessor machines
244As long as select indicates that data is waiting, loop within DNSServiceProcessResult delivering additional results
245
246Revision 1.68  2007/05/16 01:06:52  cheshire
247<rdar://problem/4471320> Improve reliability of kDNSServiceFlagsMoreComing flag on multiprocessor machines
248
249Revision 1.67  2007/05/15 21:57:16  cheshire
250<rdar://problem/4608220> Use dnssd_SocketValid(x) macro instead of just
251assuming that all negative values (or zero!) are invalid socket numbers
252
253Revision 1.66  2007/03/27 22:23:04  cheshire
254Add "dnssd_clientstub" prefix onto syslog messages
255
256Revision 1.65  2007/03/21 22:25:23  cheshire
257<rdar://problem/4172796> Remove client retry logic now that mDNSResponder uses launchd for its Unix Domain Socket
258
259Revision 1.64  2007/03/21 19:01:56  cheshire
260<rdar://problem/5078494> IPC code not 64-bit-savvy: assumes long=32bits, and short=16bits
261
262Revision 1.63  2007/03/12 21:48:21  cheshire
263<rdar://problem/5000162> Scary unlink errors in system.log
264Code was using memory after it had been freed
265
266Revision 1.62  2007/02/28 01:44:30  cheshire
267<rdar://problem/5027863> Byte order bugs in uDNS.c, uds_daemon.c, dnssd_clientstub.c
268
269Revision 1.61  2007/02/09 03:09:42  cheshire
270<rdar://problem/3869251> Cleanup: Stop returning kDNSServiceErr_Unknown so often
271<rdar://problem/4177924> API: Should return kDNSServiceErr_ServiceNotRunning
272
273Revision 1.60  2007/02/08 20:33:44  cheshire
274<rdar://problem/4985095> Leak on error path in DNSServiceProcessResult
275
276Revision 1.59  2007/01/05 08:30:55  cheshire
277Trim excessive "Log" checkin history from before 2006
278(checkin history still available via "cvs log ..." of course)
279
280Revision 1.58  2006/10/27 00:38:22  cheshire
281Strip accidental trailing whitespace from lines
282
283Revision 1.57  2006/09/30 01:06:54  cheshire
284Protocol field should be uint32_t
285
286Revision 1.56  2006/09/27 00:44:16  herscher
287<rdar://problem/4249761> API: Need DNSServiceGetAddrInfo()
288
289Revision 1.55  2006/09/26 01:52:01  herscher
290<rdar://problem/4245016> NAT Port Mapping API (for both NAT-PMP and UPnP Gateway Protocol)
291
292Revision 1.54  2006/09/21 21:34:09  cheshire
293<rdar://problem/4100000> Allow empty string name when using kDNSServiceFlagsNoAutoRename
294
295Revision 1.53  2006/09/07 04:43:12  herscher
296Fix compile error on Win32 platform by moving inclusion of syslog.h
297
298Revision 1.52  2006/08/15 23:04:21  mkrochma
299<rdar://problem/4090354> Client should be able to specify service name w/o callback
300
301Revision 1.51  2006/07/24 23:45:55  cheshire
302<rdar://problem/4605276> DNSServiceReconfirmRecord() should return error code
303
304Revision 1.50  2006/06/28 08:22:27  cheshire
305<rdar://problem/4605264> dnssd_clientstub.c needs to report unlink failures in syslog
306
307Revision 1.49  2006/06/28 07:58:59  cheshire
308Minor textual tidying
309
310*/
311
312#include <errno.h>
313#include <stdlib.h>
314
315#include "dnssd_ipc.h"
316
317#if defined(_WIN32)
318
319	#define _SSIZE_T
320	#include <CommonServices.h>
321	#include <DebugServices.h>
322	#include <winsock2.h>
323	#include <ws2tcpip.h>
324	#include <windows.h>
325	#include <stdarg.h>
326
327	#define sockaddr_mdns sockaddr_in
328	#define AF_MDNS AF_INET
329
330	// Disable warning: "'type cast' : from data pointer 'void *' to function pointer"
331	#pragma warning(disable:4055)
332
333	// Disable warning: "nonstandard extension, function/data pointer conversion in expression"
334	#pragma warning(disable:4152)
335
336	extern BOOL IsSystemServiceDisabled();
337
338	#define sleep(X) Sleep((X) * 1000)
339
340	static int g_initWinsock = 0;
341	#define LOG_WARNING kDebugLevelWarning
342	static void syslog( int priority, const char * message, ...)
343		{
344		va_list args;
345		int len;
346		char * buffer;
347		DWORD err = WSAGetLastError();
348		va_start( args, message );
349		len = _vscprintf( message, args ) + 1;
350		buffer = malloc( len * sizeof(char) );
351		if ( buffer ) { vsprintf( buffer, message, args ); OutputDebugString( buffer ); free( buffer ); }
352		WSASetLastError( err );
353		}
354#else
355
356	#include <sys/fcntl.h>		// For O_RDWR etc.
357	#include <sys/time.h>
358	#include <sys/socket.h>
359	#include <syslog.h>
360
361	#define sockaddr_mdns sockaddr_un
362	#define AF_MDNS AF_LOCAL
363
364#endif
365
366// <rdar://problem/4096913> Specifies how many times we'll try and connect to the server.
367
368#define DNSSD_CLIENT_MAXTRIES 4
369
370// Uncomment the line below to use the old error return mechanism of creating a temporary named socket (e.g. in /var/tmp)
371//#define USE_NAMED_ERROR_RETURN_SOCKET 1
372
373#ifndef CTL_PATH_PREFIX
374#define CTL_PATH_PREFIX "/var/tmp/dnssd_result_socket."
375#endif
376
377typedef struct
378	{
379	ipc_msg_hdr         ipc_hdr;
380	DNSServiceFlags     cb_flags;
381	uint32_t            cb_interface;
382	DNSServiceErrorType cb_err;
383	} CallbackHeader;
384
385typedef struct _DNSServiceRef_t DNSServiceOp;
386typedef struct _DNSRecordRef_t DNSRecord;
387
388// client stub callback to process message from server and deliver results to client application
389typedef void (*ProcessReplyFn)(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *msg, const char *const end);
390
391#define ValidatorBits 0x12345678
392#define DNSServiceRefValid(X) (dnssd_SocketValid((X)->sockfd) && (((X)->sockfd ^ (X)->validator) == ValidatorBits))
393
394// When using kDNSServiceFlagsShareConnection, there is one primary _DNSServiceOp_t, and zero or more subordinates
395// For the primary, the 'next' field points to the first subordinate, and its 'next' field points to the next, and so on.
396// For the primary, the 'primary' field is NULL; for subordinates the 'primary' field points back to the associated primary
397struct _DNSServiceRef_t
398	{
399	DNSServiceOp    *next;				// For shared connection
400	DNSServiceOp    *primary;			// For shared connection
401	dnssd_sock_t     sockfd;			// Connected socket between client and daemon
402	dnssd_sock_t     validator;			// Used to detect memory corruption, double disposals, etc.
403	client_context_t uid;				// For shared connection requests, each subordinate DNSServiceRef has its own ID,
404										// unique within the scope of the same shared parent DNSServiceRef
405	uint32_t         op;				// request_op_t or reply_op_t
406	uint32_t         max_index;			// Largest assigned record index - 0 if no additional records registered
407	uint32_t         logcounter;		// Counter used to control number of syslog messages we write
408	int             *moreptr;			// Set while DNSServiceProcessResult working on this particular DNSServiceRef
409	ProcessReplyFn   ProcessReply;		// Function pointer to the code to handle received messages
410	void            *AppCallback;		// Client callback function and context
411	void            *AppContext;
412	};
413
414struct _DNSRecordRef_t
415	{
416	void *AppContext;
417	DNSServiceRegisterRecordReply AppCallback;
418	DNSRecordRef recref;
419	uint32_t record_index;  // index is unique to the ServiceDiscoveryRef
420	DNSServiceOp *sdr;
421	};
422
423// Write len bytes. Return 0 on success, -1 on error
424static int write_all(dnssd_sock_t sd, char *buf, int len)
425	{
426	// Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; use an explicit while() loop instead.
427	//if (send(sd, buf, len, MSG_WAITALL) != len) return -1;
428	while (len)
429		{
430		ssize_t num_written = send(sd, buf, len, 0);
431		if (num_written < 0 || num_written > len)
432			{
433			// Should never happen. If it does, it indicates some OS bug,
434			// or that the mDNSResponder daemon crashed (which should never happen).
435			syslog(LOG_WARNING, "dnssd_clientstub write_all(%d) failed %zd/%d %d %s", sd, num_written, len,
436				(num_written < 0) ? dnssd_errno                 : 0,
437				(num_written < 0) ? dnssd_strerror(dnssd_errno) : "");
438			return -1;
439			}
440		buf += num_written;
441		len -= num_written;
442		}
443	return 0;
444	}
445
446enum { read_all_success = 0, read_all_fail = -1, read_all_wouldblock = -2 };
447
448// Read len bytes. Return 0 on success, read_all_fail on error, or read_all_wouldblock for
449static int read_all(dnssd_sock_t sd, char *buf, int len)
450	{
451	// Don't use "MSG_WAITALL"; it returns "Invalid argument" on some Linux versions; use an explicit while() loop instead.
452	//if (recv(sd, buf, len, MSG_WAITALL) != len) return -1;
453
454	while (len)
455		{
456		ssize_t num_read = recv(sd, buf, len, 0);
457		if ((num_read == 0) || (num_read < 0) || (num_read > len))
458			{
459			// Should never happen. If it does, it indicates some OS bug,
460			// or that the mDNSResponder daemon crashed (which should never happen).
461			syslog(LOG_WARNING, "dnssd_clientstub read_all(%d) failed %zd/%d %d %s", sd, num_read, len,
462				(num_read < 0) ? dnssd_errno                 : 0,
463				(num_read < 0) ? dnssd_strerror(dnssd_errno) : "");
464			return (num_read < 0 && dnssd_errno == dnssd_EWOULDBLOCK) ? read_all_wouldblock : read_all_fail;
465			}
466		buf += num_read;
467		len -= num_read;
468		}
469	return read_all_success;
470	}
471
472// Returns 1 if more bytes remain to be read on socket descriptor sd, 0 otherwise
473static int more_bytes(dnssd_sock_t sd)
474	{
475	struct timeval tv = { 0, 0 };
476	fd_set readfds;
477	FD_ZERO(&readfds);
478	FD_SET(sd, &readfds);
479	return(select(sd+1, &readfds, (fd_set*)NULL, (fd_set*)NULL, &tv) > 0);
480	}
481
482/* create_hdr
483 *
484 * allocate and initialize an ipc message header. Value of len should initially be the
485 * length of the data, and is set to the value of the data plus the header. data_start
486 * is set to point to the beginning of the data section. SeparateReturnSocket should be
487 * non-zero for calls that can't receive an immediate error return value on their primary
488 * socket, and therefore require a separate return path for the error code result.
489 * if zero, the path to a control socket is appended at the beginning of the message buffer.
490 * data_start is set past this string.
491 */
492static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int SeparateReturnSocket, DNSServiceOp *ref)
493	{
494	char *msg = NULL;
495	ipc_msg_hdr *hdr;
496	int datalen;
497#if !defined(USE_TCP_LOOPBACK)
498	char ctrl_path[64] = "";	// "/var/tmp/dnssd_result_socket.xxxxxxxxxx-xxx-xxxxxx"
499#endif
500
501	if (SeparateReturnSocket)
502		{
503#if defined(USE_TCP_LOOPBACK)
504		*len += 2;  // Allocate space for two-byte port number
505#elif defined(USE_NAMED_ERROR_RETURN_SOCKET)
506		struct timeval time;
507		if (gettimeofday(&time, NULL) < 0)
508			{ syslog(LOG_WARNING, "dnssd_clientstub create_hdr: gettimeofday failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno)); return NULL; }
509		sprintf(ctrl_path, "%s%d-%.3lx-%.6lu", CTL_PATH_PREFIX, (int)getpid(),
510			(unsigned long)(time.tv_sec & 0xFFF), (unsigned long)(time.tv_usec));
511		*len += strlen(ctrl_path) + 1;
512#else
513		*len += 1;		// Allocate space for single zero byte (empty C string)
514#endif
515		}
516
517	datalen = (int) *len;
518	*len += sizeof(ipc_msg_hdr);
519
520	// Write message to buffer
521	msg = malloc(*len);
522	if (!msg) { syslog(LOG_WARNING, "dnssd_clientstub create_hdr: malloc failed"); return NULL; }
523
524	memset(msg, 0, *len);
525	hdr = (ipc_msg_hdr *)msg;
526	hdr->version                = VERSION;
527	hdr->datalen                = datalen;
528	hdr->ipc_flags              = 0;
529	hdr->op                     = op;
530	hdr->client_context         = ref->uid;
531	hdr->reg_index              = 0;
532	*data_start = msg + sizeof(ipc_msg_hdr);
533#if defined(USE_TCP_LOOPBACK)
534	// Put dummy data in for the port, since we don't know what it is yet.
535	// The data will get filled in before we send the message. This happens in deliver_request().
536	if (SeparateReturnSocket) put_uint16(0, data_start);
537#else
538	if (SeparateReturnSocket) put_string(ctrl_path, data_start);
539#endif
540	return hdr;
541	}
542
543static void FreeDNSServiceOp(DNSServiceOp *x)
544	{
545	// We don't use our DNSServiceRefValid macro here because if we're cleaning up after a socket() call failed
546	// then sockfd could legitimately contain a failing value (e.g. dnssd_InvalidSocket)
547	if ((x->sockfd ^ x->validator) != ValidatorBits)
548		syslog(LOG_WARNING, "dnssd_clientstub attempt to dispose invalid DNSServiceRef %p %08X %08X", x, x->sockfd, x->validator);
549	else
550		{
551		x->next         = NULL;
552		x->primary      = NULL;
553		x->sockfd       = dnssd_InvalidSocket;
554		x->validator    = 0xDDDDDDDD;
555		x->op           = request_op_none;
556		x->max_index    = 0;
557		x->logcounter   = 0;
558		x->moreptr      = NULL;
559		x->ProcessReply = NULL;
560		x->AppCallback  = NULL;
561		x->AppContext   = NULL;
562		free(x);
563		}
564	}
565
566// Return a connected service ref (deallocate with DNSServiceRefDeallocate)
567static DNSServiceErrorType ConnectToServer(DNSServiceRef *ref, DNSServiceFlags flags, uint32_t op, ProcessReplyFn ProcessReply, void *AppCallback, void *AppContext)
568	{
569	#if APPLE_OSX_mDNSResponder
570	int NumTries = DNSSD_CLIENT_MAXTRIES;
571	#else
572	int NumTries = 0;
573	#endif
574
575	dnssd_sockaddr_t saddr;
576	DNSServiceOp *sdr;
577
578	if (!ref) { syslog(LOG_WARNING, "dnssd_clientstub DNSService operation with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
579
580	if (flags & kDNSServiceFlagsShareConnection)
581		{
582		if (!*ref)
583			{
584			syslog(LOG_WARNING, "dnssd_clientstub kDNSServiceFlagsShareConnection used with NULL DNSServiceRef");
585			return kDNSServiceErr_BadParam;
586			}
587		if (!DNSServiceRefValid(*ref) || (*ref)->op != connection_request || (*ref)->primary)
588			{
589			syslog(LOG_WARNING, "dnssd_clientstub kDNSServiceFlagsShareConnection used with invalid DNSServiceRef %p %08X %08X",
590				(*ref), (*ref)->sockfd, (*ref)->validator);
591			*ref = NULL;
592			return kDNSServiceErr_BadReference;
593			}
594		}
595
596	#if defined(_WIN32)
597	if (!g_initWinsock)
598		{
599		WSADATA wsaData;
600		g_initWinsock = 1;
601		if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) { *ref = NULL; return kDNSServiceErr_ServiceNotRunning; }
602		}
603	// <rdar://problem/4096913> If the system service is disabled, we only want to try to connect once
604	if (IsSystemServiceDisabled()) NumTries = DNSSD_CLIENT_MAXTRIES;
605	#endif
606
607	sdr = malloc(sizeof(DNSServiceOp));
608	if (!sdr) { syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: malloc failed"); *ref = NULL; return kDNSServiceErr_NoMemory; }
609	sdr->next          = NULL;
610	sdr->primary       = NULL;
611	sdr->sockfd        = dnssd_InvalidSocket;
612	sdr->validator     = sdr->sockfd ^ ValidatorBits;
613	sdr->op            = op;
614	sdr->max_index     = 0;
615	sdr->logcounter    = 0;
616	sdr->moreptr       = NULL;
617	sdr->uid.u32[0]    = 0;
618	sdr->uid.u32[1]    = 0;
619	sdr->ProcessReply  = ProcessReply;
620	sdr->AppCallback   = AppCallback;
621	sdr->AppContext    = AppContext;
622
623	if (flags & kDNSServiceFlagsShareConnection)
624		{
625		DNSServiceOp **p = &(*ref)->next;		// Append ourselves to end of primary's list
626		while (*p) p = &(*p)->next;
627		*p = sdr;
628		// Preincrement counter before we use it -- it helps with debugging if we know the all-zeroes ID should never appear
629		if (++(*ref)->uid.u32[0] == 0) ++(*ref)->uid.u32[1];	// In parent DNSServiceOp increment UID counter
630		sdr->primary    = *ref;					// Set our primary pointer
631		sdr->sockfd     = (*ref)->sockfd;		// Inherit primary's socket
632		sdr->validator  = (*ref)->validator;
633		sdr->uid        = (*ref)->uid;
634		//printf("ConnectToServer sharing socket %d\n", sdr->sockfd);
635		}
636	else
637		{
638		#ifdef SO_NOSIGPIPE
639		int optval = 1;
640		#endif
641		*ref = NULL;
642		sdr->sockfd    = socket(AF_DNSSD, SOCK_STREAM, 0);
643		sdr->validator = sdr->sockfd ^ ValidatorBits;
644		if (!dnssd_SocketValid(sdr->sockfd))
645			{
646			syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: socket failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
647			FreeDNSServiceOp(sdr);
648			return kDNSServiceErr_NoMemory;
649			}
650		#ifdef SO_NOSIGPIPE
651		// Some environments (e.g. OS X) support turning off SIGPIPE for a socket
652		if (setsockopt(sdr->sockfd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)
653			syslog(LOG_WARNING, "dnssd_clientstub ConnectToServer: SO_NOSIGPIPE failed %d %s", dnssd_errno, dnssd_strerror(dnssd_errno));
654		#endif
655		#if defined(USE_TCP_LOOPBACK)
656		saddr.sin_family      = AF_INET;
657		saddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
658		saddr.sin_port        = htons(MDNS_TCP_SERVERPORT);
659		#else
660		saddr.sun_family      = AF_LOCAL;
661		strcpy(saddr.sun_path, MDNS_UDS_SERVERPATH);
662		#endif
663
664		while (1)
665			{
666			int err = connect(sdr->sockfd, (struct sockaddr *) &saddr, sizeof(saddr));
667			if (!err) break; // If we succeeded, return sdr
668			// If we failed, then it may be because the daemon is still launching.
669			// This can happen for processes that launch early in the boot process, while the
670			// daemon is still coming up. Rather than fail here, we'll wait a bit and try again.
671			// If, after four seconds, we still can't connect to the daemon,
672			// then we give up and return a failure code.
673			if (++NumTries < DNSSD_CLIENT_MAXTRIES) sleep(1); // Sleep a bit, then try again
674			else { dnssd_close(sdr->sockfd); FreeDNSServiceOp(sdr); return kDNSServiceErr_ServiceNotRunning; }
675			}
676		//printf("ConnectToServer opened socket %d\n", sdr->sockfd);
677		}
678
679	*ref = sdr;
680	return kDNSServiceErr_NoError;
681	}
682
683#define deliver_request_bailout(MSG) \
684	do { syslog(LOG_WARNING, "dnssd_clientstub deliver_request: %s failed %d (%s)", (MSG), dnssd_errno, dnssd_strerror(dnssd_errno)); goto cleanup; } while(0)
685
686static DNSServiceErrorType deliver_request(ipc_msg_hdr *hdr, DNSServiceOp *sdr)
687	{
688	uint32_t datalen = hdr->datalen;	// We take a copy here because we're going to convert hdr->datalen to network byte order
689	#if defined(USE_TCP_LOOPBACK) || defined(USE_NAMED_ERROR_RETURN_SOCKET)
690	char *const data = (char *)hdr + sizeof(ipc_msg_hdr);
691	#endif
692	dnssd_sock_t listenfd = dnssd_InvalidSocket, errsd = dnssd_InvalidSocket;
693	DNSServiceErrorType err = kDNSServiceErr_Unknown;	// Default for the "goto cleanup" cases
694	int MakeSeparateReturnSocket = 0;
695
696	// Note: need to check hdr->op, not sdr->op.
697	// hdr->op contains the code for the specific operation we're currently doing, whereas sdr->op
698	// contains the original parent DNSServiceOp (e.g. for an add_record_request, hdr->op will be
699	// add_record_request but the parent sdr->op will be connection_request or reg_service_request)
700	if (sdr->primary ||
701		hdr->op == reg_record_request || hdr->op == add_record_request || hdr->op == update_record_request || hdr->op == remove_record_request)
702		MakeSeparateReturnSocket = 1;
703
704	if (!DNSServiceRefValid(sdr))
705		{
706		syslog(LOG_WARNING, "dnssd_clientstub deliver_request: invalid DNSServiceRef %p %08X %08X", sdr, sdr->sockfd, sdr->validator);
707		return kDNSServiceErr_BadReference;
708		}
709
710	if (!hdr) { syslog(LOG_WARNING, "dnssd_clientstub deliver_request: !hdr"); return kDNSServiceErr_Unknown; }
711
712	if (MakeSeparateReturnSocket)
713		{
714		#if defined(USE_TCP_LOOPBACK)
715			{
716			union { uint16_t s; u_char b[2]; } port;
717			dnssd_sockaddr_t caddr;
718			dnssd_socklen_t len = (dnssd_socklen_t) sizeof(caddr);
719			listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
720			if (!dnssd_SocketValid(listenfd)) deliver_request_bailout("TCP socket");
721
722			caddr.sin_family      = AF_INET;
723			caddr.sin_port        = 0;
724			caddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
725			if (bind(listenfd, (struct sockaddr*) &caddr, sizeof(caddr)) < 0) deliver_request_bailout("TCP bind");
726			if (getsockname(listenfd, (struct sockaddr*) &caddr, &len)   < 0) deliver_request_bailout("TCP getsockname");
727			if (listen(listenfd, 1)                                      < 0) deliver_request_bailout("TCP listen");
728			port.s = caddr.sin_port;
729			data[0] = port.b[0];  // don't switch the byte order, as the
730			data[1] = port.b[1];  // daemon expects it in network byte order
731			}
732		#elif defined(USE_NAMED_ERROR_RETURN_SOCKET)
733			{
734			mode_t mask;
735			int bindresult;
736			dnssd_sockaddr_t caddr;
737			listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
738			if (!dnssd_SocketValid(listenfd)) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET socket");
739
740			caddr.sun_family = AF_LOCAL;
741			// According to Stevens (section 3.2), there is no portable way to
742			// determine whether sa_len is defined on a particular platform.
743			#ifndef NOT_HAVE_SA_LEN
744			caddr.sun_len = sizeof(struct sockaddr_un);
745			#endif
746			strcpy(caddr.sun_path, data);
747			mask = umask(0);
748			bindresult = bind(listenfd, (struct sockaddr *)&caddr, sizeof(caddr));
749			umask(mask);
750			if (bindresult          < 0) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET bind");
751			if (listen(listenfd, 1) < 0) deliver_request_bailout("USE_NAMED_ERROR_RETURN_SOCKET listen");
752			}
753		#else
754			{
755			dnssd_sock_t sp[2];
756			if (socketpair(AF_DNSSD, SOCK_STREAM, 0, sp) < 0) deliver_request_bailout("socketpair");
757			else
758				{
759				errsd    = sp[0];	// We'll read our four-byte error code from sp[0]
760				listenfd = sp[1];	// We'll send sp[1] to the daemon
761				}
762			}
763		#endif
764		}
765
766#if !defined(USE_TCP_LOOPBACK) && !defined(USE_NAMED_ERROR_RETURN_SOCKET)
767	// If we're going to make a separate error return socket, and pass it to the daemon
768	// using sendmsg, then we'll hold back one data byte to go with it.
769	// On some versions of Unix (including Leopard) sending a control message without
770	// any associated data does not work reliably -- e.g. one particular issue we ran
771	// into is that if the receiving program is in a kqueue loop waiting to be notified
772	// of the received message, it doesn't get woken up when the control message arrives.
773	if (MakeSeparateReturnSocket || sdr->op == send_bpf) datalen--;		// Okay to use sdr->op when checking for op == send_bpf
774#endif
775
776	// At this point, our listening socket is set up and waiting, if necessary, for the daemon to connect back to
777	ConvertHeaderBytes(hdr);
778	//syslog(LOG_WARNING, "dnssd_clientstub deliver_request writing %lu bytes", (unsigned long)(datalen + sizeof(ipc_msg_hdr)));
779	//if (MakeSeparateReturnSocket) syslog(LOG_WARNING, "dnssd_clientstub deliver_request name is %s", data);
780#if TEST_SENDING_ONE_BYTE_AT_A_TIME
781	unsigned int i;
782	for (i=0; i<datalen + sizeof(ipc_msg_hdr); i++)
783		{
784		syslog(LOG_WARNING, "dnssd_clientstub deliver_request writing %d", i);
785		if (write_all(sdr->sockfd, ((char *)hdr)+i, 1) < 0)
786			{ syslog(LOG_WARNING, "write_all (byte %u) failed", i); goto cleanup; }
787		usleep(10000);
788		}
789#else
790	if (write_all(sdr->sockfd, (char *)hdr, datalen + sizeof(ipc_msg_hdr)) < 0)
791		{
792		syslog(LOG_WARNING, "dnssd_clientstub deliver_request ERROR: write_all(%d, %lu bytes) failed",
793			sdr->sockfd, (unsigned long)(datalen + sizeof(ipc_msg_hdr)));
794		goto cleanup;
795		}
796#endif
797
798	if (!MakeSeparateReturnSocket) errsd = sdr->sockfd;
799	if (MakeSeparateReturnSocket || sdr->op == send_bpf)	// Okay to use sdr->op when checking for op == send_bpf
800		{
801#if defined(USE_TCP_LOOPBACK) || defined(USE_NAMED_ERROR_RETURN_SOCKET)
802		// At this point we may block in accept for a few milliseconds waiting for the daemon to connect back to us,
803		// but that's okay -- the daemon is a trusted service and we know if won't take more than a few milliseconds to respond.
804		dnssd_sockaddr_t daddr;
805		dnssd_socklen_t len = sizeof(daddr);
806		errsd = accept(listenfd, (struct sockaddr *)&daddr, &len);
807		if (!dnssd_SocketValid(errsd)) deliver_request_bailout("accept");
808#else
809
810#if APPLE_OSX_mDNSResponder
811// On Leopard, the stock definitions of the CMSG_* macros in /usr/include/sys/socket.h,
812// while arguably correct in theory, nonetheless in practice produce code that doesn't work on 64-bit machines
813// For details see <rdar://problem/5565787> Bonjour API broken for 64-bit apps (SCM_RIGHTS sendmsg fails)
814#undef  CMSG_DATA
815#define CMSG_DATA(cmsg) ((unsigned char *)(cmsg) + (sizeof(struct cmsghdr)))
816#undef  CMSG_SPACE
817#define CMSG_SPACE(l)   ((sizeof(struct cmsghdr)) + (l))
818#undef  CMSG_LEN
819#define CMSG_LEN(l)     ((sizeof(struct cmsghdr)) + (l))
820#endif
821
822		struct iovec vec = { ((char *)hdr) + sizeof(ipc_msg_hdr) + datalen, 1 }; // Send the last byte along with the SCM_RIGHTS
823		struct msghdr msg;
824		struct cmsghdr *cmsg;
825		char cbuf[CMSG_SPACE(sizeof(dnssd_sock_t))];
826
827		if (sdr->op == send_bpf)	// Okay to use sdr->op when checking for op == send_bpf
828			{
829			int i;
830			char p[12];		// Room for "/dev/bpf999" with terminating null
831			for (i=0; i<100; i++)
832				{
833				snprintf(p, sizeof(p), "/dev/bpf%d", i);
834				listenfd = open(p, O_RDWR, 0);
835				//if (dnssd_SocketValid(listenfd)) syslog(LOG_WARNING, "Sending fd %d for %s", listenfd, p);
836				if (!dnssd_SocketValid(listenfd) && dnssd_errno != EBUSY)
837					syslog(LOG_WARNING, "Error opening %s %d (%s)", p, dnssd_errno, dnssd_strerror(dnssd_errno));
838				if (dnssd_SocketValid(listenfd) || dnssd_errno != EBUSY) break;
839				}
840			}
841
842		msg.msg_name       = 0;
843		msg.msg_namelen    = 0;
844		msg.msg_iov        = &vec;
845		msg.msg_iovlen     = 1;
846		msg.msg_control    = cbuf;
847		msg.msg_controllen = CMSG_LEN(sizeof(dnssd_sock_t));
848		msg.msg_flags      = 0;
849		cmsg = CMSG_FIRSTHDR(&msg);
850		cmsg->cmsg_len     = CMSG_LEN(sizeof(dnssd_sock_t));
851		cmsg->cmsg_level   = SOL_SOCKET;
852		cmsg->cmsg_type    = SCM_RIGHTS;
853		*((dnssd_sock_t *)CMSG_DATA(cmsg)) = listenfd;
854
855#if TEST_KQUEUE_CONTROL_MESSAGE_BUG
856		sleep(1);
857#endif
858
859#if DEBUG_64BIT_SCM_RIGHTS
860		syslog(LOG_WARNING, "dnssd_clientstub sendmsg read sd=%d write sd=%d %ld %ld %ld/%ld/%ld/%ld",
861			errsd, listenfd, sizeof(dnssd_sock_t), sizeof(void*),
862			sizeof(struct cmsghdr) + sizeof(dnssd_sock_t),
863			CMSG_LEN(sizeof(dnssd_sock_t)), (long)CMSG_SPACE(sizeof(dnssd_sock_t)),
864			(long)((char*)CMSG_DATA(cmsg) + 4 - cbuf));
865#endif // DEBUG_64BIT_SCM_RIGHTS
866
867		if (sendmsg(sdr->sockfd, &msg, 0) < 0)
868			{
869			syslog(LOG_WARNING, "dnssd_clientstub deliver_request ERROR: sendmsg failed read sd=%d write sd=%d errno %d (%s)",
870				errsd, listenfd, dnssd_errno, dnssd_strerror(dnssd_errno));
871			err = kDNSServiceErr_Incompatible;
872			goto cleanup;
873			}
874
875#if DEBUG_64BIT_SCM_RIGHTS
876		syslog(LOG_WARNING, "dnssd_clientstub sendmsg read sd=%d write sd=%d okay", errsd, listenfd);
877#endif // DEBUG_64BIT_SCM_RIGHTS
878
879#endif
880		// Close our end of the socketpair *before* blocking in read_all to get the four-byte error code.
881		// Otherwise, if the daemon closes our socket (or crashes), we block in read_all() forever
882		// because the socket is not closed (we still have an open reference to it ourselves).
883		dnssd_close(listenfd);
884		listenfd = dnssd_InvalidSocket;		// Make sure we don't close it a second time in the cleanup handling below
885		}
886
887	// At this point we may block in read_all for a few milliseconds waiting for the daemon to send us the error code,
888	// but that's okay -- the daemon is a trusted service and we know if won't take more than a few milliseconds to respond.
889	if (sdr->op == send_bpf)	// Okay to use sdr->op when checking for op == send_bpf
890		err = kDNSServiceErr_NoError;
891	else if (read_all(errsd, (char*)&err, (int)sizeof(err)) < 0)
892		err = kDNSServiceErr_ServiceNotRunning;	// On failure read_all will have written a message to syslog for us
893	else
894		err = ntohl(err);
895
896	//syslog(LOG_WARNING, "dnssd_clientstub deliver_request: retrieved error code %d", err);
897
898cleanup:
899	if (MakeSeparateReturnSocket)
900		{
901		if (dnssd_SocketValid(listenfd)) dnssd_close(listenfd);
902		if (dnssd_SocketValid(errsd))    dnssd_close(errsd);
903#if defined(USE_NAMED_ERROR_RETURN_SOCKET)
904		// syslog(LOG_WARNING, "dnssd_clientstub deliver_request: removing UDS: %s", data);
905		if (unlink(data) != 0)
906			syslog(LOG_WARNING, "dnssd_clientstub WARNING: unlink(\"%s\") failed errno %d (%s)", data, dnssd_errno, dnssd_strerror(dnssd_errno));
907		// else syslog(LOG_WARNING, "dnssd_clientstub deliver_request: removed UDS: %s", data);
908#endif
909		}
910
911	free(hdr);
912	return err;
913	}
914
915int DNSSD_API DNSServiceRefSockFD(DNSServiceRef sdRef)
916	{
917	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD called with NULL DNSServiceRef"); return dnssd_InvalidSocket; }
918
919	if (!DNSServiceRefValid(sdRef))
920		{
921		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD called with invalid DNSServiceRef %p %08X %08X",
922			sdRef, sdRef->sockfd, sdRef->validator);
923		return dnssd_InvalidSocket;
924		}
925
926	if (sdRef->primary)
927		{
928		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefSockFD undefined for kDNSServiceFlagsShareConnection subordinate DNSServiceRef %p", sdRef);
929		return dnssd_InvalidSocket;
930		}
931
932	return (int) sdRef->sockfd;
933	}
934
935// Handle reply from server, calling application client callback. If there is no reply
936// from the daemon on the socket contained in sdRef, the call will block.
937DNSServiceErrorType DNSSD_API DNSServiceProcessResult(DNSServiceRef sdRef)
938	{
939	int morebytes = 0;
940
941	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
942
943	if (!DNSServiceRefValid(sdRef))
944		{
945		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
946		return kDNSServiceErr_BadReference;
947		}
948
949	if (sdRef->primary)
950		{
951		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult undefined for kDNSServiceFlagsShareConnection subordinate DNSServiceRef %p", sdRef);
952		return kDNSServiceErr_BadReference;
953		}
954
955	if (!sdRef->ProcessReply)
956		{
957		static int num_logs = 0;
958		if (num_logs < 10) syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult called with DNSServiceRef with no ProcessReply function");
959		if (num_logs < 1000) num_logs++; else sleep(1);
960		return kDNSServiceErr_BadReference;
961		}
962
963	do
964		{
965		CallbackHeader cbh;
966		char *data;
967
968		// return NoError on EWOULDBLOCK. This will handle the case
969		// where a non-blocking socket is told there is data, but it was a false positive.
970		// On error, read_all will write a message to syslog for us, so don't need to duplicate that here
971		// Note: If we want to properly support using non-blocking sockets in the future
972		int result = read_all(sdRef->sockfd, (void *)&cbh.ipc_hdr, sizeof(cbh.ipc_hdr));
973		if (result == read_all_fail)
974			{
975			sdRef->ProcessReply = NULL;
976			return kDNSServiceErr_ServiceNotRunning;
977			}
978		else if (result == read_all_wouldblock)
979			{
980			if (morebytes && sdRef->logcounter < 100)
981				{
982				sdRef->logcounter++;
983				syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult error: select indicated data was waiting but read_all returned EWOULDBLOCK");
984				}
985			return kDNSServiceErr_NoError;
986			}
987
988		ConvertHeaderBytes(&cbh.ipc_hdr);
989		if (cbh.ipc_hdr.version != VERSION)
990			{
991			syslog(LOG_WARNING, "dnssd_clientstub DNSServiceProcessResult daemon version %d does not match client version %d", cbh.ipc_hdr.version, VERSION);
992			sdRef->ProcessReply = NULL;
993			return kDNSServiceErr_Incompatible;
994			}
995
996		data = malloc(cbh.ipc_hdr.datalen);
997		if (!data) return kDNSServiceErr_NoMemory;
998		if (read_all(sdRef->sockfd, data, cbh.ipc_hdr.datalen) < 0) // On error, read_all will write a message to syslog for us
999			{
1000			free(data);
1001			sdRef->ProcessReply = NULL;
1002			return kDNSServiceErr_ServiceNotRunning;
1003			}
1004		else
1005			{
1006			const char *ptr = data;
1007			cbh.cb_flags     = get_flags     (&ptr, data + cbh.ipc_hdr.datalen);
1008			cbh.cb_interface = get_uint32    (&ptr, data + cbh.ipc_hdr.datalen);
1009			cbh.cb_err       = get_error_code(&ptr, data + cbh.ipc_hdr.datalen);
1010
1011			// CAUTION: We have to handle the case where the client calls DNSServiceRefDeallocate from within the callback function.
1012			// To do this we set moreptr to point to morebytes. If the client does call DNSServiceRefDeallocate(),
1013			// then that routine will clear morebytes for us, and cause us to exit our loop.
1014			morebytes = more_bytes(sdRef->sockfd);
1015			if (morebytes)
1016				{
1017				cbh.cb_flags |= kDNSServiceFlagsMoreComing;
1018				sdRef->moreptr = &morebytes;
1019				}
1020			if (ptr) sdRef->ProcessReply(sdRef, &cbh, ptr, data + cbh.ipc_hdr.datalen);
1021			// Careful code here:
1022			// If morebytes is non-zero, that means we set sdRef->moreptr above, and the operation was not
1023			// cancelled out from under us, so now we need to clear sdRef->moreptr so we don't leave a stray
1024			// dangling pointer pointing to a long-gone stack variable.
1025			// If morebytes is zero, then one of two thing happened:
1026			// (a) morebytes was 0 above, so we didn't set sdRef->moreptr, so we don't need to clear it
1027			// (b) morebytes was 1 above, and we set sdRef->moreptr, but the operation was cancelled (with DNSServiceRefDeallocate()),
1028			//     so we MUST NOT try to dereference our stale sdRef pointer.
1029			if (morebytes) sdRef->moreptr = NULL;
1030			}
1031		free(data);
1032		} while (morebytes);
1033
1034	return kDNSServiceErr_NoError;
1035	}
1036
1037void DNSSD_API DNSServiceRefDeallocate(DNSServiceRef sdRef)
1038	{
1039	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefDeallocate called with NULL DNSServiceRef"); return; }
1040
1041	if (!DNSServiceRefValid(sdRef))		// Also verifies dnssd_SocketValid(sdRef->sockfd) for us too
1042		{
1043		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRefDeallocate called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1044		return;
1045		}
1046
1047	// 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
1048	if (sdRef->moreptr) *(sdRef->moreptr) = 0;
1049
1050	if (sdRef->primary)		// If this is a subordinate DNSServiceOp, just send a 'stop' command
1051		{
1052		DNSServiceOp **p = &sdRef->primary->next;
1053		while (*p && *p != sdRef) p = &(*p)->next;
1054		if (*p)
1055			{
1056			char *ptr;
1057			size_t len = 0;
1058			ipc_msg_hdr *hdr = create_hdr(cancel_request, &len, &ptr, 0, sdRef);
1059			ConvertHeaderBytes(hdr);
1060			write_all(sdRef->sockfd, (char *)hdr, len);
1061			free(hdr);
1062			*p = sdRef->next;
1063			FreeDNSServiceOp(sdRef);
1064			}
1065		}
1066	else					// else, make sure to terminate all subordinates as well
1067		{
1068		dnssd_close(sdRef->sockfd);
1069		while (sdRef)
1070			{
1071			DNSServiceOp *p = sdRef;
1072			sdRef = sdRef->next;
1073			FreeDNSServiceOp(p);
1074			}
1075		}
1076	}
1077
1078DNSServiceErrorType DNSSD_API DNSServiceGetProperty(const char *property, void *result, uint32_t *size)
1079	{
1080	char *ptr;
1081	size_t len = strlen(property) + 1;
1082	ipc_msg_hdr *hdr;
1083	DNSServiceOp *tmp;
1084	uint32_t actualsize;
1085
1086	DNSServiceErrorType err = ConnectToServer(&tmp, 0, getproperty_request, NULL, NULL, NULL);
1087	if (err) return err;
1088
1089	hdr = create_hdr(getproperty_request, &len, &ptr, 0, tmp);
1090	if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
1091
1092	put_string(property, &ptr);
1093	err = deliver_request(hdr, tmp);		// Will free hdr for us
1094	if (read_all(tmp->sockfd, (char*)&actualsize, (int)sizeof(actualsize)) < 0)
1095		{ DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
1096
1097	actualsize = ntohl(actualsize);
1098	if (read_all(tmp->sockfd, (char*)result, actualsize < *size ? actualsize : *size) < 0)
1099		{ DNSServiceRefDeallocate(tmp); return kDNSServiceErr_ServiceNotRunning; }
1100	DNSServiceRefDeallocate(tmp);
1101
1102	// Swap version result back to local process byte order
1103	if (!strcmp(property, kDNSServiceProperty_DaemonVersion) && *size >= 4)
1104		*(uint32_t*)result = ntohl(*(uint32_t*)result);
1105
1106	*size = actualsize;
1107	return kDNSServiceErr_NoError;
1108	}
1109
1110static void handle_resolve_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *end)
1111	{
1112	char fullname[kDNSServiceMaxDomainName];
1113	char target[kDNSServiceMaxDomainName];
1114	uint16_t txtlen;
1115	union { uint16_t s; u_char b[2]; } port;
1116	unsigned char *txtrecord;
1117
1118	get_string(&data, end, fullname, kDNSServiceMaxDomainName);
1119	get_string(&data, end, target,   kDNSServiceMaxDomainName);
1120	if (!data || data + 2 > end) data = NULL;
1121	else
1122		{
1123		port.b[0] = *data++;
1124		port.b[1] = *data++;
1125		}
1126	txtlen = get_uint16(&data, end);
1127	txtrecord = (unsigned char *)get_rdata(&data, end, txtlen);
1128
1129	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_resolve_response: error reading result from daemon");
1130	else ((DNSServiceResolveReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, fullname, target, port.s, txtlen, txtrecord, sdr->AppContext);
1131	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1132	}
1133
1134DNSServiceErrorType DNSSD_API DNSServiceResolve
1135	(
1136	DNSServiceRef                 *sdRef,
1137	DNSServiceFlags               flags,
1138	uint32_t                      interfaceIndex,
1139	const char                    *name,
1140	const char                    *regtype,
1141	const char                    *domain,
1142	DNSServiceResolveReply        callBack,
1143	void                          *context
1144	)
1145	{
1146	char *ptr;
1147	size_t len;
1148	ipc_msg_hdr *hdr;
1149	DNSServiceErrorType err;
1150
1151	if (!name || !regtype || !domain || !callBack) return kDNSServiceErr_BadParam;
1152
1153	err = ConnectToServer(sdRef, flags, resolve_request, handle_resolve_response, callBack, context);
1154	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1155
1156	// Calculate total message length
1157	len = sizeof(flags);
1158	len += sizeof(interfaceIndex);
1159	len += strlen(name) + 1;
1160	len += strlen(regtype) + 1;
1161	len += strlen(domain) + 1;
1162
1163	hdr = create_hdr(resolve_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1164	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1165
1166	put_flags(flags, &ptr);
1167	put_uint32(interfaceIndex, &ptr);
1168	put_string(name, &ptr);
1169	put_string(regtype, &ptr);
1170	put_string(domain, &ptr);
1171
1172	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1173	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1174	return err;
1175	}
1176
1177static void handle_query_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1178	{
1179	uint32_t ttl;
1180	char name[kDNSServiceMaxDomainName];
1181	uint16_t rrtype, rrclass, rdlen;
1182	const char *rdata;
1183
1184	get_string(&data, end, name, kDNSServiceMaxDomainName);
1185	rrtype  = get_uint16(&data, end);
1186	rrclass = get_uint16(&data, end);
1187	rdlen   = get_uint16(&data, end);
1188	rdata   = get_rdata(&data, end, rdlen);
1189	ttl     = get_uint32(&data, end);
1190
1191	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_query_response: error reading result from daemon");
1192	else ((DNSServiceQueryRecordReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, name, rrtype, rrclass, rdlen, rdata, ttl, sdr->AppContext);
1193	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1194	}
1195
1196DNSServiceErrorType DNSSD_API DNSServiceQueryRecord
1197	(
1198	DNSServiceRef              *sdRef,
1199	DNSServiceFlags             flags,
1200	uint32_t                    interfaceIndex,
1201	const char                 *name,
1202	uint16_t                    rrtype,
1203	uint16_t                    rrclass,
1204	DNSServiceQueryRecordReply  callBack,
1205	void                       *context
1206	)
1207	{
1208	char *ptr;
1209	size_t len;
1210	ipc_msg_hdr *hdr;
1211	DNSServiceErrorType err = ConnectToServer(sdRef, flags, query_request, handle_query_response, callBack, context);
1212	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1213
1214	if (!name) name = "\0";
1215
1216	// Calculate total message length
1217	len = sizeof(flags);
1218	len += sizeof(uint32_t);  // interfaceIndex
1219	len += strlen(name) + 1;
1220	len += 2 * sizeof(uint16_t);  // rrtype, rrclass
1221
1222	hdr = create_hdr(query_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1223	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1224
1225	put_flags(flags, &ptr);
1226	put_uint32(interfaceIndex, &ptr);
1227	put_string(name, &ptr);
1228	put_uint16(rrtype, &ptr);
1229	put_uint16(rrclass, &ptr);
1230
1231	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1232	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1233	return err;
1234	}
1235
1236static void handle_addrinfo_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1237	{
1238	char hostname[kDNSServiceMaxDomainName];
1239	uint16_t rrtype, rrclass, rdlen;
1240	const char *rdata;
1241	uint32_t ttl;
1242
1243	get_string(&data, end, hostname, kDNSServiceMaxDomainName);
1244	rrtype  = get_uint16(&data, end);
1245	rrclass = get_uint16(&data, end);
1246	rdlen   = get_uint16(&data, end);
1247	rdata   = get_rdata (&data, end, rdlen);
1248	ttl     = get_uint32(&data, end);
1249
1250	// We only generate client callbacks for A and AAAA results (including NXDOMAIN results for
1251	// those types, if the client has requested those with the kDNSServiceFlagsReturnIntermediates).
1252	// Other result types, specifically CNAME referrals, are not communicated to the client, because
1253	// the DNSServiceGetAddrInfoReply interface doesn't have any meaningful way to communiate CNAME referrals.
1254	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_addrinfo_response: error reading result from daemon");
1255	else if (rrtype == kDNSServiceType_A || rrtype == kDNSServiceType_AAAA)
1256		{
1257		struct sockaddr_in  sa4;
1258		struct sockaddr_in6 sa6;
1259		const struct sockaddr *const sa = (rrtype == kDNSServiceType_A) ? (struct sockaddr*)&sa4 : (struct sockaddr*)&sa6;
1260		if (rrtype == kDNSServiceType_A)
1261			{
1262			memset(&sa4, 0, sizeof(sa4));
1263			#ifndef NOT_HAVE_SA_LEN
1264			sa4.sin_len = sizeof(struct sockaddr_in);
1265			#endif
1266			sa4.sin_family = AF_INET;
1267			//  sin_port   = 0;
1268			if (!cbh->cb_err) memcpy(&sa4.sin_addr, rdata, rdlen);
1269			}
1270		else
1271			{
1272			memset(&sa6, 0, sizeof(sa6));
1273			#ifndef NOT_HAVE_SA_LEN
1274			sa6.sin6_len = sizeof(struct sockaddr_in6);
1275			#endif
1276			sa6.sin6_family     = AF_INET6;
1277			//  sin6_port     = 0;
1278			//  sin6_flowinfo = 0;
1279			//  sin6_scope_id = 0;
1280			if (!cbh->cb_err)
1281				{
1282				memcpy(&sa6.sin6_addr, rdata, rdlen);
1283				if (IN6_IS_ADDR_LINKLOCAL(&sa6.sin6_addr)) sa6.sin6_scope_id = cbh->cb_interface;
1284				}
1285			}
1286		((DNSServiceGetAddrInfoReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, hostname, sa, ttl, sdr->AppContext);
1287		// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1288		}
1289	}
1290
1291DNSServiceErrorType DNSSD_API DNSServiceGetAddrInfo
1292	(
1293	DNSServiceRef                    *sdRef,
1294	DNSServiceFlags                  flags,
1295	uint32_t                         interfaceIndex,
1296	uint32_t                         protocol,
1297	const char                       *hostname,
1298	DNSServiceGetAddrInfoReply       callBack,
1299	void                             *context          /* may be NULL */
1300	)
1301	{
1302	char *ptr;
1303	size_t len;
1304	ipc_msg_hdr *hdr;
1305	DNSServiceErrorType err;
1306
1307	if (!hostname) return kDNSServiceErr_BadParam;
1308
1309	err = ConnectToServer(sdRef, flags, addrinfo_request, handle_addrinfo_response, callBack, context);
1310	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1311
1312	// Calculate total message length
1313	len = sizeof(flags);
1314	len += sizeof(uint32_t);      // interfaceIndex
1315	len += sizeof(uint32_t);      // protocol
1316	len += strlen(hostname) + 1;
1317
1318	hdr = create_hdr(addrinfo_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1319	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1320
1321	put_flags(flags, &ptr);
1322	put_uint32(interfaceIndex, &ptr);
1323	put_uint32(protocol, &ptr);
1324	put_string(hostname, &ptr);
1325
1326	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1327	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1328	return err;
1329	}
1330
1331static void handle_browse_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1332	{
1333	char replyName[256], replyType[kDNSServiceMaxDomainName], replyDomain[kDNSServiceMaxDomainName];
1334	get_string(&data, end, replyName, 256);
1335	get_string(&data, end, replyType, kDNSServiceMaxDomainName);
1336	get_string(&data, end, replyDomain, kDNSServiceMaxDomainName);
1337	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_browse_response: error reading result from daemon");
1338	else ((DNSServiceBrowseReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, replyName, replyType, replyDomain, sdr->AppContext);
1339	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1340	}
1341
1342DNSServiceErrorType DNSSD_API DNSServiceBrowse
1343	(
1344	DNSServiceRef         *sdRef,
1345	DNSServiceFlags        flags,
1346	uint32_t               interfaceIndex,
1347	const char            *regtype,
1348	const char            *domain,
1349	DNSServiceBrowseReply  callBack,
1350	void                  *context
1351	)
1352	{
1353	char *ptr;
1354	size_t len;
1355	ipc_msg_hdr *hdr;
1356	DNSServiceErrorType err = ConnectToServer(sdRef, flags, browse_request, handle_browse_response, callBack, context);
1357	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1358
1359	if (!domain) domain = "";
1360	len = sizeof(flags);
1361	len += sizeof(interfaceIndex);
1362	len += strlen(regtype) + 1;
1363	len += strlen(domain) + 1;
1364
1365	hdr = create_hdr(browse_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1366	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1367
1368	put_flags(flags, &ptr);
1369	put_uint32(interfaceIndex, &ptr);
1370	put_string(regtype, &ptr);
1371	put_string(domain, &ptr);
1372
1373	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1374	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1375	return err;
1376	}
1377
1378DNSServiceErrorType DNSSD_API DNSServiceSetDefaultDomainForUser(DNSServiceFlags flags, const char *domain)
1379	{
1380	DNSServiceOp *tmp;
1381	char *ptr;
1382	size_t len = sizeof(flags) + strlen(domain) + 1;
1383	ipc_msg_hdr *hdr;
1384	DNSServiceErrorType err = ConnectToServer(&tmp, 0, setdomain_request, NULL, NULL, NULL);
1385	if (err) return err;
1386
1387	hdr = create_hdr(setdomain_request, &len, &ptr, 0, tmp);
1388	if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
1389
1390	put_flags(flags, &ptr);
1391	put_string(domain, &ptr);
1392	err = deliver_request(hdr, tmp);		// Will free hdr for us
1393	DNSServiceRefDeallocate(tmp);
1394	return err;
1395	}
1396
1397static void handle_regservice_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1398	{
1399	char name[256], regtype[kDNSServiceMaxDomainName], domain[kDNSServiceMaxDomainName];
1400	get_string(&data, end, name, 256);
1401	get_string(&data, end, regtype, kDNSServiceMaxDomainName);
1402	get_string(&data, end, domain,  kDNSServiceMaxDomainName);
1403	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_regservice_response: error reading result from daemon");
1404	else ((DNSServiceRegisterReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_err, name, regtype, domain, sdr->AppContext);
1405	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1406	}
1407
1408DNSServiceErrorType DNSSD_API DNSServiceRegister
1409	(
1410	DNSServiceRef                       *sdRef,
1411	DNSServiceFlags                     flags,
1412	uint32_t                            interfaceIndex,
1413	const char                          *name,
1414	const char                          *regtype,
1415	const char                          *domain,
1416	const char                          *host,
1417	uint16_t                            PortInNetworkByteOrder,
1418	uint16_t                            txtLen,
1419	const void                          *txtRecord,
1420	DNSServiceRegisterReply             callBack,
1421	void                                *context
1422	)
1423	{
1424	char *ptr;
1425	size_t len;
1426	ipc_msg_hdr *hdr;
1427	DNSServiceErrorType err;
1428	union { uint16_t s; u_char b[2]; } port = { PortInNetworkByteOrder };
1429
1430	if (!name) name = "";
1431	if (!regtype) return kDNSServiceErr_BadParam;
1432	if (!domain) domain = "";
1433	if (!host) host = "";
1434	if (!txtRecord) txtRecord = (void*)"";
1435
1436	// No callback must have auto-rename
1437	if (!callBack && (flags & kDNSServiceFlagsNoAutoRename)) return kDNSServiceErr_BadParam;
1438
1439	err = ConnectToServer(sdRef, flags, reg_service_request, callBack ? handle_regservice_response : NULL, callBack, context);
1440	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1441
1442	len = sizeof(DNSServiceFlags);
1443	len += sizeof(uint32_t);  // interfaceIndex
1444	len += strlen(name) + strlen(regtype) + strlen(domain) + strlen(host) + 4;
1445	len += 2 * sizeof(uint16_t);  // port, txtLen
1446	len += txtLen;
1447
1448	hdr = create_hdr(reg_service_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1449	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1450	if (!callBack) hdr->ipc_flags |= IPC_FLAGS_NOREPLY;
1451
1452	put_flags(flags, &ptr);
1453	put_uint32(interfaceIndex, &ptr);
1454	put_string(name, &ptr);
1455	put_string(regtype, &ptr);
1456	put_string(domain, &ptr);
1457	put_string(host, &ptr);
1458	*ptr++ = port.b[0];
1459	*ptr++ = port.b[1];
1460	put_uint16(txtLen, &ptr);
1461	put_rdata(txtLen, txtRecord, &ptr);
1462
1463	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1464	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1465	return err;
1466	}
1467
1468static void handle_enumeration_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1469	{
1470	char domain[kDNSServiceMaxDomainName];
1471	get_string(&data, end, domain, kDNSServiceMaxDomainName);
1472	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_enumeration_response: error reading result from daemon");
1473	else ((DNSServiceDomainEnumReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, domain, sdr->AppContext);
1474	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1475	}
1476
1477DNSServiceErrorType DNSSD_API DNSServiceEnumerateDomains
1478	(
1479	DNSServiceRef             *sdRef,
1480	DNSServiceFlags            flags,
1481	uint32_t                   interfaceIndex,
1482	DNSServiceDomainEnumReply  callBack,
1483	void                      *context
1484	)
1485	{
1486	char *ptr;
1487	size_t len;
1488	ipc_msg_hdr *hdr;
1489	DNSServiceErrorType err;
1490
1491	int f1 = (flags & kDNSServiceFlagsBrowseDomains) != 0;
1492	int f2 = (flags & kDNSServiceFlagsRegistrationDomains) != 0;
1493	if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
1494
1495	err = ConnectToServer(sdRef, flags, enumeration_request, handle_enumeration_response, callBack, context);
1496	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1497
1498	len = sizeof(DNSServiceFlags);
1499	len += sizeof(uint32_t);
1500
1501	hdr = create_hdr(enumeration_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1502	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1503
1504	put_flags(flags, &ptr);
1505	put_uint32(interfaceIndex, &ptr);
1506
1507	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1508	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1509	return err;
1510	}
1511
1512static void ConnectionResponse(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *const data, const char *const end)
1513	{
1514	DNSRecordRef rref = cbh->ipc_hdr.client_context.context;
1515	(void)data; // Unused
1516
1517	//printf("ConnectionResponse got %d\n", cbh->ipc_hdr.op);
1518	if (cbh->ipc_hdr.op != reg_record_reply_op)
1519		{
1520		// When using kDNSServiceFlagsShareConnection, need to search the list of associated DNSServiceOps
1521		// to find the one this response is intended for, and then call through to its ProcessReply handler.
1522		// We start with our first subordinate DNSServiceRef -- don't want to accidentally match the parent DNSServiceRef.
1523		DNSServiceOp *op = sdr->next;
1524		while (op && (op->uid.u32[0] != cbh->ipc_hdr.client_context.u32[0] || op->uid.u32[1] != cbh->ipc_hdr.client_context.u32[1]))
1525			op = op->next;
1526		// Note: We may sometimes not find a matching DNSServiceOp, in the case where the client has
1527		// cancelled the subordinate DNSServiceOp, but there are still messages in the pipeline from the daemon
1528		if (op && op->ProcessReply) op->ProcessReply(op, cbh, data, end);
1529		// WARNING: Don't touch op or sdr after this -- client may have called DNSServiceRefDeallocate
1530		return;
1531		}
1532
1533	if (sdr->op == connection_request)
1534		rref->AppCallback(rref->sdr, rref, cbh->cb_flags, cbh->cb_err, rref->AppContext);
1535	else
1536		{
1537		syslog(LOG_WARNING, "dnssd_clientstub ConnectionResponse: sdr->op != connection_request");
1538		rref->AppCallback(rref->sdr, rref, 0, kDNSServiceErr_Unknown, rref->AppContext);
1539		}
1540	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1541	}
1542
1543DNSServiceErrorType DNSSD_API DNSServiceCreateConnection(DNSServiceRef *sdRef)
1544	{
1545	char *ptr;
1546	size_t len = 0;
1547	ipc_msg_hdr *hdr;
1548	DNSServiceErrorType err = ConnectToServer(sdRef, 0, connection_request, ConnectionResponse, NULL, NULL);
1549	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1550
1551	hdr = create_hdr(connection_request, &len, &ptr, 0, *sdRef);
1552	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1553
1554	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1555	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1556	return err;
1557	}
1558
1559DNSServiceErrorType DNSSD_API DNSServiceRegisterRecord
1560	(
1561	DNSServiceRef                  sdRef,
1562	DNSRecordRef                  *RecordRef,
1563	DNSServiceFlags                flags,
1564	uint32_t                       interfaceIndex,
1565	const char                    *fullname,
1566	uint16_t                       rrtype,
1567	uint16_t                       rrclass,
1568	uint16_t                       rdlen,
1569	const void                    *rdata,
1570	uint32_t                       ttl,
1571	DNSServiceRegisterRecordReply  callBack,
1572	void                          *context
1573	)
1574	{
1575	char *ptr;
1576	size_t len;
1577	ipc_msg_hdr *hdr = NULL;
1578	DNSRecordRef rref = NULL;
1579	int f1 = (flags & kDNSServiceFlagsShared) != 0;
1580	int f2 = (flags & kDNSServiceFlagsUnique) != 0;
1581	if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
1582
1583	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
1584
1585	if (!DNSServiceRefValid(sdRef))
1586		{
1587		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1588		return kDNSServiceErr_BadReference;
1589		}
1590
1591	if (sdRef->op != connection_request)
1592		{
1593		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRegisterRecord called with non-DNSServiceCreateConnection DNSServiceRef %p %d", sdRef, sdRef->op);
1594		return kDNSServiceErr_BadReference;
1595		}
1596
1597	*RecordRef = NULL;
1598
1599	len = sizeof(DNSServiceFlags);
1600	len += 2 * sizeof(uint32_t);  // interfaceIndex, ttl
1601	len += 3 * sizeof(uint16_t);  // rrtype, rrclass, rdlen
1602	len += strlen(fullname) + 1;
1603	len += rdlen;
1604
1605	hdr = create_hdr(reg_record_request, &len, &ptr, 1, sdRef);
1606	if (!hdr) return kDNSServiceErr_NoMemory;
1607
1608	put_flags(flags, &ptr);
1609	put_uint32(interfaceIndex, &ptr);
1610	put_string(fullname, &ptr);
1611	put_uint16(rrtype, &ptr);
1612	put_uint16(rrclass, &ptr);
1613	put_uint16(rdlen, &ptr);
1614	put_rdata(rdlen, rdata, &ptr);
1615	put_uint32(ttl, &ptr);
1616
1617	rref = malloc(sizeof(DNSRecord));
1618	if (!rref) { free(hdr); return kDNSServiceErr_NoMemory; }
1619	rref->AppContext = context;
1620	rref->AppCallback = callBack;
1621	rref->record_index = sdRef->max_index++;
1622	rref->sdr = sdRef;
1623	*RecordRef = rref;
1624	hdr->client_context.context = rref;
1625	hdr->reg_index = rref->record_index;
1626
1627	return deliver_request(hdr, sdRef);		// Will free hdr for us
1628	}
1629
1630// sdRef returned by DNSServiceRegister()
1631DNSServiceErrorType DNSSD_API DNSServiceAddRecord
1632	(
1633	DNSServiceRef    sdRef,
1634	DNSRecordRef    *RecordRef,
1635	DNSServiceFlags  flags,
1636	uint16_t         rrtype,
1637	uint16_t         rdlen,
1638	const void      *rdata,
1639	uint32_t         ttl
1640	)
1641	{
1642	ipc_msg_hdr *hdr;
1643	size_t len = 0;
1644	char *ptr;
1645	DNSRecordRef rref;
1646
1647	if (!sdRef)     { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with NULL DNSServiceRef");        return kDNSServiceErr_BadParam; }
1648	if (!RecordRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with NULL DNSRecordRef pointer"); return kDNSServiceErr_BadParam; }
1649	if (sdRef->op != reg_service_request)
1650		{
1651		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with non-DNSServiceRegister DNSServiceRef %p %d", sdRef, sdRef->op);
1652		return kDNSServiceErr_BadReference;
1653		}
1654
1655	if (!DNSServiceRefValid(sdRef))
1656		{
1657		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceAddRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1658		return kDNSServiceErr_BadReference;
1659		}
1660
1661	*RecordRef = NULL;
1662
1663	len += 2 * sizeof(uint16_t);  // rrtype, rdlen
1664	len += rdlen;
1665	len += sizeof(uint32_t);
1666	len += sizeof(DNSServiceFlags);
1667
1668	hdr = create_hdr(add_record_request, &len, &ptr, 1, sdRef);
1669	if (!hdr) return kDNSServiceErr_NoMemory;
1670	put_flags(flags, &ptr);
1671	put_uint16(rrtype, &ptr);
1672	put_uint16(rdlen, &ptr);
1673	put_rdata(rdlen, rdata, &ptr);
1674	put_uint32(ttl, &ptr);
1675
1676	rref = malloc(sizeof(DNSRecord));
1677	if (!rref) { free(hdr); return kDNSServiceErr_NoMemory; }
1678	rref->AppContext = NULL;
1679	rref->AppCallback = NULL;
1680	rref->record_index = sdRef->max_index++;
1681	rref->sdr = sdRef;
1682	*RecordRef = rref;
1683	hdr->reg_index = rref->record_index;
1684
1685	return deliver_request(hdr, sdRef);		// Will free hdr for us
1686	}
1687
1688// DNSRecordRef returned by DNSServiceRegisterRecord or DNSServiceAddRecord
1689DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord
1690	(
1691	DNSServiceRef    sdRef,
1692	DNSRecordRef     RecordRef,
1693	DNSServiceFlags  flags,
1694	uint16_t         rdlen,
1695	const void      *rdata,
1696	uint32_t         ttl
1697	)
1698	{
1699	ipc_msg_hdr *hdr;
1700	size_t len = 0;
1701	char *ptr;
1702
1703	if (!sdRef) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceUpdateRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
1704
1705	if (!DNSServiceRefValid(sdRef))
1706		{
1707		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceUpdateRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1708		return kDNSServiceErr_BadReference;
1709		}
1710
1711	// Note: RecordRef is allowed to be NULL
1712
1713	len += sizeof(uint16_t);
1714	len += rdlen;
1715	len += sizeof(uint32_t);
1716	len += sizeof(DNSServiceFlags);
1717
1718	hdr = create_hdr(update_record_request, &len, &ptr, 1, sdRef);
1719	if (!hdr) return kDNSServiceErr_NoMemory;
1720	hdr->reg_index = RecordRef ? RecordRef->record_index : TXT_RECORD_INDEX;
1721	put_flags(flags, &ptr);
1722	put_uint16(rdlen, &ptr);
1723	put_rdata(rdlen, rdata, &ptr);
1724	put_uint32(ttl, &ptr);
1725	return deliver_request(hdr, sdRef);		// Will free hdr for us
1726	}
1727
1728DNSServiceErrorType DNSSD_API DNSServiceRemoveRecord
1729	(
1730	DNSServiceRef    sdRef,
1731	DNSRecordRef     RecordRef,
1732	DNSServiceFlags  flags
1733	)
1734	{
1735	ipc_msg_hdr *hdr;
1736	size_t len = 0;
1737	char *ptr;
1738	DNSServiceErrorType err;
1739
1740	if (!sdRef)            { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with NULL DNSServiceRef"); return kDNSServiceErr_BadParam; }
1741	if (!RecordRef)        { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with NULL DNSRecordRef");  return kDNSServiceErr_BadParam; }
1742	if (!sdRef->max_index) { syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with bad DNSServiceRef");  return kDNSServiceErr_BadReference; }
1743
1744	if (!DNSServiceRefValid(sdRef))
1745		{
1746		syslog(LOG_WARNING, "dnssd_clientstub DNSServiceRemoveRecord called with invalid DNSServiceRef %p %08X %08X", sdRef, sdRef->sockfd, sdRef->validator);
1747		return kDNSServiceErr_BadReference;
1748		}
1749
1750	len += sizeof(flags);
1751	hdr = create_hdr(remove_record_request, &len, &ptr, 1, sdRef);
1752	if (!hdr) return kDNSServiceErr_NoMemory;
1753	hdr->reg_index = RecordRef->record_index;
1754	put_flags(flags, &ptr);
1755	err = deliver_request(hdr, sdRef);		// Will free hdr for us
1756	if (!err) free(RecordRef);
1757	return err;
1758	}
1759
1760DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord
1761	(
1762	DNSServiceFlags  flags,
1763	uint32_t         interfaceIndex,
1764	const char      *fullname,
1765	uint16_t         rrtype,
1766	uint16_t         rrclass,
1767	uint16_t         rdlen,
1768	const void      *rdata
1769	)
1770	{
1771	char *ptr;
1772	size_t len;
1773	ipc_msg_hdr *hdr;
1774	DNSServiceOp *tmp;
1775
1776	DNSServiceErrorType err = ConnectToServer(&tmp, flags, reconfirm_record_request, NULL, NULL, NULL);
1777	if (err) return err;
1778
1779	len = sizeof(DNSServiceFlags);
1780	len += sizeof(uint32_t);
1781	len += strlen(fullname) + 1;
1782	len += 3 * sizeof(uint16_t);
1783	len += rdlen;
1784	hdr = create_hdr(reconfirm_record_request, &len, &ptr, 0, tmp);
1785	if (!hdr) { DNSServiceRefDeallocate(tmp); return kDNSServiceErr_NoMemory; }
1786
1787	put_flags(flags, &ptr);
1788	put_uint32(interfaceIndex, &ptr);
1789	put_string(fullname, &ptr);
1790	put_uint16(rrtype, &ptr);
1791	put_uint16(rrclass, &ptr);
1792	put_uint16(rdlen, &ptr);
1793	put_rdata(rdlen, rdata, &ptr);
1794
1795	err = deliver_request(hdr, tmp);		// Will free hdr for us
1796	DNSServiceRefDeallocate(tmp);
1797	return err;
1798	}
1799
1800static void handle_port_mapping_response(DNSServiceOp *const sdr, const CallbackHeader *const cbh, const char *data, const char *const end)
1801	{
1802	union { uint32_t l; u_char b[4]; } addr;
1803	uint8_t protocol = 0;
1804	union { uint16_t s; u_char b[2]; } internalPort;
1805	union { uint16_t s; u_char b[2]; } externalPort;
1806	uint32_t ttl = 0;
1807
1808	if (!data || data + 13 > end) data = NULL;
1809	else
1810		{
1811		addr        .b[0] = *data++;
1812		addr        .b[1] = *data++;
1813		addr        .b[2] = *data++;
1814		addr        .b[3] = *data++;
1815		protocol          = *data++;
1816		internalPort.b[0] = *data++;
1817		internalPort.b[1] = *data++;
1818		externalPort.b[0] = *data++;
1819		externalPort.b[1] = *data++;
1820		ttl               = get_uint32(&data, end);
1821		}
1822
1823	if (!data) syslog(LOG_WARNING, "dnssd_clientstub handle_port_mapping_response: error reading result from daemon");
1824	else ((DNSServiceNATPortMappingReply)sdr->AppCallback)(sdr, cbh->cb_flags, cbh->cb_interface, cbh->cb_err, addr.l, protocol, internalPort.s, externalPort.s, ttl, sdr->AppContext);
1825	// MUST NOT touch sdr after invoking AppCallback -- client is allowed to dispose it from within callback function
1826	}
1827
1828DNSServiceErrorType DNSSD_API DNSServiceNATPortMappingCreate
1829	(
1830	DNSServiceRef                       *sdRef,
1831	DNSServiceFlags                     flags,
1832	uint32_t                            interfaceIndex,
1833	uint32_t                            protocol,     /* TCP and/or UDP */
1834	uint16_t                            internalPortInNetworkByteOrder,
1835	uint16_t                            externalPortInNetworkByteOrder,
1836	uint32_t                            ttl,          /* time to live in seconds */
1837	DNSServiceNATPortMappingReply       callBack,
1838	void                                *context      /* may be NULL */
1839	)
1840	{
1841	char *ptr;
1842	size_t len;
1843	ipc_msg_hdr *hdr;
1844	union { uint16_t s; u_char b[2]; } internalPort = { internalPortInNetworkByteOrder };
1845	union { uint16_t s; u_char b[2]; } externalPort = { externalPortInNetworkByteOrder };
1846
1847	DNSServiceErrorType err = ConnectToServer(sdRef, flags, port_mapping_request, handle_port_mapping_response, callBack, context);
1848	if (err) return err;	// On error ConnectToServer leaves *sdRef set to NULL
1849
1850	len = sizeof(flags);
1851	len += sizeof(interfaceIndex);
1852	len += sizeof(protocol);
1853	len += sizeof(internalPort);
1854	len += sizeof(externalPort);
1855	len += sizeof(ttl);
1856
1857	hdr = create_hdr(port_mapping_request, &len, &ptr, (*sdRef)->primary ? 1 : 0, *sdRef);
1858	if (!hdr) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; return kDNSServiceErr_NoMemory; }
1859
1860	put_flags(flags, &ptr);
1861	put_uint32(interfaceIndex, &ptr);
1862	put_uint32(protocol, &ptr);
1863	*ptr++ = internalPort.b[0];
1864	*ptr++ = internalPort.b[1];
1865	*ptr++ = externalPort.b[0];
1866	*ptr++ = externalPort.b[1];
1867	put_uint32(ttl, &ptr);
1868
1869	err = deliver_request(hdr, *sdRef);		// Will free hdr for us
1870	if (err) { DNSServiceRefDeallocate(*sdRef); *sdRef = NULL; }
1871	return err;
1872	}
1873