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