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