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 if_nametoindex_win(const char * ifname)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 if_indextoname_win(unsigned ifindex,char * ifname)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 _sa_len(const struct sockaddr * addr)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 GetRRType(const char * s)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 GetProtocol(const char * s)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 printtimestamp(void)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 enum_reply(DNSServiceRef sdref,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * replyDomain,void * context)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 CopyLabels(char * dst,const char * lim,const char ** srcp,int labels)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 zonedata_resolve(DNSServiceRef sdref,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * fullname,const char * hosttarget,uint16_t opaqueport,uint16_t txtLen,const unsigned char * txt,void * context)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 zonedata_browse(DNSServiceRef sdref,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * replyName,const char * replyType,const char * replyDomain,void * context)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 browse_reply(DNSServiceRef sdref,const DNSServiceFlags flags,uint32_t ifIndex,DNSServiceErrorType errorCode,const char * replyName,const char * replyType,const char * replyDomain,void * context)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 ShowTXTRecord(uint16_t txtLen,const unsigned char * txtRecord)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 resolve_reply(DNSServiceRef sdref,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)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 myTimerCallBack(void)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 reg_reply(DNSServiceRef sdref,const DNSServiceFlags flags,DNSServiceErrorType errorCode,const char * name,const char * regtype,const char * domain,void * context)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 snprintd(char * p,int max,const unsigned char ** 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 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)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 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)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 addrinfo_reply(DNSServiceRef sdref,DNSServiceFlags flags,uint32_t interfaceIndex,DNSServiceErrorType errorCode,const char * hostname,const struct sockaddr * address,uint32_t ttl,void * context)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 HandleEvents(void)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 getfirstoption(int argc,char ** argv,const char * optstr,int * pOptInd)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 MyRegisterRecordCallback(DNSServiceRef service,DNSRecordRef rec,const DNSServiceFlags flags,DNSServiceErrorType errorCode,void * context)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 getip(const char * const name,struct sockaddr_storage * result)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 RegisterProxyAddressRecord(DNSServiceRef sdref,const char * host,const char * ip,DNSServiceFlags flags)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 RegisterService(DNSServiceRef * sdref,const char * nam,const char * typ,const char * dom,const char * host,const char * port,int argc,char ** argv,DNSServiceFlags flags)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 gettype(char * buffer,char * typ)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 main(int argc,char ** argv)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 #ifndef __ANDROID__ 1342 // NOT static -- otherwise the compiler may optimize it out 1343 // The "@(#) " pattern is a special prefix the "what" command looks for 1344 const char VersionString_SCCS[] = "@(#) dns-sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")"; 1345 #endif 1346 1347 #if _BUILDING_XCODE_PROJECT_ 1348 // If the process crashes, then this string will be magically included in the automatically-generated crash log 1349 const char *__crashreporter_info__ = VersionString_SCCS + 5; 1350 asm(".desc ___crashreporter_info__, 0x10"); 1351 #endif 1352