xref: /titanic_41/usr/src/cmd/cmd-inet/usr.bin/dns-sd.c (revision 4b22b9337f359bfd063322244f5336cc7c6ffcfa)
1 /* -*- Mode: C; tab-width: 4 -*-
2  *
3  * Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved.
4  *
5  * Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
6  * ("Apple") in consideration of your agreement to the following terms, and your
7  * use, installation, modification or redistribution of this Apple software
8  * constitutes acceptance of these terms.  If you do not agree with these terms,
9  * please do not use, install, modify or redistribute this Apple software.
10  *
11  * In consideration of your agreement to abide by the following terms, and subject
12  * to these terms, Apple grants you a personal, non-exclusive license, under Apple's
13  * copyrights in this original Apple software (the "Apple Software"), to use,
14  * reproduce, modify and redistribute the Apple Software, with or without
15  * modifications, in source and/or binary forms; provided that if you redistribute
16  * the Apple Software in its entirety and without modifications, you must retain
17  * this notice and the following text and disclaimers in all such redistributions of
18  * the Apple Software.  Neither the name, trademarks, service marks or logos of
19  * Apple Computer, Inc. may be used to endorse or promote products derived from the
20  * Apple Software without specific prior written permission from Apple.  Except as
21  * expressly stated in this notice, no other rights or licenses, express or implied,
22  * are granted by Apple herein, including but not limited to any patent rights that
23  * may be infringed by your derivative works or by other works in which the Apple
24  * Software may be incorporated.
25  *
26  * The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
27  * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
28  * WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29  * PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
30  * COMBINATION WITH YOUR PRODUCTS.
31  *
32  * IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
34  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35  * ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
36  * OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
37  * (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
38  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39  *
40  * Formatting notes:
41  * This code follows the "Whitesmiths style" C indentation rules. Plenty of discussion
42  * on C indentation can be found on the web, such as <http://www.kafejo.com/komp/1tbs.htm>,
43  * but for the sake of brevity here I will say just this: Curly braces are not syntactially
44  * part of an "if" statement; they are the beginning and ending markers of a compound statement;
45  * therefore common sense dictates that if they are part of a compound statement then they
46  * should be indented to the same level as everything else in that compound statement.
47  * Indenting curly braces at the same level as the "if" implies that curly braces are
48  * part of the "if", which is false. (This is as misleading as people who write "char* x,y;"
49  * thinking that variables x and y are both of type "char*" -- and anyone who doesn't
50  * understand why variable y is not of type "char*" just proves the point that poor code
51  * layout leads people to unfortunate misunderstandings about how the C language really works.)
52 
53 To build this tool, copy and paste the following into a command line:
54 
55 OS X:
56 gcc dns-sd.c -o dns-sd
57 
58 POSIX systems:
59 gcc dns-sd.c -o dns-sd -I../mDNSShared -ldns_sd
60 
61 Windows:
62 cl dns-sd.c -I../mDNSShared -DNOT_HAVE_GETOPT ws2_32.lib ..\mDNSWindows\DLL\Release\dnssd.lib
63 (may require that you run a Visual Studio script such as vsvars32.bat first)
64 */
65 
66 #pragma ident	"%Z%%M%	%I%	%E% SMI"
67 
68 // For testing changes to dnssd_clientstub.c, uncomment this line and the #include below
69 // #define __APPLE_API_PRIVATE 1
70 
71 #include "dns_sd.h"
72 #include <ctype.h>
73 #include <stdio.h>			// For stdout, stderr
74 #include <stdlib.h>			// For exit()
75 #include <string.h>			// For strlen(), strcpy(), bzero()
76 #include <errno.h>			// For errno, EINTR
77 #include <time.h>
78 #include <sys/types.h>		// For u_char
79 
80 #ifdef _WIN32
81 #include <winsock2.h>
82 #include <ws2tcpip.h>
83 #include <process.h>
84 typedef int        pid_t;
85 #define getpid     _getpid
86 #define strcasecmp _stricmp
87 #define snprintf   _snprintf
88 static const char kFilePathSep = '\\';
89 #else
90 #include <unistd.h>			// For getopt() and optind
91 #include <netdb.h>			// For getaddrinfo()
92 #include <sys/time.h>		// For struct timeval
93 #include <sys/socket.h>		// For AF_INET
94 #include <netinet/in.h>		// For struct sockaddr_in()
95 #include <arpa/inet.h>		// For inet_addr()
96 static const char kFilePathSep = '/';
97 #endif
98 
99 //#include "../mDNSShared/dnssd_clientstub.c"
100 
101 //*************************************************************************************************************
102 // Globals
103 
104 typedef union { unsigned char b[2]; unsigned short NotAnInteger; } Opaque16;
105 
106 static int operation;
107 static uint32_t opinterface = kDNSServiceInterfaceIndexAny;
108 static DNSServiceRef client  = NULL;
109 static DNSServiceRef client2 = NULL;
110 static int num_printed;
111 static char addtest = 0;
112 static DNSRecordRef record = NULL;
113 static char myhinfoW[14] = "\002PC\012Windows XP";
114 static char myhinfoX[ 9] = "\003Mac\004OS X";
115 static char updatetest[3] = "\002AA";
116 static char bigNULL[8200];
117 
118 // Note: the select() implementation on Windows (Winsock2) fails with any timeout much larger than this
119 #define LONG_TIME 100000000
120 
121 static volatile int stopNow = 0;
122 static volatile int timeOut = LONG_TIME;
123 
124 //*************************************************************************************************************
125 // Supporting Utility Function
126 
GetRRType(const char * s)127 static uint16_t GetRRType(const char *s)
128 	{
129 	if      (!strcasecmp(s, "A"       )) return(kDNSServiceType_A);
130 	else if (!strcasecmp(s, "NS"      )) return(kDNSServiceType_NS);
131 	else if (!strcasecmp(s, "MD"      )) return(kDNSServiceType_MD);
132 	else if (!strcasecmp(s, "MF"      )) return(kDNSServiceType_MF);
133 	else if (!strcasecmp(s, "CNAME"   )) return(kDNSServiceType_CNAME);
134 	else if (!strcasecmp(s, "SOA"     )) return(kDNSServiceType_SOA);
135 	else if (!strcasecmp(s, "MB"      )) return(kDNSServiceType_MB);
136 	else if (!strcasecmp(s, "MG"      )) return(kDNSServiceType_MG);
137 	else if (!strcasecmp(s, "MR"      )) return(kDNSServiceType_MR);
138 	else if (!strcasecmp(s, "NULL"    )) return(kDNSServiceType_NULL);
139 	else if (!strcasecmp(s, "WKS"     )) return(kDNSServiceType_WKS);
140 	else if (!strcasecmp(s, "PTR"     )) return(kDNSServiceType_PTR);
141 	else if (!strcasecmp(s, "HINFO"   )) return(kDNSServiceType_HINFO);
142 	else if (!strcasecmp(s, "MINFO"   )) return(kDNSServiceType_MINFO);
143 	else if (!strcasecmp(s, "MX"      )) return(kDNSServiceType_MX);
144 	else if (!strcasecmp(s, "TXT"     )) return(kDNSServiceType_TXT);
145 	else if (!strcasecmp(s, "RP"      )) return(kDNSServiceType_RP);
146 	else if (!strcasecmp(s, "AFSDB"   )) return(kDNSServiceType_AFSDB);
147 	else if (!strcasecmp(s, "X25"     )) return(kDNSServiceType_X25);
148 	else if (!strcasecmp(s, "ISDN"    )) return(kDNSServiceType_ISDN);
149 	else if (!strcasecmp(s, "RT"      )) return(kDNSServiceType_RT);
150 	else if (!strcasecmp(s, "NSAP"    )) return(kDNSServiceType_NSAP);
151 	else if (!strcasecmp(s, "NSAP_PTR")) return(kDNSServiceType_NSAP_PTR);
152 	else if (!strcasecmp(s, "SIG"     )) return(kDNSServiceType_SIG);
153 	else if (!strcasecmp(s, "KEY"     )) return(kDNSServiceType_KEY);
154 	else if (!strcasecmp(s, "PX"      )) return(kDNSServiceType_PX);
155 	else if (!strcasecmp(s, "GPOS"    )) return(kDNSServiceType_GPOS);
156 	else if (!strcasecmp(s, "AAAA"    )) return(kDNSServiceType_AAAA);
157 	else if (!strcasecmp(s, "LOC"     )) return(kDNSServiceType_LOC);
158 	else if (!strcasecmp(s, "NXT"     )) return(kDNSServiceType_NXT);
159 	else if (!strcasecmp(s, "EID"     )) return(kDNSServiceType_EID);
160 	else if (!strcasecmp(s, "NIMLOC"  )) return(kDNSServiceType_NIMLOC);
161 	else if (!strcasecmp(s, "SRV"     )) return(kDNSServiceType_SRV);
162 	else if (!strcasecmp(s, "ATMA"    )) return(kDNSServiceType_ATMA);
163 	else if (!strcasecmp(s, "NAPTR"   )) return(kDNSServiceType_NAPTR);
164 	else if (!strcasecmp(s, "KX"      )) return(kDNSServiceType_KX);
165 	else if (!strcasecmp(s, "CERT"    )) return(kDNSServiceType_CERT);
166 	else if (!strcasecmp(s, "A6"      )) return(kDNSServiceType_A6);
167 	else if (!strcasecmp(s, "DNAME"   )) return(kDNSServiceType_DNAME);
168 	else if (!strcasecmp(s, "SINK"    )) return(kDNSServiceType_SINK);
169 	else if (!strcasecmp(s, "OPT"     )) return(kDNSServiceType_OPT);
170 	else if (!strcasecmp(s, "TKEY"    )) return(kDNSServiceType_TKEY);
171 	else if (!strcasecmp(s, "TSIG"    )) return(kDNSServiceType_TSIG);
172 	else if (!strcasecmp(s, "IXFR"    )) return(kDNSServiceType_IXFR);
173 	else if (!strcasecmp(s, "AXFR"    )) return(kDNSServiceType_AXFR);
174 	else if (!strcasecmp(s, "MAILB"   )) return(kDNSServiceType_MAILB);
175 	else if (!strcasecmp(s, "MAILA"   )) return(kDNSServiceType_MAILA);
176 	else if (!strcasecmp(s, "ANY"     )) return(kDNSServiceType_ANY);
177 	else                                 return(atoi(s));
178 	}
179 
180 //*************************************************************************************************************
181 // Sample callback functions for each of the operation types
182 
printtimestamp(void)183 static void printtimestamp(void)
184 	{
185 	struct tm tm;
186 	int ms;
187 #ifdef _WIN32
188 	SYSTEMTIME sysTime;
189 	time_t uct = time(NULL);
190 	tm = *localtime(&uct);
191 	GetLocalTime(&sysTime);
192 	ms = sysTime.wMilliseconds;
193 #else
194 	struct timeval tv;
195 	gettimeofday(&tv, NULL);
196 	localtime_r((time_t*)&tv.tv_sec, &tm);
197 	ms = tv.tv_usec/1000;
198 #endif
199 	printf("%2d:%02d:%02d.%03d  ", tm.tm_hour, tm.tm_min, tm.tm_sec, ms);
200 	}
201 
202 #define DomainMsg(X) (((X) & kDNSServiceFlagsDefault) ? "(Default)" : \
203                       ((X) & kDNSServiceFlagsAdd)     ? "Added"     : "Removed")
204 
GetNextLabel(const char * cstr,char label[64])205 static const char *GetNextLabel(const char *cstr, char label[64])
206 	{
207 	char *ptr = label;
208 	while (*cstr && *cstr != '.')								// While we have characters in the label...
209 		{
210 		char c = *cstr++;
211 		if (c == '\\')
212 			{
213 			c = *cstr++;
214 			if (isdigit(cstr[-1]) && isdigit(cstr[0]) && isdigit(cstr[1]))
215 				{
216 				int v0 = cstr[-1] - '0';						// then interpret as three-digit decimal
217 				int v1 = cstr[ 0] - '0';
218 				int v2 = cstr[ 1] - '0';
219 				int val = v0 * 100 + v1 * 10 + v2;
220 				if (val <= 255) { c = (char)val; cstr += 2; }	// If valid three-digit decimal value, use it
221 				}
222 			}
223 		*ptr++ = c;
224 		if (ptr >= label+64) return(NULL);
225 		}
226 	if (*cstr) cstr++;											// Skip over the trailing dot (if present)
227 	*ptr++ = 0;
228 	return(cstr);
229 	}
230 
enum_reply(DNSServiceRef client,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * replyDomain,void * context)231 static void DNSSD_API enum_reply(DNSServiceRef client, const DNSServiceFlags flags, uint32_t ifIndex,
232 	DNSServiceErrorType errorCode, const char *replyDomain, void *context)
233 	{
234 	DNSServiceFlags partialflags = flags & ~(kDNSServiceFlagsMoreComing | kDNSServiceFlagsAdd | kDNSServiceFlagsDefault);
235 	int labels = 0, depth = 0, i, initial = 0;
236 	char text[64];
237 	const char *label[128];
238 
239 	(void)client;       // Unused
240 	(void)ifIndex;      // Unused
241 	(void)context;      // Unused
242 
243 	// 1. Print the header
244 	if (num_printed++ == 0) printf("Timestamp     Recommended %s domain\n", operation == 'E' ? "Registration" : "Browsing");
245 	printtimestamp();
246 	if (errorCode)
247 		printf("Error code %d\n", errorCode);
248 	else if (!*replyDomain)
249 		printf("Error: No reply domain\n");
250 	else
251 		{
252 		printf("%-10s", DomainMsg(flags));
253 		printf("%-8s", (flags & kDNSServiceFlagsMoreComing) ? "(More)" : "");
254 		if (partialflags) printf("Flags: %4X  ", partialflags);
255 		else printf("             ");
256 
257 		// 2. Count the labels
258 		while (*replyDomain)
259 			{
260 			label[labels++] = replyDomain;
261 			replyDomain = GetNextLabel(replyDomain, text);
262 			}
263 
264 		// 3. Decide if we're going to clump the last two or three labels (e.g. "apple.com", or "nicta.com.au")
265 		if      (labels >= 3 && replyDomain - label[labels-1] <= 3 && label[labels-1] - label[labels-2] <= 4) initial = 3;
266 		else if (labels >= 2 && replyDomain - label[labels-1] <= 4) initial = 2;
267 		else initial = 1;
268 		labels -= initial;
269 
270 		// 4. Print the initial one-, two- or three-label clump
271 		for (i=0; i<initial; i++)
272 			{
273 			GetNextLabel(label[labels+i], text);
274 			if (i>0) printf(".");
275 			printf("%s", text);
276 			}
277 		printf("\n");
278 
279 		// 5. Print the remainder of the hierarchy
280 		for (depth=0; depth<labels; depth++)
281 			{
282 			printf("                                             ");
283 			for (i=0; i<=depth; i++) printf("- ");
284 			GetNextLabel(label[labels-1-depth], text);
285 			printf("> %s\n", text);
286 			}
287 		}
288 
289 	if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
290 	}
291 
browse_reply(DNSServiceRef client,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * replyName,const char * replyType,const char * replyDomain,void * context)292 static void DNSSD_API browse_reply(DNSServiceRef client, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
293 	const char *replyName, const char *replyType, const char *replyDomain, void *context)
294 	{
295 	char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv";
296 	(void)client;       // Unused
297 	(void)context;      // Unused
298 	if (num_printed++ == 0) printf("Timestamp     A/R Flags if %-25s %-25s %s\n", "Domain", "Service Type", "Instance Name");
299 	printtimestamp();
300 	if (errorCode) printf("Error code %d\n", errorCode);
301 	else printf("%s%6X%3d %-25s %-25s %s\n", op, flags, ifIndex, replyDomain, replyType, replyName);
302 	if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
303 	}
304 
ShowTXTRecord(uint16_t txtLen,const unsigned char * txtRecord)305 static void ShowTXTRecord(uint16_t txtLen, const unsigned char *txtRecord)
306 	{
307 	const unsigned char *ptr = txtRecord;
308 	const unsigned char *max = txtRecord + txtLen;
309 	while (ptr < max)
310 		{
311 		const unsigned char *const end = ptr + 1 + ptr[0];
312 		if (end > max) { printf("<< invalid data >>"); break; }
313 		if (++ptr < end) printf(" ");   // As long as string is non-empty, begin with a space
314 		while (ptr<end)
315 			{
316 			// We'd like the output to be shell-friendly, so that it can be copied and pasted unchanged into a "dns-sd -R" command.
317 			// However, this is trickier than it seems. Enclosing a string in double quotes doesn't necessarily make it
318 			// shell-safe, because shells still expand variables like $foo even when they appear inside quoted strings.
319 			// Enclosing a string in single quotes is better, but when using single quotes even backslash escapes are ignored,
320 			// meaning there's simply no way to represent a single quote (or apostrophe) inside a single-quoted string.
321 			// The only remaining solution is not to surround the string with quotes at all, but instead to use backslash
322 			// escapes to encode spaces and all other known shell metacharacters.
323 			// (If we've missed any known shell metacharacters, please let us know.)
324 			// In addition, non-printing ascii codes (0-31) are displayed as \xHH, using a two-digit hex value.
325 			// Because '\' is itself a shell metacharacter (the shell escape character), it has to be escaped as "\\" to survive
326 			// the round-trip to the shell and back. This means that a single '\' is represented here as EIGHT backslashes:
327 			// The C compiler eats half of them, resulting in four appearing in the output.
328 			// The shell parses those four as a pair of "\\" sequences, passing two backslashes to the "dns-sd -R" command.
329 			// The "dns-sd -R" command interprets this single "\\" pair as an escaped literal backslash. Sigh.
330 			if (strchr(" &;`'\"|*?~<>^()[]{}$", *ptr)) printf("\\");
331 			if      (*ptr == '\\') printf("\\\\\\\\");
332 			else if (*ptr >= ' ' ) printf("%c",        *ptr);
333 			else                   printf("\\\\x%02X", *ptr);
334 			ptr++;
335 			}
336 		}
337 	}
338 
resolve_reply(DNSServiceRef client,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * fullname,const char * hosttarget,uint16_t opaqueport,uint16_t txtLen,const unsigned char * txtRecord,void * context)339 static void DNSSD_API resolve_reply(DNSServiceRef client, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
340 	const char *fullname, const char *hosttarget, uint16_t opaqueport, uint16_t txtLen, const unsigned char *txtRecord, void *context)
341 	{
342 	union { uint16_t s; u_char b[2]; } port = { opaqueport };
343 	uint16_t PortAsNumber = ((uint16_t)port.b[0]) << 8 | port.b[1];
344 
345 	(void)client;       // Unused
346 	(void)ifIndex;      // Unused
347 	(void)context;      // Unused
348 
349 	printtimestamp();
350 	if (errorCode) printf("Error code %d\n", errorCode);
351 	else
352 		{
353 		printf("%s can be reached at %s:%u", fullname, hosttarget, PortAsNumber);
354 		if (flags) printf(" Flags: %X", flags);
355 		// Don't show degenerate TXT records containing nothing but a single empty string
356 		if (txtLen > 1) { printf("\n"); ShowTXTRecord(txtLen, txtRecord); }
357 		printf("\n");
358 		}
359 
360 	if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
361 	}
362 
myTimerCallBack(void)363 static void myTimerCallBack(void)
364 	{
365 	DNSServiceErrorType err = kDNSServiceErr_Unknown;
366 
367 	switch (operation)
368 		{
369 		case 'A':
370 			{
371 			switch (addtest)
372 				{
373 				case 0: printf("Adding Test HINFO record\n");
374 						err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_HINFO, sizeof(myhinfoW), &myhinfoW[0], 0);
375 						addtest = 1;
376 						break;
377 				case 1: printf("Updating Test HINFO record\n");
378 						err = DNSServiceUpdateRecord(client, record, 0, sizeof(myhinfoX), &myhinfoX[0], 0);
379 						addtest = 2;
380 						break;
381 				case 2: printf("Removing Test HINFO record\n");
382 						err = DNSServiceRemoveRecord(client, record, 0);
383 						addtest = 0;
384 						break;
385 				}
386 			}
387 			break;
388 
389 		case 'U':
390 			{
391 			if (updatetest[1] != 'Z') updatetest[1]++;
392 			else                      updatetest[1] = 'A';
393 			updatetest[0] = 3 - updatetest[0];
394 			updatetest[2] = updatetest[1];
395 			printf("Updating Test TXT record to %c\n", updatetest[1]);
396 			err = DNSServiceUpdateRecord(client, NULL, 0, 1+updatetest[0], &updatetest[0], 0);
397 			}
398 			break;
399 
400 		case 'N':
401 			{
402 			printf("Adding big NULL record\n");
403 			err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_NULL, sizeof(bigNULL), &bigNULL[0], 0);
404 			timeOut = LONG_TIME;
405 			}
406 			break;
407 		}
408 
409 	if (err != kDNSServiceErr_NoError)
410 		{
411 		fprintf(stderr, "DNSService call failed %ld\n", (long int)err);
412 		stopNow = 1;
413 		}
414 	}
415 
reg_reply(DNSServiceRef client,const DNSServiceFlags flags,DNSServiceErrorType errorCode,const char * name,const char * regtype,const char * domain,void * context)416 static void DNSSD_API reg_reply(DNSServiceRef client, const DNSServiceFlags flags, DNSServiceErrorType errorCode,
417 	const char *name, const char *regtype, const char *domain, void *context)
418 	{
419 	(void)client;   // Unused
420 	(void)flags;    // Unused
421 	(void)context;  // Unused
422 
423 	printf("Got a reply for %s.%s%s: ", name, regtype, domain);
424 
425 	if (errorCode == kDNSServiceErr_NoError)
426 		{
427 		printf("Name now registered and active\n");
428 		if (operation == 'A' || operation == 'U' || operation == 'N') timeOut = 5;
429 		}
430 	else if (errorCode == kDNSServiceErr_NameConflict)
431 		{
432 		printf("Name in use, please choose another\n");
433 		exit(-1);
434 		}
435 	else
436 		printf("Error %d\n", errorCode);
437 
438 	if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
439 	}
440 
qr_reply(DNSServiceRef sdRef,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * fullname,uint16_t rrtype,uint16_t rrclass,uint16_t rdlen,const void * rdata,uint32_t ttl,void * context)441 static void DNSSD_API qr_reply(DNSServiceRef sdRef, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
442 	const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context)
443 	{
444 	char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv";
445 	const unsigned char *rd  = rdata;
446 	const unsigned char *end = (const unsigned char *) rdata + rdlen;
447 	char rdb[1000];
448 	int unknowntype = 0;
449 
450 	(void)sdRef;    // Unused
451 	(void)flags;    // Unused
452 	(void)ifIndex;  // Unused
453 	(void)ttl;      // Unused
454 	(void)context;  // Unused
455 
456 	if (num_printed++ == 0) printf("Timestamp     A/R Flags if %-30s%4s%4s Rdata\n", "Name", "T", "C");
457 	printtimestamp();
458 	if (errorCode)
459 		printf("Error code %d\n", errorCode);
460 	else
461 		{
462 		switch (rrtype)
463 			{
464 			case kDNSServiceType_A: sprintf(rdb, "%d.%d.%d.%d", rd[0], rd[1], rd[2], rd[3]); break;
465 			case kDNSServiceType_AAAA: sprintf(rdb, "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
466 				rd[0x0], rd[0x1], rd[0x2], rd[0x3], rd[0x4], rd[0x5], rd[0x6], rd[0x7],
467 				rd[0x8], rd[0x9], rd[0xA], rd[0xB], rd[0xC], rd[0xD], rd[0xE], rd[0xF]); break;
468 				break;
469 			default : sprintf(rdb, "%d bytes%s", rdlen, rdlen ? ":" : ""); unknowntype = 1; break;
470 			}
471 
472 		printf("%s%6X%3d %-30s%4d%4d %s", op, flags, ifIndex, fullname, rrtype, rrclass, rdb);
473 		if (unknowntype) while (rd < end) printf(" %02X", *rd++);
474 		printf("\n");
475 
476 		if (operation == 'C')
477 			if (flags & kDNSServiceFlagsAdd)
478 				DNSServiceReconfirmRecord(flags, ifIndex, fullname, rrtype, rrclass, rdlen, rdata);
479 		}
480 
481 	if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
482 	}
483 
484 //*************************************************************************************************************
485 // The main test function
486 
HandleEvents(void)487 static void HandleEvents(void)
488 	{
489 	int dns_sd_fd  = client  ? DNSServiceRefSockFD(client ) : -1;
490 	int dns_sd_fd2 = client2 ? DNSServiceRefSockFD(client2) : -1;
491 	int nfds = dns_sd_fd + 1;
492 	fd_set readfds;
493 	struct timeval tv;
494 	int result;
495 
496 	if (dns_sd_fd2 > dns_sd_fd) nfds = dns_sd_fd2 + 1;
497 
498 	while (!stopNow)
499 		{
500 		// 1. Set up the fd_set as usual here.
501 		// This example client has no file descriptors of its own,
502 		// but a real application would call FD_SET to add them to the set here
503 		FD_ZERO(&readfds);
504 
505 		// 2. Add the fd for our client(s) to the fd_set
506 		if (client ) FD_SET(dns_sd_fd , &readfds);
507 		if (client2) FD_SET(dns_sd_fd2, &readfds);
508 
509 		// 3. Set up the timeout.
510 		tv.tv_sec  = timeOut;
511 		tv.tv_usec = 0;
512 
513 		result = select(nfds, &readfds, (fd_set*)NULL, (fd_set*)NULL, &tv);
514 		if (result > 0)
515 			{
516 			DNSServiceErrorType err = kDNSServiceErr_NoError;
517 			if      (client  && FD_ISSET(dns_sd_fd , &readfds)) err = DNSServiceProcessResult(client );
518 			else if (client2 && FD_ISSET(dns_sd_fd2, &readfds)) err = DNSServiceProcessResult(client2);
519 			if (err) { fprintf(stderr, "DNSServiceProcessResult returned %d\n", err); stopNow = 1; }
520 			}
521 		else if (result == 0)
522 			myTimerCallBack();
523 		else
524 			{
525 			printf("select() returned %d errno %d %s\n", result, errno, strerror(errno));
526 			if (errno != EINTR) stopNow = 1;
527 			}
528 		}
529 	}
530 
getfirstoption(int argc,char ** argv,const char * optstr,int * pOptInd)531 static int getfirstoption( int argc, char **argv, const char *optstr, int *pOptInd)
532 // Return the recognized option in optstr and the option index of the next arg.
533 #if NOT_HAVE_GETOPT
534 	{
535 	int i;
536 	for ( i=1; i < argc; i++)
537 		{
538 		if ( argv[i][0] == '-' && &argv[i][1] &&
539 			 NULL != strchr( optstr, argv[i][1]))
540 			{
541 			*pOptInd = i + 1;
542 			return argv[i][1];
543 			}
544 		}
545 	return -1;
546 	}
547 #else
548 	{
549 	int operation = getopt(argc, (char * const *)argv, optstr);
550 	*pOptInd = optind;
551 	return operation;
552 	}
553 #endif
554 
MyRegisterRecordCallback(DNSServiceRef service,DNSRecordRef record,const DNSServiceFlags flags,DNSServiceErrorType errorCode,void * context)555 static void DNSSD_API MyRegisterRecordCallback(DNSServiceRef service, DNSRecordRef record, const DNSServiceFlags flags,
556     DNSServiceErrorType errorCode, void * context)
557 	{
558 	char *name = (char *)context;
559 
560 	(void)service;	// Unused
561 	(void)record;	// Unused
562 	(void)flags;	// Unused
563 
564 	printf("Got a reply for %s: ", name);
565 	switch (errorCode)
566 		{
567 		case kDNSServiceErr_NoError:      printf("Name now registered and active\n"); break;
568 		case kDNSServiceErr_NameConflict: printf("Name in use, please choose another\n"); exit(-1);
569 		default:                          printf("Error %d\n", errorCode); break;
570 		}
571 	if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
572 	}
573 
getip(const char * const name)574 static unsigned long getip(const char *const name)
575 	{
576 	unsigned long ip = 0;
577 	struct addrinfo hints;
578 	struct addrinfo * addrs = NULL;
579 
580 	memset(&hints, 0, sizeof(hints));
581 	hints.ai_family = AF_INET;
582 
583 	if (getaddrinfo(name, NULL, &hints, &addrs) == 0)
584 		{
585 		ip = ((struct sockaddr_in*) addrs->ai_addr)->sin_addr.s_addr;
586 		}
587 
588 	if (addrs)
589 		{
590 		freeaddrinfo(addrs);
591 		}
592 
593 	return(ip);
594 	}
595 
RegisterProxyAddressRecord(DNSServiceRef * sdRef,const char * host,const char * ip)596 static DNSServiceErrorType RegisterProxyAddressRecord(DNSServiceRef *sdRef, const char *host, const char *ip)
597 	{
598 	// Call getip() after the call DNSServiceCreateConnection().
599 	// On the Win32 platform, WinSock must be initialized for getip() to succeed.
600 	// Any DNSService* call will initialize WinSock for us, so we make sure
601 	// DNSServiceCreateConnection() is called before getip() is.
602 	unsigned long addr = 0;
603 	DNSServiceErrorType err = DNSServiceCreateConnection(sdRef);
604 	if (err) { fprintf(stderr, "DNSServiceCreateConnection returned %d\n", err); return(err); }
605 	addr = getip(ip);
606 	return(DNSServiceRegisterRecord(*sdRef, &record, kDNSServiceFlagsUnique, kDNSServiceInterfaceIndexAny, host,
607 		kDNSServiceType_A, kDNSServiceClass_IN, sizeof(addr), &addr, 240, MyRegisterRecordCallback, (void*)host));
608 	// Note, should probably add support for creating proxy AAAA records too, one day
609 	}
610 
611 #define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0'     ) :  \
612 					((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) :  \
613 					((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : 0)
614 
615 #define HexPair(P) ((HexVal((P)[0]) << 4) | HexVal((P)[1]))
616 
RegisterService(DNSServiceRef * sdRef,const char * nam,const char * typ,const char * dom,const char * host,const char * port,int argc,char ** argv)617 static DNSServiceErrorType RegisterService(DNSServiceRef *sdRef,
618 	const char *nam, const char *typ, const char *dom, const char *host, const char *port, int argc, char **argv)
619 	{
620 	uint16_t PortAsNumber = atoi(port);
621 	Opaque16 registerPort = { { PortAsNumber >> 8, PortAsNumber & 0xFF } };
622 	unsigned char txt[2048] = "";
623 	unsigned char *ptr = txt;
624 	int i;
625 
626 	if (nam[0] == '.' && nam[1] == 0) nam = "";   // We allow '.' on the command line as a synonym for empty string
627 	if (dom[0] == '.' && dom[1] == 0) dom = "";   // We allow '.' on the command line as a synonym for empty string
628 
629 	printf("Registering Service %s.%s%s%s", nam[0] ? nam : "<<Default>>", typ, dom[0] ? "." : "", dom);
630 	if (host && *host) printf(" host %s", host);
631 	printf(" port %s\n", port);
632 
633 	if (argc)
634 		{
635 		for (i = 0; i < argc; i++)
636 			{
637 			const char *p = argv[i];
638 			*ptr = 0;
639 			while (*p && *ptr < 255 && ptr + 1 + *ptr < txt+sizeof(txt))
640 				{
641 				if      (p[0] != '\\' || p[1] == 0)                       { ptr[++*ptr] = *p;           p+=1; }
642 				else if (p[1] == 'x' && isxdigit(p[2]) && isxdigit(p[3])) { ptr[++*ptr] = HexPair(p+2); p+=4; }
643 				else                                                      { ptr[++*ptr] = p[1];         p+=2; }
644 				}
645 			ptr += 1 + *ptr;
646 			}
647 		ShowTXTRecord(ptr-txt, txt);
648 		printf("\n");
649 		}
650 
651 	return(DNSServiceRegister(sdRef, /* kDNSServiceFlagsAllowRemoteQuery */ 0, opinterface, nam, typ, dom, host, registerPort.NotAnInteger, (uint16_t) (ptr-txt), txt, reg_reply, NULL));
652 	}
653 
main(int argc,char ** argv)654 int main(int argc, char **argv)
655 	{
656 	DNSServiceErrorType err;
657 	char *dom;
658 	int optind;
659 
660 	// Extract the program name from argv[0], which by convention contains the path to this executable.
661 	// Note that this is just a voluntary convention, not enforced by the kernel --
662 	// the process calling exec() can pass bogus data in argv[0] if it chooses to.
663 	const char *a0 = strrchr(argv[0], kFilePathSep) + 1;
664 	if (a0 == (const char *)1) a0 = argv[0];
665 
666 	if (argc > 1 && !strcmp(argv[1], "-lo"))
667 		{
668 		argc--;
669 		argv++;
670 		opinterface = kDNSServiceInterfaceIndexLocalOnly;
671 		printf("Using LocalOnly\n");
672 		}
673 
674 	if (argc > 2 && !strcmp(argv[1], "-i") && atoi(argv[2]))
675 		{
676 		opinterface = atoi(argv[2]);
677 		argc -= 2;
678 		argv += 2;
679 		printf("Using interface %d\n", opinterface);
680 		}
681 
682 	if (argc < 2) goto Fail;        // Minimum command line is the command name and one argument
683 	operation = getfirstoption( argc, argv, "EFBLRPQCAUNTMI", &optind);
684 	if (operation == -1) goto Fail;
685 
686 	switch (operation)
687 		{
688 		case 'E':	printf("Looking for recommended registration domains:\n");
689 					err = DNSServiceEnumerateDomains(&client, kDNSServiceFlagsRegistrationDomains, opinterface, enum_reply, NULL);
690 					break;
691 
692 		case 'F':	printf("Looking for recommended browsing domains:\n");
693 					err = DNSServiceEnumerateDomains(&client, kDNSServiceFlagsBrowseDomains, opinterface, enum_reply, NULL);
694 					//enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "nicta.com.au.", NULL);
695 					//enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "bonjour.nicta.com.au.", NULL);
696 					//enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "ibm.com.", NULL);
697 					//enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "dns-sd.ibm.com.", NULL);
698 					break;
699 
700 		case 'B':	if (argc < optind+1) goto Fail;
701 					dom = (argc < optind+2) ? "" : argv[optind+1];
702 					if (dom[0] == '.' && dom[1] == 0) dom[0] = 0;   // We allow '.' on the command line as a synonym for empty string
703 					printf("Browsing for %s%s%s\n", argv[optind+0], dom[0] ? "." : "", dom);
704 					err = DNSServiceBrowse(&client, 0, opinterface, argv[optind+0], dom, browse_reply, NULL);
705 					break;
706 
707 		case 'L':	if (argc < optind+2) goto Fail;
708 					dom = (argc < optind+3) ? "local" : argv[optind+2];
709 					if (dom[0] == '.' && dom[1] == 0) dom = "local";   // We allow '.' on the command line as a synonym for "local"
710 					printf("Lookup %s.%s.%s\n", argv[optind+0], argv[optind+1], dom);
711 					err = DNSServiceResolve(&client, 0, opinterface, argv[optind+0], argv[optind+1], dom, (DNSServiceResolveReply)resolve_reply, NULL);
712 					break;
713 
714 		case 'R':	if (argc < optind+4) goto Fail;
715 					err = RegisterService(&client, argv[optind+0], argv[optind+1], argv[optind+2], NULL, argv[optind+3], argc-(optind+4), argv+(optind+4));
716 					break;
717 
718 		case 'P':	if (argc < optind+6) goto Fail;
719 					err = RegisterProxyAddressRecord(&client2, argv[optind+4], argv[optind+5]);
720 					if (err) break;
721 					err = RegisterService(&client, argv[optind+0], argv[optind+1], argv[optind+2], argv[optind+4], argv[optind+3], argc-(optind+6), argv+(optind+6));
722 					break;
723 
724 		case 'Q':
725 		case 'C':	{
726 					uint16_t rrtype, rrclass;
727 					DNSServiceFlags flags = kDNSServiceFlagsReturnCNAME;
728 					if (argc < optind+1) goto Fail;
729 					rrtype = (argc <= optind+1) ? kDNSServiceType_A  : GetRRType(argv[optind+1]);
730 					rrclass = (argc <= optind+2) ? kDNSServiceClass_IN : atoi(argv[optind+2]);
731 					if (rrtype == kDNSServiceType_TXT || rrtype == kDNSServiceType_PTR) flags |= kDNSServiceFlagsLongLivedQuery;
732 					err = DNSServiceQueryRecord(&client, flags, opinterface, argv[optind+0], rrtype, rrclass, qr_reply, NULL);
733 					break;
734 					}
735 
736 		case 'A':
737 		case 'U':
738 		case 'N':	{
739 					Opaque16 registerPort = { { 0x12, 0x34 } };
740 					static const char TXT[] = "\xC" "First String" "\xD" "Second String" "\xC" "Third String";
741 					printf("Registering Service Test._testupdate._tcp.local.\n");
742 					err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testupdate._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT)-1, TXT, reg_reply, NULL);
743 					break;
744 					}
745 
746 		case 'T':	{
747 					Opaque16 registerPort = { { 0x23, 0x45 } };
748 					char TXT[1024];
749 					unsigned int i;
750 					for (i=0; i<sizeof(TXT); i++)
751 						if ((i & 0x1F) == 0) TXT[i] = 0x1F; else TXT[i] = 'A' + (i >> 5);
752 					printf("Registering Service Test._testlargetxt._tcp.local.\n");
753 					err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testlargetxt._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT), TXT, reg_reply, NULL);
754 					break;
755 					}
756 
757 		case 'M':	{
758 					pid_t pid = getpid();
759 					Opaque16 registerPort = { { pid >> 8, pid & 0xFF } };
760 					static const char TXT1[] = "\xC" "First String"  "\xD" "Second String" "\xC" "Third String";
761 					static const char TXT2[] = "\xD" "Fourth String" "\xC" "Fifth String"  "\xC" "Sixth String";
762 					printf("Registering Service Test._testdualtxt._tcp.local.\n");
763 					err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testdualtxt._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT1)-1, TXT1, reg_reply, NULL);
764 					if (!err) err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_TXT, sizeof(TXT2)-1, TXT2, 0);
765 					break;
766 					}
767 
768 		case 'I':	{
769 					pid_t pid = getpid();
770 					Opaque16 registerPort = { { pid >> 8, pid & 0xFF } };
771 					static const char TXT[] = "\x09" "Test Data";
772 					printf("Registering Service Test._testtxt._tcp.local.\n");
773 					err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testtxt._tcp.", "", NULL, registerPort.NotAnInteger, 0, NULL, reg_reply, NULL);
774 					if (!err) err = DNSServiceUpdateRecord(client, NULL, 0, sizeof(TXT)-1, TXT, 0);
775 					break;
776 					}
777 
778 		default: goto Fail;
779 		}
780 
781 	if (!client || err != kDNSServiceErr_NoError) { fprintf(stderr, "DNSService call failed %ld\n", (long int)err); return (-1); }
782 	HandleEvents();
783 
784 	// Be sure to deallocate the DNSServiceRef when you're finished
785 	if (client ) DNSServiceRefDeallocate(client );
786 	if (client2) DNSServiceRefDeallocate(client2);
787 	return 0;
788 
789 Fail:
790 	fprintf(stderr, "%s -E                  (Enumerate recommended registration domains)\n", a0);
791 	fprintf(stderr, "%s -F                      (Enumerate recommended browsing domains)\n", a0);
792 	fprintf(stderr, "%s -B        <Type> <Domain>        (Browse for services instances)\n", a0);
793 	fprintf(stderr, "%s -L <Name> <Type> <Domain>           (Look up a service instance)\n", a0);
794 	fprintf(stderr, "%s -R <Name> <Type> <Domain> <Port> [<TXT>...] (Register a service)\n", a0);
795 	fprintf(stderr, "%s -P <Name> <Type> <Domain> <Port> <Host> <IP> [<TXT>...]  (Proxy)\n", a0);
796 	fprintf(stderr, "%s -Q <FQDN> <rrtype> <rrclass> (Generic query for any record type)\n", a0);
797 	fprintf(stderr, "%s -C <FQDN> <rrtype> <rrclass>   (Query; reconfirming each result)\n", a0);
798 	fprintf(stderr, "%s -A                      (Test Adding/Updating/Deleting a record)\n", a0);
799 	fprintf(stderr, "%s -U                                  (Test updating a TXT record)\n", a0);
800 	fprintf(stderr, "%s -N                             (Test adding a large NULL record)\n", a0);
801 	fprintf(stderr, "%s -T                            (Test creating a large TXT record)\n", a0);
802 	fprintf(stderr, "%s -M      (Test creating a registration with multiple TXT records)\n", a0);
803 	fprintf(stderr, "%s -I   (Test registering and then immediately updating TXT record)\n", a0);
804 	return 0;
805 	}
806