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 #ifndef MDNS_VERSIONSTR_NODTS
1815 const char VersionString_SCCS[] = "@(#) dns-sd " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";
1816 #else
1817 const char VersionString_SCCS[] = "@(#) dns-sd " STRINGIFY(mDNSResponderVersion);
1818 #endif
1819 
1820 #if _BUILDING_XCODE_PROJECT_
1821 // If the process crashes, then this string will be magically included in the automatically-generated crash log
1822 const char *__crashreporter_info__ = VersionString_SCCS + 5;
1823 asm (".desc ___crashreporter_info__, 0x10");
1824 #endif