]> git.saurik.com Git - apple/mdnsresponder.git/blob - Clients/dns-sd.c
mDNSResponder-320.10.80.tar.gz
[apple/mdnsresponder.git] / Clients / dns-sd.c
1 /* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2002-2008 Apple 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 // For testing changes to dnssd_clientstub.c, uncomment this line and the code will be compiled
67 // with an embedded copy of the client stub instead of linking the system library version at runtime.
68 // This also useful to work around link errors when you're working on an older version of Mac OS X,
69 // and trying to build a newer version of the "dns-sd" command which uses new API entry points that
70 // aren't in the system's /usr/lib/libSystem.dylib.
71 //#define TEST_NEW_CLIENTSTUB 1
72
73 // When building mDNSResponder for Mac OS X 10.4 and earlier, /usr/lib/libSystem.dylib is built using its own private
74 // copy of dnssd_clientstub.c, which is old and doesn't have all the entry points defined in the latest version, so
75 // when we're building dns-sd.c on Mac OS X 10.4 or earlier, we automatically set TEST_NEW_CLIENTSTUB so that we'll
76 // embed a copy of the latest dnssd_clientstub.c instead of trying to link to the incomplete version in libSystem.dylib
77 #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ <= 1040
78 #define TEST_NEW_CLIENTSTUB 1
79 #endif
80
81 #include <ctype.h>
82 #include <stdio.h> // For stdout, stderr
83 #include <stdlib.h> // For exit()
84 #include <string.h> // For strlen(), strcpy()
85 #include <errno.h> // For errno, EINTR
86 #include <time.h>
87 #include <sys/types.h> // For u_char
88
89 #ifdef _WIN32
90 #include <winsock2.h>
91 #include <ws2tcpip.h>
92 #include <Iphlpapi.h>
93 #include <process.h>
94 typedef int pid_t;
95 #define getpid _getpid
96 #define strcasecmp _stricmp
97 #define snprintf _snprintf
98 static const char kFilePathSep = '\\';
99 #ifndef HeapEnableTerminationOnCorruption
100 # define HeapEnableTerminationOnCorruption (HEAP_INFORMATION_CLASS)1
101 #endif
102 #if !defined(IFNAMSIZ)
103 #define IFNAMSIZ 16
104 #endif
105 #define if_nametoindex if_nametoindex_win
106 #define if_indextoname if_indextoname_win
107
108 typedef PCHAR (WINAPI * if_indextoname_funcptr_t)(ULONG index, PCHAR name);
109 typedef ULONG (WINAPI * if_nametoindex_funcptr_t)(PCSTR name);
110
111 unsigned if_nametoindex_win(const char *ifname)
112 {
113 HMODULE library;
114 unsigned index = 0;
115
116 // Try and load the IP helper library dll
117 if ((library = LoadLibrary(TEXT("Iphlpapi")) ) != NULL )
118 {
119 if_nametoindex_funcptr_t if_nametoindex_funcptr;
120
121 // On Vista and above there is a Posix like implementation of if_nametoindex
122 if ((if_nametoindex_funcptr = (if_nametoindex_funcptr_t) GetProcAddress(library, "if_nametoindex")) != NULL )
123 {
124 index = if_nametoindex_funcptr(ifname);
125 }
126
127 FreeLibrary(library);
128 }
129
130 return index;
131 }
132
133 char * if_indextoname_win( unsigned ifindex, char *ifname)
134 {
135 HMODULE library;
136 char * name = NULL;
137
138 // Try and load the IP helper library dll
139 if ((library = LoadLibrary(TEXT("Iphlpapi")) ) != NULL )
140 {
141 if_indextoname_funcptr_t if_indextoname_funcptr;
142
143 // On Vista and above there is a Posix like implementation of if_indextoname
144 if ((if_indextoname_funcptr = (if_indextoname_funcptr_t) GetProcAddress(library, "if_indextoname")) != NULL )
145 {
146 name = if_indextoname_funcptr(ifindex, ifname);
147 }
148
149 FreeLibrary(library);
150 }
151
152 return name;
153 }
154
155 static size_t _sa_len(const struct sockaddr *addr)
156 {
157 if (addr->sa_family == AF_INET) return (sizeof(struct sockaddr_in));
158 else if (addr->sa_family == AF_INET6) return (sizeof(struct sockaddr_in6));
159 else return (sizeof(struct sockaddr));
160 }
161
162 # define SA_LEN(addr) (_sa_len(addr))
163
164 #else
165 #include <unistd.h> // For getopt() and optind
166 #include <netdb.h> // For getaddrinfo()
167 #include <sys/time.h> // For struct timeval
168 #include <sys/socket.h> // For AF_INET
169 #include <netinet/in.h> // For struct sockaddr_in()
170 #include <arpa/inet.h> // For inet_addr()
171 #include <net/if.h> // For if_nametoindex()
172 static const char kFilePathSep = '/';
173 // #ifndef NOT_HAVE_SA_LEN
174 // #define SA_LEN(addr) ((addr)->sa_len)
175 // #else
176 #define SA_LEN(addr) (((addr)->sa_family == AF_INET6)? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in))
177 // #endif
178 #endif
179
180 #if (TEST_NEW_CLIENTSTUB && !defined(__APPLE_API_PRIVATE))
181 #define __APPLE_API_PRIVATE 1
182 #endif
183
184 // DNSServiceSetDispatchQueue is not supported on 10.6 & prior
185 #if ! TEST_NEW_CLIENTSTUB && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ % 10) <= 1060)
186 #undef _DNS_SD_LIBDISPATCH
187 #endif
188 #include "dns_sd.h"
189 #include "ClientCommon.h"
190
191 #if TEST_NEW_CLIENTSTUB
192 #include "../mDNSShared/dnssd_ipc.c"
193 #include "../mDNSShared/dnssd_clientlib.c"
194 #include "../mDNSShared/dnssd_clientstub.c"
195 #endif
196
197 // The "+0" is to cope with the case where _DNS_SD_H is defined but empty (e.g. on Mac OS X 10.4 and earlier)
198 #if _DNS_SD_H+0 >= 116
199 #define HAS_NAT_PMP_API 1
200 #define HAS_ADDRINFO_API 1
201 #else
202 #define kDNSServiceFlagsReturnIntermediates 0
203 #endif
204
205 //*************************************************************************************************************
206 // Globals
207
208 typedef union { unsigned char b[2]; unsigned short NotAnInteger; } Opaque16;
209
210 static int operation;
211 static uint32_t opinterface = kDNSServiceInterfaceIndexAny;
212 static DNSServiceRef client = NULL;
213 static DNSServiceRef client_pa = NULL; // DNSServiceRef for RegisterProxyAddressRecord
214 static DNSServiceRef sc1, sc2, sc3; // DNSServiceRefs for kDNSServiceFlagsShareConnection testing
215
216 static int num_printed;
217 static char addtest = 0;
218 static DNSRecordRef record = NULL;
219 static char myhinfoW[14] = "\002PC\012Windows XP";
220 static char myhinfoX[ 9] = "\003Mac\004OS X";
221 static char updatetest[3] = "\002AA";
222 static char bigNULL[8192]; // 8K is maximum rdata we support
223
224 #if _DNS_SD_LIBDISPATCH
225 dispatch_queue_t main_queue;
226 dispatch_source_t timer_source;
227 #endif
228
229 // Note: the select() implementation on Windows (Winsock2) fails with any timeout much larger than this
230 #define LONG_TIME 100000000
231
232 static volatile int stopNow = 0;
233 static volatile int timeOut = LONG_TIME;
234
235 #if _DNS_SD_LIBDISPATCH
236 #define EXIT_IF_LIBDISPATCH_FATAL_ERROR(E) \
237 if (main_queue && (E) == kDNSServiceErr_ServiceNotRunning) { fprintf(stderr, "Error code %d\n", (E)); exit(0); }
238 #else
239 #define EXIT_IF_LIBDISPATCH_FATAL_ERROR(E)
240 #endif
241
242 //*************************************************************************************************************
243 // Supporting Utility Functions
244
245 static uint16_t GetRRType(const char *s)
246 {
247 if (!strcasecmp(s, "A" )) return(kDNSServiceType_A);
248 else if (!strcasecmp(s, "NS" )) return(kDNSServiceType_NS);
249 else if (!strcasecmp(s, "MD" )) return(kDNSServiceType_MD);
250 else if (!strcasecmp(s, "MF" )) return(kDNSServiceType_MF);
251 else if (!strcasecmp(s, "CNAME" )) return(kDNSServiceType_CNAME);
252 else if (!strcasecmp(s, "SOA" )) return(kDNSServiceType_SOA);
253 else if (!strcasecmp(s, "MB" )) return(kDNSServiceType_MB);
254 else if (!strcasecmp(s, "MG" )) return(kDNSServiceType_MG);
255 else if (!strcasecmp(s, "MR" )) return(kDNSServiceType_MR);
256 else if (!strcasecmp(s, "NULL" )) return(kDNSServiceType_NULL);
257 else if (!strcasecmp(s, "WKS" )) return(kDNSServiceType_WKS);
258 else if (!strcasecmp(s, "PTR" )) return(kDNSServiceType_PTR);
259 else if (!strcasecmp(s, "HINFO" )) return(kDNSServiceType_HINFO);
260 else if (!strcasecmp(s, "MINFO" )) return(kDNSServiceType_MINFO);
261 else if (!strcasecmp(s, "MX" )) return(kDNSServiceType_MX);
262 else if (!strcasecmp(s, "TXT" )) return(kDNSServiceType_TXT);
263 else if (!strcasecmp(s, "RP" )) return(kDNSServiceType_RP);
264 else if (!strcasecmp(s, "AFSDB" )) return(kDNSServiceType_AFSDB);
265 else if (!strcasecmp(s, "X25" )) return(kDNSServiceType_X25);
266 else if (!strcasecmp(s, "ISDN" )) return(kDNSServiceType_ISDN);
267 else if (!strcasecmp(s, "RT" )) return(kDNSServiceType_RT);
268 else if (!strcasecmp(s, "NSAP" )) return(kDNSServiceType_NSAP);
269 else if (!strcasecmp(s, "NSAP_PTR")) return(kDNSServiceType_NSAP_PTR);
270 else if (!strcasecmp(s, "SIG" )) return(kDNSServiceType_SIG);
271 else if (!strcasecmp(s, "KEY" )) return(kDNSServiceType_KEY);
272 else if (!strcasecmp(s, "PX" )) return(kDNSServiceType_PX);
273 else if (!strcasecmp(s, "GPOS" )) return(kDNSServiceType_GPOS);
274 else if (!strcasecmp(s, "AAAA" )) return(kDNSServiceType_AAAA);
275 else if (!strcasecmp(s, "LOC" )) return(kDNSServiceType_LOC);
276 else if (!strcasecmp(s, "NXT" )) return(kDNSServiceType_NXT);
277 else if (!strcasecmp(s, "EID" )) return(kDNSServiceType_EID);
278 else if (!strcasecmp(s, "NIMLOC" )) return(kDNSServiceType_NIMLOC);
279 else if (!strcasecmp(s, "SRV" )) return(kDNSServiceType_SRV);
280 else if (!strcasecmp(s, "ATMA" )) return(kDNSServiceType_ATMA);
281 else if (!strcasecmp(s, "NAPTR" )) return(kDNSServiceType_NAPTR);
282 else if (!strcasecmp(s, "KX" )) return(kDNSServiceType_KX);
283 else if (!strcasecmp(s, "CERT" )) return(kDNSServiceType_CERT);
284 else if (!strcasecmp(s, "A6" )) return(kDNSServiceType_A6);
285 else if (!strcasecmp(s, "DNAME" )) return(kDNSServiceType_DNAME);
286 else if (!strcasecmp(s, "SINK" )) return(kDNSServiceType_SINK);
287 else if (!strcasecmp(s, "OPT" )) return(kDNSServiceType_OPT);
288 else if (!strcasecmp(s, "TKEY" )) return(kDNSServiceType_TKEY);
289 else if (!strcasecmp(s, "TSIG" )) return(kDNSServiceType_TSIG);
290 else if (!strcasecmp(s, "IXFR" )) return(kDNSServiceType_IXFR);
291 else if (!strcasecmp(s, "AXFR" )) return(kDNSServiceType_AXFR);
292 else if (!strcasecmp(s, "MAILB" )) return(kDNSServiceType_MAILB);
293 else if (!strcasecmp(s, "MAILA" )) return(kDNSServiceType_MAILA);
294 else if (!strcasecmp(s, "ANY" )) return(kDNSServiceType_ANY);
295 else return(atoi(s));
296 }
297
298 #if HAS_NAT_PMP_API | HAS_ADDRINFO_API
299 static DNSServiceProtocol GetProtocol(const char *s)
300 {
301 if (!strcasecmp(s, "v4" )) return(kDNSServiceProtocol_IPv4);
302 else if (!strcasecmp(s, "v6" )) return(kDNSServiceProtocol_IPv6);
303 else if (!strcasecmp(s, "v4v6" )) return(kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6);
304 else if (!strcasecmp(s, "v6v4" )) return(kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6);
305 else if (!strcasecmp(s, "udp" )) return(kDNSServiceProtocol_UDP);
306 else if (!strcasecmp(s, "tcp" )) return(kDNSServiceProtocol_TCP);
307 else if (!strcasecmp(s, "udptcp" )) return(kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP);
308 else if (!strcasecmp(s, "tcpudp" )) return(kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP);
309 else return(atoi(s));
310 }
311 #endif
312
313 //*************************************************************************************************************
314 // Sample callback functions for each of the operation types
315
316 static void printtimestamp(void)
317 {
318 struct tm tm;
319 int ms;
320 #ifdef _WIN32
321 SYSTEMTIME sysTime;
322 time_t uct = time(NULL);
323 tm = *localtime(&uct);
324 GetLocalTime(&sysTime);
325 ms = sysTime.wMilliseconds;
326 #else
327 struct timeval tv;
328 gettimeofday(&tv, NULL);
329 localtime_r((time_t*)&tv.tv_sec, &tm);
330 ms = tv.tv_usec/1000;
331 #endif
332 printf("%2d:%02d:%02d.%03d ", tm.tm_hour, tm.tm_min, tm.tm_sec, ms);
333 }
334
335 #define DomainMsg(X) (((X) & kDNSServiceFlagsDefault) ? "(Default)" : \
336 ((X) & kDNSServiceFlagsAdd) ? "Added" : "Removed")
337
338 #define MAX_LABELS 128
339
340 static void DNSSD_API enum_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex,
341 DNSServiceErrorType errorCode, const char *replyDomain, void *context)
342 {
343 DNSServiceFlags partialflags = flags & ~(kDNSServiceFlagsMoreComing | kDNSServiceFlagsAdd | kDNSServiceFlagsDefault);
344 int labels = 0, depth = 0, i, initial = 0;
345 char text[64];
346 const char *label[MAX_LABELS];
347
348 (void)sdref; // Unused
349 (void)ifIndex; // Unused
350 (void)context; // Unused
351 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
352
353 // 1. Print the header
354 if (num_printed++ == 0) printf("Timestamp Recommended %s domain\n", operation == 'E' ? "Registration" : "Browsing");
355 printtimestamp();
356 if (errorCode)
357 printf("Error code %d\n", errorCode);
358 else if (!*replyDomain)
359 printf("Error: No reply domain\n");
360 else
361 {
362 printf("%-10s", DomainMsg(flags));
363 printf("%-8s", (flags & kDNSServiceFlagsMoreComing) ? "(More)" : "");
364 if (partialflags) printf("Flags: %4X ", partialflags);
365 else printf(" ");
366
367 // 2. Count the labels
368 while (replyDomain && *replyDomain && labels < MAX_LABELS)
369 {
370 label[labels++] = replyDomain;
371 replyDomain = GetNextLabel(replyDomain, text);
372 }
373
374 // 3. Decide if we're going to clump the last two or three labels (e.g. "apple.com", or "nicta.com.au")
375 if (labels >= 3 && replyDomain - label[labels-1] <= 3 && label[labels-1] - label[labels-2] <= 4) initial = 3;
376 else if (labels >= 2 && replyDomain - label[labels-1] <= 4) initial = 2;
377 else initial = 1;
378 labels -= initial;
379
380 // 4. Print the initial one-, two- or three-label clump
381 for (i=0; i<initial; i++)
382 {
383 GetNextLabel(label[labels+i], text);
384 if (i>0) printf(".");
385 printf("%s", text);
386 }
387 printf("\n");
388
389 // 5. Print the remainder of the hierarchy
390 for (depth=0; depth<labels; depth++)
391 {
392 printf(" ");
393 for (i=0; i<=depth; i++) printf("- ");
394 GetNextLabel(label[labels-1-depth], text);
395 printf("> %s\n", text);
396 }
397 }
398
399 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
400 }
401
402 static int CopyLabels(char *dst, const char *lim, const char **srcp, int labels)
403 {
404 const char *src = *srcp;
405 while (*src != '.' || --labels > 0)
406 {
407 if (*src == '\\') *dst++ = *src++; // Make sure "\." doesn't confuse us
408 if (!*src || dst >= lim) return -1;
409 *dst++ = *src++;
410 if (!*src || dst >= lim) return -1;
411 }
412 *dst++ = 0;
413 *srcp = src + 1; // skip over final dot
414 return 0;
415 }
416
417 static void DNSSD_API zonedata_resolve(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
418 const char *fullname, const char *hosttarget, uint16_t opaqueport, uint16_t txtLen, const unsigned char *txt, void *context)
419 {
420 union { uint16_t s; u_char b[2]; } port = { opaqueport };
421 uint16_t PortAsNumber = ((uint16_t)port.b[0]) << 8 | port.b[1];
422
423 const char *p = fullname;
424 char n[kDNSServiceMaxDomainName];
425 char t[kDNSServiceMaxDomainName];
426
427 const unsigned char *max = txt + txtLen;
428
429 (void)sdref; // Unused
430 (void)ifIndex; // Unused
431 (void)context; // Unused
432
433 //if (!(flags & kDNSServiceFlagsAdd)) return;
434 if (errorCode) { printf("Error code %d\n", errorCode); return; }
435
436 if (CopyLabels(n, n + kDNSServiceMaxDomainName, &p, 3)) return; // Fetch name+type
437 p = fullname;
438 if (CopyLabels(t, t + kDNSServiceMaxDomainName, &p, 1)) return; // Skip first label
439 if (CopyLabels(t, t + kDNSServiceMaxDomainName, &p, 2)) return; // Fetch next two labels (service type)
440
441 if (num_printed++ == 0)
442 {
443 printf("\n");
444 printf("; To direct clients to browse a different domain, substitute that domain in place of '@'\n");
445 printf("%-47s PTR %s\n", "lb._dns-sd._udp", "@");
446 printf("\n");
447 printf("; In the list of services below, the SRV records will typically reference dot-local Multicast DNS names.\n");
448 printf("; When transferring this zone file data to your unicast DNS server, you'll need to replace those dot-local\n");
449 printf("; names with the correct fully-qualified (unicast) domain name of the target host offering the service.\n");
450 }
451
452 printf("\n");
453 printf("%-47s PTR %s\n", t, n);
454 printf("%-47s SRV 0 0 %d %s ; Replace with unicast FQDN of target host\n", n, PortAsNumber, hosttarget);
455 printf("%-47s TXT ", n);
456
457 while (txt < max)
458 {
459 const unsigned char *const end = txt + 1 + txt[0];
460 txt++; // Skip over length byte
461 printf(" \"");
462 while (txt<end)
463 {
464 if (*txt == '\\' || *txt == '\"') printf("\\");
465 printf("%c", *txt++);
466 }
467 printf("\"");
468 }
469 printf("\n");
470
471 DNSServiceRefDeallocate(sdref);
472 free(context);
473
474 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
475 }
476
477 static void DNSSD_API zonedata_browse(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
478 const char *replyName, const char *replyType, const char *replyDomain, void *context)
479 {
480 DNSServiceRef *newref;
481
482 (void)sdref; // Unused
483 (void)context; // Unused
484 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
485
486 if (!(flags & kDNSServiceFlagsAdd)) return;
487 if (errorCode) { printf("Error code %d\n", errorCode); return; }
488
489 newref = malloc(sizeof(*newref));
490 *newref = client;
491 DNSServiceResolve(newref, kDNSServiceFlagsShareConnection, ifIndex, replyName, replyType, replyDomain, zonedata_resolve, newref);
492 }
493
494 static void DNSSD_API browse_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
495 const char *replyName, const char *replyType, const char *replyDomain, void *context)
496 {
497 char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv";
498 (void)sdref; // Unused
499 (void)context; // Unused
500 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
501
502 if (num_printed++ == 0) printf("Timestamp A/R Flags if %-25s %-25s %s\n", "Domain", "Service Type", "Instance Name");
503 printtimestamp();
504 if (errorCode) printf("Error code %d\n", errorCode);
505 else printf("%s%6X%3d %-25s %-25s %s\n", op, flags, ifIndex, replyDomain, replyType, replyName);
506 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
507
508 // To test selective cancellation of operations of shared sockets,
509 // cancel the current operation when we've got a multiple of five results
510 //if (operation == 'S' && num_printed % 5 == 0) DNSServiceRefDeallocate(sdref);
511 }
512
513 static void ShowTXTRecord(uint16_t txtLen, const unsigned char *txtRecord)
514 {
515 const unsigned char *ptr = txtRecord;
516 const unsigned char *max = txtRecord + txtLen;
517 while (ptr < max)
518 {
519 const unsigned char *const end = ptr + 1 + ptr[0];
520 if (end > max) { printf("<< invalid data >>"); break; }
521 if (++ptr < end) printf(" "); // As long as string is non-empty, begin with a space
522 while (ptr<end)
523 {
524 // We'd like the output to be shell-friendly, so that it can be copied and pasted unchanged into a "dns-sd -R" command.
525 // However, this is trickier than it seems. Enclosing a string in double quotes doesn't necessarily make it
526 // shell-safe, because shells still expand variables like $foo even when they appear inside quoted strings.
527 // Enclosing a string in single quotes is better, but when using single quotes even backslash escapes are ignored,
528 // meaning there's simply no way to represent a single quote (or apostrophe) inside a single-quoted string.
529 // The only remaining solution is not to surround the string with quotes at all, but instead to use backslash
530 // escapes to encode spaces and all other known shell metacharacters.
531 // (If we've missed any known shell metacharacters, please let us know.)
532 // In addition, non-printing ascii codes (0-31) are displayed as \xHH, using a two-digit hex value.
533 // Because '\' is itself a shell metacharacter (the shell escape character), it has to be escaped as "\\" to survive
534 // the round-trip to the shell and back. This means that a single '\' is represented here as EIGHT backslashes:
535 // The C compiler eats half of them, resulting in four appearing in the output.
536 // The shell parses those four as a pair of "\\" sequences, passing two backslashes to the "dns-sd -R" command.
537 // The "dns-sd -R" command interprets this single "\\" pair as an escaped literal backslash. Sigh.
538 if (strchr(" &;`'\"|*?~<>^()[]{}$", *ptr)) printf("\\");
539 if (*ptr == '\\') printf("\\\\\\\\");
540 else if (*ptr >= ' ' ) printf("%c", *ptr);
541 else printf("\\\\x%02X", *ptr);
542 ptr++;
543 }
544 }
545 }
546
547 static void DNSSD_API resolve_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
548 const char *fullname, const char *hosttarget, uint16_t opaqueport, uint16_t txtLen, const unsigned char *txtRecord, void *context)
549 {
550 union { uint16_t s; u_char b[2]; } port = { opaqueport };
551 uint16_t PortAsNumber = ((uint16_t)port.b[0]) << 8 | port.b[1];
552
553 (void)sdref; // Unused
554 (void)ifIndex; // Unused
555 (void)context; // Unused
556 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
557
558 if (errorCode)
559 printf("Error code %d\n", errorCode);
560 else
561 {
562 printtimestamp();
563 printf("%s can be reached at %s:%u (interface %d)", fullname, hosttarget, PortAsNumber, ifIndex);
564 if (flags) printf(" Flags: %X", flags);
565 // Don't show degenerate TXT records containing nothing but a single empty string
566 if (txtLen > 1) { printf("\n"); ShowTXTRecord(txtLen, txtRecord); }
567 printf("\n");
568 }
569
570 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
571 }
572
573 static void myTimerCallBack(void)
574 {
575 DNSServiceErrorType err = kDNSServiceErr_Unknown;
576
577 switch (operation)
578 {
579 case 'A':
580 {
581 switch (addtest)
582 {
583 case 0: printf("Adding Test HINFO record\n");
584 err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_HINFO, sizeof(myhinfoW), &myhinfoW[0], 0);
585 addtest = 1;
586 break;
587 case 1: printf("Updating Test HINFO record\n");
588 err = DNSServiceUpdateRecord(client, record, 0, sizeof(myhinfoX), &myhinfoX[0], 0);
589 addtest = 2;
590 break;
591 case 2: printf("Removing Test HINFO record\n");
592 err = DNSServiceRemoveRecord(client, record, 0);
593 addtest = 0;
594 break;
595 }
596 }
597 break;
598
599 case 'U':
600 {
601 if (updatetest[1] != 'Z') updatetest[1]++;
602 else updatetest[1] = 'A';
603 updatetest[0] = 3 - updatetest[0];
604 updatetest[2] = updatetest[1];
605 printtimestamp();
606 printf("Updating Test TXT record to %c\n", updatetest[1]);
607 err = DNSServiceUpdateRecord(client, NULL, 0, 1+updatetest[0], &updatetest[0], 0);
608 }
609 break;
610
611 case 'N':
612 {
613 printf("Adding big NULL record\n");
614 err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_NULL, sizeof(bigNULL), &bigNULL[0], 0);
615 if (err) printf("Failed: %d\n", err); else printf("Succeeded\n");
616 timeOut = LONG_TIME;
617 #if _DNS_SD_LIBDISPATCH
618 if (timer_source)
619 dispatch_source_set_timer(timer_source, dispatch_time(DISPATCH_TIME_NOW, (uint64_t)timeOut * NSEC_PER_SEC),
620 (uint64_t)timeOut * NSEC_PER_SEC, 0);
621 #endif
622 }
623 break;
624 }
625
626 if (err != kDNSServiceErr_NoError)
627 {
628 fprintf(stderr, "DNSService add/update/remove failed %ld\n", (long int)err);
629 stopNow = 1;
630 }
631 }
632
633 static void DNSSD_API reg_reply(DNSServiceRef sdref, const DNSServiceFlags flags, DNSServiceErrorType errorCode,
634 const char *name, const char *regtype, const char *domain, void *context)
635 {
636 (void)sdref; // Unused
637 (void)flags; // Unused
638 (void)context; // Unused
639 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
640
641 printtimestamp();
642 printf("Got a reply for service %s.%s%s: ", name, regtype, domain);
643
644 if (errorCode == kDNSServiceErr_NoError)
645 {
646 if (flags & kDNSServiceFlagsAdd) printf("Name now registered and active\n");
647 else printf("Name registration removed\n");
648 if (operation == 'A' || operation == 'U' || operation == 'N')
649 {
650 timeOut = 5;
651 #if _DNS_SD_LIBDISPATCH
652 if (timer_source)
653 dispatch_source_set_timer(timer_source, dispatch_time(DISPATCH_TIME_NOW, (uint64_t)timeOut * NSEC_PER_SEC),
654 (uint64_t)timeOut * NSEC_PER_SEC, 0);
655 #endif
656 }
657 }
658 else if (errorCode == kDNSServiceErr_NameConflict)
659 {
660 printf("Name in use, please choose another\n");
661 exit(-1);
662 }
663 else
664 printf("Error %d\n", errorCode);
665
666 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
667 }
668
669 // Output the wire-format domainname pointed to by rd
670 static int snprintd(char *p, int max, const unsigned char **rd)
671 {
672 const char *const buf = p;
673 const char *const end = p + max;
674 while (**rd) { p += snprintf(p, end-p, "%.*s.", **rd, *rd+1); *rd += 1 + **rd; }
675 *rd += 1; // Advance over the final zero byte
676 return(p-buf);
677 }
678
679 static void DNSSD_API qr_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode,
680 const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context)
681 {
682 char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv";
683 const unsigned char *rd = rdata;
684 const unsigned char *end = (const unsigned char *) rdata + rdlen;
685 char rdb[1000] = "", *p = rdb;
686 int unknowntype = 0;
687
688 (void)sdref; // Unused
689 (void)flags; // Unused
690 (void)ifIndex; // Unused
691 (void)ttl; // Unused
692 (void)context; // Unused
693 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
694
695 if (num_printed++ == 0) printf("Timestamp A/R Flags if %-30s%4s%4s Rdata\n", "Name", "T", "C");
696 printtimestamp();
697
698 if (!errorCode)
699 {
700 switch (rrtype)
701 {
702 case kDNSServiceType_A:
703 snprintf(rdb, sizeof(rdb), "%d.%d.%d.%d", rd[0], rd[1], rd[2], rd[3]);
704 break;
705
706 case kDNSServiceType_NS:
707 case kDNSServiceType_CNAME:
708 case kDNSServiceType_PTR:
709 case kDNSServiceType_DNAME:
710 p += snprintd(p, sizeof(rdb), &rd);
711 break;
712
713 case kDNSServiceType_SOA:
714 p += snprintd(p, rdb + sizeof(rdb) - p, &rd); // mname
715 p += snprintf(p, rdb + sizeof(rdb) - p, " ");
716 p += snprintd(p, rdb + sizeof(rdb) - p, &rd); // rname
717 p += snprintf(p, rdb + sizeof(rdb) - p, " Ser %d Ref %d Ret %d Exp %d Min %d",
718 ntohl(((uint32_t*)rd)[0]), ntohl(((uint32_t*)rd)[1]), ntohl(((uint32_t*)rd)[2]), ntohl(((uint32_t*)rd)[3]), ntohl(((uint32_t*)rd)[4]));
719 break;
720
721 case kDNSServiceType_AAAA:
722 snprintf(rdb, sizeof(rdb), "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
723 rd[0x0], rd[0x1], rd[0x2], rd[0x3], rd[0x4], rd[0x5], rd[0x6], rd[0x7],
724 rd[0x8], rd[0x9], rd[0xA], rd[0xB], rd[0xC], rd[0xD], rd[0xE], rd[0xF]);
725 break;
726
727 case kDNSServiceType_SRV:
728 p += snprintf(p, rdb + sizeof(rdb) - p, "%d %d %d ", // priority, weight, port
729 ntohs(*(unsigned short*)rd), ntohs(*(unsigned short*)(rd+2)), ntohs(*(unsigned short*)(rd+4)));
730 rd += 6;
731 p += snprintd(p, rdb + sizeof(rdb) - p, &rd); // target host
732 break;
733
734 default : snprintf(rdb, sizeof(rdb), "%d bytes%s", rdlen, rdlen ? ":" : ""); unknowntype = 1; break;
735 }
736 }
737
738 printf("%s%6X%3d %-30s%4d%4d %s", op, flags, ifIndex, fullname, rrtype, rrclass, rdb);
739 if (unknowntype) while (rd < end) printf(" %02X", *rd++);
740 if (errorCode)
741 {
742 if (errorCode == kDNSServiceErr_NoSuchRecord) printf("No Such Record");
743 else if (errorCode == kDNSServiceErr_Timeout)
744 {
745 printf("No Such Record\n");
746 printf("Query Timed Out\n");
747 exit(1);
748 }
749 }
750 printf("\n");
751
752 if (operation == 'C')
753 if (flags & kDNSServiceFlagsAdd)
754 DNSServiceReconfirmRecord(flags, ifIndex, fullname, rrtype, rrclass, rdlen, rdata);
755
756 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
757 }
758
759 #if HAS_NAT_PMP_API
760 static void DNSSD_API port_mapping_create_reply(DNSServiceRef sdref, DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, uint32_t publicAddress, uint32_t protocol, uint16_t privatePort, uint16_t publicPort, uint32_t ttl, void *context)
761 {
762 (void)sdref; // Unused
763 (void)flags; // Unused
764 (void)context; // Unused
765 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
766
767 if (num_printed++ == 0) printf("Timestamp if %-20s %-15s %-15s %-15s %-6s\n", "External Address", "Protocol", "Internal Port", "External Port", "TTL");
768 printtimestamp();
769 if (errorCode && errorCode != kDNSServiceErr_DoubleNAT) printf("Error code %d\n", errorCode);
770 else
771 {
772 const unsigned char *digits = (const unsigned char *)&publicAddress;
773 char addr[256];
774
775 snprintf(addr, sizeof(addr), "%d.%d.%d.%d", digits[0], digits[1], digits[2], digits[3]);
776 printf("%-4d %-20s %-15d %-15d %-15d %-6d%s\n", ifIndex, addr, protocol, ntohs(privatePort), ntohs(publicPort), ttl, errorCode == kDNSServiceErr_DoubleNAT ? " Double NAT" : "");
777 }
778
779 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
780 }
781 #endif
782
783 #if HAS_ADDRINFO_API
784 static void DNSSD_API addrinfo_reply(DNSServiceRef sdref, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *hostname, const struct sockaddr *address, uint32_t ttl, void *context)
785 {
786 char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv";
787 char addr[256] = "";
788 (void) sdref;
789 (void) context;
790 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
791
792 if (num_printed++ == 0) printf("Timestamp A/R Flags if %-25s %-44s %s\n", "Hostname", "Address", "TTL");
793 printtimestamp();
794
795 if (address && address->sa_family == AF_INET)
796 {
797 const unsigned char *b = (const unsigned char *) &((struct sockaddr_in *)address)->sin_addr;
798 snprintf(addr, sizeof(addr), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
799 }
800 else if (address && address->sa_family == AF_INET6)
801 {
802 char if_name[IFNAMSIZ]; // Older Linux distributions don't define IF_NAMESIZE
803 const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *)address;
804 const unsigned char *b = (const unsigned char * )&s6->sin6_addr;
805 if (!if_indextoname(s6->sin6_scope_id, if_name))
806 snprintf(if_name, sizeof(if_name), "<%d>", s6->sin6_scope_id);
807 snprintf(addr, sizeof(addr), "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X%%%s",
808 b[0x0], b[0x1], b[0x2], b[0x3], b[0x4], b[0x5], b[0x6], b[0x7],
809 b[0x8], b[0x9], b[0xA], b[0xB], b[0xC], b[0xD], b[0xE], b[0xF], if_name);
810 }
811
812 printf("%s%6X%3d %-25s %-44s %d", op, flags, interfaceIndex, hostname, addr, ttl);
813 if (errorCode)
814 {
815 if (errorCode == kDNSServiceErr_NoSuchRecord) printf(" No Such Record");
816 else printf(" Error code %d", errorCode);
817 }
818 printf("\n");
819
820 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
821 }
822 #endif
823
824 //*************************************************************************************************************
825 // The main test function
826
827 static void HandleEvents(void)
828 #if _DNS_SD_LIBDISPATCH
829 {
830 main_queue = dispatch_get_main_queue();
831 if (client) DNSServiceSetDispatchQueue(client, main_queue);
832 if (client_pa) DNSServiceSetDispatchQueue(client_pa, main_queue);
833 if (operation == 'A' || operation == 'U' || operation == 'N')
834 {
835 timer_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, main_queue);
836 if (timer_source)
837 {
838 // Start the timer "timeout" seconds into the future and repeat it every "timeout" seconds
839 dispatch_source_set_timer(timer_source, dispatch_time(DISPATCH_TIME_NOW, (uint64_t)timeOut * NSEC_PER_SEC),
840 (uint64_t)timeOut * NSEC_PER_SEC, 0);
841 dispatch_source_set_event_handler(timer_source, ^{myTimerCallBack();});
842 dispatch_resume(timer_source);
843 }
844 }
845 dispatch_main();
846 }
847 #else
848 {
849 int dns_sd_fd = client ? DNSServiceRefSockFD(client ) : -1;
850 int dns_sd_fd2 = client_pa ? DNSServiceRefSockFD(client_pa) : -1;
851 int nfds = dns_sd_fd + 1;
852 fd_set readfds;
853 struct timeval tv;
854 int result;
855
856 if (dns_sd_fd2 > dns_sd_fd) nfds = dns_sd_fd2 + 1;
857
858 while (!stopNow)
859 {
860 // 1. Set up the fd_set as usual here.
861 // This example client has no file descriptors of its own,
862 // but a real application would call FD_SET to add them to the set here
863 FD_ZERO(&readfds);
864
865 // 2. Add the fd for our client(s) to the fd_set
866 if (client ) FD_SET(dns_sd_fd , &readfds);
867 if (client_pa) FD_SET(dns_sd_fd2, &readfds);
868
869 // 3. Set up the timeout.
870 tv.tv_sec = timeOut;
871 tv.tv_usec = 0;
872
873 result = select(nfds, &readfds, (fd_set*)NULL, (fd_set*)NULL, &tv);
874 if (result > 0)
875 {
876 DNSServiceErrorType err = kDNSServiceErr_NoError;
877 if (client && FD_ISSET(dns_sd_fd , &readfds)) err = DNSServiceProcessResult(client );
878 else if (client_pa && FD_ISSET(dns_sd_fd2, &readfds)) err = DNSServiceProcessResult(client_pa);
879 if (err) { fprintf(stderr, "DNSServiceProcessResult returned %d\n", err); stopNow = 1; }
880 }
881 else if (result == 0)
882 myTimerCallBack();
883 else
884 {
885 printf("select() returned %d errno %d %s\n", result, errno, strerror(errno));
886 if (errno != EINTR) stopNow = 1;
887 }
888 }
889 }
890 #endif
891
892 static int getfirstoption(int argc, char **argv, const char *optstr, int *pOptInd)
893 // Return the recognized option in optstr and the option index of the next arg.
894 #if NOT_HAVE_GETOPT
895 {
896 int i;
897 for (i=1; i < argc; i++)
898 {
899 if (argv[i][0] == '-' && &argv[i][1] &&
900 NULL != strchr(optstr, argv[i][1]))
901 {
902 *pOptInd = i + 1;
903 return argv[i][1];
904 }
905 }
906 return -1;
907 }
908 #else
909 {
910 int o = getopt(argc, (char *const *)argv, optstr);
911 *pOptInd = optind;
912 return o;
913 }
914 #endif
915
916 static void DNSSD_API MyRegisterRecordCallback(DNSServiceRef service, DNSRecordRef rec, const DNSServiceFlags flags,
917 DNSServiceErrorType errorCode, void *context)
918 {
919 char *name = (char *)context;
920
921 (void)service; // Unused
922 (void)rec; // Unused
923 (void)flags; // Unused
924 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode);
925
926 printtimestamp();
927 printf("Got a reply for record %s: ", name);
928
929 switch (errorCode)
930 {
931 case kDNSServiceErr_NoError: printf("Name now registered and active\n"); break;
932 case kDNSServiceErr_NameConflict: printf("Name in use, please choose another\n"); exit(-1);
933 default: printf("Error %d\n", errorCode); break;
934 }
935 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
936 // DNSServiceRemoveRecord(service, rec, 0); to test record removal
937
938 #if 0 // To test updating of individual records registered via DNSServiceRegisterRecord
939 if (!errorCode)
940 {
941 int x = 0x11111111;
942 printf("Updating\n");
943 DNSServiceUpdateRecord(service, rec, 0, sizeof(x), &x, 0);
944 }
945 #endif
946
947 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
948 }
949
950 static void getip(const char *const name, struct sockaddr_storage *result)
951 {
952 struct addrinfo *addrs = NULL;
953 int err = getaddrinfo(name, NULL, NULL, &addrs);
954 if (err) fprintf(stderr, "getaddrinfo error %d for %s", err, name);
955 else memcpy(result, addrs->ai_addr, SA_LEN(addrs->ai_addr));
956 if (addrs) freeaddrinfo(addrs);
957 }
958
959 static DNSServiceErrorType RegisterProxyAddressRecord(DNSServiceRef sdref, const char *host, const char *ip, DNSServiceFlags flags)
960 {
961 // Call getip() after the call DNSServiceCreateConnection().
962 // On the Win32 platform, WinSock must be initialized for getip() to succeed.
963 // Any DNSService* call will initialize WinSock for us, so we make sure
964 // DNSServiceCreateConnection() is called before getip() is.
965 struct sockaddr_storage hostaddr;
966 getip(ip, &hostaddr);
967 flags |= kDNSServiceFlagsUnique;
968 if (hostaddr.ss_family == AF_INET)
969 return(DNSServiceRegisterRecord(sdref, &record, flags, opinterface, host,
970 kDNSServiceType_A, kDNSServiceClass_IN, 4, &((struct sockaddr_in *)&hostaddr)->sin_addr, 240, MyRegisterRecordCallback, (void*)host));
971 else if (hostaddr.ss_family == AF_INET6)
972 return(DNSServiceRegisterRecord(sdref, &record, flags, opinterface, host,
973 kDNSServiceType_AAAA, kDNSServiceClass_IN, 16, &((struct sockaddr_in6*)&hostaddr)->sin6_addr, 240, MyRegisterRecordCallback, (void*)host));
974 else return(kDNSServiceErr_BadParam);
975 }
976
977 #define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0' ) : \
978 ((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) : \
979 ((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : 0)
980
981 #define HexPair(P) ((HexVal((P)[0]) << 4) | HexVal((P)[1]))
982
983 static DNSServiceErrorType RegisterService(DNSServiceRef *sdref,
984 const char *nam, const char *typ, const char *dom, const char *host, const char *port, int argc, char **argv, DNSServiceFlags flags)
985 {
986 uint16_t PortAsNumber = atoi(port);
987 Opaque16 registerPort = { { PortAsNumber >> 8, PortAsNumber & 0xFF } };
988 unsigned char txt[2048] = "";
989 unsigned char *ptr = txt;
990 int i;
991
992 if (nam[0] == '.' && nam[1] == 0) nam = ""; // We allow '.' on the command line as a synonym for empty string
993 if (dom[0] == '.' && dom[1] == 0) dom = ""; // We allow '.' on the command line as a synonym for empty string
994
995 printf("Registering Service %s.%s%s%s", nam[0] ? nam : "<<Default>>", typ, dom[0] ? "." : "", dom);
996 if (host && *host) printf(" host %s", host);
997 printf(" port %s", port);
998
999 if (argc)
1000 {
1001 for (i = 0; i < argc; i++)
1002 {
1003 const char *p = argv[i];
1004 *ptr = 0;
1005 while (*p && *ptr < 255 && ptr + 1 + *ptr < txt+sizeof(txt))
1006 {
1007 if (p[0] != '\\' || p[1] == 0) { ptr[++*ptr] = *p; p+=1; }
1008 else if (p[1] == 'x' && isxdigit(p[2]) && isxdigit(p[3])) { ptr[++*ptr] = HexPair(p+2); p+=4; }
1009 else { ptr[++*ptr] = p[1]; p+=2; }
1010 }
1011 ptr += 1 + *ptr;
1012 }
1013 printf(" TXT");
1014 ShowTXTRecord(ptr-txt, txt);
1015 }
1016 printf("\n");
1017
1018 //flags |= kDNSServiceFlagsAllowRemoteQuery;
1019 //flags |= kDNSServiceFlagsNoAutoRename;
1020
1021 return(DNSServiceRegister(sdref, flags, opinterface, nam, typ, dom, host, registerPort.NotAnInteger, (uint16_t) (ptr-txt), txt, reg_reply, NULL));
1022 }
1023
1024 #define TypeBufferSize 80
1025 static char *gettype(char *buffer, char *typ)
1026 {
1027 if (!typ || !*typ || (typ[0] == '.' && typ[1] == 0)) typ = "_http._tcp";
1028 if (!strchr(typ, '.')) { snprintf(buffer, TypeBufferSize, "%s._tcp", typ); typ = buffer; }
1029 return(typ);
1030 }
1031
1032 int main(int argc, char **argv)
1033 {
1034 DNSServiceErrorType err;
1035 char buffer[TypeBufferSize], *typ, *dom;
1036 int opi;
1037 DNSServiceFlags flags = 0;
1038
1039 // Extract the program name from argv[0], which by convention contains the path to this executable.
1040 // Note that this is just a voluntary convention, not enforced by the kernel --
1041 // the process calling exec() can pass bogus data in argv[0] if it chooses to.
1042 const char *a0 = strrchr(argv[0], kFilePathSep) + 1;
1043 if (a0 == (const char *)1) a0 = argv[0];
1044
1045 #if defined(_WIN32)
1046 HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
1047 #endif
1048
1049 #if TEST_NEW_CLIENTSTUB
1050 printf("Using embedded copy of dnssd_clientstub instead of system library\n");
1051 if (sizeof(argv) == 8) printf("Running in 64-bit mode\n");
1052 #endif
1053
1054 // Test code for TXTRecord functions
1055 //TXTRecordRef txtRecord;
1056 //TXTRecordCreate(&txtRecord, 0, NULL);
1057 //TXTRecordSetValue(&txtRecord, "aaa", 1, "b");
1058 //printf("%d\n", TXTRecordContainsKey(TXTRecordGetLength(&txtRecord), TXTRecordGetBytesPtr(&txtRecord), "Aaa"));
1059
1060 if (argc > 1 && !strcmp(argv[1], "-lo"))
1061 {
1062 argc--;
1063 argv++;
1064 opinterface = kDNSServiceInterfaceIndexLocalOnly;
1065 printf("Using LocalOnly\n");
1066 }
1067
1068 if (argc > 1 && (!strcmp(argv[1], "-p2p") || !strcmp(argv[1], "-P2P")))
1069 {
1070 argc--;
1071 argv++;
1072 opinterface = kDNSServiceInterfaceIndexP2P;
1073 printf("Using P2P\n");
1074 }
1075
1076 if (argc > 1 && !strcasecmp(argv[1], "-includep2p"))
1077 {
1078 argc--;
1079 argv++;
1080 flags |= kDNSServiceFlagsIncludeP2P;
1081 printf("Including P2P\n");
1082 }
1083
1084 if (argc > 2 && !strcmp(argv[1], "-i"))
1085 {
1086 opinterface = if_nametoindex(argv[2]);
1087 if (!opinterface) opinterface = atoi(argv[2]);
1088 if (!opinterface) { fprintf(stderr, "Unknown interface %s\n", argv[2]); goto Fail; }
1089 argc -= 2;
1090 argv += 2;
1091 }
1092
1093 if (argc < 2) goto Fail; // Minimum command line is the command name and one argument
1094 operation = getfirstoption(argc, argv, "EFBZLlRPQqtCAUNTMISV"
1095 #if HAS_NAT_PMP_API
1096 "X"
1097 #endif
1098 #if HAS_ADDRINFO_API
1099 "G"
1100 #endif
1101 , &opi);
1102 if (operation == -1) goto Fail;
1103
1104 if (opinterface) printf("Using interface %d\n", opinterface);
1105
1106 switch (operation)
1107 {
1108 case 'E': printf("Looking for recommended registration domains:\n");
1109 err = DNSServiceEnumerateDomains(&client, kDNSServiceFlagsRegistrationDomains, opinterface, enum_reply, NULL);
1110 break;
1111
1112 case 'F': printf("Looking for recommended browsing domains:\n");
1113 err = DNSServiceEnumerateDomains(&client, kDNSServiceFlagsBrowseDomains, opinterface, enum_reply, NULL);
1114 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "nicta.com.au.", NULL);
1115 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "bonjour.nicta.com.au.", NULL);
1116 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "ibm.com.", NULL);
1117 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "dns-sd.ibm.com.", NULL);
1118 break;
1119
1120 case 'B': typ = (argc < opi+1) ? "" : argv[opi+0];
1121 dom = (argc < opi+2) ? "" : argv[opi+1]; // Missing domain argument is the same as empty string i.e. use system default(s)
1122 typ = gettype(buffer, typ);
1123 if (dom[0] == '.' && dom[1] == 0) dom[0] = 0; // We allow '.' on the command line as a synonym for empty string
1124 printf("Browsing for %s%s%s\n", typ, dom[0] ? "." : "", dom);
1125 err = DNSServiceBrowse(&client, flags, opinterface, typ, dom, browse_reply, NULL);
1126 break;
1127
1128 case 'Z': typ = (argc < opi+1) ? "" : argv[opi+0];
1129 dom = (argc < opi+2) ? "" : argv[opi+1]; // Missing domain argument is the same as empty string i.e. use system default(s)
1130 typ = gettype(buffer, typ);
1131 if (dom[0] == '.' && dom[1] == 0) dom[0] = 0; // We allow '.' on the command line as a synonym for empty string
1132 printf("Browsing for %s%s%s\n", typ, dom[0] ? "." : "", dom);
1133 err = DNSServiceCreateConnection(&client);
1134 sc1 = client;
1135 err = DNSServiceBrowse(&sc1, kDNSServiceFlagsShareConnection, opinterface, typ, dom, zonedata_browse, NULL);
1136 break;
1137
1138 case 'l':
1139 case 'L': {
1140 DNSServiceFlags rflags = 0;
1141 if (argc < opi+2) goto Fail;
1142 typ = (argc < opi+2) ? "" : argv[opi+1];
1143 dom = (argc < opi+3) ? "local" : argv[opi+2];
1144 typ = gettype(buffer, typ);
1145 if (dom[0] == '.' && dom[1] == 0) dom = "local"; // We allow '.' on the command line as a synonym for "local"
1146 printf("Lookup %s.%s.%s\n", argv[opi+0], typ, dom);
1147 if (operation == 'l') rflags |= kDNSServiceFlagsWakeOnResolve;
1148 err = DNSServiceResolve(&client, rflags, opinterface, argv[opi+0], typ, dom, resolve_reply, NULL);
1149 break;
1150 }
1151
1152 case 'R': if (argc < opi+4) goto Fail;
1153 typ = (argc < opi+2) ? "" : argv[opi+1];
1154 dom = (argc < opi+3) ? "" : argv[opi+2];
1155 typ = gettype(buffer, typ);
1156 if (dom[0] == '.' && dom[1] == 0) dom[0] = 0; // We allow '.' on the command line as a synonym for empty string
1157 err = RegisterService(&client, argv[opi+0], typ, dom, NULL, argv[opi+3], argc-(opi+4), argv+(opi+4), flags);
1158 break;
1159
1160 case 'P': if (argc < opi+6) goto Fail;
1161 err = DNSServiceCreateConnection(&client_pa);
1162 if (err) { fprintf(stderr, "DNSServiceCreateConnection returned %d\n", err); return(err); }
1163 err = RegisterProxyAddressRecord(client_pa, argv[opi+4], argv[opi+5], flags);
1164 if (err) break;
1165 err = RegisterService(&client, argv[opi+0], gettype(buffer, argv[opi+1]), argv[opi+2], argv[opi+4], argv[opi+3], argc-(opi+6), argv+(opi+6), flags);
1166 break;
1167
1168 case 't':
1169 case 'q':
1170 case 'Q':
1171 case 'C': {
1172 uint16_t rrtype, rrclass;
1173 flags |= kDNSServiceFlagsReturnIntermediates;
1174 if (operation == 'q') flags |= kDNSServiceFlagsSuppressUnusable;
1175 if (operation == 't') flags |= (kDNSServiceFlagsSuppressUnusable | kDNSServiceFlagsTimeout);
1176 if (argc < opi+1) goto Fail;
1177 rrtype = (argc <= opi+1) ? kDNSServiceType_A : GetRRType(argv[opi+1]);
1178 rrclass = (argc <= opi+2) ? kDNSServiceClass_IN : atoi(argv[opi+2]);
1179 if (rrtype == kDNSServiceType_TXT || rrtype == kDNSServiceType_PTR) flags |= kDNSServiceFlagsLongLivedQuery;
1180 err = DNSServiceQueryRecord(&client, flags, opinterface, argv[opi+0], rrtype, rrclass, qr_reply, NULL);
1181 break;
1182 }
1183
1184 case 'A':
1185 case 'U':
1186 case 'N': {
1187 Opaque16 registerPort = { { 0x12, 0x34 } };
1188 static const char TXT[] = "\xC" "First String" "\xD" "Second String" "\xC" "Third String";
1189 printf("Registering Service Test._testupdate._tcp.local.\n");
1190 err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testupdate._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT)-1, TXT, reg_reply, NULL);
1191 break;
1192 }
1193
1194 case 'T': {
1195 Opaque16 registerPort = { { 0x23, 0x45 } };
1196 char TXT[1024];
1197 unsigned int i;
1198 for (i=0; i<sizeof(TXT); i++)
1199 if ((i & 0x1F) == 0) TXT[i] = 0x1F; else TXT[i] = 'A' + (i >> 5);
1200 printf("Registering Service Test._testlargetxt._tcp.local.\n");
1201 err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testlargetxt._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT), TXT, reg_reply, NULL);
1202 break;
1203 }
1204
1205 case 'M': {
1206 pid_t pid = getpid();
1207 Opaque16 registerPort = { { pid >> 8, pid & 0xFF } };
1208 static const char TXT1[] = "\xC" "First String" "\xD" "Second String" "\xC" "Third String";
1209 static const char TXT2[] = "\xD" "Fourth String" "\xC" "Fifth String" "\xC" "Sixth String";
1210 printf("Registering Service Test._testdualtxt._tcp.local.\n");
1211 err = DNSServiceRegister(&client, flags, opinterface, "Test", "_testdualtxt._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT1)-1, TXT1, reg_reply, NULL);
1212 if (!err) err = DNSServiceAddRecord(client, &record, flags, kDNSServiceType_TXT, sizeof(TXT2)-1, TXT2, 0);
1213 break;
1214 }
1215
1216 case 'I': {
1217 pid_t pid = getpid();
1218 Opaque16 registerPort = { { pid >> 8, pid & 0xFF } };
1219 static const char TXT[] = "\x09" "Test Data";
1220 printf("Registering Service Test._testtxt._tcp.local.\n");
1221 err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testtxt._tcp.", "", NULL, registerPort.NotAnInteger, 0, NULL, reg_reply, NULL);
1222 if (!err) err = DNSServiceUpdateRecord(client, NULL, 0, sizeof(TXT)-1, TXT, 0);
1223 break;
1224 }
1225
1226 #if HAS_NAT_PMP_API
1227 case 'X': {
1228 if (argc == opi) // If no arguments, just fetch IP address
1229 err = DNSServiceNATPortMappingCreate(&client, 0, 0, 0, 0, 0, 0, port_mapping_create_reply, NULL);
1230 else if (argc >= opi+2 && atoi(argv[opi+0]) == 0)
1231 {
1232 DNSServiceProtocol prot = GetProtocol(argv[opi+0]); // Must specify TCP or UDP
1233 uint16_t IntPortAsNumber = atoi(argv[opi+1]); // Must specify internal port
1234 uint16_t ExtPortAsNumber = (argc < opi+3) ? 0 : atoi(argv[opi+2]); // Optional desired external port
1235 uint32_t ttl = (argc < opi+4) ? 0 : atoi(argv[opi+3]); // Optional desired lease lifetime
1236 Opaque16 intp = { { IntPortAsNumber >> 8, IntPortAsNumber & 0xFF } };
1237 Opaque16 extp = { { ExtPortAsNumber >> 8, ExtPortAsNumber & 0xFF } };
1238 err = DNSServiceNATPortMappingCreate(&client, 0, 0, prot, intp.NotAnInteger, extp.NotAnInteger, ttl, port_mapping_create_reply, NULL);
1239 }
1240 else goto Fail;
1241 break;
1242 }
1243 #endif
1244
1245 #if HAS_ADDRINFO_API
1246 case 'G': {
1247 if (argc != opi+2) goto Fail;
1248 else err = DNSServiceGetAddrInfo(&client, kDNSServiceFlagsReturnIntermediates, opinterface, GetProtocol(argv[opi+0]), argv[opi+1], addrinfo_reply, NULL);
1249 break;
1250 }
1251 #endif
1252
1253 case 'S': {
1254 Opaque16 registerPort = { { 0x23, 0x45 } }; // 9029 decimal
1255 unsigned char txtrec[16] = "\xF" "/path=test.html";
1256 DNSRecordRef rec;
1257 unsigned char nulrec[4] = "1234";
1258
1259 err = DNSServiceCreateConnection(&client);
1260 if (err) { fprintf(stderr, "DNSServiceCreateConnection failed %ld\n", (long int)err); return (-1); }
1261
1262 sc1 = client;
1263 err = DNSServiceBrowse(&sc1, kDNSServiceFlagsShareConnection, opinterface, "_http._tcp", "", browse_reply, NULL);
1264 if (err) { fprintf(stderr, "DNSServiceBrowse _http._tcp failed %ld\n", (long int)err); return (-1); }
1265
1266 sc2 = client;
1267 err = DNSServiceBrowse(&sc2, kDNSServiceFlagsShareConnection, opinterface, "_ftp._tcp", "", browse_reply, NULL);
1268 if (err) { fprintf(stderr, "DNSServiceBrowse _ftp._tcp failed %ld\n", (long int)err); return (-1); }
1269
1270 sc3 = client;
1271 err = DNSServiceRegister(&sc3, kDNSServiceFlagsShareConnection, opinterface, "kDNSServiceFlagsShareConnection",
1272 "_http._tcp", "local", NULL, registerPort.NotAnInteger, 0, NULL, reg_reply, NULL);
1273 if (err) { fprintf(stderr, "SharedConnection DNSServiceRegister failed %ld\n", (long int)err); return (-1); }
1274
1275 err = DNSServiceUpdateRecord(sc3, NULL, 0, sizeof(txtrec), txtrec, 0);
1276 if (err) { fprintf(stderr, "SharedConnection DNSServiceUpdateRecord failed %ld\n", (long int)err); return (-1); }
1277
1278 err = DNSServiceAddRecord(sc3, &rec, 0, kDNSServiceType_NULL, sizeof(nulrec), nulrec, 0);
1279 if (err) { fprintf(stderr, "SharedConnection DNSServiceAddRecord failed %ld\n", (long int)err); return (-1); }
1280
1281 err = DNSServiceRemoveRecord(sc3, rec, 0);
1282 if (err) { fprintf(stderr, "SharedConnection DNSServiceRemoveRecord failed %ld\n", (long int)err); return (-1); }
1283
1284 break;
1285 }
1286
1287 case 'V': {
1288 uint32_t v;
1289 uint32_t size = sizeof(v);
1290 err = DNSServiceGetProperty(kDNSServiceProperty_DaemonVersion, &v, &size);
1291 if (err) fprintf(stderr, "DNSServiceGetProperty failed %ld\n", (long int)err);
1292 else printf("Currently running daemon (system service) is version %d.%d\n", v / 10000, v / 100 % 100);
1293 exit(0);
1294 }
1295
1296 default: goto Fail;
1297 }
1298
1299 if (!client || err != kDNSServiceErr_NoError) { fprintf(stderr, "DNSService call failed %ld\n", (long int)err); return (-1); }
1300 HandleEvents();
1301
1302 // Be sure to deallocate the DNSServiceRef when you're finished
1303 if (client ) DNSServiceRefDeallocate(client );
1304 if (client_pa) DNSServiceRefDeallocate(client_pa);
1305 return 0;
1306
1307 Fail:
1308 fprintf(stderr, "%s -E (Enumerate recommended registration domains)\n", a0);
1309 fprintf(stderr, "%s -F (Enumerate recommended browsing domains)\n", a0);
1310 fprintf(stderr, "%s -B <Type> <Domain> (Browse for services instances)\n", a0);
1311 fprintf(stderr, "%s -L <Name> <Type> <Domain> (Look up a service instance)\n", a0);
1312 fprintf(stderr, "%s -R <Name> <Type> <Domain> <Port> [<TXT>...] (Register a service)\n", a0);
1313 fprintf(stderr, "%s -P <Name> <Type> <Domain> <Port> <Host> <IP> [<TXT>...] (Proxy)\n", a0);
1314 fprintf(stderr, "%s -Z <Type> <Domain> (Output results in Zone File format)\n", a0);
1315 fprintf(stderr, "%s -Q <FQDN> <rrtype> <rrclass> (Generic query for any record type)\n", a0);
1316 fprintf(stderr, "%s -C <FQDN> <rrtype> <rrclass> (Query; reconfirming each result)\n", a0);
1317 #if HAS_NAT_PMP_API
1318 fprintf(stderr, "%s -X udp/tcp/udptcp <IntPort> <ExtPort> <TTL> (NAT Port Mapping)\n", a0);
1319 #endif
1320 #if HAS_ADDRINFO_API
1321 fprintf(stderr, "%s -G v4/v6/v4v6 <Hostname> (Get address information for hostname)\n", a0);
1322 #endif
1323 fprintf(stderr, "%s -V (Get version of currently running daemon / system service)\n", a0);
1324
1325 fprintf(stderr, "%s -A (Test Adding/Updating/Deleting a record)\n", a0);
1326 fprintf(stderr, "%s -U (Test updating a TXT record)\n", a0);
1327 fprintf(stderr, "%s -N (Test adding a large NULL record)\n", a0);
1328 fprintf(stderr, "%s -T (Test creating a large TXT record)\n", a0);
1329 fprintf(stderr, "%s -M (Test creating a registration with multiple TXT records)\n", a0);
1330 fprintf(stderr, "%s -I (Test registering and then immediately updating TXT record)\n", a0);
1331 fprintf(stderr, "%s -S (Test multiple operations on a shared socket)\n", a0);
1332 return 0;
1333 }
1334
1335 // Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion
1336 // e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4"
1337 // To expand "version" to its value before making the string, use STRINGIFY(version) instead
1338 #define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) #s
1339 #define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s)
1340
1341 // NOT static -- otherwise the compiler may optimize it out
1342 // The "@(#) " pattern is a special prefix the "what" command looks for
1343 const char VersionString_SCCS[] = "@(#) dns-sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";
1344
1345 #if _BUILDING_XCODE_PROJECT_
1346 // If the process crashes, then this string will be magically included in the automatically-generated crash log
1347 const char *__crashreporter_info__ = VersionString_SCCS + 5;
1348 asm(".desc ___crashreporter_info__, 0x10");
1349 #endif