1 /* -*- Mode: C; tab-width: 4 -*- 2 * 3 * Copyright (c) 2002-2013 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 To build this tool, copy and paste the following into a command line: 41 42 OS X: 43 gcc dns-sd.c -o dns-sd 44 45 POSIX systems: 46 gcc dns-sd.c -o dns-sd -I../mDNSShared -ldns_sd 47 48 Windows: 49 cl dns-sd.c -I../mDNSShared -DNOT_HAVE_GETOPT ws2_32.lib ..\mDNSWindows\DLL\Release\dnssd.lib 50 (may require that you run a Visual Studio script such as vsvars32.bat first) 51 */ 52 53 // For testing changes to dnssd_clientstub.c, uncomment this line and the code will be compiled 54 // with an embedded copy of the client stub instead of linking the system library version at runtime. 55 // This also useful to work around link errors when you're working on an older version of Mac OS X, 56 // and trying to build a newer version of the "dns-sd" command which uses new API entry points that 57 // aren't in the system's /usr/lib/libSystem.dylib. 58 //#define TEST_NEW_CLIENTSTUB 1 59 60 // When building mDNSResponder for Mac OS X 10.4 and earlier, /usr/lib/libSystem.dylib is built using its own private 61 // copy of dnssd_clientstub.c, which is old and doesn't have all the entry points defined in the latest version, so 62 // 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 63 // embed a copy of the latest dnssd_clientstub.c instead of trying to link to the incomplete version in libSystem.dylib 64 #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ <= 1040 65 #define TEST_NEW_CLIENTSTUB 1 66 #endif 67 68 #include <ctype.h> 69 #include <stdio.h> // For stdout, stderr 70 #include <stdlib.h> // For exit() 71 #include <string.h> // For strlen(), strcpy() 72 #include <errno.h> // For errno, EINTR 73 #include <time.h> 74 #include <sys/types.h> // For u_char 75 76 #ifdef _WIN32 77 #include <winsock2.h> 78 #include <ws2tcpip.h> 79 #include <Iphlpapi.h> 80 #include <process.h> 81 typedef int pid_t; 82 #define getpid _getpid 83 #define strcasecmp _stricmp 84 #define snprintf _snprintf 85 static const char kFilePathSep = '\\'; 86 #ifndef HeapEnableTerminationOnCorruption 87 # define HeapEnableTerminationOnCorruption (HEAP_INFORMATION_CLASS)1 88 #endif 89 #if !defined(IFNAMSIZ) 90 #define IFNAMSIZ 16 91 #endif 92 #define if_nametoindex if_nametoindex_win 93 #define if_indextoname if_indextoname_win 94 95 typedef PCHAR (WINAPI * if_indextoname_funcptr_t)(ULONG index, PCHAR name); 96 typedef ULONG (WINAPI * if_nametoindex_funcptr_t)(PCSTR name); 97 98 unsigned if_nametoindex_win(const char *ifname) 99 { 100 HMODULE library; 101 unsigned index = 0; 102 103 // Try and load the IP helper library dll 104 if ((library = LoadLibrary(TEXT("Iphlpapi")) ) != NULL ) 105 { 106 if_nametoindex_funcptr_t if_nametoindex_funcptr; 107 108 // On Vista and above there is a Posix like implementation of if_nametoindex 109 if ((if_nametoindex_funcptr = (if_nametoindex_funcptr_t) GetProcAddress(library, "if_nametoindex")) != NULL ) 110 { 111 index = if_nametoindex_funcptr(ifname); 112 } 113 114 FreeLibrary(library); 115 } 116 117 return index; 118 } 119 120 char * if_indextoname_win( unsigned ifindex, char *ifname) 121 { 122 HMODULE library; 123 char * name = NULL; 124 125 // Try and load the IP helper library dll 126 if ((library = LoadLibrary(TEXT("Iphlpapi")) ) != NULL ) 127 { 128 if_indextoname_funcptr_t if_indextoname_funcptr; 129 130 // On Vista and above there is a Posix like implementation of if_indextoname 131 if ((if_indextoname_funcptr = (if_indextoname_funcptr_t) GetProcAddress(library, "if_indextoname")) != NULL ) 132 { 133 name = if_indextoname_funcptr(ifindex, ifname); 134 } 135 136 FreeLibrary(library); 137 } 138 139 return name; 140 } 141 142 static size_t _sa_len(const struct sockaddr *addr) 143 { 144 if (addr->sa_family == AF_INET) return (sizeof(struct sockaddr_in)); 145 else if (addr->sa_family == AF_INET6) return (sizeof(struct sockaddr_in6)); 146 else return (sizeof(struct sockaddr)); 147 } 148 149 # define SA_LEN(addr) (_sa_len(addr)) 150 151 #else 152 #include <unistd.h> // For getopt() and optind 153 #include <netdb.h> // For getaddrinfo() 154 #include <sys/time.h> // For struct timeval 155 #include <sys/socket.h> // For AF_INET 156 #include <netinet/in.h> // For struct sockaddr_in() 157 #include <arpa/inet.h> // For inet_addr() 158 #include <net/if.h> // For if_nametoindex() 159 static const char kFilePathSep = '/'; 160 // #ifndef NOT_HAVE_SA_LEN 161 // #define SA_LEN(addr) ((addr)->sa_len) 162 // #else 163 #define SA_LEN(addr) (((addr)->sa_family == AF_INET6) ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) 164 // #endif 165 #endif 166 167 #if (TEST_NEW_CLIENTSTUB && !defined(__APPLE_API_PRIVATE)) 168 #define __APPLE_API_PRIVATE 1 169 #endif 170 171 // DNSServiceSetDispatchQueue is not supported on 10.6 & prior 172 #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) 173 #undef _DNS_SD_LIBDISPATCH 174 #endif 175 #include "dns_sd.h" 176 #include "ClientCommon.h" 177 178 #if TEST_NEW_CLIENTSTUB 179 #include "../mDNSShared/dnssd_ipc.c" 180 #include "../mDNSShared/dnssd_clientlib.c" 181 #include "../mDNSShared/dnssd_clientstub.c" 182 #endif 183 184 #if _DNS_SD_LIBDISPATCH 185 #include <dispatch/private.h> 186 #endif 187 188 // 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) 189 #if _DNS_SD_H+0 >= 116 190 #define HAS_NAT_PMP_API 1 191 #define HAS_ADDRINFO_API 1 192 #else 193 #define kDNSServiceFlagsReturnIntermediates 0 194 #endif 195 196 //************************************************************************************************************* 197 // Globals 198 199 #define DS_FIXED_SIZE 4 200 typedef struct 201 { 202 unsigned short keyTag; 203 unsigned char alg; 204 unsigned char digestType; 205 unsigned char *digest; 206 } rdataDS; 207 208 #define DNSKEY_FIXED_SIZE 4 209 typedef struct 210 { 211 unsigned short flags; 212 unsigned char proto; 213 unsigned char alg; 214 unsigned char *data; 215 } rdataDNSKey; 216 217 //size of rdataRRSIG excluding signerName and signature (which are variable fields) 218 #define RRSIG_FIXED_SIZE 18 219 typedef struct 220 { 221 unsigned short typeCovered; 222 unsigned char alg; 223 unsigned char labels; 224 unsigned int origTTL; 225 unsigned int sigExpireTime; 226 unsigned int sigInceptTime; 227 unsigned short keyTag; 228 char signerName[256]; 229 //unsigned char *signature 230 } rdataRRSig; 231 232 #define RR_TYPE_SIZE 16 233 234 typedef union { unsigned char b[2]; unsigned short NotAnInteger; } Opaque16; 235 236 static int operation; 237 static uint32_t opinterface = kDNSServiceInterfaceIndexAny; 238 static DNSServiceRef client = NULL; 239 static DNSServiceRef client_pa = NULL; // DNSServiceRef for RegisterProxyAddressRecord 240 static DNSServiceRef sc1, sc2, sc3; // DNSServiceRefs for kDNSServiceFlagsShareConnection testing 241 242 static int num_printed; 243 static char addtest = 0; 244 static DNSRecordRef record = NULL; 245 static char myhinfoW[14] = "\002PC\012Windows XP"; 246 static char myhinfoX[ 9] = "\003Mac\004OS X"; 247 static char updatetest[3] = "\002AA"; 248 static char bigNULL[8192]; // 8K is maximum rdata we support 249 250 #if _DNS_SD_LIBDISPATCH 251 dispatch_queue_t main_queue; 252 dispatch_source_t timer_source; 253 #endif 254 255 // Note: the select() implementation on Windows (Winsock2) fails with any timeout much larger than this 256 #define LONG_TIME 100000000 257 258 static volatile int stopNow = 0; 259 static volatile int timeOut = LONG_TIME; 260 261 #if _DNS_SD_LIBDISPATCH 262 #define EXIT_IF_LIBDISPATCH_FATAL_ERROR(E) \ 263 if (main_queue && (E) == kDNSServiceErr_ServiceNotRunning) { fprintf(stderr, "Error code %d\n", (E)); exit(0); } 264 #else 265 #define EXIT_IF_LIBDISPATCH_FATAL_ERROR(E) 266 #endif 267 268 //************************************************************************************************************* 269 // Supporting Utility Functions 270 static uint16_t GetRRClass(const char *s) 271 { 272 if (!strcasecmp(s, "IN")) 273 return kDNSServiceClass_IN; 274 else 275 return(atoi(s)); 276 } 277 278 static uint16_t GetRRType(const char *s) 279 { 280 if (!strcasecmp(s, "A" )) return(kDNSServiceType_A); 281 else if (!strcasecmp(s, "NS" )) return(kDNSServiceType_NS); 282 else if (!strcasecmp(s, "MD" )) return(kDNSServiceType_MD); 283 else if (!strcasecmp(s, "MF" )) return(kDNSServiceType_MF); 284 else if (!strcasecmp(s, "CNAME" )) return(kDNSServiceType_CNAME); 285 else if (!strcasecmp(s, "SOA" )) return(kDNSServiceType_SOA); 286 else if (!strcasecmp(s, "MB" )) return(kDNSServiceType_MB); 287 else if (!strcasecmp(s, "MG" )) return(kDNSServiceType_MG); 288 else if (!strcasecmp(s, "MR" )) return(kDNSServiceType_MR); 289 else if (!strcasecmp(s, "NULL" )) return(kDNSServiceType_NULL); 290 else if (!strcasecmp(s, "WKS" )) return(kDNSServiceType_WKS); 291 else if (!strcasecmp(s, "PTR" )) return(kDNSServiceType_PTR); 292 else if (!strcasecmp(s, "HINFO" )) return(kDNSServiceType_HINFO); 293 else if (!strcasecmp(s, "MINFO" )) return(kDNSServiceType_MINFO); 294 else if (!strcasecmp(s, "MX" )) return(kDNSServiceType_MX); 295 else if (!strcasecmp(s, "TXT" )) return(kDNSServiceType_TXT); 296 else if (!strcasecmp(s, "RP" )) return(kDNSServiceType_RP); 297 else if (!strcasecmp(s, "AFSDB" )) return(kDNSServiceType_AFSDB); 298 else if (!strcasecmp(s, "X25" )) return(kDNSServiceType_X25); 299 else if (!strcasecmp(s, "ISDN" )) return(kDNSServiceType_ISDN); 300 else if (!strcasecmp(s, "RT" )) return(kDNSServiceType_RT); 301 else if (!strcasecmp(s, "NSAP" )) return(kDNSServiceType_NSAP); 302 else if (!strcasecmp(s, "NSAP_PTR")) return(kDNSServiceType_NSAP_PTR); 303 else if (!strcasecmp(s, "SIG" )) return(kDNSServiceType_SIG); 304 else if (!strcasecmp(s, "KEY" )) return(kDNSServiceType_KEY); 305 else if (!strcasecmp(s, "PX" )) return(kDNSServiceType_PX); 306 else if (!strcasecmp(s, "GPOS" )) return(kDNSServiceType_GPOS); 307 else if (!strcasecmp(s, "AAAA" )) return(kDNSServiceType_AAAA); 308 else if (!strcasecmp(s, "LOC" )) return(kDNSServiceType_LOC); 309 else if (!strcasecmp(s, "NXT" )) return(kDNSServiceType_NXT); 310 else if (!strcasecmp(s, "EID" )) return(kDNSServiceType_EID); 311 else if (!strcasecmp(s, "NIMLOC" )) return(kDNSServiceType_NIMLOC); 312 else if (!strcasecmp(s, "SRV" )) return(kDNSServiceType_SRV); 313 else if (!strcasecmp(s, "ATMA" )) return(kDNSServiceType_ATMA); 314 else if (!strcasecmp(s, "NAPTR" )) return(kDNSServiceType_NAPTR); 315 else if (!strcasecmp(s, "KX" )) return(kDNSServiceType_KX); 316 else if (!strcasecmp(s, "CERT" )) return(kDNSServiceType_CERT); 317 else if (!strcasecmp(s, "A6" )) return(kDNSServiceType_A6); 318 else if (!strcasecmp(s, "DNAME" )) return(kDNSServiceType_DNAME); 319 else if (!strcasecmp(s, "SINK" )) return(kDNSServiceType_SINK); 320 else if (!strcasecmp(s, "OPT" )) return(kDNSServiceType_OPT); 321 else if (!strcasecmp(s, "TKEY" )) return(kDNSServiceType_TKEY); 322 else if (!strcasecmp(s, "TSIG" )) return(kDNSServiceType_TSIG); 323 else if (!strcasecmp(s, "IXFR" )) return(kDNSServiceType_IXFR); 324 else if (!strcasecmp(s, "AXFR" )) return(kDNSServiceType_AXFR); 325 else if (!strcasecmp(s, "MAILB" )) return(kDNSServiceType_MAILB); 326 else if (!strcasecmp(s, "MAILA" )) return(kDNSServiceType_MAILA); 327 else if (!strcasecmp(s, "dnskey" )) return(kDNSServiceType_DNSKEY); 328 else if (!strcasecmp(s, "ds" )) return(kDNSServiceType_DS); 329 else if (!strcasecmp(s, "rrsig" )) return(kDNSServiceType_RRSIG); 330 else if (!strcasecmp(s, "nsec" )) return(kDNSServiceType_NSEC); 331 else if (!strcasecmp(s, "ANY" )) return(kDNSServiceType_ANY); 332 else return(atoi(s)); 333 } 334 335 static char *DNSTypeName(unsigned short rr_type) 336 { 337 switch (rr_type) 338 { 339 case kDNSServiceType_A: return("Addr"); 340 case kDNSServiceType_NS: return("NS"); 341 case kDNSServiceType_MX: return("MX"); 342 case kDNSServiceType_CNAME: return("CNAME"); 343 case kDNSServiceType_SOA: return("SOA"); 344 case kDNSServiceType_PTR: return("PTR"); 345 case kDNSServiceType_AAAA: return("AAAA"); 346 case kDNSServiceType_NSEC: return("NSEC"); 347 case kDNSServiceType_TSIG: return("TSIG"); 348 case kDNSServiceType_RRSIG: return("RRSIG"); 349 case kDNSServiceType_DNSKEY: return("DNSKEY"); 350 case kDNSServiceType_DS: return("DS"); 351 default: 352 { 353 static char buffer[RR_TYPE_SIZE]; 354 snprintf(buffer, sizeof(buffer), "TYPE%d", rr_type); 355 return(buffer); 356 } 357 } 358 } 359 360 static unsigned short swap16(unsigned short x) 361 { 362 unsigned char *ptr = (unsigned char *)&x; 363 return (unsigned short)((unsigned short)ptr[0] << 8 | ptr[1]); 364 } 365 366 static unsigned int swap32(unsigned int x) 367 { 368 unsigned char *ptr = (unsigned char *)&x; 369 return (unsigned int)((unsigned int)ptr[0] << 24 | (unsigned int)ptr[1] << 16 | (unsigned int)ptr[2] << 8 | ptr[3]); 370 } 371 static unsigned int keytag(unsigned char *key, unsigned int keysize) 372 { 373 unsigned long ac; 374 unsigned int i; 375 376 for (ac = 0, i = 0; i < keysize; ++i) 377 ac += (i & 1) ? key[i] : key[i] << 8; 378 ac += (ac >> 16) & 0xFFFF; 379 return ac & 0xFFFF; 380 } 381 382 static void base64Encode(char *buffer, int buflen, void *rdata, unsigned int rdlen) 383 { 384 #if _DNS_SD_LIBDISPATCH 385 const void *result = NULL; 386 size_t size; 387 dispatch_data_t src_data = NULL, dest_data = NULL, null_str = NULL, data = NULL, map = NULL; 388 389 src_data = dispatch_data_create(rdata, rdlen, dispatch_get_global_queue(0, 0), ^{}); 390 if (!src_data) 391 goto done; 392 393 dest_data = dispatch_data_create_with_transform(src_data, DISPATCH_DATA_FORMAT_TYPE_NONE, DISPATCH_DATA_FORMAT_TYPE_BASE64); 394 if (!dest_data) 395 goto done; 396 397 null_str = dispatch_data_create("", 1, dispatch_get_global_queue(0, 0), ^{}); 398 if (!null_str) 399 goto done; 400 401 data = dispatch_data_create_concat(dest_data, null_str); 402 if (!data) 403 goto done; 404 405 map = dispatch_data_create_map(data, &result, &size); 406 if (!map) 407 goto done; 408 409 snprintf(buffer, buflen, " %s", (char *)result); 410 411 done: 412 if (src_data) dispatch_release(src_data); 413 if (dest_data) dispatch_release(dest_data); 414 if (data) dispatch_release(data); 415 if (null_str) dispatch_release(null_str); 416 if (map) dispatch_release(map); 417 return; 418 #else //_DNS_SD_LIBDISPATCH 419 snprintf(buffer, buflen, " %s", "."); 420 return; 421 #endif //_DNS_SD_LIBDISPATCH 422 } 423 424 #if HAS_NAT_PMP_API | HAS_ADDRINFO_API 425 static DNSServiceProtocol GetProtocol(const char *s) 426 { 427 if (!strcasecmp(s, "v4" )) return(kDNSServiceProtocol_IPv4); 428 else if (!strcasecmp(s, "v6" )) return(kDNSServiceProtocol_IPv6); 429 else if (!strcasecmp(s, "v4v6" )) return(kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6); 430 else if (!strcasecmp(s, "v6v4" )) return(kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6); 431 else if (!strcasecmp(s, "udp" )) return(kDNSServiceProtocol_UDP); 432 else if (!strcasecmp(s, "tcp" )) return(kDNSServiceProtocol_TCP); 433 else if (!strcasecmp(s, "udptcp" )) return(kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP); 434 else if (!strcasecmp(s, "tcpudp" )) return(kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP); 435 else return(atoi(s)); 436 } 437 #endif 438 439 440 //************************************************************************************************************* 441 // Sample callback functions for each of the operation types 442 443 static void printtimestamp(void) 444 { 445 struct tm tm; 446 int ms; 447 static char date[16]; 448 static char new_date[16]; 449 #ifdef _WIN32 450 SYSTEMTIME sysTime; 451 time_t uct = time(NULL); 452 tm = *localtime(&uct); 453 GetLocalTime(&sysTime); 454 ms = sysTime.wMilliseconds; 455 #else 456 struct timeval tv; 457 gettimeofday(&tv, NULL); 458 localtime_r((time_t*)&tv.tv_sec, &tm); 459 ms = tv.tv_usec/1000; 460 #endif 461 strftime(new_date, sizeof(new_date), "%a %d %b %Y", &tm); 462 if (strncmp(date, new_date, sizeof(new_date))) 463 { 464 printf("DATE: ---%s---\n", new_date); //display date only if it has changed 465 strncpy(date, new_date, sizeof(date)); 466 } 467 printf("%2d:%02d:%02d.%03d ", tm.tm_hour, tm.tm_min, tm.tm_sec, ms); 468 } 469 470 // formating time to RFC 4034 format 471 static void FormatTime(unsigned long te, unsigned char *buf, int bufsize) 472 { 473 struct tm tmTime; 474 #ifdef _WIN32 475 __time32_t t = (__time32_t) te; 476 _gmtime32_s(&tmTime, &t); 477 #else 478 // Time since epoch : strftime takes "tm". Convert seconds to "tm" using 479 // gmtime_r first and then use strftime 480 time_t t = (time_t)te; 481 gmtime_r(&t, &tmTime); 482 #endif 483 strftime((char *)buf, bufsize, "%Y%m%d%H%M%S", &tmTime); 484 } 485 486 static void print_usage(const char *arg0, int print_all) 487 { 488 fprintf(stderr, "%s -E (Enumerate recommended registration domains)\n", arg0); 489 fprintf(stderr, "%s -F (Enumerate recommended browsing domains)\n", arg0); 490 fprintf(stderr, "%s -R <Name> <Type> <Domain> <Port> [<TXT>...] (Register a service)\n", arg0); 491 fprintf(stderr, "%s -B <Type> <Domain> (Browse for services instances)\n", arg0); 492 fprintf(stderr, "%s -L <Name> <Type> <Domain> (Look up a service instance)\n", arg0); 493 fprintf(stderr, "%s -P <Name> <Type> <Domain> <Port> <Host> <IP> [<TXT>...] (Proxy)\n", arg0); 494 fprintf(stderr, "%s -q <name> <rrtype> <rrclass> (Generic query for any record type)\n", arg0); 495 fprintf(stderr, "%s -D <name> <rrtype> <rrclass>(Validate query for any record type with DNSSEC)\n", arg0); 496 fprintf(stderr, "%s -Z <Type> <Domain> (Output results in Zone File format)\n", arg0); 497 #if HAS_ADDRINFO_API 498 fprintf(stderr, "%s -G v4/v6/v4v6 <name> (Get address information for hostname)\n", arg0); 499 fprintf(stderr, "%s -g v4/v6/v4v6 <name> (Validate address info for hostname with DNSSEC)\n", arg0); 500 #endif 501 fprintf(stderr, "%s -V (Get version of currently running daemon / system service)\n", arg0); 502 503 if (print_all) //Print all available options for dns-sd tool 504 { 505 fprintf(stderr, "%s -C <FQDN> <rrtype> <rrclass> (Query; reconfirming each result)\n", arg0); 506 #if HAS_NAT_PMP_API 507 fprintf(stderr, "%s -X udp/tcp/udptcp <IntPort> <ExtPort> <TTL> (NAT Port Mapping)\n", arg0); 508 #endif 509 fprintf(stderr, "%s -A (Test Adding/Updating/Deleting a record)\n", arg0); 510 fprintf(stderr, "%s -U (Test updating a TXT record)\n", arg0); 511 fprintf(stderr, "%s -N (Test adding a large NULL record)\n", arg0); 512 fprintf(stderr, "%s -T (Test creating a large TXT record)\n", arg0); 513 fprintf(stderr, "%s -M (Test creating a registration with multiple TXT records)\n", arg0); 514 fprintf(stderr, "%s -I (Test registering and then immediately updating TXT record)\n", arg0); 515 fprintf(stderr, "%s -S (Test multiple operations on a shared socket)\n", arg0); 516 fprintf(stderr, "%s -i <Interface> (Run dns-sd cmd on a specific interface (en0/en1)\n", arg0); 517 fprintf(stderr, "%s -lo (Run dns-sd cmd using local only interface)\n", arg0); 518 fprintf(stderr, "%s -p2p (Use kDNSServiceInterfaceIndexP2P)\n", arg0); 519 fprintf(stderr, "%s -includep2p (Set kDNSServiceFlagsIncludeP2P flag)\n", arg0); 520 fprintf(stderr, "%s -includeAWDL (Set kDNSServiceFlagsIncludeAWDL flag)\n", arg0); 521 fprintf(stderr, "%s -optional (Set kDNSServiceFlagsValidateOptional flag)\n", arg0); 522 fprintf(stderr, "%s -tc (Set kDNSServiceFlagsBackgroundTrafficClass flag)\n", arg0); 523 fprintf(stderr, "%s -unicastResponse (Set kDNSServiceFlagsUnicastResponse flag)\n", arg0); 524 fprintf(stderr, "%s -t1 (Set kDNSServiceFlagsThresholdOne flag)\n", arg0); 525 fprintf(stderr, "%s -tFinder (Set kDNSServiceFlagsThresholdFinder flag)\n", arg0); 526 fprintf(stderr, "%s -timeout (Set kDNSServiceFlagsTimeout flag)\n", arg0); 527 } 528 } 529 530 #define DomainMsg(X) (((X) &kDNSServiceFlagsDefault) ? "(Default)" : \ 531 ((X) &kDNSServiceFlagsAdd) ? "Added" : "Removed") 532 533 #define MAX_LABELS 128 534 535 static void DNSSD_API enum_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, 536 DNSServiceErrorType errorCode, const char *replyDomain, void *context) 537 { 538 DNSServiceFlags partialflags = flags & ~(kDNSServiceFlagsMoreComing | kDNSServiceFlagsAdd | kDNSServiceFlagsDefault); 539 int labels = 0, depth = 0, i, initial = 0; 540 char text[64]; 541 const char *label[MAX_LABELS]; 542 543 (void)sdref; // Unused 544 (void)ifIndex; // Unused 545 (void)context; // Unused 546 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 547 548 // 1. Print the header 549 if (num_printed++ == 0) printf("Timestamp Recommended %s domain\n", operation == 'E' ? "Registration" : "Browsing"); 550 printtimestamp(); 551 if (errorCode) 552 printf("Error code %d\n", errorCode); 553 else if (!*replyDomain) 554 printf("Error: No reply domain\n"); 555 else 556 { 557 printf("%-10s", DomainMsg(flags)); 558 printf("%-8s", (flags & kDNSServiceFlagsMoreComing) ? "(More)" : ""); 559 if (partialflags) printf("Flags: %4X ", partialflags); 560 else printf(" "); 561 562 // 2. Count the labels 563 while (replyDomain && *replyDomain && labels < MAX_LABELS) 564 { 565 label[labels++] = replyDomain; 566 replyDomain = GetNextLabel(replyDomain, text); 567 } 568 569 // 3. Decide if we're going to clump the last two or three labels (e.g. "apple.com", or "nicta.com.au") 570 if (labels >= 3 && replyDomain - label[labels-1] <= 3 && label[labels-1] - label[labels-2] <= 4) initial = 3; 571 else if (labels >= 2 && replyDomain - label[labels-1] <= 4) initial = 2; 572 else initial = 1; 573 labels -= initial; 574 575 // 4. Print the initial one-, two- or three-label clump 576 for (i=0; i<initial; i++) 577 { 578 GetNextLabel(label[labels+i], text); 579 if (i>0) printf("."); 580 printf("%s", text); 581 } 582 printf("\n"); 583 584 // 5. Print the remainder of the hierarchy 585 for (depth=0; depth<labels; depth++) 586 { 587 printf(" "); 588 for (i=0; i<=depth; i++) printf("- "); 589 GetNextLabel(label[labels-1-depth], text); 590 printf("> %s\n", text); 591 } 592 } 593 594 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 595 } 596 597 static int CopyLabels(char *dst, const char *lim, const char **srcp, int labels) 598 { 599 const char *src = *srcp; 600 while (*src != '.' || --labels > 0) 601 { 602 if (*src == '\\') *dst++ = *src++; // Make sure "\." doesn't confuse us 603 if (!*src || dst >= lim) return -1; 604 *dst++ = *src++; 605 if (!*src || dst >= lim) return -1; 606 } 607 *dst++ = 0; 608 *srcp = src + 1; // skip over final dot 609 return 0; 610 } 611 612 static void DNSSD_API zonedata_resolve(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, 613 const char *fullname, const char *hosttarget, uint16_t opaqueport, uint16_t txtLen, const unsigned char *txt, void *context) 614 { 615 union { uint16_t s; u_char b[2]; } port = { opaqueport }; 616 uint16_t PortAsNumber = ((uint16_t)port.b[0]) << 8 | port.b[1]; 617 618 const char *p = fullname; 619 char n[kDNSServiceMaxDomainName]; 620 char t[kDNSServiceMaxDomainName]; 621 622 const unsigned char *max = txt + txtLen; 623 624 (void)sdref; // Unused 625 (void)ifIndex; // Unused 626 (void)context; // Unused 627 628 //if (!(flags & kDNSServiceFlagsAdd)) return; 629 if (errorCode) { printf("Error code %d\n", errorCode); return; } 630 631 if (CopyLabels(n, n + kDNSServiceMaxDomainName, &p, 3)) return; // Fetch name+type 632 p = fullname; 633 if (CopyLabels(t, t + kDNSServiceMaxDomainName, &p, 1)) return; // Skip first label 634 if (CopyLabels(t, t + kDNSServiceMaxDomainName, &p, 2)) return; // Fetch next two labels (service type) 635 636 if (num_printed++ == 0) 637 { 638 printf("\n"); 639 printf("; To direct clients to browse a different domain, substitute that domain in place of '@'\n"); 640 printf("%-47s PTR %s\n", "lb._dns-sd._udp", "@"); 641 printf("\n"); 642 printf("; In the list of services below, the SRV records will typically reference dot-local Multicast DNS names.\n"); 643 printf("; When transferring this zone file data to your unicast DNS server, you'll need to replace those dot-local\n"); 644 printf("; names with the correct fully-qualified (unicast) domain name of the target host offering the service.\n"); 645 } 646 647 printf("\n"); 648 printf("%-47s PTR %s\n", t, n); 649 printf("%-47s SRV 0 0 %d %s ; Replace with unicast FQDN of target host\n", n, PortAsNumber, hosttarget); 650 printf("%-47s TXT ", n); 651 652 while (txt < max) 653 { 654 const unsigned char *const end = txt + 1 + txt[0]; 655 txt++; // Skip over length byte 656 printf(" \""); 657 while (txt<end) 658 { 659 if (*txt == '\\' || *txt == '\"') printf("\\"); 660 printf("%c", *txt++); 661 } 662 printf("\""); 663 } 664 printf("\n"); 665 666 DNSServiceRefDeallocate(sdref); 667 free(context); 668 669 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 670 } 671 672 static void DNSSD_API zonedata_browse(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, 673 const char *replyName, const char *replyType, const char *replyDomain, void *context) 674 { 675 DNSServiceRef *newref; 676 677 (void)sdref; // Unused 678 (void)context; // Unused 679 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 680 681 if (!(flags & kDNSServiceFlagsAdd)) return; 682 if (errorCode) { printf("Error code %d\n", errorCode); return; } 683 684 newref = malloc(sizeof(*newref)); 685 *newref = client; 686 DNSServiceResolve(newref, kDNSServiceFlagsShareConnection, ifIndex, replyName, replyType, replyDomain, zonedata_resolve, newref); 687 } 688 689 static void DNSSD_API browse_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, 690 const char *replyName, const char *replyType, const char *replyDomain, void *context) 691 { 692 char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv"; 693 (void)sdref; // Unused 694 (void)context; // Unused 695 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 696 697 if (num_printed++ == 0) printf("Timestamp A/R Flags if %-20s %-20s %s\n", "Domain", "Service Type", "Instance Name"); 698 printtimestamp(); 699 if (errorCode) 700 printf("Error code %d\n", errorCode); 701 else 702 printf("%s %8X %3d %-20s %-20s %s\n", 703 op, flags, ifIndex, replyDomain, replyType, replyName); 704 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 705 706 // To test selective cancellation of operations of shared sockets, 707 // cancel the current operation when we've got a multiple of five results 708 //if (operation == 'S' && num_printed % 5 == 0) DNSServiceRefDeallocate(sdref); 709 } 710 711 static void ShowTXTRecord(uint16_t txtLen, const unsigned char *txtRecord) 712 { 713 const unsigned char *ptr = txtRecord; 714 const unsigned char *max = txtRecord + txtLen; 715 while (ptr < max) 716 { 717 const unsigned char *const end = ptr + 1 + ptr[0]; 718 if (end > max) { printf("<< invalid data >>"); break; } 719 if (++ptr < end) printf(" "); // As long as string is non-empty, begin with a space 720 while (ptr<end) 721 { 722 // We'd like the output to be shell-friendly, so that it can be copied and pasted unchanged into a "dns-sd -R" command. 723 // However, this is trickier than it seems. Enclosing a string in double quotes doesn't necessarily make it 724 // shell-safe, because shells still expand variables like $foo even when they appear inside quoted strings. 725 // Enclosing a string in single quotes is better, but when using single quotes even backslash escapes are ignored, 726 // meaning there's simply no way to represent a single quote (or apostrophe) inside a single-quoted string. 727 // The only remaining solution is not to surround the string with quotes at all, but instead to use backslash 728 // escapes to encode spaces and all other known shell metacharacters. 729 // (If we've missed any known shell metacharacters, please let us know.) 730 // In addition, non-printing ascii codes (0-31) are displayed as \xHH, using a two-digit hex value. 731 // Because '\' is itself a shell metacharacter (the shell escape character), it has to be escaped as "\\" to survive 732 // the round-trip to the shell and back. This means that a single '\' is represented here as EIGHT backslashes: 733 // The C compiler eats half of them, resulting in four appearing in the output. 734 // The shell parses those four as a pair of "\\" sequences, passing two backslashes to the "dns-sd -R" command. 735 // The "dns-sd -R" command interprets this single "\\" pair as an escaped literal backslash. Sigh. 736 if (strchr(" &;`'\"|*?~<>^()[]{}$", *ptr)) printf("\\"); 737 if (*ptr == '\\') printf("\\\\\\\\"); 738 else if (*ptr >= ' ' ) printf("%c", *ptr); 739 else printf("\\\\x%02X", *ptr); 740 ptr++; 741 } 742 } 743 } 744 745 static void DNSSD_API resolve_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, 746 const char *fullname, const char *hosttarget, uint16_t opaqueport, uint16_t txtLen, const unsigned char *txtRecord, void *context) 747 { 748 union { uint16_t s; u_char b[2]; } port = { opaqueport }; 749 uint16_t PortAsNumber = ((uint16_t)port.b[0]) << 8 | port.b[1]; 750 751 (void)sdref; // Unused 752 (void)ifIndex; // Unused 753 (void)context; // Unused 754 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 755 756 if (errorCode) 757 printf("Error code %d\n", errorCode); 758 else 759 { 760 printtimestamp(); 761 printf("%s can be reached at %s:%u (interface %d)", fullname, hosttarget, PortAsNumber, ifIndex); 762 if (flags) printf(" Flags: %X", flags); 763 // Don't show degenerate TXT records containing nothing but a single empty string 764 if (txtLen > 1) { printf("\n"); ShowTXTRecord(txtLen, txtRecord); } 765 printf("\n"); 766 } 767 768 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 769 } 770 771 static void myTimerCallBack(void) 772 { 773 DNSServiceErrorType err = kDNSServiceErr_Unknown; 774 775 switch (operation) 776 { 777 case 'A': 778 { 779 switch (addtest) 780 { 781 case 0: printf("Adding Test HINFO record\n"); 782 err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_HINFO, sizeof(myhinfoW), &myhinfoW[0], 0); 783 addtest = 1; 784 break; 785 case 1: printf("Updating Test HINFO record\n"); 786 err = DNSServiceUpdateRecord(client, record, 0, sizeof(myhinfoX), &myhinfoX[0], 0); 787 addtest = 2; 788 break; 789 case 2: printf("Removing Test HINFO record\n"); 790 err = DNSServiceRemoveRecord(client, record, 0); 791 addtest = 0; 792 break; 793 } 794 } 795 break; 796 797 case 'U': 798 { 799 if (updatetest[1] != 'Z') updatetest[1]++; 800 else updatetest[1] = 'A'; 801 updatetest[0] = 3 - updatetest[0]; 802 updatetest[2] = updatetest[1]; 803 printtimestamp(); 804 printf("Updating Test TXT record to %c\n", updatetest[1]); 805 err = DNSServiceUpdateRecord(client, NULL, 0, 1+updatetest[0], &updatetest[0], 0); 806 } 807 break; 808 809 case 'N': 810 { 811 printf("Adding big NULL record\n"); 812 err = DNSServiceAddRecord(client, &record, 0, kDNSServiceType_NULL, sizeof(bigNULL), &bigNULL[0], 0); 813 if (err) printf("Failed: %d\n", err);else printf("Succeeded\n"); 814 timeOut = LONG_TIME; 815 #if _DNS_SD_LIBDISPATCH 816 if (timer_source) 817 dispatch_source_set_timer(timer_source, dispatch_time(DISPATCH_TIME_NOW, (uint64_t)timeOut * NSEC_PER_SEC), 818 (uint64_t)timeOut * NSEC_PER_SEC, 0); 819 #endif 820 } 821 break; 822 } 823 824 if (err != kDNSServiceErr_NoError) 825 { 826 fprintf(stderr, "DNSService add/update/remove failed %ld\n", (long int)err); 827 stopNow = 1; 828 } 829 } 830 831 static void DNSSD_API reg_reply(DNSServiceRef sdref, const DNSServiceFlags flags, DNSServiceErrorType errorCode, 832 const char *name, const char *regtype, const char *domain, void *context) 833 { 834 (void)sdref; // Unused 835 (void)flags; // Unused 836 (void)context; // Unused 837 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 838 839 printtimestamp(); 840 printf("Got a reply for service %s.%s%s: ", name, regtype, domain); 841 842 if (errorCode == kDNSServiceErr_NoError) 843 { 844 if (flags & kDNSServiceFlagsAdd) printf("Name now registered and active\n"); 845 else printf("Name registration removed\n"); 846 if (operation == 'A' || operation == 'U' || operation == 'N') 847 { 848 timeOut = 5; 849 #if _DNS_SD_LIBDISPATCH 850 if (timer_source) 851 dispatch_source_set_timer(timer_source, dispatch_time(DISPATCH_TIME_NOW, (uint64_t)timeOut * NSEC_PER_SEC), 852 (uint64_t)timeOut * NSEC_PER_SEC, 0); 853 #endif 854 } 855 } 856 else if (errorCode == kDNSServiceErr_NameConflict) 857 { 858 printf("Name in use, please choose another\n"); 859 exit(-1); 860 } 861 else 862 printf("Error %d\n", errorCode); 863 864 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 865 } 866 867 // Output the wire-format domainname pointed to by rd 868 static int snprintd(char *p, int max, const unsigned char **rd) 869 { 870 const char *const buf = p; 871 const char *const end = p + max; 872 while (**rd) 873 { 874 p += snprintf(p, end-p, "%.*s.", **rd, *rd+1); 875 *rd += 1 + **rd; 876 } 877 *rd += 1; // Advance over the final zero byte 878 return(p-buf); 879 } 880 881 static void ParseDNSSECRecords(uint16_t rrtype, char *rdb, char *p, unsigned const char *rd, uint16_t rdlen) 882 { 883 int rdb_size = 1000; 884 switch (rrtype) 885 { 886 case kDNSServiceType_DS: 887 { 888 unsigned char *ptr; 889 int i; 890 rdataDS *rrds = (rdataDS *)rd; 891 p += snprintf(p, rdb + rdb_size - p, "%d %d %d ", 892 rrds->alg, swap16(rrds->keyTag), rrds->digestType); 893 ptr = (unsigned char *)(rd + DS_FIXED_SIZE); 894 for (i = 0; i < (rdlen - DS_FIXED_SIZE); i++) 895 p += snprintf(p, rdb + rdb_size - p, "%x", ptr[i]); 896 break; 897 } 898 899 case kDNSServiceType_DNSKEY: 900 { 901 rdataDNSKey *rrkey = (rdataDNSKey *)rd; 902 p += snprintf(p, rdb + rdb_size - p, "%d %d %d %u", swap16(rrkey->flags), rrkey->proto, 903 rrkey->alg, (unsigned int)keytag((unsigned char *)rrkey, rdlen)); 904 base64Encode(p, rdb + rdb_size - p, (unsigned char *)(rd + DNSKEY_FIXED_SIZE), rdlen - DNSKEY_FIXED_SIZE); 905 break; 906 } 907 908 case kDNSServiceType_NSEC: 909 { 910 unsigned char *next = (unsigned char *)rd; 911 int len, bitmaplen; 912 int win, wlen, type; 913 unsigned char *bmap; 914 char *l = NULL; 915 916 l = p; 917 p += snprintd(p, rdb + rdb_size - p, &rd); 918 len = p - l + 1; 919 920 bitmaplen = rdlen - len; 921 bmap = (unsigned char *)((unsigned char *)next + len); 922 923 while (bitmaplen > 0) 924 { 925 int i; 926 927 if (bitmaplen < 3) 928 { 929 printf("Case NSEC: malformed nsec, bitmaplen %d short\n", bitmaplen); 930 break; 931 } 932 933 win = *bmap++; 934 wlen = *bmap++; 935 bitmaplen -= 2; 936 if (bitmaplen < wlen || wlen < 1 || wlen > 32) 937 { 938 printf("Case NSEC: malformed nsec, bitmaplen %d wlen %d\n", bitmaplen, wlen); 939 break; 940 } 941 if (win < 0 || win >= 256) 942 { 943 printf("Case NSEC: malformed nsec, bad window win %d\n", win); 944 break; 945 } 946 type = win * 256; 947 for (i = 0; i < wlen * 8; i++) 948 { 949 if (bmap[i>>3] & (128 >> (i&7))) 950 p += snprintf(p, rdb + rdb_size - p, " %s ", DNSTypeName(type + i)); 951 } 952 bmap += wlen; 953 bitmaplen -= wlen; 954 } 955 break; 956 } 957 958 case kDNSServiceType_RRSIG: 959 { 960 rdataRRSig *rrsig = (rdataRRSig *)rd; 961 unsigned char expTimeBuf[64]; 962 unsigned char inceptTimeBuf[64]; 963 unsigned long inceptClock; 964 unsigned long expClock; 965 const unsigned char *q = NULL; 966 char *k = NULL; 967 int len; 968 969 expClock = (unsigned long)swap32(rrsig->sigExpireTime); 970 FormatTime(expClock, expTimeBuf, sizeof(expTimeBuf)); 971 972 inceptClock = (unsigned long)swap32(rrsig->sigInceptTime); 973 FormatTime(inceptClock, inceptTimeBuf, sizeof(inceptTimeBuf)); 974 975 p += snprintf(p, rdb + rdb_size - p, " %-7s %d %d %d %s %s %7d ", 976 DNSTypeName(swap16(rrsig->typeCovered)), rrsig->alg, rrsig->labels, swap32(rrsig->origTTL), 977 expTimeBuf, inceptTimeBuf, swap16(rrsig->keyTag)); 978 979 q = (const unsigned char *)&rrsig->signerName; 980 k = p; 981 p += snprintd(p, rdb + rdb_size - p, &q); 982 len = p - k + 1; 983 984 base64Encode(p, rdb + rdb_size - p, (unsigned char *)(rd + len + RRSIG_FIXED_SIZE), rdlen - (len + RRSIG_FIXED_SIZE)); 985 break; 986 } 987 } 988 return; 989 } 990 991 static void DNSSD_API qr_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t ifIndex, DNSServiceErrorType errorCode, 992 const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *rdata, uint32_t ttl, void *context) 993 { 994 char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv"; 995 const unsigned char *rd = rdata; 996 const unsigned char *end = (const unsigned char *) rdata + rdlen; 997 char rdb[1000] = "0.0.0.0", *p = rdb; 998 int unknowntype = 0; 999 char dnssec_status[15] = "Unknown"; 1000 char rr_type[RR_TYPE_SIZE]; 1001 char rr_class[3]; 1002 DNSServiceFlags check_flags = flags;//local flags for dnssec status checking 1003 1004 (void)sdref; // Unused 1005 (void)ifIndex; // Unused 1006 (void)ttl; // Unused 1007 (void)context; // Unused 1008 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 1009 1010 if (num_printed++ == 0) 1011 { 1012 if (operation == 'D') 1013 printf("Timestamp A/R if %-30s%-6s%-7s%-18s Rdata\n", "Name", "Type", "Class", "DNSSECStatus"); 1014 else 1015 printf("Timestamp A/R Flags if %-30s%-6s%-7s Rdata\n", "Name", "Type", "Class"); 1016 } 1017 printtimestamp(); 1018 1019 switch (rrclass) 1020 { 1021 case kDNSServiceClass_IN: 1022 strncpy(rr_class, "IN", sizeof(rr_class)); 1023 break; 1024 default: 1025 snprintf(rr_class, sizeof(rr_class), "%d", rrclass); 1026 break; 1027 } 1028 strncpy(rr_type, DNSTypeName(rrtype), sizeof(rr_type)); 1029 1030 if (!errorCode) //to avoid printing garbage in rdata 1031 { 1032 if (!(check_flags & (kDNSServiceFlagsValidate | kDNSServiceFlagsValidateOptional))) 1033 { 1034 switch (rrtype) 1035 { 1036 case kDNSServiceType_A: 1037 snprintf(rdb, sizeof(rdb), "%d.%d.%d.%d", rd[0], rd[1], rd[2], rd[3]); 1038 break; 1039 1040 case kDNSServiceType_NS: 1041 case kDNSServiceType_CNAME: 1042 case kDNSServiceType_PTR: 1043 case kDNSServiceType_DNAME: 1044 p += snprintd(p, sizeof(rdb), &rd); 1045 break; 1046 1047 case kDNSServiceType_SOA: 1048 p += snprintd(p, rdb + sizeof(rdb) - p, &rd); // mname 1049 p += snprintf(p, rdb + sizeof(rdb) - p, " "); 1050 p += snprintd(p, rdb + sizeof(rdb) - p, &rd); // rname 1051 p += snprintf(p, rdb + sizeof(rdb) - p, " Ser %d Ref %d Ret %d Exp %d Min %d", 1052 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])); 1053 break; 1054 1055 case kDNSServiceType_AAAA: 1056 snprintf(rdb, sizeof(rdb), "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X", 1057 rd[0x0], rd[0x1], rd[0x2], rd[0x3], rd[0x4], rd[0x5], rd[0x6], rd[0x7], 1058 rd[0x8], rd[0x9], rd[0xA], rd[0xB], rd[0xC], rd[0xD], rd[0xE], rd[0xF]); 1059 break; 1060 1061 case kDNSServiceType_SRV: 1062 p += snprintf(p, rdb + sizeof(rdb) - p, "%d %d %d ", // priority, weight, port 1063 ntohs(*(unsigned short*)rd), ntohs(*(unsigned short*)(rd+2)), ntohs(*(unsigned short*)(rd+4))); 1064 rd += 6; 1065 p += snprintd(p, rdb + sizeof(rdb) - p, &rd); // target host 1066 break; 1067 1068 case kDNSServiceType_DS: 1069 case kDNSServiceType_DNSKEY: 1070 case kDNSServiceType_NSEC: 1071 case kDNSServiceType_RRSIG: 1072 ParseDNSSECRecords(rrtype, rdb, p, rd, rdlen); 1073 break; 1074 1075 default: 1076 snprintf(rdb, sizeof(rdb), "%d bytes%s", rdlen, rdlen ? ":" : ""); 1077 unknowntype = 1; 1078 break; 1079 } 1080 } 1081 else 1082 { 1083 strncpy(rdb, "----", sizeof(rdb)); 1084 //Clear all o/p bits, and then check for dnssec status 1085 check_flags &= ~kDNSServiceOutputFlags; 1086 if (check_flags & kDNSServiceFlagsSecure) 1087 strncpy(dnssec_status, "Secure", sizeof(dnssec_status)); 1088 else if (check_flags & kDNSServiceFlagsInsecure) 1089 strncpy(dnssec_status, "Insecure", sizeof(dnssec_status)); 1090 else if (check_flags & kDNSServiceFlagsIndeterminate) 1091 strncpy(dnssec_status, "Indeterminate", sizeof(dnssec_status)); 1092 else if (check_flags & kDNSServiceFlagsBogus) 1093 strncpy(dnssec_status, "Bogus", sizeof(dnssec_status)); 1094 } 1095 } 1096 1097 if (operation == 'D') 1098 printf("%s%3d %-30s%-6s%-7s%-18s %s", op, ifIndex, fullname, rr_type, rr_class, dnssec_status, rdb); 1099 else 1100 printf("%s%6X%3d %-30s%-7s%-6s %s", op, flags, ifIndex, fullname, rr_type, rr_class, rdb); 1101 if (unknowntype) 1102 { 1103 while (rd < end) 1104 printf(" %02X", *rd++); 1105 } 1106 if (errorCode) 1107 { 1108 if (errorCode == kDNSServiceErr_NoSuchRecord) 1109 printf(" No Such Record"); 1110 else if (errorCode == kDNSServiceErr_Timeout) 1111 { 1112 printf(" No Such Record\n"); 1113 printf("Query Timed Out\n"); 1114 exit(1); 1115 } 1116 } 1117 printf("\n"); 1118 1119 if (operation == 'C') 1120 if (flags & kDNSServiceFlagsAdd) 1121 DNSServiceReconfirmRecord(flags, ifIndex, fullname, rrtype, rrclass, rdlen, rdata); 1122 1123 if (!(flags & kDNSServiceFlagsMoreComing)) 1124 fflush(stdout); 1125 } 1126 1127 #if HAS_NAT_PMP_API 1128 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) 1129 { 1130 (void)sdref; // Unused 1131 (void)flags; // Unused 1132 (void)context; // Unused 1133 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 1134 1135 if (num_printed++ == 0) printf("Timestamp if %-20s %-15s %-15s %-15s %-6s\n", "External Address", "Protocol", "Internal Port", "External Port", "TTL"); 1136 printtimestamp(); 1137 if (errorCode && errorCode != kDNSServiceErr_DoubleNAT) printf("Error code %d\n", errorCode); 1138 else 1139 { 1140 const unsigned char *digits = (const unsigned char *)&publicAddress; 1141 char addr[256]; 1142 1143 snprintf(addr, sizeof(addr), "%d.%d.%d.%d", digits[0], digits[1], digits[2], digits[3]); 1144 printf("%-4d %-20s %-15d %-15d %-15d %-6d%s\n", ifIndex, addr, protocol, ntohs(privatePort), ntohs(publicPort), ttl, errorCode == kDNSServiceErr_DoubleNAT ? " Double NAT" : ""); 1145 } 1146 1147 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 1148 } 1149 #endif 1150 1151 #if HAS_ADDRINFO_API 1152 static void DNSSD_API addrinfo_reply(DNSServiceRef sdref, const DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *hostname, const struct sockaddr *address, uint32_t ttl, void *context) 1153 { 1154 char *op = (flags & kDNSServiceFlagsAdd) ? "Add" : "Rmv"; 1155 char addr[256] = ""; 1156 char dnssec_status[15] = "Unknown"; 1157 DNSServiceFlags check_flags = flags; 1158 (void) sdref; 1159 (void) context; 1160 1161 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 1162 1163 if (num_printed++ == 0) 1164 { 1165 if (operation == 'g') 1166 printf("Timestamp A/R if %-25s %-44s %-18s\n", "Hostname", "Address", "DNSSECStatus"); 1167 else 1168 printf("Timestamp A/R Flags if %-38s %-44s %s\n", "Hostname", "Address", "TTL"); 1169 } 1170 printtimestamp(); 1171 1172 if (address && address->sa_family == AF_INET) 1173 { 1174 const unsigned char *b = (const unsigned char *) &((struct sockaddr_in *)address)->sin_addr; 1175 snprintf(addr, sizeof(addr), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]); 1176 } 1177 else if (address && address->sa_family == AF_INET6) 1178 { 1179 char if_name[IFNAMSIZ]; // Older Linux distributions don't define IF_NAMESIZE 1180 const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *)address; 1181 const unsigned char *b = (const unsigned char * )&s6->sin6_addr; 1182 if (!if_indextoname(s6->sin6_scope_id, if_name)) 1183 snprintf(if_name, sizeof(if_name), "<%d>", s6->sin6_scope_id); 1184 snprintf(addr, sizeof(addr), "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X%%%s", 1185 b[0x0], b[0x1], b[0x2], b[0x3], b[0x4], b[0x5], b[0x6], b[0x7], 1186 b[0x8], b[0x9], b[0xA], b[0xB], b[0xC], b[0xD], b[0xE], b[0xF], if_name); 1187 } 1188 1189 //go through this only if you have a dnssec validation status 1190 if (!errorCode && (check_flags & (kDNSServiceFlagsValidate | kDNSServiceFlagsValidateOptional))) 1191 { 1192 strncpy(addr, "----", sizeof(addr)); 1193 //Clear all o/p bits, and then check for dnssec status 1194 check_flags &= ~kDNSServiceOutputFlags; 1195 if (check_flags & kDNSServiceFlagsSecure) 1196 strncpy(dnssec_status, "Secure", sizeof(dnssec_status)); 1197 else if (check_flags & kDNSServiceFlagsInsecure) 1198 strncpy(dnssec_status, "Insecure", sizeof(dnssec_status)); 1199 else if (check_flags & kDNSServiceFlagsIndeterminate) 1200 strncpy(dnssec_status, "Indeterminate", sizeof(dnssec_status)); 1201 else if (check_flags & kDNSServiceFlagsBogus) 1202 strncpy(dnssec_status, "Bogus", sizeof(dnssec_status)); 1203 } 1204 1205 if (operation == 'g') 1206 printf("%s%3d %-25s %-44s %-18s", op, interfaceIndex, hostname, addr, dnssec_status); 1207 else 1208 printf("%s%6X%3d %-38s %-44s %d", op, flags, interfaceIndex, hostname, addr, ttl); 1209 if (errorCode) 1210 { 1211 if (errorCode == kDNSServiceErr_NoSuchRecord) 1212 printf(" No Such Record"); 1213 else 1214 printf(" Error code %d", errorCode); 1215 } 1216 printf("\n"); 1217 1218 if (!(flags & kDNSServiceFlagsMoreComing)) 1219 fflush(stdout); 1220 } 1221 #endif 1222 1223 //************************************************************************************************************* 1224 // The main test function 1225 1226 static void HandleEvents(void) 1227 #if _DNS_SD_LIBDISPATCH 1228 { 1229 main_queue = dispatch_get_main_queue(); 1230 if (client) DNSServiceSetDispatchQueue(client, main_queue); 1231 if (client_pa) DNSServiceSetDispatchQueue(client_pa, main_queue); 1232 if (operation == 'A' || operation == 'U' || operation == 'N') 1233 { 1234 timer_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, main_queue); 1235 if (timer_source) 1236 { 1237 // Start the timer "timeout" seconds into the future and repeat it every "timeout" seconds 1238 dispatch_source_set_timer(timer_source, dispatch_time(DISPATCH_TIME_NOW, (uint64_t)timeOut * NSEC_PER_SEC), 1239 (uint64_t)timeOut * NSEC_PER_SEC, 0); 1240 dispatch_source_set_event_handler(timer_source, ^{myTimerCallBack();}); 1241 dispatch_resume(timer_source); 1242 } 1243 } 1244 dispatch_main(); 1245 } 1246 #else 1247 { 1248 int dns_sd_fd = client ? DNSServiceRefSockFD(client ) : -1; 1249 int dns_sd_fd2 = client_pa ? DNSServiceRefSockFD(client_pa) : -1; 1250 int nfds = dns_sd_fd + 1; 1251 fd_set readfds; 1252 struct timeval tv; 1253 int result; 1254 1255 if (dns_sd_fd2 > dns_sd_fd) nfds = dns_sd_fd2 + 1; 1256 1257 while (!stopNow) 1258 { 1259 // 1. Set up the fd_set as usual here. 1260 // This example client has no file descriptors of its own, 1261 // but a real application would call FD_SET to add them to the set here 1262 FD_ZERO(&readfds); 1263 1264 // 2. Add the fd for our client(s) to the fd_set 1265 if (client ) FD_SET(dns_sd_fd, &readfds); 1266 if (client_pa) FD_SET(dns_sd_fd2, &readfds); 1267 1268 // 3. Set up the timeout. 1269 tv.tv_sec = timeOut; 1270 tv.tv_usec = 0; 1271 1272 result = select(nfds, &readfds, (fd_set*)NULL, (fd_set*)NULL, &tv); 1273 if (result > 0) 1274 { 1275 DNSServiceErrorType err = kDNSServiceErr_NoError; 1276 if (client && FD_ISSET(dns_sd_fd, &readfds)) err = DNSServiceProcessResult(client ); 1277 else if (client_pa && FD_ISSET(dns_sd_fd2, &readfds)) err = DNSServiceProcessResult(client_pa); 1278 if (err) { fprintf(stderr, "DNSServiceProcessResult returned %d\n", err); stopNow = 1; } 1279 } 1280 else if (result == 0) 1281 myTimerCallBack(); 1282 else 1283 { 1284 printf("select() returned %d errno %d %s\n", result, errno, strerror(errno)); 1285 if (errno != EINTR) stopNow = 1; 1286 } 1287 } 1288 } 1289 #endif 1290 1291 static int getfirstoption(int argc, char **argv, const char *optstr, int *pOptInd) 1292 // Return the recognized option in optstr and the option index of the next arg. 1293 #if NOT_HAVE_GETOPT 1294 { 1295 int i; 1296 for (i=1; i < argc; i++) 1297 { 1298 if (argv[i][0] == '-' && &argv[i][1] && 1299 NULL != strchr(optstr, argv[i][1])) 1300 { 1301 *pOptInd = i + 1; 1302 return argv[i][1]; 1303 } 1304 } 1305 return -1; 1306 } 1307 #else 1308 { 1309 int o = getopt(argc, (char *const *)argv, optstr); 1310 *pOptInd = optind; 1311 return o; 1312 } 1313 #endif 1314 1315 static void DNSSD_API MyRegisterRecordCallback(DNSServiceRef service, DNSRecordRef rec, const DNSServiceFlags flags, 1316 DNSServiceErrorType errorCode, void *context) 1317 { 1318 char *name = (char *)context; 1319 1320 (void)service; // Unused 1321 (void)rec; // Unused 1322 (void)flags; // Unused 1323 EXIT_IF_LIBDISPATCH_FATAL_ERROR(errorCode); 1324 1325 printtimestamp(); 1326 printf("Got a reply for record %s: ", name); 1327 1328 switch (errorCode) 1329 { 1330 case kDNSServiceErr_NoError: printf("Name now registered and active\n"); break; 1331 case kDNSServiceErr_NameConflict: printf("Name in use, please choose another\n"); exit(-1); 1332 default: printf("Error %d\n", errorCode); break; 1333 } 1334 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 1335 // DNSServiceRemoveRecord(service, rec, 0); to test record removal 1336 1337 #if 0 // To test updating of individual records registered via DNSServiceRegisterRecord 1338 if (!errorCode) 1339 { 1340 int x = 0x11111111; 1341 printf("Updating\n"); 1342 DNSServiceUpdateRecord(service, rec, 0, sizeof(x), &x, 0); 1343 } 1344 #endif 1345 1346 if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout); 1347 } 1348 1349 static void getip(const char *const name, struct sockaddr_storage *result) 1350 { 1351 struct addrinfo *addrs = NULL; 1352 int err = getaddrinfo(name, NULL, NULL, &addrs); 1353 if (err) fprintf(stderr, "getaddrinfo error %d for %s", err, name); 1354 else memcpy(result, addrs->ai_addr, SA_LEN(addrs->ai_addr)); 1355 if (addrs) freeaddrinfo(addrs); 1356 } 1357 1358 static DNSServiceErrorType RegisterProxyAddressRecord(DNSServiceRef sdref, const char *host, const char *ip, DNSServiceFlags flags) 1359 { 1360 // Call getip() after the call DNSServiceCreateConnection(). 1361 // On the Win32 platform, WinSock must be initialized for getip() to succeed. 1362 // Any DNSService* call will initialize WinSock for us, so we make sure 1363 // DNSServiceCreateConnection() is called before getip() is. 1364 struct sockaddr_storage hostaddr; 1365 getip(ip, &hostaddr); 1366 flags |= kDNSServiceFlagsUnique; 1367 if (hostaddr.ss_family == AF_INET) 1368 return(DNSServiceRegisterRecord(sdref, &record, flags, opinterface, host, 1369 kDNSServiceType_A, kDNSServiceClass_IN, 4, &((struct sockaddr_in *)&hostaddr)->sin_addr, 240, MyRegisterRecordCallback, (void*)host)); 1370 else if (hostaddr.ss_family == AF_INET6) 1371 return(DNSServiceRegisterRecord(sdref, &record, flags, opinterface, host, 1372 kDNSServiceType_AAAA, kDNSServiceClass_IN, 16, &((struct sockaddr_in6*)&hostaddr)->sin6_addr, 240, MyRegisterRecordCallback, (void*)host)); 1373 else return(kDNSServiceErr_BadParam); 1374 } 1375 1376 #define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0' ) : \ 1377 ((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) : \ 1378 ((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : 0) 1379 1380 #define HexPair(P) ((HexVal((P)[0]) << 4) | HexVal((P)[1])) 1381 1382 static DNSServiceErrorType RegisterService(DNSServiceRef *sdref, 1383 const char *nam, const char *typ, const char *dom, const char *host, const char *port, int argc, char **argv, DNSServiceFlags flags) 1384 { 1385 uint16_t PortAsNumber = atoi(port); 1386 Opaque16 registerPort = { { PortAsNumber >> 8, PortAsNumber & 0xFF } }; 1387 unsigned char txt[2048] = ""; 1388 unsigned char *ptr = txt; 1389 int i; 1390 1391 if (nam[0] == '.' && nam[1] == 0) nam = ""; // We allow '.' on the command line as a synonym for empty string 1392 if (dom[0] == '.' && dom[1] == 0) dom = ""; // We allow '.' on the command line as a synonym for empty string 1393 1394 printf("Registering Service %s.%s%s%s", nam[0] ? nam : "<<Default>>", typ, dom[0] ? "." : "", dom); 1395 if (host && *host) printf(" host %s", host); 1396 printf(" port %s", port); 1397 1398 if (argc) 1399 { 1400 for (i = 0; i < argc; i++) 1401 { 1402 const char *p = argv[i]; 1403 *ptr = 0; 1404 while (*p && *ptr < 255 && ptr + 1 + *ptr < txt+sizeof(txt)) 1405 { 1406 if (p[0] != '\\' || p[1] == 0) { ptr[++*ptr] = *p; p+=1; } 1407 else if (p[1] == 'x' && isxdigit(p[2]) && isxdigit(p[3])) { ptr[++*ptr] = HexPair(p+2); p+=4; } 1408 else { ptr[++*ptr] = p[1]; p+=2; } 1409 } 1410 ptr += 1 + *ptr; 1411 } 1412 printf(" TXT"); 1413 ShowTXTRecord(ptr-txt, txt); 1414 } 1415 printf("\n"); 1416 1417 //flags |= kDNSServiceFlagsAllowRemoteQuery; 1418 //flags |= kDNSServiceFlagsNoAutoRename; 1419 1420 return(DNSServiceRegister(sdref, flags, opinterface, nam, typ, dom, host, registerPort.NotAnInteger, (uint16_t) (ptr-txt), txt, reg_reply, NULL)); 1421 } 1422 1423 #define TypeBufferSize 80 1424 static char *gettype(char *buffer, char *typ) 1425 { 1426 if (!typ || !*typ || (typ[0] == '.' && typ[1] == 0)) typ = "_http._tcp"; 1427 if (!strchr(typ, '.')) { snprintf(buffer, TypeBufferSize, "%s._tcp", typ); typ = buffer; } 1428 return(typ); 1429 } 1430 1431 int main(int argc, char **argv) 1432 { 1433 DNSServiceErrorType err; 1434 char buffer[TypeBufferSize], *typ, *dom; 1435 int opi; 1436 DNSServiceFlags flags = 0; 1437 int optional = 0; 1438 1439 // Extract the program name from argv[0], which by convention contains the path to this executable. 1440 // Note that this is just a voluntary convention, not enforced by the kernel -- 1441 // the process calling exec() can pass bogus data in argv[0] if it chooses to. 1442 const char *a0 = strrchr(argv[0], kFilePathSep) + 1; 1443 if (a0 == (const char *)1) a0 = argv[0]; 1444 1445 #if defined(_WIN32) 1446 HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0); 1447 #endif 1448 1449 #if TEST_NEW_CLIENTSTUB 1450 printf("Using embedded copy of dnssd_clientstub instead of system library\n"); 1451 if (sizeof(argv) == 8) printf("Running in 64-bit mode\n"); 1452 #endif 1453 1454 // Test code for TXTRecord functions 1455 //TXTRecordRef txtRecord; 1456 //TXTRecordCreate(&txtRecord, 0, NULL); 1457 //TXTRecordSetValue(&txtRecord, "aaa", 1, "b"); 1458 //printf("%d\n", TXTRecordContainsKey(TXTRecordGetLength(&txtRecord), TXTRecordGetBytesPtr(&txtRecord), "Aaa")); 1459 1460 if (argc > 1 && !strcmp(argv[1], "-lo")) 1461 { 1462 argc--; 1463 argv++; 1464 opinterface = kDNSServiceInterfaceIndexLocalOnly; 1465 printf("Using LocalOnly\n"); 1466 } 1467 1468 if (argc > 1 && (!strcmp(argv[1], "-p2p") || !strcmp(argv[1], "-P2P"))) 1469 { 1470 argc--; 1471 argv++; 1472 opinterface = kDNSServiceInterfaceIndexP2P; 1473 } 1474 1475 if (argc > 1 && !strcasecmp(argv[1], "-includep2p")) 1476 { 1477 argc--; 1478 argv++; 1479 flags |= kDNSServiceFlagsIncludeP2P; 1480 printf("Setting kDNSServiceFlagsIncludeP2P\n"); 1481 } 1482 1483 if (argc > 1 && !strcasecmp(argv[1], "-includeAWDL")) 1484 { 1485 argc--; 1486 argv++; 1487 flags |= kDNSServiceFlagsIncludeAWDL; 1488 printf("Setting kDNSServiceFlagsIncludeAWDL\n"); 1489 } 1490 1491 if (argc > 1 && !strcasecmp(argv[1], "-tc")) 1492 { 1493 argc--; 1494 argv++; 1495 flags |= kDNSServiceFlagsBackgroundTrafficClass; 1496 printf("Setting kDNSServiceFlagsBackgroundTrafficClass\n"); 1497 } 1498 1499 if (argc > 1 && !strcasecmp(argv[1], "-t1")) 1500 { 1501 argc--; 1502 argv++; 1503 flags |= kDNSServiceFlagsThresholdOne; 1504 printf("Setting kDNSServiceFlagsThresholdOne\n"); 1505 } 1506 1507 if (argc > 1 && !strcasecmp(argv[1], "-tFinder")) 1508 { 1509 argc--; 1510 argv++; 1511 flags |= kDNSServiceFlagsThresholdFinder; 1512 printf("Setting kDNSServiceFlagsThresholdFinder\n"); 1513 } 1514 1515 if (argc > 1 && !strcasecmp(argv[1], "-wo")) 1516 { 1517 argc--; 1518 argv++; 1519 flags |= kDNSServiceFlagsWakeOnlyService; 1520 printf("Setting kDNSServiceFlagsWakeOnlyService\n"); 1521 } 1522 1523 if (argc > 1 && !strcasecmp(argv[1], "-unicastResponse")) 1524 { 1525 argc--; 1526 argv++; 1527 flags |= kDNSServiceFlagsUnicastResponse; 1528 printf("Setting kDNSServiceFlagsUnicastResponse\n"); 1529 } 1530 if (argc > 1 && !strcasecmp(argv[1], "-timeout")) 1531 { 1532 argc--; 1533 argv++; 1534 flags |= kDNSServiceFlagsTimeout; 1535 printf("Setting kDNSServiceFlagsTimeout\n"); 1536 } 1537 if (argc > 1 && !strcasecmp(argv[1], "-optional")) 1538 { 1539 argc--; 1540 argv++; 1541 optional = 1; 1542 printf("Setting DNSSEC optional flag\n"); 1543 } 1544 1545 if (argc > 2 && !strcmp(argv[1], "-i")) 1546 { 1547 opinterface = if_nametoindex(argv[2]); 1548 if (!opinterface) opinterface = atoi(argv[2]); 1549 if (!opinterface) { fprintf(stderr, "Unknown interface %s\n", argv[2]); goto Fail; } 1550 argc -= 2; 1551 argv += 2; 1552 } 1553 1554 if (argc < 2) goto Fail; // Minimum command line is the command name and one argument 1555 operation = getfirstoption(argc, argv, "EFBZLlRPQqCAUNTMISVHhD" 1556 #if HAS_NAT_PMP_API 1557 "X" 1558 #endif 1559 #if HAS_ADDRINFO_API 1560 "Gg" 1561 #endif 1562 , &opi); 1563 if (operation == -1) goto Fail; 1564 1565 if (opinterface) printf("Using interface %d\n", opinterface); 1566 1567 switch (operation) 1568 { 1569 case 'E': printf("Looking for recommended registration domains:\n"); 1570 err = DNSServiceEnumerateDomains(&client, kDNSServiceFlagsRegistrationDomains, opinterface, enum_reply, NULL); 1571 break; 1572 1573 case 'F': printf("Looking for recommended browsing domains:\n"); 1574 err = DNSServiceEnumerateDomains(&client, kDNSServiceFlagsBrowseDomains, opinterface, enum_reply, NULL); 1575 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "nicta.com.au.", NULL); 1576 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "bonjour.nicta.com.au.", NULL); 1577 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "ibm.com.", NULL); 1578 //enum_reply(client, kDNSServiceFlagsAdd, 0, 0, "dns-sd.ibm.com.", NULL); 1579 break; 1580 1581 case 'B': typ = (argc < opi+1) ? "" : argv[opi+0]; 1582 dom = (argc < opi+2) ? "" : argv[opi+1]; // Missing domain argument is the same as empty string i.e. use system default(s) 1583 typ = gettype(buffer, typ); 1584 if (dom[0] == '.' && dom[1] == 0) dom[0] = 0; // We allow '.' on the command line as a synonym for empty string 1585 printf("Browsing for %s%s%s\n", typ, dom[0] ? "." : "", dom); 1586 err = DNSServiceBrowse(&client, flags, opinterface, typ, dom, browse_reply, NULL); 1587 break; 1588 1589 case 'Z': typ = (argc < opi+1) ? "" : argv[opi+0]; 1590 dom = (argc < opi+2) ? "" : argv[opi+1]; // Missing domain argument is the same as empty string i.e. use system default(s) 1591 typ = gettype(buffer, typ); 1592 if (dom[0] == '.' && dom[1] == 0) dom[0] = 0; // We allow '.' on the command line as a synonym for empty string 1593 printf("Browsing for %s%s%s\n", typ, dom[0] ? "." : "", dom); 1594 err = DNSServiceCreateConnection(&client); 1595 sc1 = client; 1596 err = DNSServiceBrowse(&sc1, kDNSServiceFlagsShareConnection, opinterface, typ, dom, zonedata_browse, NULL); 1597 break; 1598 1599 case 'l': 1600 case 'L': { 1601 if (argc < opi+2) goto Fail; 1602 typ = (argc < opi+2) ? "" : argv[opi+1]; 1603 dom = (argc < opi+3) ? "local" : argv[opi+2]; 1604 typ = gettype(buffer, typ); 1605 if (dom[0] == '.' && dom[1] == 0) dom = "local"; // We allow '.' on the command line as a synonym for "local" 1606 printf("Lookup %s.%s.%s\n", argv[opi+0], typ, dom); 1607 if (operation == 'l') flags |= kDNSServiceFlagsWakeOnResolve; 1608 err = DNSServiceResolve(&client, flags, opinterface, argv[opi+0], typ, dom, resolve_reply, NULL); 1609 break; 1610 } 1611 1612 case 'R': if (argc < opi+4) goto Fail; 1613 typ = (argc < opi+2) ? "" : argv[opi+1]; 1614 dom = (argc < opi+3) ? "" : argv[opi+2]; 1615 typ = gettype(buffer, typ); 1616 if (dom[0] == '.' && dom[1] == 0) dom[0] = 0; // We allow '.' on the command line as a synonym for empty string 1617 err = RegisterService(&client, argv[opi+0], typ, dom, NULL, argv[opi+3], argc-(opi+4), argv+(opi+4), flags); 1618 break; 1619 1620 1621 case 'P': if (argc < opi+6) goto Fail; 1622 err = DNSServiceCreateConnection(&client_pa); 1623 if (err) { fprintf(stderr, "DNSServiceCreateConnection returned %d\n", err); return(err); } 1624 err = RegisterProxyAddressRecord(client_pa, argv[opi+4], argv[opi+5], flags); 1625 if (err) break; 1626 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); 1627 break; 1628 1629 case 'D': 1630 case 'q': 1631 case 'Q': 1632 case 'C': { 1633 uint16_t rrtype, rrclass; 1634 flags |= kDNSServiceFlagsReturnIntermediates; 1635 if (operation == 'q') 1636 flags |= kDNSServiceFlagsSuppressUnusable; 1637 if (argc < opi+1) 1638 goto Fail; 1639 rrtype = (argc <= opi+1) ? kDNSServiceType_A : GetRRType(argv[opi+1]); 1640 rrclass = (argc <= opi+2) ? kDNSServiceClass_IN : GetRRClass(argv[opi+2]); 1641 if (rrtype == kDNSServiceType_TXT || rrtype == kDNSServiceType_PTR) 1642 flags |= kDNSServiceFlagsLongLivedQuery; 1643 if (operation == 'D') 1644 { 1645 flags |= kDNSServiceFlagsSuppressUnusable; 1646 if (optional) 1647 flags |= kDNSServiceFlagsValidateOptional; 1648 else 1649 flags |= kDNSServiceFlagsValidate; 1650 } 1651 err = DNSServiceQueryRecord(&client, flags, opinterface, argv[opi+0], rrtype, rrclass, qr_reply, NULL); 1652 break; 1653 } 1654 1655 case 'A': 1656 case 'U': 1657 case 'N': { 1658 Opaque16 registerPort = { { 0x12, 0x34 } }; 1659 static const char TXT[] = "\xC" "First String" "\xD" "Second String" "\xC" "Third String"; 1660 printf("Registering Service Test._testupdate._tcp.local.\n"); 1661 err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testupdate._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT)-1, TXT, reg_reply, NULL); 1662 break; 1663 } 1664 1665 case 'T': { 1666 Opaque16 registerPort = { { 0x23, 0x45 } }; 1667 char TXT[1024]; 1668 unsigned int i; 1669 for (i=0; i<sizeof(TXT); i++) 1670 if ((i & 0x1F) == 0) TXT[i] = 0x1F;else TXT[i] = 'A' + (i >> 5); 1671 printf("Registering Service Test._testlargetxt._tcp.local.\n"); 1672 err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testlargetxt._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT), TXT, reg_reply, NULL); 1673 break; 1674 } 1675 1676 case 'M': { 1677 pid_t pid = getpid(); 1678 Opaque16 registerPort = { { pid >> 8, pid & 0xFF } }; 1679 static const char TXT1[] = "\xC" "First String" "\xD" "Second String" "\xC" "Third String"; 1680 static const char TXT2[] = "\xD" "Fourth String" "\xC" "Fifth String" "\xC" "Sixth String"; 1681 printf("Registering Service Test._testdualtxt._tcp.local.\n"); 1682 err = DNSServiceRegister(&client, flags, opinterface, "Test", "_testdualtxt._tcp.", "", NULL, registerPort.NotAnInteger, sizeof(TXT1)-1, TXT1, reg_reply, NULL); 1683 if (!err) err = DNSServiceAddRecord(client, &record, flags, kDNSServiceType_TXT, sizeof(TXT2)-1, TXT2, 0); 1684 break; 1685 } 1686 1687 case 'I': { 1688 pid_t pid = getpid(); 1689 Opaque16 registerPort = { { pid >> 8, pid & 0xFF } }; 1690 static const char TXT[] = "\x09" "Test Data"; 1691 printf("Registering Service Test._testtxt._tcp.local.\n"); 1692 err = DNSServiceRegister(&client, 0, opinterface, "Test", "_testtxt._tcp.", "", NULL, registerPort.NotAnInteger, 0, NULL, reg_reply, NULL); 1693 if (!err) err = DNSServiceUpdateRecord(client, NULL, 0, sizeof(TXT)-1, TXT, 0); 1694 break; 1695 } 1696 1697 #if HAS_NAT_PMP_API 1698 case 'X': { 1699 if (argc == opi) // If no arguments, just fetch IP address 1700 err = DNSServiceNATPortMappingCreate(&client, 0, 0, 0, 0, 0, 0, port_mapping_create_reply, NULL); 1701 else if (argc >= opi+2 && atoi(argv[opi+0]) == 0) 1702 { 1703 DNSServiceProtocol prot = GetProtocol(argv[opi+0]); // Must specify TCP or UDP 1704 uint16_t IntPortAsNumber = atoi(argv[opi+1]); // Must specify internal port 1705 uint16_t ExtPortAsNumber = (argc < opi+3) ? 0 : atoi(argv[opi+2]); // Optional desired external port 1706 uint32_t ttl = (argc < opi+4) ? 0 : atoi(argv[opi+3]); // Optional desired lease lifetime 1707 Opaque16 intp = { { IntPortAsNumber >> 8, IntPortAsNumber & 0xFF } }; 1708 Opaque16 extp = { { ExtPortAsNumber >> 8, ExtPortAsNumber & 0xFF } }; 1709 err = DNSServiceNATPortMappingCreate(&client, 0, 0, prot, intp.NotAnInteger, extp.NotAnInteger, ttl, port_mapping_create_reply, NULL); 1710 } 1711 else goto Fail; 1712 break; 1713 } 1714 #endif 1715 1716 #if HAS_ADDRINFO_API 1717 case 'g': 1718 case 'G': { 1719 flags |= kDNSServiceFlagsReturnIntermediates; 1720 if (operation == 'g') 1721 { 1722 flags |= kDNSServiceFlagsSuppressUnusable; 1723 if (optional) 1724 flags |= kDNSServiceFlagsValidateOptional; 1725 else 1726 flags |= kDNSServiceFlagsValidate; 1727 } 1728 if (argc != opi+2) 1729 goto Fail; 1730 else 1731 err = DNSServiceGetAddrInfo(&client, flags, opinterface, GetProtocol(argv[opi+0]), argv[opi+1], addrinfo_reply, NULL); 1732 break; 1733 } 1734 #endif 1735 1736 case 'S': { 1737 Opaque16 registerPort = { { 0x23, 0x45 } }; // 9029 decimal 1738 unsigned char txtrec[16] = "\xF" "/path=test.html"; 1739 DNSRecordRef rec; 1740 unsigned char nulrec[4] = "1234"; 1741 1742 err = DNSServiceCreateConnection(&client); 1743 if (err) { fprintf(stderr, "DNSServiceCreateConnection failed %ld\n", (long int)err); return (-1); } 1744 1745 sc1 = client; 1746 err = DNSServiceBrowse(&sc1, kDNSServiceFlagsShareConnection, opinterface, "_http._tcp", "", browse_reply, NULL); 1747 if (err) { fprintf(stderr, "DNSServiceBrowse _http._tcp failed %ld\n", (long int)err); return (-1); } 1748 1749 sc2 = client; 1750 err = DNSServiceBrowse(&sc2, kDNSServiceFlagsShareConnection, opinterface, "_ftp._tcp", "", browse_reply, NULL); 1751 if (err) { fprintf(stderr, "DNSServiceBrowse _ftp._tcp failed %ld\n", (long int)err); return (-1); } 1752 1753 sc3 = client; 1754 err = DNSServiceRegister(&sc3, kDNSServiceFlagsShareConnection, opinterface, "kDNSServiceFlagsShareConnection", 1755 "_http._tcp", "local", NULL, registerPort.NotAnInteger, 0, NULL, reg_reply, NULL); 1756 if (err) { fprintf(stderr, "SharedConnection DNSServiceRegister failed %ld\n", (long int)err); return (-1); } 1757 1758 err = DNSServiceUpdateRecord(sc3, NULL, 0, sizeof(txtrec), txtrec, 0); 1759 if (err) { fprintf(stderr, "SharedConnection DNSServiceUpdateRecord failed %ld\n", (long int)err); return (-1); } 1760 1761 err = DNSServiceAddRecord(sc3, &rec, 0, kDNSServiceType_NULL, sizeof(nulrec), nulrec, 0); 1762 if (err) { fprintf(stderr, "SharedConnection DNSServiceAddRecord failed %ld\n", (long int)err); return (-1); } 1763 1764 err = DNSServiceRemoveRecord(sc3, rec, 0); 1765 if (err) { fprintf(stderr, "SharedConnection DNSServiceRemoveRecord failed %ld\n", (long int)err); return (-1); } 1766 1767 break; 1768 } 1769 1770 case 'V': { 1771 uint32_t v; 1772 uint32_t size = sizeof(v); 1773 err = DNSServiceGetProperty(kDNSServiceProperty_DaemonVersion, &v, &size); 1774 if (err) fprintf(stderr, "DNSServiceGetProperty failed %ld\n", (long int)err); 1775 else printf("Currently running daemon (system service) is version %d.%d.%d\n", v / 10000, v / 100 % 100, v % 100); 1776 exit(0); 1777 } 1778 1779 case 'H': goto Fail; 1780 1781 default: goto Fail; 1782 } 1783 1784 if (!client || err != kDNSServiceErr_NoError) 1785 { 1786 fprintf(stderr, "DNSService call failed %ld%s\n", (long int)err, 1787 (err == kDNSServiceErr_ServiceNotRunning) ? " (Service Not Running)" : ""); 1788 return (-1); 1789 } 1790 printtimestamp(); 1791 printf("...STARTING...\n"); 1792 HandleEvents(); 1793 1794 // Be sure to deallocate the DNSServiceRef when you're finished 1795 if (client ) DNSServiceRefDeallocate(client ); 1796 if (client_pa) DNSServiceRefDeallocate(client_pa); 1797 return 0; 1798 1799 Fail: 1800 if (operation == 'H') print_usage(a0,1); 1801 else print_usage(a0,0); 1802 return 0; 1803 1804 } 1805 1806 // Note: The C preprocessor stringify operator ('#') makes a string from its argument, without macro expansion 1807 // e.g. If "version" is #define'd to be "4", then STRINGIFY_AWE(version) will return the string "version", not "4" 1808 // To expand "version" to its value before making the string, use STRINGIFY(version) instead 1809 #define STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) # s 1810 #define STRINGIFY(s) STRINGIFY_ARGUMENT_WITHOUT_EXPANSION(s) 1811 1812 // NOT static -- otherwise the compiler may optimize it out 1813 // The "@(#) " pattern is a special prefix the "what" command looks for 1814 const char VersionString_SCCS[] = "@(#) dns-sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")"; 1815 1816 #if _BUILDING_XCODE_PROJECT_ 1817 // If the process crashes, then this string will be magically included in the automatically-generated crash log 1818 const char *__crashreporter_info__ = VersionString_SCCS + 5; 1819 asm (".desc ___crashreporter_info__, 0x10"); 1820 #endif 1821