]> git.saurik.com Git - apple/mdnsresponder.git/blob - Clients/dnssdutil.c
projects / apple / mdnsresponder.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mDNSResponder-878.50.17.tar.gz
[apple/mdnsresponder.git] / Clients / dnssdutil.c
1 /*
2 Copyright (c) 2016-2018 Apple Inc. All rights reserved.
3
4 dnssdutil is a command-line utility for testing the DNS-SD API.
5 */
6
7 #include <CoreUtils/CommonServices.h> // Include early.
8 #include <CoreUtils/AsyncConnection.h>
9 #include <CoreUtils/CommandLineUtils.h>
10 #include <CoreUtils/DataBufferUtils.h>
11 #include <CoreUtils/DebugServices.h>
12 #include <CoreUtils/HTTPUtils.h>
13 #include <CoreUtils/MiscUtils.h>
14 #include <CoreUtils/NetUtils.h>
15 #include <CoreUtils/PrintFUtils.h>
16 #include <CoreUtils/RandomNumberUtils.h>
17 #include <CoreUtils/SoftLinking.h>
18 #include <CoreUtils/StringUtils.h>
19 #include <CoreUtils/TickUtils.h>
20 #include <dns_sd.h>
21 #include <dns_sd_private.h>
22
23 #if( TARGET_OS_DARWIN )
24 #include <dnsinfo.h>
25 #include <libproc.h>
26 #include <netdb.h>
27 #include <sys/proc_info.h>
28 #endif
29
30 #if( TARGET_OS_POSIX )
31 #include <sys/resource.h>
32 #endif
33
34 #if( DNSSDUTIL_INCLUDE_DNSCRYPT )
35 #include "tweetnacl.h" // TweetNaCl from <https://tweetnacl.cr.yp.to/software.html>.
36 #endif
37
38 //===========================================================================================================================
39 // Global Constants
40 //===========================================================================================================================
41
42 // Versioning
43
44 #define kDNSSDUtilNumVersion NumVersionBuild( 2, 0, 0, kVersionStageBeta, 0 )
45
46 #if( !MDNSRESPONDER_PROJECT && !defined( DNSSDUTIL_SOURCE_VERSION ) )
47 #define DNSSDUTIL_SOURCE_VERSION "0.0.0"
48 #endif
49
50 // DNS-SD API flag descriptors
51
52 #define kDNSServiceFlagsDescriptors \
53 "\x00" "AutoTrigger\0" \
54 "\x01" "Add\0" \
55 "\x02" "Default\0" \
56 "\x03" "NoAutoRename\0" \
57 "\x04" "Shared\0" \
58 "\x05" "Unique\0" \
59 "\x06" "BrowseDomains\0" \
60 "\x07" "RegistrationDomains\0" \
61 "\x08" "LongLivedQuery\0" \
62 "\x09" "AllowRemoteQuery\0" \
63 "\x0A" "ForceMulticast\0" \
64 "\x0B" "KnownUnique\0" \
65 "\x0C" "ReturnIntermediates\0" \
66 "\x0D" "NonBrowsable\0" \
67 "\x0E" "ShareConnection\0" \
68 "\x0F" "SuppressUnusable\0" \
69 "\x10" "Timeout\0" \
70 "\x11" "IncludeP2P\0" \
71 "\x12" "WakeOnResolve\0" \
72 "\x13" "BackgroundTrafficClass\0" \
73 "\x14" "IncludeAWDL\0" \
74 "\x15" "Validate\0" \
75 "\x16" "UnicastResponse\0" \
76 "\x17" "ValidateOptional\0" \
77 "\x18" "WakeOnlyService\0" \
78 "\x19" "ThresholdOne\0" \
79 "\x1A" "ThresholdFinder\0" \
80 "\x1B" "DenyCellular\0" \
81 "\x1C" "ServiceIndex\0" \
82 "\x1D" "DenyExpensive\0" \
83 "\x1E" "PathEvaluationDone\0" \
84 "\x00"
85
86 #define kDNSServiceProtocolDescriptors \
87 "\x00" "IPv4\0" \
88 "\x01" "IPv6\0" \
89 "\x04" "UDP\0" \
90 "\x05" "TCP\0" \
91 "\x00"
92
93 // (m)DNS
94
95 #define kDNSHeaderFlag_Response ( 1 << 15 )
96 #define kDNSHeaderFlag_AuthAnswer ( 1 << 10 )
97 #define kDNSHeaderFlag_Truncation ( 1 << 9 )
98 #define kDNSHeaderFlag_RecursionDesired ( 1 << 8 )
99 #define kDNSHeaderFlag_RecursionAvailable ( 1 << 7 )
100
101 #define kDNSOpCode_Query 0
102 #define kDNSOpCode_InverseQuery 1
103 #define kDNSOpCode_Status 2
104 #define kDNSOpCode_Notify 4
105 #define kDNSOpCode_Update 5
106
107 #define kDNSRCode_NoError 0
108 #define kDNSRCode_FormatError 1
109 #define kDNSRCode_ServerFailure 2
110 #define kDNSRCode_NXDomain 3
111 #define kDNSRCode_NotImplemented 4
112 #define kDNSRCode_Refused 5
113
114 #define kQClassUnicastResponseBit ( 1U << 15 )
115 #define kRRClassCacheFlushBit ( 1U << 15 )
116
117 #define kDomainLabelLengthMax 63
118 #define kDomainNameLengthMax 256
119
120 //===========================================================================================================================
121 // Gerneral Command Options
122 //===========================================================================================================================
123
124 // Command option macros
125
126 #define Command( NAME, CALLBACK, SUB_OPTIONS, SHORT_HELP, IS_NOTCOMMON ) \
127 CLI_COMMAND_EX( NAME, CALLBACK, SUB_OPTIONS, (IS_NOTCOMMON) ? kCLIOptionFlags_NotCommon : kCLIOptionFlags_None, \
128 (SHORT_HELP), NULL )
129
130 #define kRequiredOptionSuffix " [REQUIRED]"
131
132 #define MultiStringOptionEx( SHORT_CHAR, LONG_NAME, VAL_PTR, VAL_COUNT_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED, LONG_HELP ) \
133 CLI_OPTION_MULTI_STRING_EX( SHORT_CHAR, LONG_NAME, VAL_PTR, VAL_COUNT_PTR, ARG_HELP, \
134 (IS_REQUIRED) ? SHORT_HELP kRequiredOptionSuffix : SHORT_HELP, \
135 (IS_REQUIRED) ? kCLIOptionFlags_Required : kCLIOptionFlags_None, LONG_HELP )
136
137 #define MultiStringOption( SHORT_CHAR, LONG_NAME, VAL_PTR, VAL_COUNT_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED ) \
138 MultiStringOptionEx( SHORT_CHAR, LONG_NAME, VAL_PTR, VAL_COUNT_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED, NULL )
139
140 #define IntegerOption( SHORT_CHAR, LONG_NAME, VAL_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED ) \
141 CLI_OPTION_INTEGER_EX( SHORT_CHAR, LONG_NAME, VAL_PTR, ARG_HELP, \
142 (IS_REQUIRED) ? SHORT_HELP kRequiredOptionSuffix : SHORT_HELP, \
143 (IS_REQUIRED) ? kCLIOptionFlags_Required : kCLIOptionFlags_None, NULL )
144
145 #define BooleanOption( SHORT_CHAR, LONG_NAME, VAL_PTR, SHORT_HELP ) \
146 CLI_OPTION_BOOLEAN( (SHORT_CHAR), (LONG_NAME), (VAL_PTR), (SHORT_HELP), NULL )
147
148 #define StringOptionEx( SHORT_CHAR, LONG_NAME, VAL_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED, LONG_HELP ) \
149 CLI_OPTION_STRING_EX( SHORT_CHAR, LONG_NAME, VAL_PTR, ARG_HELP, \
150 (IS_REQUIRED) ? SHORT_HELP kRequiredOptionSuffix : SHORT_HELP, \
151 (IS_REQUIRED) ? kCLIOptionFlags_Required : kCLIOptionFlags_None, LONG_HELP )
152
153 #define StringOption( SHORT_CHAR, LONG_NAME, VAL_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED ) \
154 StringOptionEx( SHORT_CHAR, LONG_NAME, VAL_PTR, ARG_HELP, SHORT_HELP, IS_REQUIRED, NULL )
155
156 // DNS-SD API flag options
157
158 static int gDNSSDFlags = 0;
159 static int gDNSSDFlag_BrowseDomains = false;
160 static int gDNSSDFlag_DenyCellular = false;
161 static int gDNSSDFlag_DenyExpensive = false;
162 static int gDNSSDFlag_ForceMulticast = false;
163 static int gDNSSDFlag_IncludeAWDL = false;
164 static int gDNSSDFlag_NoAutoRename = false;
165 static int gDNSSDFlag_PathEvaluationDone = false;
166 static int gDNSSDFlag_RegistrationDomains = false;
167 static int gDNSSDFlag_ReturnIntermediates = false;
168 static int gDNSSDFlag_Shared = false;
169 static int gDNSSDFlag_SuppressUnusable = false;
170 static int gDNSSDFlag_Timeout = false;
171 static int gDNSSDFlag_UnicastResponse = false;
172 static int gDNSSDFlag_Unique = false;
173 static int gDNSSDFlag_WakeOnResolve = false;
174
175 #define DNSSDFlagsOption() \
176 IntegerOption( 'f', "flags", &gDNSSDFlags, "flags", \
177 "DNSServiceFlags as an integer. This value is bitwise ORed with other single flag options.", false )
178
179 #define DNSSDFlagOption( SHORT_CHAR, FLAG_NAME ) \
180 BooleanOption( SHORT_CHAR, # FLAG_NAME, &gDNSSDFlag_ ## FLAG_NAME, "Use kDNSServiceFlags" # FLAG_NAME "." )
181
182 #define DNSSDFlagsOption_DenyCellular() DNSSDFlagOption( 'C', DenyCellular )
183 #define DNSSDFlagsOption_DenyExpensive() DNSSDFlagOption( 'E', DenyExpensive )
184 #define DNSSDFlagsOption_ForceMulticast() DNSSDFlagOption( 'M', ForceMulticast )
185 #define DNSSDFlagsOption_IncludeAWDL() DNSSDFlagOption( 'A', IncludeAWDL )
186 #define DNSSDFlagsOption_NoAutoRename() DNSSDFlagOption( 'N', NoAutoRename )
187 #define DNSSDFlagsOption_PathEvalDone() DNSSDFlagOption( 'P', PathEvaluationDone )
188 #define DNSSDFlagsOption_ReturnIntermediates() DNSSDFlagOption( 'I', ReturnIntermediates )
189 #define DNSSDFlagsOption_Shared() DNSSDFlagOption( 'S', Shared )
190 #define DNSSDFlagsOption_SuppressUnusable() DNSSDFlagOption( 'S', SuppressUnusable )
191 #define DNSSDFlagsOption_Timeout() DNSSDFlagOption( 'T', Timeout )
192 #define DNSSDFlagsOption_UnicastResponse() DNSSDFlagOption( 'U', UnicastResponse )
193 #define DNSSDFlagsOption_Unique() DNSSDFlagOption( 'U', Unique )
194 #define DNSSDFlagsOption_WakeOnResolve() DNSSDFlagOption( 'W', WakeOnResolve )
195
196 // Interface option
197
198 static const char * gInterface = NULL;
199
200 #define InterfaceOption() \
201 StringOption( 'i', "interface", &gInterface, "interface", \
202 "Network interface by name or index. Use index -1 for local-only.", false )
203
204 // Connection options
205
206 #define kConnectionArg_Normal ""
207 #define kConnectionArgPrefix_PID "pid:"
208 #define kConnectionArgPrefix_UUID "uuid:"
209
210 static const char * gConnectionOpt = kConnectionArg_Normal;
211
212 #define ConnectionOptions() \
213 { kCLIOptionType_String, 0, "connection", &gConnectionOpt, NULL, (intptr_t) kConnectionArg_Normal, "type", \
214 kCLIOptionFlags_OptionalArgument, NULL, NULL, NULL, NULL, \
215 "Specifies the type of main connection to use. See " kConnectionSection_Name " below.", NULL }
216
217 #define kConnectionSection_Name "Connection Option"
218 #define kConnectionSection_Text \
219 "The default behavior is to create a main connection with DNSServiceCreateConnection() and perform operations on\n" \
220 "the main connection using the kDNSServiceFlagsShareConnection flag. This behavior can be explicitly invoked by\n" \
221 "specifying the connection option without an argument, i.e.,\n" \
222 "\n" \
223 " --connection\n" \
224 "\n" \
225 "To instead use a delegate connection created with DNSServiceCreateDelegateConnection(), use\n" \
226 "\n" \
227 " --connection=pid:<PID>\n" \
228 "\n" \
229 "to specify the delegator by PID, or use\n" \
230 "\n" \
231 " --connection=uuid:<UUID>\n" \
232 "\n" \
233 "to specify the delegator by UUID.\n" \
234 "\n" \
235 "To not use a main connection at all, but instead perform operations on their own implicit connections, use\n" \
236 "\n" \
237 " --no-connection\n"
238
239 #define ConnectionSection() CLI_SECTION( kConnectionSection_Name, kConnectionSection_Text )
240
241 // Help text for record data options
242
243 #define kRDataArgPrefix_Domain "domain:"
244 #define kRDataArgPrefix_File "file:"
245 #define kRDataArgPrefix_HexString "hex:"
246 #define kRDataArgPrefix_IPv4 "ipv4:"
247 #define kRDataArgPrefix_IPv6 "ipv6:"
248 #define kRDataArgPrefix_SRV "srv:"
249 #define kRDataArgPrefix_String "string:"
250 #define kRDataArgPrefix_TXT "txt:"
251
252 #define kRecordDataSection_Name "Record Data Arguments"
253 #define kRecordDataSection_Text \
254 "A record data argument is specified in one of the following formats:\n" \
255 "\n" \
256 "Format Syntax Example\n" \
257 "Domain name domain:<domain name> domain:demo._test._tcp.local\n" \
258 "File containing record data file:<file path> file:/path/to/rdata.bin\n" \
259 "Hexadecimal string hex:<hex string> hex:c0000201 or hex:'C0 00 02 01'\n" \
260 "IPv4 address ipv4:<IPv4 address> ipv4:192.0.2.1\n" \
261 "IPv6 address ipv6:<IPv6 address> ipv6:2001:db8::1\n" \
262 "SRV record srv:<priority>,<weight>,<port>,<target> srv:0,0,64206,example.local\n" \
263 "String (w/escaped hex bytes) string:<string> string:'\\x09color=red'\n" \
264 "TXT record keys and values txt:<comma-delimited keys and values> txt:'vers=1.0,lang=en\\,es\\,fr,passreq'\n"
265
266 #define RecordDataSection() CLI_SECTION( kRecordDataSection_Name, kRecordDataSection_Text )
267
268 //===========================================================================================================================
269 // Browse Command Options
270 //===========================================================================================================================
271
272 static char ** gBrowse_ServiceTypes = NULL;
273 static size_t gBrowse_ServiceTypesCount = 0;
274 static const char * gBrowse_Domain = NULL;
275 static int gBrowse_DoResolve = false;
276 static int gBrowse_QueryTXT = false;
277 static int gBrowse_TimeLimitSecs = 0;
278
279 static CLIOption kBrowseOpts[] =
280 {
281 InterfaceOption(),
282 MultiStringOption( 't', "type", &gBrowse_ServiceTypes, &gBrowse_ServiceTypesCount, "service type", "Service type(s), e.g., \"_ssh._tcp\".", true ),
283 StringOption( 'd', "domain", &gBrowse_Domain, "domain", "Domain in which to browse for the service type(s).", false ),
284
285 CLI_OPTION_GROUP( "Flags" ),
286 DNSSDFlagsOption(),
287 DNSSDFlagsOption_IncludeAWDL(),
288
289 CLI_OPTION_GROUP( "Operation" ),
290 ConnectionOptions(),
291 BooleanOption( 0 , "resolve", &gBrowse_DoResolve, "Resolve service instances." ),
292 BooleanOption( 0 , "queryTXT", &gBrowse_QueryTXT, "Query TXT records of service instances." ),
293 IntegerOption( 'l', "timeLimit", &gBrowse_TimeLimitSecs, "seconds", "Specifies the max duration of the browse operation. Use '0' for no time limit.", false ),
294
295 ConnectionSection(),
296 CLI_OPTION_END()
297 };
298
299 //===========================================================================================================================
300 // GetAddrInfo Command Options
301 //===========================================================================================================================
302
303 static const char * gGetAddrInfo_Name = NULL;
304 static int gGetAddrInfo_ProtocolIPv4 = false;
305 static int gGetAddrInfo_ProtocolIPv6 = false;
306 static int gGetAddrInfo_OneShot = false;
307 static int gGetAddrInfo_TimeLimitSecs = 0;
308
309 static CLIOption kGetAddrInfoOpts[] =
310 {
311 InterfaceOption(),
312 StringOption( 'n', "name", &gGetAddrInfo_Name, "domain name", "Domain name to resolve.", true ),
313 BooleanOption( 0 , "ipv4", &gGetAddrInfo_ProtocolIPv4, "Use kDNSServiceProtocol_IPv4." ),
314 BooleanOption( 0 , "ipv6", &gGetAddrInfo_ProtocolIPv6, "Use kDNSServiceProtocol_IPv6." ),
315
316 CLI_OPTION_GROUP( "Flags" ),
317 DNSSDFlagsOption(),
318 DNSSDFlagsOption_DenyCellular(),
319 DNSSDFlagsOption_DenyExpensive(),
320 DNSSDFlagsOption_PathEvalDone(),
321 DNSSDFlagsOption_ReturnIntermediates(),
322 DNSSDFlagsOption_SuppressUnusable(),
323 DNSSDFlagsOption_Timeout(),
324
325 CLI_OPTION_GROUP( "Operation" ),
326 ConnectionOptions(),
327 BooleanOption( 'o', "oneshot", &gGetAddrInfo_OneShot, "Finish after first set of results." ),
328 IntegerOption( 'l', "timeLimit", &gGetAddrInfo_TimeLimitSecs, "seconds", "Maximum duration of the GetAddrInfo operation. Use '0' for no time limit.", false ),
329
330 ConnectionSection(),
331 CLI_OPTION_END()
332 };
333
334 //===========================================================================================================================
335 // QueryRecord Command Options
336 //===========================================================================================================================
337
338 static const char * gQueryRecord_Name = NULL;
339 static const char * gQueryRecord_Type = NULL;
340 static int gQueryRecord_OneShot = false;
341 static int gQueryRecord_TimeLimitSecs = 0;
342 static int gQueryRecord_RawRData = false;
343
344 static CLIOption kQueryRecordOpts[] =
345 {
346 InterfaceOption(),
347 StringOption( 'n', "name", &gQueryRecord_Name, "domain name", "Full domain name of record to query.", true ),
348 StringOption( 't', "type", &gQueryRecord_Type, "record type", "Record type by name (e.g., TXT, SRV, etc.) or number.", true ),
349
350 CLI_OPTION_GROUP( "Flags" ),
351 DNSSDFlagsOption(),
352 DNSSDFlagsOption_IncludeAWDL(),
353 DNSSDFlagsOption_ForceMulticast(),
354 DNSSDFlagsOption_Timeout(),
355 DNSSDFlagsOption_ReturnIntermediates(),
356 DNSSDFlagsOption_SuppressUnusable(),
357 DNSSDFlagsOption_UnicastResponse(),
358 DNSSDFlagsOption_DenyCellular(),
359 DNSSDFlagsOption_DenyExpensive(),
360 DNSSDFlagsOption_PathEvalDone(),
361
362 CLI_OPTION_GROUP( "Operation" ),
363 ConnectionOptions(),
364 BooleanOption( 'o', "oneshot", &gQueryRecord_OneShot, "Finish after first set of results." ),
365 IntegerOption( 'l', "timeLimit", &gQueryRecord_TimeLimitSecs, "seconds", "Maximum duration of the query record operation. Use '0' for no time limit.", false ),
366 BooleanOption( 0 , "raw", &gQueryRecord_RawRData, "Show record data as a hexdump." ),
367
368 ConnectionSection(),
369 CLI_OPTION_END()
370 };
371
372 //===========================================================================================================================
373 // Register Command Options
374 //===========================================================================================================================
375
376 static const char * gRegister_Name = NULL;
377 static const char * gRegister_Type = NULL;
378 static const char * gRegister_Domain = NULL;
379 static int gRegister_Port = 0;
380 static const char * gRegister_TXT = NULL;
381 static int gRegister_LifetimeMs = -1;
382 static const char ** gAddRecord_Types = NULL;
383 static size_t gAddRecord_TypesCount = 0;
384 static const char ** gAddRecord_Data = NULL;
385 static size_t gAddRecord_DataCount = 0;
386 static const char ** gAddRecord_TTLs = NULL;
387 static size_t gAddRecord_TTLsCount = 0;
388 static const char * gUpdateRecord_Data = NULL;
389 static int gUpdateRecord_DelayMs = 0;
390 static int gUpdateRecord_TTL = 0;
391
392 static CLIOption kRegisterOpts[] =
393 {
394 InterfaceOption(),
395 StringOption( 'n', "name", &gRegister_Name, "service name", "Name of service.", false ),
396 StringOption( 't', "type", &gRegister_Type, "service type", "Service type, e.g., \"_ssh._tcp\".", true ),
397 StringOption( 'd', "domain", &gRegister_Domain, "domain", "Domain in which to advertise the service.", false ),
398 IntegerOption( 'p', "port", &gRegister_Port, "port number", "Service's port number.", true ),
399 StringOption( 0 , "txt", &gRegister_TXT, "record data", "The TXT record data. See " kRecordDataSection_Name " below.", false ),
400
401 CLI_OPTION_GROUP( "Flags" ),
402 DNSSDFlagsOption(),
403 DNSSDFlagsOption_IncludeAWDL(),
404 DNSSDFlagsOption_NoAutoRename(),
405
406 CLI_OPTION_GROUP( "Operation" ),
407 IntegerOption( 'l', "lifetime", &gRegister_LifetimeMs, "ms", "Lifetime of the service registration in milliseconds.", false ),
408
409 CLI_OPTION_GROUP( "Options for updating the registered service's primary TXT record with DNSServiceUpdateRecord()\n" ),
410 StringOption( 0 , "updateData", &gUpdateRecord_Data, "record data", "Record data for the record update. See " kRecordDataSection_Name " below.", false ),
411 IntegerOption( 0 , "updateDelay", &gUpdateRecord_DelayMs, "ms", "Number of milliseconds after registration to wait before record update.", false ),
412 IntegerOption( 0 , "updateTTL", &gUpdateRecord_TTL, "seconds", "Time-to-live of the updated record.", false ),
413
414 CLI_OPTION_GROUP( "Options for adding extra record(s) to the registered service with DNSServiceAddRecord()\n" ),
415 MultiStringOption( 0 , "addType", &gAddRecord_Types, &gAddRecord_TypesCount, "record type", "Type of additional record by name (e.g., TXT, SRV, etc.) or number.", false ),
416 MultiStringOptionEx( 0 , "addData", &gAddRecord_Data, &gAddRecord_DataCount, "record data", "Additional record's data. See " kRecordDataSection_Name " below.", false, NULL ),
417 MultiStringOption( 0 , "addTTL", &gAddRecord_TTLs, &gAddRecord_TTLsCount, "seconds", "Time-to-live of additional record in seconds. Use '0' for default.", false ),
418
419 RecordDataSection(),
420 CLI_OPTION_END()
421 };
422
423 //===========================================================================================================================
424 // RegisterRecord Command Options
425 //===========================================================================================================================
426
427 static const char * gRegisterRecord_Name = NULL;
428 static const char * gRegisterRecord_Type = NULL;
429 static const char * gRegisterRecord_Data = NULL;
430 static int gRegisterRecord_TTL = 0;
431 static int gRegisterRecord_LifetimeMs = -1;
432 static const char * gRegisterRecord_UpdateData = NULL;
433 static int gRegisterRecord_UpdateDelayMs = 0;
434 static int gRegisterRecord_UpdateTTL = 0;
435
436 static CLIOption kRegisterRecordOpts[] =
437 {
438 InterfaceOption(),
439 StringOption( 'n', "name", &gRegisterRecord_Name, "record name", "Fully qualified domain name of record.", true ),
440 StringOption( 't', "type", &gRegisterRecord_Type, "record type", "Record type by name (e.g., TXT, PTR, A) or number.", true ),
441 StringOption( 'd', "data", &gRegisterRecord_Data, "record data", "The record data. See " kRecordDataSection_Name " below.", false ),
442 IntegerOption( 0 , "ttl", &gRegisterRecord_TTL, "seconds", "Time-to-live in seconds. Use '0' for default.", false ),
443
444 CLI_OPTION_GROUP( "Flags" ),
445 DNSSDFlagsOption(),
446 DNSSDFlagsOption_IncludeAWDL(),
447 DNSSDFlagsOption_Shared(),
448 DNSSDFlagsOption_Unique(),
449
450 CLI_OPTION_GROUP( "Operation" ),
451 IntegerOption( 'l', "lifetime", &gRegisterRecord_LifetimeMs, "ms", "Lifetime of the service registration in milliseconds.", false ),
452
453 CLI_OPTION_GROUP( "Options for updating the registered record with DNSServiceUpdateRecord()\n" ),
454 StringOption( 0 , "updateData", &gRegisterRecord_UpdateData, "record data", "Record data for the record update.", false ),
455 IntegerOption( 0 , "updateDelay", &gRegisterRecord_UpdateDelayMs, "ms", "Number of milliseconds after registration to wait before record update.", false ),
456 IntegerOption( 0 , "updateTTL", &gRegisterRecord_UpdateTTL, "seconds", "Time-to-live of the updated record.", false ),
457
458 RecordDataSection(),
459 CLI_OPTION_END()
460 };
461
462 //===========================================================================================================================
463 // Resolve Command Options
464 //===========================================================================================================================
465
466 static char * gResolve_Name = NULL;
467 static char * gResolve_Type = NULL;
468 static char * gResolve_Domain = NULL;
469 static int gResolve_TimeLimitSecs = 0;
470
471 static CLIOption kResolveOpts[] =
472 {
473 InterfaceOption(),
474 StringOption( 'n', "name", &gResolve_Name, "service name", "Name of the service instance to resolve.", true ),
475 StringOption( 't', "type", &gResolve_Type, "service type", "Type of the service instance to resolve.", true ),
476 StringOption( 'd', "domain", &gResolve_Domain, "domain", "Domain of the service instance to resolve.", true ),
477
478 CLI_OPTION_GROUP( "Flags" ),
479 DNSSDFlagsOption(),
480 DNSSDFlagsOption_ForceMulticast(),
481 DNSSDFlagsOption_IncludeAWDL(),
482 DNSSDFlagsOption_ReturnIntermediates(),
483 DNSSDFlagsOption_WakeOnResolve(),
484
485 CLI_OPTION_GROUP( "Operation" ),
486 ConnectionOptions(),
487 IntegerOption( 'l', "timeLimit", &gResolve_TimeLimitSecs, "seconds", "Maximum duration of the resolve operation. Use '0' for no time limit.", false ),
488
489 ConnectionSection(),
490 CLI_OPTION_END()
491 };
492
493 //===========================================================================================================================
494 // Reconfirm Command Options
495 //===========================================================================================================================
496
497 static const char * gReconfirmRecord_Name = NULL;
498 static const char * gReconfirmRecord_Type = NULL;
499 static const char * gReconfirmRecord_Class = NULL;
500 static const char * gReconfirmRecord_Data = NULL;
501
502 static CLIOption kReconfirmOpts[] =
503 {
504 InterfaceOption(),
505 StringOption( 'n', "name", &gReconfirmRecord_Name, "record name", "Full name of the record to reconfirm.", true ),
506 StringOption( 't', "type", &gReconfirmRecord_Type, "record type", "Type of the record to reconfirm.", true ),
507 StringOption( 'c', "class", &gReconfirmRecord_Class, "record class", "Class of the record to reconfirm. Default class is IN.", false ),
508 StringOption( 'd', "data", &gReconfirmRecord_Data, "record data", "The record data. See " kRecordDataSection_Name " below.", false ),
509
510 CLI_OPTION_GROUP( "Flags" ),
511 DNSSDFlagsOption(),
512
513 RecordDataSection(),
514 CLI_OPTION_END()
515 };
516
517 //===========================================================================================================================
518 // getaddrinfo-POSIX Command Options
519 //===========================================================================================================================
520
521 static const char * gGAIPOSIX_HostName = NULL;
522 static const char * gGAIPOSIX_ServName = NULL;
523 static const char * gGAIPOSIX_Family = NULL;
524 static int gGAIPOSIXFlag_AddrConfig = false;
525 static int gGAIPOSIXFlag_All = false;
526 static int gGAIPOSIXFlag_CanonName = false;
527 static int gGAIPOSIXFlag_NumericHost = false;
528 static int gGAIPOSIXFlag_NumericServ = false;
529 static int gGAIPOSIXFlag_Passive = false;
530 static int gGAIPOSIXFlag_V4Mapped = false;
531 #if( defined( AI_V4MAPPED_CFG ) )
532 static int gGAIPOSIXFlag_V4MappedCFG = false;
533 #endif
534 #if( defined( AI_DEFAULT ) )
535 static int gGAIPOSIXFlag_Default = false;
536 #endif
537 #if( defined( AI_UNUSABLE ) )
538 static int gGAIPOSIXFlag_Unusable = false;
539 #endif
540
541 static CLIOption kGetAddrInfoPOSIXOpts[] =
542 {
543 StringOption( 'n', "hostname", &gGAIPOSIX_HostName, "hostname", "Domain name to resolve or an IPv4 or IPv6 address.", true ),
544 StringOption( 's', "servname", &gGAIPOSIX_ServName, "servname", "Port number in decimal or service name from services(5).", false ),
545
546 CLI_OPTION_GROUP( "Hints " ),
547 StringOptionEx( 'f', "family", &gGAIPOSIX_Family, "address family", "Address family to use for hints ai_family field.", false,
548 "\n"
549 "Possible address family values are 'inet' for AF_INET, 'inet6' for AF_INET6, or 'unspec' for AF_UNSPEC. If no\n"
550 "address family is specified, then AF_UNSPEC is used.\n"
551 "\n" ),
552 BooleanOption( 0 , "flag-addrconfig", &gGAIPOSIXFlag_AddrConfig, "In hints ai_flags field, set AI_ADDRCONFIG." ),
553 BooleanOption( 0 , "flag-all", &gGAIPOSIXFlag_All, "In hints ai_flags field, set AI_ALL." ),
554 BooleanOption( 0 , "flag-canonname", &gGAIPOSIXFlag_CanonName, "In hints ai_flags field, set AI_CANONNAME." ),
555 BooleanOption( 0 , "flag-numerichost", &gGAIPOSIXFlag_NumericHost, "In hints ai_flags field, set AI_NUMERICHOST." ),
556 BooleanOption( 0 , "flag-numericserv", &gGAIPOSIXFlag_NumericServ, "In hints ai_flags field, set AI_NUMERICSERV." ),
557 BooleanOption( 0 , "flag-passive", &gGAIPOSIXFlag_Passive, "In hints ai_flags field, set AI_PASSIVE." ),
558 BooleanOption( 0 , "flag-v4mapped", &gGAIPOSIXFlag_V4Mapped, "In hints ai_flags field, set AI_V4MAPPED." ),
559 #if( defined( AI_V4MAPPED_CFG ) )
560 BooleanOption( 0 , "flag-v4mappedcfg", &gGAIPOSIXFlag_V4MappedCFG, "In hints ai_flags field, set AI_V4MAPPED_CFG." ),
561 #endif
562 #if( defined( AI_DEFAULT ) )
563 BooleanOption( 0 , "flag-default", &gGAIPOSIXFlag_Default, "In hints ai_flags field, set AI_DEFAULT." ),
564 #endif
565 #if( defined( AI_UNUSABLE ) )
566 BooleanOption( 0 , "flag-unusable", &gGAIPOSIXFlag_Unusable, "In hints ai_flags field, set AI_UNUSABLE." ),
567 #endif
568
569 CLI_SECTION( "Notes", "See getaddrinfo(3) man page for more details.\n" ),
570 CLI_OPTION_END()
571 };
572
573 //===========================================================================================================================
574 // ReverseLookup Command Options
575 //===========================================================================================================================
576
577 static const char * gReverseLookup_IPAddr = NULL;
578 static int gReverseLookup_OneShot = false;
579 static int gReverseLookup_TimeLimitSecs = 0;
580
581 static CLIOption kReverseLookupOpts[] =
582 {
583 InterfaceOption(),
584 StringOption( 'a', "address", &gReverseLookup_IPAddr, "IP address", "IPv4 or IPv6 address for which to perform a reverse IP lookup.", true ),
585
586 CLI_OPTION_GROUP( "Flags" ),
587 DNSSDFlagsOption(),
588 DNSSDFlagsOption_ForceMulticast(),
589 DNSSDFlagsOption_ReturnIntermediates(),
590 DNSSDFlagsOption_SuppressUnusable(),
591
592 CLI_OPTION_GROUP( "Operation" ),
593 ConnectionOptions(),
594 BooleanOption( 'o', "oneshot", &gReverseLookup_OneShot, "Finish after first set of results." ),
595 IntegerOption( 'l', "timeLimit", &gReverseLookup_TimeLimitSecs, "seconds", "Specifies the max duration of the query record operation. Use '0' for no time limit.", false ),
596
597 ConnectionSection(),
598 CLI_OPTION_END()
599 };
600
601 //===========================================================================================================================
602 // PortMapping Command Options
603 //===========================================================================================================================
604
605 static int gPortMapping_ProtocolTCP = false;
606 static int gPortMapping_ProtocolUDP = false;
607 static int gPortMapping_InternalPort = 0;
608 static int gPortMapping_ExternalPort = 0;
609 static int gPortMapping_TTL = 0;
610
611 static CLIOption kPortMappingOpts[] =
612 {
613 InterfaceOption(),
614 BooleanOption( 0, "tcp", &gPortMapping_ProtocolTCP, "Use kDNSServiceProtocol_TCP." ),
615 BooleanOption( 0, "udp", &gPortMapping_ProtocolUDP, "Use kDNSServiceProtocol_UDP." ),
616 IntegerOption( 0, "internalPort", &gPortMapping_InternalPort, "port number", "Internal port.", false ),
617 IntegerOption( 0, "externalPort", &gPortMapping_ExternalPort, "port number", "Requested external port. Use '0' for any external port.", false ),
618 IntegerOption( 0, "ttl", &gPortMapping_TTL, "seconds", "Requested TTL (renewal period) in seconds. Use '0' for a default value.", false ),
619
620 CLI_OPTION_GROUP( "Flags" ),
621 DNSSDFlagsOption(),
622
623 CLI_OPTION_GROUP( "Operation" ),
624 ConnectionOptions(),
625
626 ConnectionSection(),
627 CLI_OPTION_END()
628 };
629
630 //===========================================================================================================================
631 // BrowseAll Command Options
632 //===========================================================================================================================
633
634 static const char * gBrowseAll_Domain = NULL;
635 static char ** gBrowseAll_ServiceTypes = NULL;
636 static size_t gBrowseAll_ServiceTypesCount = 0;
637 static int gBrowseAll_IncludeAWDL = false;
638 static int gBrowseAll_BrowseTimeSecs = 5;
639 static int gBrowseAll_MaxConnectTimeSecs = 0;
640
641 static CLIOption kBrowseAllOpts[] =
642 {
643 InterfaceOption(),
644 StringOption( 'd', "domain", &gBrowseAll_Domain, "domain", "Domain in which to browse for the service.", false ),
645 MultiStringOption( 't', "type", &gBrowseAll_ServiceTypes, &gBrowseAll_ServiceTypesCount, "service type", "Service type(s), e.g., \"_ssh._tcp\". All services are browsed for if none is specified.", false ),
646
647 CLI_OPTION_GROUP( "Flags" ),
648 DNSSDFlagsOption_IncludeAWDL(),
649
650 CLI_OPTION_GROUP( "Operation" ),
651 IntegerOption( 'b', "browseTime", &gBrowseAll_BrowseTimeSecs, "seconds", "Amount of time to spend browsing. (Default: 5 seconds)", false ),
652 IntegerOption( 'c', "maxConnectTime", &gBrowseAll_MaxConnectTimeSecs, "seconds", "Max duration of connection attempts. If <= 0, then no connections are attempted. (Default: 0 seconds)", false ),
653 CLI_OPTION_END()
654 };
655
656 //===========================================================================================================================
657 // GetAddrInfoStress Command Options
658 //===========================================================================================================================
659
660 static int gGAIStress_TestDurationSecs = 0;
661 static int gGAIStress_ConnectionCount = 0;
662 static int gGAIStress_DurationMinMs = 0;
663 static int gGAIStress_DurationMaxMs = 0;
664 static int gGAIStress_RequestCountMax = 0;
665
666 static CLIOption kGetAddrInfoStressOpts[] =
667 {
668 InterfaceOption(),
669
670 CLI_OPTION_GROUP( "Flags" ),
671 DNSSDFlagsOption_ReturnIntermediates(),
672 DNSSDFlagsOption_SuppressUnusable(),
673
674 CLI_OPTION_GROUP( "Operation" ),
675 IntegerOption( 0, "testDuration", &gGAIStress_TestDurationSecs, "seconds", "Stress test duration in seconds. Use '0' for forever.", false ),
676 IntegerOption( 0, "connectionCount", &gGAIStress_ConnectionCount, "integer", "Number of simultaneous DNS-SD connections.", true ),
677 IntegerOption( 0, "requestDurationMin", &gGAIStress_DurationMinMs, "ms", "Minimum duration of DNSServiceGetAddrInfo() request in milliseconds.", true ),
678 IntegerOption( 0, "requestDurationMax", &gGAIStress_DurationMaxMs, "ms", "Maximum duration of DNSServiceGetAddrInfo() request in milliseconds.", true ),
679 IntegerOption( 0, "consecutiveRequestMax", &gGAIStress_RequestCountMax, "integer", "Maximum number of requests on a connection before restarting it.", true ),
680 CLI_OPTION_END()
681 };
682
683 //===========================================================================================================================
684 // DNSQuery Command Options
685 //===========================================================================================================================
686
687 static char * gDNSQuery_Name = NULL;
688 static char * gDNSQuery_Type = "A";
689 static char * gDNSQuery_Server = NULL;
690 static int gDNSQuery_TimeLimitSecs = 5;
691 static int gDNSQuery_UseTCP = false;
692 static int gDNSQuery_Flags = kDNSHeaderFlag_RecursionDesired;
693 static int gDNSQuery_RawRData = false;
694 static int gDNSQuery_Verbose = false;
695
696 #if( TARGET_OS_DARWIN )
697 #define kDNSQueryServerOptionIsRequired false
698 #else
699 #define kDNSQueryServerOptionIsRequired true
700 #endif
701
702 static CLIOption kDNSQueryOpts[] =
703 {
704 StringOption( 'n', "name", &gDNSQuery_Name, "name", "Question name (QNAME) to put in DNS query message.", true ),
705 StringOption( 't', "type", &gDNSQuery_Type, "type", "Question type (QTYPE) to put in DNS query message. Default value is 'A'.", false ),
706 StringOption( 's', "server", &gDNSQuery_Server, "IP address", "DNS server's IPv4 or IPv6 address.", kDNSQueryServerOptionIsRequired ),
707 IntegerOption( 'l', "timeLimit", &gDNSQuery_TimeLimitSecs, "seconds", "Specifies query time limit. Use '-1' for no limit and '0' to exit immediately after sending.", false ),
708 BooleanOption( 0 , "tcp", &gDNSQuery_UseTCP, "Send the DNS query via TCP instead of UDP." ),
709 IntegerOption( 'f', "flags", &gDNSQuery_Flags, "flags", "16-bit value for DNS header flags/codes field. Default value is 0x0100 (Recursion Desired).", false ),
710 BooleanOption( 0 , "raw", &gDNSQuery_RawRData, "Present record data as a hexdump." ),
711 BooleanOption( 'v', "verbose", &gDNSQuery_Verbose, "Prints the DNS message to be sent to the server." ),
712 CLI_OPTION_END()
713 };
714
715 #if( DNSSDUTIL_INCLUDE_DNSCRYPT )
716 //===========================================================================================================================
717 // DNSCrypt Command Options
718 //===========================================================================================================================
719
720 static char * gDNSCrypt_ProviderName = NULL;
721 static char * gDNSCrypt_ProviderKey = NULL;
722 static char * gDNSCrypt_Name = NULL;
723 static char * gDNSCrypt_Type = NULL;
724 static char * gDNSCrypt_Server = NULL;
725 static int gDNSCrypt_TimeLimitSecs = 5;
726 static int gDNSCrypt_RawRData = false;
727 static int gDNSCrypt_Verbose = false;
728
729 static CLIOption kDNSCryptOpts[] =
730 {
731 StringOption( 'p', "providerName", &gDNSCrypt_ProviderName, "name", "The DNSCrypt provider name.", true ),
732 StringOption( 'k', "providerKey", &gDNSCrypt_ProviderKey, "hex string", "The DNSCrypt provider's public signing key.", true ),
733 StringOption( 'n', "name", &gDNSCrypt_Name, "name", "Question name (QNAME) to put in DNS query message.", true ),
734 StringOption( 't', "type", &gDNSCrypt_Type, "type", "Question type (QTYPE) to put in DNS query message.", true ),
735 StringOption( 's', "server", &gDNSCrypt_Server, "IP address", "DNS server's IPv4 or IPv6 address.", true ),
736 IntegerOption( 'l', "timeLimit", &gDNSCrypt_TimeLimitSecs, "seconds", "Specifies query time limit. Use '-1' for no time limit and '0' to exit immediately after sending.", false ),
737 BooleanOption( 0 , "raw", &gDNSCrypt_RawRData, "Present record data as a hexdump." ),
738 BooleanOption( 'v', "verbose", &gDNSCrypt_Verbose, "Prints the DNS message to be sent to the server." ),
739 CLI_OPTION_END()
740 };
741 #endif
742
743 //===========================================================================================================================
744 // MDNSQuery Command Options
745 //===========================================================================================================================
746
747 static char * gMDNSQuery_Name = NULL;
748 static char * gMDNSQuery_Type = NULL;
749 static int gMDNSQuery_SourcePort = 0;
750 static int gMDNSQuery_IsQU = false;
751 static int gMDNSQuery_RawRData = false;
752 static int gMDNSQuery_UseIPv4 = false;
753 static int gMDNSQuery_UseIPv6 = false;
754 static int gMDNSQuery_AllResponses = false;
755 static int gMDNSQuery_ReceiveSecs = 1;
756
757 static CLIOption kMDNSQueryOpts[] =
758 {
759 StringOption( 'i', "interface", &gInterface, "name or index", "Network interface by name or index.", true ),
760 StringOption( 'n', "name", &gMDNSQuery_Name, "name", "Question name (QNAME) to put in mDNS message.", true ),
761 StringOption( 't', "type", &gMDNSQuery_Type, "type", "Question type (QTYPE) to put in mDNS message.", true ),
762 IntegerOption( 'p', "sourcePort", &gMDNSQuery_SourcePort, "port number", "UDP source port to use when sending mDNS messages. Default is 5353 for QM questions.", false ),
763 BooleanOption( 'u', "QU", &gMDNSQuery_IsQU, "Set the unicast-response bit, i.e., send a QU question." ),
764 BooleanOption( 0 , "raw", &gMDNSQuery_RawRData, "Present record data as a hexdump." ),
765 BooleanOption( 0 , "ipv4", &gMDNSQuery_UseIPv4, "Use IPv4." ),
766 BooleanOption( 0 , "ipv6", &gMDNSQuery_UseIPv6, "Use IPv6." ),
767 BooleanOption( 'a', "allResponses", &gMDNSQuery_AllResponses, "Print all received mDNS messages, not just those containing answers." ),
768 IntegerOption( 'r', "receiveTime", &gMDNSQuery_ReceiveSecs, "seconds", "Amount of time to spend receiving messages after the query is sent. The default is one second. Use -1 for unlimited time.", false ),
769 CLI_OPTION_END()
770 };
771
772 //===========================================================================================================================
773 // PIDToUUID Command Options
774 //===========================================================================================================================
775
776 static int gPIDToUUID_PID = 0;
777
778 static CLIOption kPIDToUUIDOpts[] =
779 {
780 IntegerOption( 'p', "pid", &gPIDToUUID_PID, "PID", "Process ID.", true ),
781 CLI_OPTION_END()
782 };
783
784 //===========================================================================================================================
785 // SSDP Command Options
786 //===========================================================================================================================
787
788 static int gSSDPDiscover_MX = 1;
789 static const char * gSSDPDiscover_ST = "ssdp:all";
790 static int gSSDPDiscover_ReceiveSecs = 1;
791 static int gSSDPDiscover_UseIPv4 = false;
792 static int gSSDPDiscover_UseIPv6 = false;
793 static int gSSDPDiscover_Verbose = false;
794
795 static CLIOption kSSDPDiscoverOpts[] =
796 {
797 StringOption( 'i', "interface", &gInterface, "name or index", "Network interface by name or index.", true ),
798 IntegerOption( 'm', "mx", &gSSDPDiscover_MX, "seconds", "MX value in search request, i.e., max response delay in seconds. (Default: 1 second)", false ),
799 StringOption( 's', "st", &gSSDPDiscover_ST, "string", "ST value in search request, i.e., the search target. (Default: \"ssdp:all\")", false ),
800 IntegerOption( 'r', "receiveTime", &gSSDPDiscover_ReceiveSecs, "seconds", "Amount of time to spend receiving responses. -1 means unlimited. (Default: 1 second)", false ),
801 BooleanOption( 0 , "ipv4", &gSSDPDiscover_UseIPv4, "Use IPv4, i.e., multicast to 239.255.255.250:1900." ),
802 BooleanOption( 0 , "ipv6", &gSSDPDiscover_UseIPv6, "Use IPv6, i.e., multicast to [ff02::c]:1900" ),
803 BooleanOption( 'v', "verbose", &gSSDPDiscover_Verbose, "Prints the search request(s) that were sent." ),
804 CLI_OPTION_END()
805 };
806
807 static void SSDPDiscoverCmd( void );
808
809 static CLIOption kSSDPOpts[] =
810 {
811 Command( "discover", SSDPDiscoverCmd, kSSDPDiscoverOpts, "Crafts and multicasts an SSDP search message.", false ),
812 CLI_OPTION_END()
813 };
814
815 //===========================================================================================================================
816 // res_query Command Options
817 //===========================================================================================================================
818
819 static const char * gResQuery_Name = NULL;
820 static const char * gResQuery_Type = NULL;
821 static const char * gResQuery_Class = NULL;
822 static int gResQuery_UseLibInfo = false;
823
824 static CLIOption kResQueryOpts[] =
825 {
826 StringOption( 'n', "name", &gResQuery_Name, "domain name", "Full domain name of record to query.", true ),
827 StringOption( 't', "type", &gResQuery_Type, "record type", "Record type by name (e.g., TXT, SRV, etc.) or number.", true ),
828 StringOption( 'c', "class", &gResQuery_Class, "record class", "Record class by name or number. Default class is IN.", false ),
829 BooleanOption( 0 , "libinfo", &gResQuery_UseLibInfo, "Use res_query from libinfo instead of libresolv." ),
830 CLI_OPTION_END()
831 };
832
833 //===========================================================================================================================
834 // dns_query Command Options
835 //===========================================================================================================================
836
837 static const char * gResolvDNSQuery_Name = NULL;
838 static const char * gResolvDNSQuery_Type = NULL;
839 static const char * gResolvDNSQuery_Class = NULL;
840 static const char * gResolvDNSQuery_Path = NULL;
841
842 static CLIOption kResolvDNSQueryOpts[] =
843 {
844 StringOption( 'n', "name", &gResolvDNSQuery_Name, "domain name", "Full domain name of record to query.", true ),
845 StringOption( 't', "type", &gResolvDNSQuery_Type, "record type", "Record type by name (e.g., TXT, SRV, etc.) or number.", true ),
846 StringOption( 'c', "class", &gResolvDNSQuery_Class, "record class", "Record class by name or number. Default class is IN.", false ),
847 StringOption( 'p', "path", &gResolvDNSQuery_Path, "file path", "The path argument to pass to dns_open() before calling dns_query(). Default value is NULL.", false ),
848 CLI_OPTION_END()
849 };
850
851 //===========================================================================================================================
852 // Command Table
853 //===========================================================================================================================
854
855 static OSStatus VersionOptionCallback( CLIOption *inOption, const char *inArg, int inUnset );
856
857 static void BrowseCmd( void );
858 static void GetAddrInfoCmd( void );
859 static void QueryRecordCmd( void );
860 static void RegisterCmd( void );
861 static void RegisterRecordCmd( void );
862 static void ResolveCmd( void );
863 static void ReconfirmCmd( void );
864 static void GetAddrInfoPOSIXCmd( void );
865 static void ReverseLookupCmd( void );
866 static void PortMappingCmd( void );
867 static void BrowseAllCmd( void );
868 static void GetAddrInfoStressCmd( void );
869 static void DNSQueryCmd( void );
870 #if( DNSSDUTIL_INCLUDE_DNSCRYPT )
871 static void DNSCryptCmd( void );
872 #endif
873 static void MDNSQueryCmd( void );
874 static void PIDToUUIDCmd( void );
875 #if( TARGET_OS_DARWIN )
876 static void ResQueryCmd( void );
877 static void ResolvDNSQueryCmd( void );
878 #endif
879 static void DaemonVersionCmd( void );
880
881 static CLIOption kGlobalOpts[] =
882 {
883 CLI_OPTION_CALLBACK_EX( 'V', "version", VersionOptionCallback, NULL, NULL,
884 kCLIOptionFlags_NoArgument | kCLIOptionFlags_GlobalOnly, "Displays the version of this tool.", NULL ),
885 CLI_OPTION_HELP(),
886
887 // Common commands.
888
889 Command( "browse", BrowseCmd, kBrowseOpts, "Uses DNSServiceBrowse() to browse for one or more service types.", false ),
890 Command( "getAddrInfo", GetAddrInfoCmd, kGetAddrInfoOpts, "Uses DNSServiceGetAddrInfo() to resolve a hostname to IP addresses.", false ),
891 Command( "queryRecord", QueryRecordCmd, kQueryRecordOpts, "Uses DNSServiceQueryRecord() to query for an arbitrary DNS record.", false ),
892 Command( "register", RegisterCmd, kRegisterOpts, "Uses DNSServiceRegister() to register a service.", false ),
893 Command( "registerRecord", RegisterRecordCmd, kRegisterRecordOpts, "Uses DNSServiceRegisterRecord() to register a record.", false ),
894 Command( "resolve", ResolveCmd, kResolveOpts, "Uses DNSServiceResolve() to resolve a service.", false ),
895 Command( "reconfirm", ReconfirmCmd, kReconfirmOpts, "Uses DNSServiceReconfirmRecord() to reconfirm a record.", false ),
896 Command( "getaddrinfo-posix", GetAddrInfoPOSIXCmd, kGetAddrInfoPOSIXOpts, "Uses getaddrinfo() to resolve a hostname to IP addresses.", false ),
897 Command( "reverseLookup", ReverseLookupCmd, kReverseLookupOpts, "Uses DNSServiceQueryRecord() to perform a reverse IP address lookup.", false ),
898 Command( "portMapping", PortMappingCmd, kPortMappingOpts, "Uses DNSServiceNATPortMappingCreate() to create a port mapping.", false ),
899 Command( "browseAll", BrowseAllCmd, kBrowseAllOpts, "Browse and resolve all (or specific) services and, optionally, attempt connections.", false ),
900
901 // Uncommon commands.
902
903 Command( "getAddrInfoStress", GetAddrInfoStressCmd, kGetAddrInfoStressOpts, "Runs DNSServiceGetAddrInfo() stress testing.", true ),
904 Command( "DNSQuery", DNSQueryCmd, kDNSQueryOpts, "Crafts and sends a DNS query.", true ),
905 #if( DNSSDUTIL_INCLUDE_DNSCRYPT )
906 Command( "DNSCrypt", DNSCryptCmd, kDNSCryptOpts, "Crafts and sends a DNSCrypt query.", true ),
907 #endif
908 Command( "mDNSQuery", MDNSQueryCmd, kMDNSQueryOpts, "Crafts and sends an mDNS query over the specified interface.", true ),
909 Command( "pid2uuid", PIDToUUIDCmd, kPIDToUUIDOpts, "Prints the UUID of a process.", true ),
910 Command( "ssdp", NULL, kSSDPOpts, "Commands for testing with Simple Service Discovery Protocol (SSDP).", true ),
911 #if( TARGET_OS_DARWIN )
912 Command( "res_query", ResQueryCmd, kResQueryOpts, "Uses res_query() from either libresolv or libinfo to query for a record.", true ),
913 Command( "dns_query", ResolvDNSQueryCmd, kResolvDNSQueryOpts, "Uses dns_query() from libresolv to query for a record.", true ),
914 #endif
915 Command( "daemonVersion", DaemonVersionCmd, NULL, "Prints the version of the DNS-SD daemon.", true ),
916
917 CLI_COMMAND_HELP(),
918 CLI_OPTION_END()
919 };
920
921 //===========================================================================================================================
922 // Helper Prototypes
923 //===========================================================================================================================
924
925 #define kExitReason_OneShotDone "one-shot done"
926 #define kExitReason_ReceivedResponse "received response"
927 #define kExitReason_SIGINT "interrupt signal"
928 #define kExitReason_Timeout "timeout"
929 #define kExitReason_TimeLimit "time limit"
930
931 static void Exit( void *inContext ) ATTRIBUTE_NORETURN;
932
933 #define kTimestampBufLen 27
934
935 static char * GetTimestampStr( char inBuffer[ kTimestampBufLen ] );
936 static DNSServiceFlags GetDNSSDFlagsFromOpts( void );
937
938 typedef enum
939 {
940 kConnectionType_None = 0,
941 kConnectionType_Normal = 1,
942 kConnectionType_DelegatePID = 2,
943 kConnectionType_DelegateUUID = 3
944
945 } ConnectionType;
946
947 typedef struct
948 {
949 ConnectionType type;
950 union
951 {
952 int32_t pid;
953 uint8_t uuid[ 16 ];
954
955 } delegate;
956
957 } ConnectionDesc;
958
959 static OSStatus
960 CreateConnectionFromArgString(
961 const char * inString,
962 dispatch_queue_t inQueue,
963 DNSServiceRef * outSDRef,
964 ConnectionDesc * outDesc );
965 static OSStatus InterfaceIndexFromArgString( const char *inString, uint32_t *outIndex );
966 static OSStatus RecordDataFromArgString( const char *inString, uint8_t **outDataPtr, size_t *outDataLen );
967 static OSStatus RecordTypeFromArgString( const char *inString, uint16_t *outValue );
968 static OSStatus RecordClassFromArgString( const char *inString, uint16_t *outValue );
969
970 #define kInterfaceNameBufLen ( Max( IF_NAMESIZE, 16 ) + 1 )
971
972 static char * InterfaceIndexToName( uint32_t inIfIndex, char inNameBuf[ kInterfaceNameBufLen ] );
973 static const char * RecordTypeToString( unsigned int inValue );
974
975 // DNS message helpers
976
977 typedef struct
978 {
979 uint8_t id[ 2 ];
980 uint8_t flags[ 2 ];
981 uint8_t questionCount[ 2 ];
982 uint8_t answerCount[ 2 ];
983 uint8_t authorityCount[ 2 ];
984 uint8_t additionalCount[ 2 ];
985
986 } DNSHeader;
987
988 #define kDNSHeaderLength 12
989 check_compile_time( sizeof( DNSHeader ) == kDNSHeaderLength );
990
991 #define DNSHeaderGetID( HDR ) ReadBig16( ( HDR )->id )
992 #define DNSHeaderGetFlags( HDR ) ReadBig16( ( HDR )->flags )
993 #define DNSHeaderGetQuestionCount( HDR ) ReadBig16( ( HDR )->questionCount )
994 #define DNSHeaderGetAnswerCount( HDR ) ReadBig16( ( HDR )->answerCount )
995 #define DNSHeaderGetAuthorityCount( HDR ) ReadBig16( ( HDR )->authorityCount )
996 #define DNSHeaderGetAdditionalCount( HDR ) ReadBig16( ( HDR )->additionalCount )
997
998 static OSStatus
999 DNSMessageExtractDomainName(
1000 const uint8_t * inMsgPtr,
1001 size_t inMsgLen,
1002 const uint8_t * inNamePtr,
1003 uint8_t inBuf[ kDomainNameLengthMax ],
1004 const uint8_t ** outNextPtr );
1005 static OSStatus
1006 DNSMessageExtractDomainNameString(
1007 const void * inMsgPtr,
1008 size_t inMsgLen,
1009 const void * inNamePtr,
1010 char inBuf[ kDNSServiceMaxDomainName ],
1011 const uint8_t ** outNextPtr );
1012 static OSStatus
1013 DNSMessageExtractRecord(
1014 const uint8_t * inMsgPtr,
1015 size_t inMsgLen,
1016 const uint8_t * inPtr,
1017 uint8_t inNameBuf[ kDomainNameLengthMax ],
1018 uint16_t * outType,
1019 uint16_t * outClass,
1020 uint32_t * outTTL,
1021 const uint8_t ** outRDataPtr,
1022 size_t * outRDataLen,
1023 const uint8_t ** outPtr );
1024 static OSStatus DNSMessageGetAnswerSection( const uint8_t *inMsgPtr, size_t inMsgLen, const uint8_t **outPtr );
1025 static OSStatus
1026 DNSRecordDataToString(
1027 const void * inRDataPtr,
1028 size_t inRDataLen,
1029 unsigned int inRDataType,
1030 const void * inMsgPtr,
1031 size_t inMsgLen,
1032 char ** outString );
1033 static OSStatus
1034 DomainNameAppendString(
1035 uint8_t inDomainName[ kDomainNameLengthMax ],
1036 const char * inString,
1037 uint8_t ** outEndPtr );
1038 static Boolean DomainNameEqual( const uint8_t *inName1, const uint8_t *inName2 );
1039 static OSStatus
1040 DomainNameFromString(
1041 uint8_t inDomainName[ kDomainNameLengthMax ],
1042 const char * inString,
1043 uint8_t ** outEndPtr );
1044 static OSStatus
1045 DomainNameToString(
1046 const uint8_t * inDomainName,
1047 const uint8_t * inEnd,
1048 char inBuf[ kDNSServiceMaxDomainName ],
1049 const uint8_t ** outNextPtr );
1050
1051 static OSStatus PrintDNSMessage( const uint8_t *inMsgPtr, size_t inMsgLen, Boolean inIsMDNS, Boolean inPrintRaw );
1052
1053 #define PrintMDNSMessage( MSGPTR, MSGLEN, RAW ) PrintDNSMessage( MSGPTR, MSGLEN, true, RAW )
1054 #define PrintUDNSMessage( MSGPTR, MSGLEN, RAW ) PrintDNSMessage( MSGPTR, MSGLEN, false, RAW )
1055
1056 #define kDNSQueryMessageMaxLen ( kDNSHeaderLength + kDomainNameLengthMax + 4 )
1057
1058 static OSStatus
1059 WriteDNSQueryMessage(
1060 uint8_t inMsg[ kDNSQueryMessageMaxLen ],
1061 uint16_t inMsgID,
1062 uint16_t inFlags,
1063 const char * inQName,
1064 uint16_t inQType,
1065 uint16_t inQClass,
1066 size_t * outMsgLen );
1067
1068 // Dispatch helpers
1069
1070 typedef void ( *DispatchHandler )( void *inContext );
1071
1072 static OSStatus
1073 DispatchSignalSourceCreate(
1074 int inSignal,
1075 DispatchHandler inEventHandler,
1076 void * inContext,
1077 dispatch_source_t * outSource );
1078 static OSStatus
1079 DispatchReadSourceCreate(
1080 SocketRef inSock,
1081 DispatchHandler inEventHandler,
1082 DispatchHandler inCancelHandler,
1083 void * inContext,
1084 dispatch_source_t * outSource );
1085 static OSStatus
1086 DispatchTimerCreate(
1087 dispatch_time_t inStart,
1088 uint64_t inIntervalNs,
1089 uint64_t inLeewayNs,
1090 DispatchHandler inEventHandler,
1091 DispatchHandler inCancelHandler,
1092 void * inContext,
1093 dispatch_source_t * outTimer );
1094
1095 static const char * ServiceTypeDescription( const char *inName );
1096
1097 typedef struct
1098 {
1099 SocketRef sock;
1100 void * context;
1101
1102 } SocketContext;
1103
1104 static void SocketContextCancelHandler( void *inContext );
1105 static OSStatus StringToInt32( const char *inString, int32_t *outValue );
1106 static OSStatus StringToUInt32( const char *inString, uint32_t *outValue );
1107 #if( TARGET_OS_DARWIN )
1108 static OSStatus GetDefaultDNSServer( sockaddr_ip *outAddr );
1109 #endif
1110
1111 #define AddRmvString( X ) ( ( (X) & kDNSServiceFlagsAdd ) ? "Add" : "Rmv" )
1112 #define Unused( X ) (void)(X)
1113
1114 //===========================================================================================================================
1115 // main
1116 //===========================================================================================================================
1117
1118 int main( int argc, const char **argv )
1119 {
1120 // Route DebugServices logging output to stderr.
1121
1122 dlog_control( "DebugServices:output=file;stderr" );
1123
1124 CLIInit( argc, argv );
1125 CLIParse( kGlobalOpts, kCLIFlags_None );
1126
1127 return( gExitCode );
1128 }
1129
1130 //===========================================================================================================================
1131 // VersionOptionCallback
1132 //===========================================================================================================================
1133
1134 static OSStatus VersionOptionCallback( CLIOption *inOption, const char *inArg, int inUnset )
1135 {
1136 const char * srcVers;
1137 #if( MDNSRESPONDER_PROJECT )
1138 char srcStr[ 16 ];
1139 #endif
1140
1141 Unused( inOption );
1142 Unused( inArg );
1143 Unused( inUnset );
1144
1145 #if( MDNSRESPONDER_PROJECT )
1146 srcVers = SourceVersionToCString( _DNS_SD_H, srcStr );
1147 #else
1148 srcVers = DNSSDUTIL_SOURCE_VERSION;
1149 #endif
1150 FPrintF( stdout, "%s version %v (%s)\n", gProgramName, kDNSSDUtilNumVersion, srcVers );
1151
1152 return( kEndingErr );
1153 }
1154
1155 //===========================================================================================================================
1156 // BrowseCmd
1157 //===========================================================================================================================
1158
1159 typedef struct BrowseResolveOp BrowseResolveOp;
1160
1161 struct BrowseResolveOp
1162 {
1163 BrowseResolveOp * next; // Next resolve operation in list.
1164 DNSServiceRef sdRef; // sdRef of the DNSServiceResolve or DNSServiceQueryRecord operation.
1165 char * fullName; // Full name of the service to resolve.
1166 uint32_t interfaceIndex; // Interface index of the DNSServiceResolve or DNSServiceQueryRecord operation.
1167 };
1168
1169 typedef struct
1170 {
1171 DNSServiceRef mainRef; // Main sdRef for shared connection.
1172 DNSServiceRef * opRefs; // Array of sdRefs for individual Browse operarions.
1173 size_t opRefsCount; // Count of array of sdRefs for non-shared connections.
1174 const char * domain; // Domain for DNSServiceBrowse operation(s).
1175 DNSServiceFlags flags; // Flags for DNSServiceBrowse operation(s).
1176 char ** serviceTypes; // Array of service types to browse for.
1177 size_t serviceTypesCount; // Count of array of service types to browse for.
1178 int timeLimitSecs; // Time limit of DNSServiceBrowse operation in seconds.
1179 BrowseResolveOp * resolveList; // List of resolve and/or TXT record query operations.
1180 uint32_t ifIndex; // Interface index of DNSServiceBrowse operation(s).
1181 Boolean printedHeader; // True if results header has been printed.
1182 Boolean doResolve; // True if service instances are to be resolved.
1183 Boolean doResolveTXTOnly; // True if TXT records of service instances are to be queried.
1184
1185 } BrowseContext;
1186
1187 static void BrowsePrintPrologue( const BrowseContext *inContext );
1188 static void BrowseContextFree( BrowseContext *inContext );
1189 static OSStatus BrowseResolveOpCreate( const char *inFullName, uint32_t inInterfaceIndex, BrowseResolveOp **outOp );
1190 static void BrowseResolveOpFree( BrowseResolveOp *inOp );
1191 static void DNSSD_API
1192 BrowseCallback(
1193 DNSServiceRef inSDRef,
1194 DNSServiceFlags inFlags,
1195 uint32_t inInterfaceIndex,
1196 DNSServiceErrorType inError,
1197 const char * inName,
1198 const char * inRegType,
1199 const char * inDomain,
1200 void * inContext );
1201 static void DNSSD_API
1202 BrowseResolveCallback(
1203 DNSServiceRef inSDRef,
1204 DNSServiceFlags inFlags,
1205 uint32_t inInterfaceIndex,
1206 DNSServiceErrorType inError,
1207 const char * inFullName,
1208 const char * inHostname,
1209 uint16_t inPort,
1210 uint16_t inTXTLen,
1211 const unsigned char * inTXTPtr,
1212 void * inContext );
1213 static void DNSSD_API
1214 BrowseQueryRecordCallback(
1215 DNSServiceRef inSDRef,
1216 DNSServiceFlags inFlags,
1217 uint32_t inInterfaceIndex,
1218 DNSServiceErrorType inError,
1219 const char * inFullName,
1220 uint16_t inType,
1221 uint16_t inClass,
1222 uint16_t inRDataLen,
1223 const void * inRDataPtr,
1224 uint32_t inTTL,
1225 void * inContext );
1226
1227 static void BrowseCmd( void )
1228 {
1229 OSStatus err;
1230 size_t i;
1231 BrowseContext * context = NULL;
1232 dispatch_source_t signalSource = NULL;
1233 int useMainConnection;
1234
1235 // Set up SIGINT handler.
1236
1237 signal( SIGINT, SIG_IGN );
1238 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
1239 require_noerr( err, exit );
1240 dispatch_resume( signalSource );
1241
1242 // Create context.
1243
1244 context = (BrowseContext *) calloc( 1, sizeof( *context ) );
1245 require_action( context, exit, err = kNoMemoryErr );
1246
1247 context->opRefs = (DNSServiceRef *) calloc( gBrowse_ServiceTypesCount, sizeof( DNSServiceRef ) );
1248 require_action( context->opRefs, exit, err = kNoMemoryErr );
1249 context->opRefsCount = gBrowse_ServiceTypesCount;
1250
1251 // Check command parameters.
1252
1253 if( gBrowse_TimeLimitSecs < 0 )
1254 {
1255 FPrintF( stderr, "Invalid time limit: %d seconds.\n", gBrowse_TimeLimitSecs );
1256 err = kParamErr;
1257 goto exit;
1258 }
1259
1260 // Create main connection.
1261
1262 if( gConnectionOpt )
1263 {
1264 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->mainRef, NULL );
1265 require_noerr_quiet( err, exit );
1266 useMainConnection = true;
1267 }
1268 else
1269 {
1270 useMainConnection = false;
1271 }
1272
1273 // Get flags.
1274
1275 context->flags = GetDNSSDFlagsFromOpts();
1276 if( useMainConnection ) context->flags |= kDNSServiceFlagsShareConnection;
1277
1278 // Get interface.
1279
1280 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
1281 require_noerr_quiet( err, exit );
1282
1283 // Set remaining parameters.
1284
1285 context->serviceTypes = gBrowse_ServiceTypes;
1286 context->serviceTypesCount = gBrowse_ServiceTypesCount;
1287 context->domain = gBrowse_Domain;
1288 context->doResolve = gBrowse_DoResolve ? true : false;
1289 context->timeLimitSecs = gBrowse_TimeLimitSecs;
1290 context->doResolveTXTOnly = gBrowse_QueryTXT ? true : false;
1291
1292 // Print prologue.
1293
1294 BrowsePrintPrologue( context );
1295
1296 // Start operation(s).
1297
1298 for( i = 0; i < context->serviceTypesCount; ++i )
1299 {
1300 DNSServiceRef sdRef;
1301
1302 if( useMainConnection ) sdRef = context->mainRef;
1303 err = DNSServiceBrowse( &sdRef, context->flags, context->ifIndex, context->serviceTypes[ i ], context->domain,
1304 BrowseCallback, context );
1305 require_noerr( err, exit );
1306
1307 context->opRefs[ i ] = sdRef;
1308 if( !useMainConnection )
1309 {
1310 err = DNSServiceSetDispatchQueue( context->opRefs[ i ], dispatch_get_main_queue() );
1311 require_noerr( err, exit );
1312 }
1313 }
1314
1315 // Set time limit.
1316
1317 if( context->timeLimitSecs > 0 )
1318 {
1319 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(),
1320 kExitReason_TimeLimit, Exit );
1321 }
1322 dispatch_main();
1323
1324 exit:
1325 dispatch_source_forget( &signalSource );
1326 if( context ) BrowseContextFree( context );
1327 if( err ) exit( 1 );
1328 }
1329
1330 //===========================================================================================================================
1331 // BrowsePrintPrologue
1332 //===========================================================================================================================
1333
1334 static void BrowsePrintPrologue( const BrowseContext *inContext )
1335 {
1336 const int timeLimitSecs = inContext->timeLimitSecs;
1337 const char * const * serviceType = (const char **) inContext->serviceTypes;
1338 const char * const * const end = (const char **) inContext->serviceTypes + inContext->serviceTypesCount;
1339 char time[ kTimestampBufLen ];
1340 char ifName[ kInterfaceNameBufLen ];
1341
1342 InterfaceIndexToName( inContext->ifIndex, ifName );
1343
1344 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
1345 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
1346 FPrintF( stdout, "Service types: %s", *serviceType++ );
1347 while( serviceType < end ) FPrintF( stdout, ", %s", *serviceType++ );
1348 FPrintF( stdout, "\n" );
1349 FPrintF( stdout, "Domain: %s\n", inContext->domain ? inContext->domain : "<NULL> (default domains)" );
1350 FPrintF( stdout, "Time limit: " );
1351 if( timeLimitSecs > 0 ) FPrintF( stdout, "%d second%?c\n", timeLimitSecs, timeLimitSecs != 1, 's' );
1352 else FPrintF( stdout, "∞\n" );
1353 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
1354 FPrintF( stdout, "---\n" );
1355 }
1356
1357 //===========================================================================================================================
1358 // BrowseContextFree
1359 //===========================================================================================================================
1360
1361 static void BrowseContextFree( BrowseContext *inContext )
1362 {
1363 size_t i;
1364
1365 for( i = 0; i < inContext->opRefsCount; ++i )
1366 {
1367 DNSServiceForget( &inContext->opRefs[ i ] );
1368 }
1369 if( inContext->serviceTypes )
1370 {
1371 StringArray_Free( inContext->serviceTypes, inContext->serviceTypesCount );
1372 inContext->serviceTypes = NULL;
1373 inContext->serviceTypesCount = 0;
1374 }
1375 DNSServiceForget( &inContext->mainRef );
1376 free( inContext );
1377 }
1378
1379 //===========================================================================================================================
1380 // BrowseResolveOpCreate
1381 //===========================================================================================================================
1382
1383 static OSStatus BrowseResolveOpCreate( const char *inFullName, uint32_t inInterfaceIndex, BrowseResolveOp **outOp )
1384 {
1385 OSStatus err;
1386 BrowseResolveOp * resolveOp;
1387
1388 resolveOp = (BrowseResolveOp *) calloc( 1, sizeof( *resolveOp ) );
1389 require_action( resolveOp, exit, err = kNoMemoryErr );
1390
1391 resolveOp->fullName = strdup( inFullName );
1392 require_action( resolveOp->fullName, exit, err = kNoMemoryErr );
1393
1394 resolveOp->interfaceIndex = inInterfaceIndex;
1395
1396 *outOp = resolveOp;
1397 resolveOp = NULL;
1398 err = kNoErr;
1399
1400 exit:
1401 if( resolveOp ) BrowseResolveOpFree( resolveOp );
1402 return( err );
1403 }
1404
1405 //===========================================================================================================================
1406 // BrowseResolveOpFree
1407 //===========================================================================================================================
1408
1409 static void BrowseResolveOpFree( BrowseResolveOp *inOp )
1410 {
1411 DNSServiceForget( &inOp->sdRef );
1412 ForgetMem( &inOp->fullName );
1413 free( inOp );
1414 }
1415
1416 //===========================================================================================================================
1417 // BrowseCallback
1418 //===========================================================================================================================
1419
1420 static void DNSSD_API
1421 BrowseCallback(
1422 DNSServiceRef inSDRef,
1423 DNSServiceFlags inFlags,
1424 uint32_t inInterfaceIndex,
1425 DNSServiceErrorType inError,
1426 const char * inName,
1427 const char * inRegType,
1428 const char * inDomain,
1429 void * inContext )
1430 {
1431 BrowseContext * const context = (BrowseContext *) inContext;
1432 OSStatus err;
1433 BrowseResolveOp * newOp = NULL;
1434 BrowseResolveOp ** p;
1435 char fullName[ kDNSServiceMaxDomainName ];
1436 char time[ kTimestampBufLen ];
1437
1438 Unused( inSDRef );
1439
1440 GetTimestampStr( time );
1441
1442 err = inError;
1443 require_noerr( err, exit );
1444
1445 if( !context->printedHeader )
1446 {
1447 FPrintF( stdout, "%-26s A/R Flags IF %-20s %-20s Instance Name\n", "Timestamp", "Domain", "Service Type" );
1448 context->printedHeader = true;
1449 }
1450 FPrintF( stdout, "%-26s %-3s %5X %2d %-20s %-20s %s\n",
1451 time, AddRmvString( inFlags ), inFlags, (int32_t) inInterfaceIndex, inDomain, inRegType, inName );
1452
1453 if( !context->doResolve && !context->doResolveTXTOnly ) goto exit;
1454
1455 err = DNSServiceConstructFullName( fullName, inName, inRegType, inDomain );
1456 require_noerr( err, exit );
1457
1458 if( inFlags & kDNSServiceFlagsAdd )
1459 {
1460 DNSServiceRef sdRef;
1461 DNSServiceFlags flags;
1462
1463 err = BrowseResolveOpCreate( fullName, inInterfaceIndex, &newOp );
1464 require_noerr( err, exit );
1465
1466 if( context->mainRef )
1467 {
1468 sdRef = context->mainRef;
1469 flags = kDNSServiceFlagsShareConnection;
1470 }
1471 else
1472 {
1473 flags = 0;
1474 }
1475 if( context->doResolve )
1476 {
1477 err = DNSServiceResolve( &sdRef, flags, inInterfaceIndex, inName, inRegType, inDomain, BrowseResolveCallback,
1478 NULL );
1479 require_noerr( err, exit );
1480 }
1481 else
1482 {
1483 err = DNSServiceQueryRecord( &sdRef, flags, inInterfaceIndex, fullName, kDNSServiceType_TXT, kDNSServiceClass_IN,
1484 BrowseQueryRecordCallback, NULL );
1485 require_noerr( err, exit );
1486 }
1487
1488 newOp->sdRef = sdRef;
1489 if( !context->mainRef )
1490 {
1491 err = DNSServiceSetDispatchQueue( newOp->sdRef, dispatch_get_main_queue() );
1492 require_noerr( err, exit );
1493 }
1494 for( p = &context->resolveList; *p; p = &( *p )->next ) {}
1495 *p = newOp;
1496 newOp = NULL;
1497 }
1498 else
1499 {
1500 BrowseResolveOp * resolveOp;
1501
1502 for( p = &context->resolveList; ( resolveOp = *p ) != NULL; p = &resolveOp->next )
1503 {
1504 if( ( resolveOp->interfaceIndex == inInterfaceIndex ) && ( strcasecmp( resolveOp->fullName, fullName ) == 0 ) )
1505 {
1506 break;
1507 }
1508 }
1509 if( resolveOp )
1510 {
1511 *p = resolveOp->next;
1512 BrowseResolveOpFree( resolveOp );
1513 }
1514 }
1515
1516 exit:
1517 if( newOp ) BrowseResolveOpFree( newOp );
1518 if( err ) exit( 1 );
1519 }
1520
1521 //===========================================================================================================================
1522 // BrowseQueryRecordCallback
1523 //===========================================================================================================================
1524
1525 static void DNSSD_API
1526 BrowseQueryRecordCallback(
1527 DNSServiceRef inSDRef,
1528 DNSServiceFlags inFlags,
1529 uint32_t inInterfaceIndex,
1530 DNSServiceErrorType inError,
1531 const char * inFullName,
1532 uint16_t inType,
1533 uint16_t inClass,
1534 uint16_t inRDataLen,
1535 const void * inRDataPtr,
1536 uint32_t inTTL,
1537 void * inContext )
1538 {
1539 OSStatus err;
1540 char time[ kTimestampBufLen ];
1541
1542 Unused( inSDRef );
1543 Unused( inClass );
1544 Unused( inTTL );
1545 Unused( inContext );
1546
1547 GetTimestampStr( time );
1548
1549 err = inError;
1550 require_noerr( err, exit );
1551 require_action( inType == kDNSServiceType_TXT, exit, err = kTypeErr );
1552
1553 FPrintF( stdout, "%s %s %s TXT on interface %d\n TXT: %#{txt}\n",
1554 time, AddRmvString( inFlags ), inFullName, (int32_t) inInterfaceIndex, inRDataPtr, (size_t) inRDataLen );
1555
1556 exit:
1557 if( err ) exit( 1 );
1558 }
1559
1560 //===========================================================================================================================
1561 // BrowseResolveCallback
1562 //===========================================================================================================================
1563
1564 static void DNSSD_API
1565 BrowseResolveCallback(
1566 DNSServiceRef inSDRef,
1567 DNSServiceFlags inFlags,
1568 uint32_t inInterfaceIndex,
1569 DNSServiceErrorType inError,
1570 const char * inFullName,
1571 const char * inHostname,
1572 uint16_t inPort,
1573 uint16_t inTXTLen,
1574 const unsigned char * inTXTPtr,
1575 void * inContext )
1576 {
1577 char time[ kTimestampBufLen ];
1578 char errorStr[ 64 ];
1579
1580 Unused( inSDRef );
1581 Unused( inFlags );
1582 Unused( inContext );
1583
1584 GetTimestampStr( time );
1585
1586 if( inError ) SNPrintF( errorStr, sizeof( errorStr ), " error %#m", inError );
1587
1588 FPrintF( stdout, "%s %s can be reached at %s:%u (interface %d)%?s\n",
1589 time, inFullName, inHostname, ntohs( inPort ), (int32_t) inInterfaceIndex, inError, errorStr );
1590 if( inTXTLen == 1 )
1591 {
1592 FPrintF( stdout, " TXT record: %#H\n", inTXTPtr, (int) inTXTLen, INT_MAX );
1593 }
1594 else
1595 {
1596 FPrintF( stdout, " TXT record: %#{txt}\n", inTXTPtr, (size_t) inTXTLen );
1597 }
1598 }
1599
1600 //===========================================================================================================================
1601 // GetAddrInfoCmd
1602 //===========================================================================================================================
1603
1604 typedef struct
1605 {
1606 DNSServiceRef mainRef; // Main sdRef for shared connection.
1607 DNSServiceRef opRef; // sdRef for the DNSServiceGetAddrInfo operation.
1608 const char * name; // Hostname to resolve.
1609 DNSServiceFlags flags; // Flags argument for DNSServiceGetAddrInfo().
1610 DNSServiceProtocol protocols; // Protocols argument for DNSServiceGetAddrInfo().
1611 uint32_t ifIndex; // Interface index argument for DNSServiceGetAddrInfo().
1612 int timeLimitSecs; // Time limit for the DNSServiceGetAddrInfo() operation in seconds.
1613 Boolean printedHeader; // True if the results header has been printed.
1614 Boolean oneShotMode; // True if command is done after the first set of results (one-shot mode).
1615 Boolean needIPv4; // True if in one-shot mode and an IPv4 result is needed.
1616 Boolean needIPv6; // True if in one-shot mode and an IPv6 result is needed.
1617
1618 } GetAddrInfoContext;
1619
1620 static void GetAddrInfoPrintPrologue( const GetAddrInfoContext *inContext );
1621 static void GetAddrInfoContextFree( GetAddrInfoContext *inContext );
1622 static void DNSSD_API
1623 GetAddrInfoCallback(
1624 DNSServiceRef inSDRef,
1625 DNSServiceFlags inFlags,
1626 uint32_t inInterfaceIndex,
1627 DNSServiceErrorType inError,
1628 const char * inHostname,
1629 const struct sockaddr * inSockAddr,
1630 uint32_t inTTL,
1631 void * inContext );
1632
1633 static void GetAddrInfoCmd( void )
1634 {
1635 OSStatus err;
1636 DNSServiceRef sdRef;
1637 GetAddrInfoContext * context = NULL;
1638 dispatch_source_t signalSource = NULL;
1639 int useMainConnection;
1640
1641 // Set up SIGINT handler.
1642
1643 signal( SIGINT, SIG_IGN );
1644 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
1645 require_noerr( err, exit );
1646 dispatch_resume( signalSource );
1647
1648 // Check command parameters.
1649
1650 if( gGetAddrInfo_TimeLimitSecs < 0 )
1651 {
1652 FPrintF( stderr, "Invalid time limit: %d s.\n", gGetAddrInfo_TimeLimitSecs );
1653 err = kParamErr;
1654 goto exit;
1655 }
1656
1657 // Create context.
1658
1659 context = (GetAddrInfoContext *) calloc( 1, sizeof( *context ) );
1660 require_action( context, exit, err = kNoMemoryErr );
1661
1662 // Create main connection.
1663
1664 if( gConnectionOpt )
1665 {
1666 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->mainRef, NULL );
1667 require_noerr_quiet( err, exit );
1668 useMainConnection = true;
1669 }
1670 else
1671 {
1672 useMainConnection = false;
1673 }
1674
1675 // Get flags.
1676
1677 context->flags = GetDNSSDFlagsFromOpts();
1678 if( useMainConnection ) context->flags |= kDNSServiceFlagsShareConnection;
1679
1680 // Get interface.
1681
1682 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
1683 require_noerr_quiet( err, exit );
1684
1685 // Set remaining parameters.
1686
1687 context->name = gGetAddrInfo_Name;
1688 context->timeLimitSecs = gGetAddrInfo_TimeLimitSecs;
1689 if( gGetAddrInfo_ProtocolIPv4 ) context->protocols |= kDNSServiceProtocol_IPv4;
1690 if( gGetAddrInfo_ProtocolIPv6 ) context->protocols |= kDNSServiceProtocol_IPv6;
1691 if( gGetAddrInfo_OneShot )
1692 {
1693 context->oneShotMode = true;
1694 context->needIPv4 = ( gGetAddrInfo_ProtocolIPv4 || !gGetAddrInfo_ProtocolIPv6 ) ? true : false;
1695 context->needIPv6 = ( gGetAddrInfo_ProtocolIPv6 || !gGetAddrInfo_ProtocolIPv4 ) ? true : false;
1696 }
1697
1698 // Print prologue.
1699
1700 GetAddrInfoPrintPrologue( context );
1701
1702 // Start operation.
1703
1704 if( useMainConnection ) sdRef = context->mainRef;
1705 err = DNSServiceGetAddrInfo( &sdRef, context->flags, context->ifIndex, context->protocols, context->name,
1706 GetAddrInfoCallback, context );
1707 require_noerr( err, exit );
1708
1709 context->opRef = sdRef;
1710 if( !useMainConnection )
1711 {
1712 err = DNSServiceSetDispatchQueue( context->opRef, dispatch_get_main_queue() );
1713 require_noerr( err, exit );
1714 }
1715
1716 // Set time limit.
1717
1718 if( context->timeLimitSecs > 0 )
1719 {
1720 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(),
1721 kExitReason_TimeLimit, Exit );
1722 }
1723 dispatch_main();
1724
1725 exit:
1726 dispatch_source_forget( &signalSource );
1727 if( context ) GetAddrInfoContextFree( context );
1728 if( err ) exit( 1 );
1729 }
1730
1731 //===========================================================================================================================
1732 // GetAddrInfoPrintPrologue
1733 //===========================================================================================================================
1734
1735 static void GetAddrInfoPrintPrologue( const GetAddrInfoContext *inContext )
1736 {
1737 const int timeLimitSecs = inContext->timeLimitSecs;
1738 char ifName[ kInterfaceNameBufLen ];
1739 char time[ kTimestampBufLen ];
1740
1741 InterfaceIndexToName( inContext->ifIndex, ifName );
1742
1743 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
1744 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
1745 FPrintF( stdout, "Protocols: %#{flags}\n", inContext->protocols, kDNSServiceProtocolDescriptors );
1746 FPrintF( stdout, "Name: %s\n", inContext->name );
1747 FPrintF( stdout, "Mode: %s\n", inContext->oneShotMode ? "one-shot" : "continuous" );
1748 FPrintF( stdout, "Time limit: " );
1749 if( timeLimitSecs > 0 ) FPrintF( stdout, "%d second%?c\n", timeLimitSecs, timeLimitSecs != 1, 's' );
1750 else FPrintF( stdout, "∞\n" );
1751 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
1752 FPrintF( stdout, "---\n" );
1753 }
1754
1755 //===========================================================================================================================
1756 // GetAddrInfoContextFree
1757 //===========================================================================================================================
1758
1759 static void GetAddrInfoContextFree( GetAddrInfoContext *inContext )
1760 {
1761 DNSServiceForget( &inContext->opRef );
1762 DNSServiceForget( &inContext->mainRef );
1763 free( inContext );
1764 }
1765
1766 //===========================================================================================================================
1767 // GetAddrInfoCallback
1768 //===========================================================================================================================
1769
1770 static void DNSSD_API
1771 GetAddrInfoCallback(
1772 DNSServiceRef inSDRef,
1773 DNSServiceFlags inFlags,
1774 uint32_t inInterfaceIndex,
1775 DNSServiceErrorType inError,
1776 const char * inHostname,
1777 const struct sockaddr * inSockAddr,
1778 uint32_t inTTL,
1779 void * inContext )
1780 {
1781 GetAddrInfoContext * const context = (GetAddrInfoContext *) inContext;
1782 OSStatus err;
1783 const char * addrStr;
1784 char addrStrBuf[ kSockAddrStringMaxSize ];
1785 char time[ kTimestampBufLen ];
1786
1787 Unused( inSDRef );
1788
1789 GetTimestampStr( time );
1790
1791 switch( inError )
1792 {
1793 case kDNSServiceErr_NoError:
1794 case kDNSServiceErr_NoSuchRecord:
1795 err = kNoErr;
1796 break;
1797
1798 case kDNSServiceErr_Timeout:
1799 Exit( kExitReason_Timeout );
1800
1801 default:
1802 err = inError;
1803 goto exit;
1804 }
1805
1806 if( ( inSockAddr->sa_family != AF_INET ) && ( inSockAddr->sa_family != AF_INET6 ) )
1807 {
1808 dlogassert( "Unexpected address family: %d", inSockAddr->sa_family );
1809 err = kTypeErr;
1810 goto exit;
1811 }
1812
1813 if( !inError )
1814 {
1815 err = SockAddrToString( inSockAddr, kSockAddrStringFlagsNone, addrStrBuf );
1816 require_noerr( err, exit );
1817 addrStr = addrStrBuf;
1818 }
1819 else
1820 {
1821 addrStr = ( inSockAddr->sa_family == AF_INET ) ? "No Such Record (A)" : "No Such Record (AAAA)";
1822 }
1823
1824 if( !context->printedHeader )
1825 {
1826 FPrintF( stdout, "%-26s A/R Flags IF %-32s %-38s %6s\n", "Timestamp", "Hostname", "Address", "TTL" );
1827 context->printedHeader = true;
1828 }
1829 FPrintF( stdout, "%-26s %s %5X %2d %-32s %-38s %6u\n",
1830 time, AddRmvString( inFlags ), inFlags, (int32_t) inInterfaceIndex, inHostname, addrStr, inTTL );
1831
1832 if( context->oneShotMode )
1833 {
1834 if( inFlags & kDNSServiceFlagsAdd )
1835 {
1836 if( inSockAddr->sa_family == AF_INET ) context->needIPv4 = false;
1837 else context->needIPv6 = false;
1838 }
1839 if( !( inFlags & kDNSServiceFlagsMoreComing ) && !context->needIPv4 && !context->needIPv6 )
1840 {
1841 Exit( kExitReason_OneShotDone );
1842 }
1843 }
1844
1845 exit:
1846 if( err ) exit( 1 );
1847 }
1848
1849 //===========================================================================================================================
1850 // QueryRecordCmd
1851 //===========================================================================================================================
1852
1853 typedef struct
1854 {
1855 DNSServiceRef mainRef; // Main sdRef for shared connection.
1856 DNSServiceRef opRef; // sdRef for the DNSServiceQueryRecord operation.
1857 const char * recordName; // Resource record name argument for DNSServiceQueryRecord().
1858 DNSServiceFlags flags; // Flags argument for DNSServiceQueryRecord().
1859 uint32_t ifIndex; // Interface index argument for DNSServiceQueryRecord().
1860 int timeLimitSecs; // Time limit for the DNSServiceQueryRecord() operation in seconds.
1861 uint16_t recordType; // Resource record type argument for DNSServiceQueryRecord().
1862 Boolean printedHeader; // True if the results header was printed.
1863 Boolean oneShotMode; // True if command is done after the first set of results (one-shot mode).
1864 Boolean gotRecord; // True if in one-shot mode and received at least one record of the desired type.
1865 Boolean printRawRData; // True if RDATA results are not to be formatted when printed.
1866
1867 } QueryRecordContext;
1868
1869 static void QueryRecordPrintPrologue( const QueryRecordContext *inContext );
1870 static void QueryRecordContextFree( QueryRecordContext *inContext );
1871 static void DNSSD_API
1872 QueryRecordCallback(
1873 DNSServiceRef inSDRef,
1874 DNSServiceFlags inFlags,
1875 uint32_t inInterfaceIndex,
1876 DNSServiceErrorType inError,
1877 const char * inFullName,
1878 uint16_t inType,
1879 uint16_t inClass,
1880 uint16_t inRDataLen,
1881 const void * inRDataPtr,
1882 uint32_t inTTL,
1883 void * inContext );
1884
1885 static void QueryRecordCmd( void )
1886 {
1887 OSStatus err;
1888 DNSServiceRef sdRef;
1889 QueryRecordContext * context = NULL;
1890 dispatch_source_t signalSource = NULL;
1891 int useMainConnection;
1892
1893 // Set up SIGINT handler.
1894
1895 signal( SIGINT, SIG_IGN );
1896 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
1897 require_noerr( err, exit );
1898 dispatch_resume( signalSource );
1899
1900 // Create context.
1901
1902 context = (QueryRecordContext *) calloc( 1, sizeof( *context ) );
1903 require_action( context, exit, err = kNoMemoryErr );
1904
1905 // Check command parameters.
1906
1907 if( gQueryRecord_TimeLimitSecs < 0 )
1908 {
1909 FPrintF( stderr, "Invalid time limit: %d seconds.\n", gQueryRecord_TimeLimitSecs );
1910 err = kParamErr;
1911 goto exit;
1912 }
1913
1914 // Create main connection.
1915
1916 if( gConnectionOpt )
1917 {
1918 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->mainRef, NULL );
1919 require_noerr_quiet( err, exit );
1920 useMainConnection = true;
1921 }
1922 else
1923 {
1924 useMainConnection = false;
1925 }
1926
1927 // Get flags.
1928
1929 context->flags = GetDNSSDFlagsFromOpts();
1930 if( useMainConnection ) context->flags |= kDNSServiceFlagsShareConnection;
1931
1932 // Get interface.
1933
1934 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
1935 require_noerr_quiet( err, exit );
1936
1937 // Get record type.
1938
1939 err = RecordTypeFromArgString( gQueryRecord_Type, &context->recordType );
1940 require_noerr( err, exit );
1941
1942 // Set remaining parameters.
1943
1944 context->recordName = gQueryRecord_Name;
1945 context->timeLimitSecs = gQueryRecord_TimeLimitSecs;
1946 context->oneShotMode = gQueryRecord_OneShot ? true : false;
1947 context->printRawRData = gQueryRecord_RawRData ? true : false;
1948
1949 // Print prologue.
1950
1951 QueryRecordPrintPrologue( context );
1952
1953 // Start operation.
1954
1955 if( useMainConnection ) sdRef = context->mainRef;
1956 err = DNSServiceQueryRecord( &sdRef, context->flags, context->ifIndex, context->recordName, context->recordType,
1957 kDNSServiceClass_IN, QueryRecordCallback, context );
1958 require_noerr( err, exit );
1959
1960 context->opRef = sdRef;
1961 if( !useMainConnection )
1962 {
1963 err = DNSServiceSetDispatchQueue( context->opRef, dispatch_get_main_queue() );
1964 require_noerr( err, exit );
1965 }
1966
1967 // Set time limit.
1968
1969 if( context->timeLimitSecs > 0 )
1970 {
1971 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(), kExitReason_TimeLimit,
1972 Exit );
1973 }
1974 dispatch_main();
1975
1976 exit:
1977 dispatch_source_forget( &signalSource );
1978 if( context ) QueryRecordContextFree( context );
1979 if( err ) exit( 1 );
1980 }
1981
1982 //===========================================================================================================================
1983 // QueryRecordContextFree
1984 //===========================================================================================================================
1985
1986 static void QueryRecordContextFree( QueryRecordContext *inContext )
1987 {
1988 DNSServiceForget( &inContext->opRef );
1989 DNSServiceForget( &inContext->mainRef );
1990 free( inContext );
1991 }
1992
1993 //===========================================================================================================================
1994 // QueryRecordPrintPrologue
1995 //===========================================================================================================================
1996
1997 static void QueryRecordPrintPrologue( const QueryRecordContext *inContext )
1998 {
1999 const int timeLimitSecs = inContext->timeLimitSecs;
2000 char ifName[ kInterfaceNameBufLen ];
2001 char time[ kTimestampBufLen ];
2002
2003 InterfaceIndexToName( inContext->ifIndex, ifName );
2004
2005 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
2006 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
2007 FPrintF( stdout, "Name: %s\n", inContext->recordName );
2008 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( inContext->recordType ), inContext->recordType );
2009 FPrintF( stdout, "Mode: %s\n", inContext->oneShotMode ? "one-shot" : "continuous" );
2010 FPrintF( stdout, "Time limit: " );
2011 if( timeLimitSecs > 0 ) FPrintF( stdout, "%d second%?c\n", timeLimitSecs, timeLimitSecs != 1, 's' );
2012 else FPrintF( stdout, "∞\n" );
2013 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
2014 FPrintF( stdout, "---\n" );
2015
2016 }
2017
2018 //===========================================================================================================================
2019 // QueryRecordCallback
2020 //===========================================================================================================================
2021
2022 static void DNSSD_API
2023 QueryRecordCallback(
2024 DNSServiceRef inSDRef,
2025 DNSServiceFlags inFlags,
2026 uint32_t inInterfaceIndex,
2027 DNSServiceErrorType inError,
2028 const char * inFullName,
2029 uint16_t inType,
2030 uint16_t inClass,
2031 uint16_t inRDataLen,
2032 const void * inRDataPtr,
2033 uint32_t inTTL,
2034 void * inContext )
2035 {
2036 QueryRecordContext * const context = (QueryRecordContext *) inContext;
2037 OSStatus err;
2038 char * rdataStr = NULL;
2039 char time[ kTimestampBufLen ];
2040
2041 Unused( inSDRef );
2042
2043 GetTimestampStr( time );
2044
2045 switch( inError )
2046 {
2047 case kDNSServiceErr_NoError:
2048 case kDNSServiceErr_NoSuchRecord:
2049 err = kNoErr;
2050 break;
2051
2052 case kDNSServiceErr_Timeout:
2053 Exit( kExitReason_Timeout );
2054
2055 default:
2056 err = inError;
2057 goto exit;
2058 }
2059
2060 if( inError == kDNSServiceErr_NoSuchRecord )
2061 {
2062 ASPrintF( &rdataStr, "No Such Record" );
2063 }
2064 else
2065 {
2066 if( !context->printRawRData ) DNSRecordDataToString( inRDataPtr, inRDataLen, inType, NULL, 0, &rdataStr );
2067 if( !rdataStr )
2068 {
2069 ASPrintF( &rdataStr, "%#H", inRDataPtr, inRDataLen, INT_MAX );
2070 require_action( rdataStr, exit, err = kNoMemoryErr );
2071 }
2072 }
2073
2074 if( !context->printedHeader )
2075 {
2076 FPrintF( stdout, "%-26s A/R Flags IF %-32s %-5s %-5s %6s RData\n", "Timestamp", "Name", "Type", "Class", "TTL" );
2077 context->printedHeader = true;
2078 }
2079 FPrintF( stdout, "%-26s %-3s %5X %2d %-32s %-5s %?-5s%?5u %6u %s\n",
2080 time, AddRmvString( inFlags ), inFlags, (int32_t) inInterfaceIndex, inFullName, RecordTypeToString( inType ),
2081 ( inClass == kDNSServiceClass_IN ), "IN", ( inClass != kDNSServiceClass_IN ), inClass, inTTL, rdataStr );
2082
2083 if( context->oneShotMode )
2084 {
2085 if( ( inFlags & kDNSServiceFlagsAdd ) &&
2086 ( ( context->recordType == kDNSServiceType_ANY ) || ( context->recordType == inType ) ) )
2087 {
2088 context->gotRecord = true;
2089 }
2090 if( !( inFlags & kDNSServiceFlagsMoreComing ) && context->gotRecord ) Exit( kExitReason_OneShotDone );
2091 }
2092
2093 exit:
2094 FreeNullSafe( rdataStr );
2095 if( err ) exit( 1 );
2096 }
2097
2098 //===========================================================================================================================
2099 // RegisterCmd
2100 //===========================================================================================================================
2101
2102 typedef struct
2103 {
2104 DNSRecordRef recordRef; // Reference returned by DNSServiceAddRecord().
2105 uint8_t * dataPtr; // Record data.
2106 size_t dataLen; // Record data length.
2107 uint32_t ttl; // Record TTL value.
2108 uint16_t type; // Record type.
2109
2110 } ExtraRecord;
2111
2112 typedef struct
2113 {
2114 DNSServiceRef opRef; // sdRef for DNSServiceRegister operation.
2115 const char * name; // Service name argument for DNSServiceRegister().
2116 const char * type; // Service type argument for DNSServiceRegister().
2117 const char * domain; // Domain in which advertise the service.
2118 uint8_t * txtPtr; // Service TXT record data. (malloc'd)
2119 size_t txtLen; // Service TXT record data len.
2120 ExtraRecord * extraRecords; // Array of extra records to add to registered service.
2121 size_t extraRecordsCount; // Number of extra records.
2122 uint8_t * updateTXTPtr; // Pointer to record data for TXT record update. (malloc'd)
2123 size_t updateTXTLen; // Length of record data for TXT record update.
2124 uint32_t updateTTL; // TTL of updated TXT record.
2125 int updateDelayMs; // Post-registration TXT record update delay in milliseconds.
2126 DNSServiceFlags flags; // Flags argument for DNSServiceRegister().
2127 uint32_t ifIndex; // Interface index argument for DNSServiceRegister().
2128 int lifetimeMs; // Lifetime of the record registration in milliseconds.
2129 uint16_t port; // Service instance's port number.
2130 Boolean printedHeader; // True if results header was printed.
2131 Boolean didRegister; // True if service was registered.
2132
2133 } RegisterContext;
2134
2135 static void RegisterPrintPrologue( const RegisterContext *inContext );
2136 static void RegisterContextFree( RegisterContext *inContext );
2137 static void DNSSD_API
2138 RegisterCallback(
2139 DNSServiceRef inSDRef,
2140 DNSServiceFlags inFlags,
2141 DNSServiceErrorType inError,
2142 const char * inName,
2143 const char * inType,
2144 const char * inDomain,
2145 void * inContext );
2146 static void RegisterUpdate( void *inContext );
2147
2148 static void RegisterCmd( void )
2149 {
2150 OSStatus err;
2151 RegisterContext * context = NULL;
2152 dispatch_source_t signalSource = NULL;
2153
2154 // Set up SIGINT handler.
2155
2156 signal( SIGINT, SIG_IGN );
2157 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
2158 require_noerr( err, exit );
2159 dispatch_resume( signalSource );
2160
2161 // Create context.
2162
2163 context = (RegisterContext *) calloc( 1, sizeof( *context ) );
2164 require_action( context, exit, err = kNoMemoryErr );
2165
2166 // Check command parameters.
2167
2168 if( ( gRegister_Port < 0 ) || ( gRegister_Port > UINT16_MAX ) )
2169 {
2170 FPrintF( stderr, "Port number %d is out-of-range.\n", gRegister_Port );
2171 err = kParamErr;
2172 goto exit;
2173 }
2174
2175 if( ( gAddRecord_DataCount != gAddRecord_TypesCount ) || ( gAddRecord_TTLsCount != gAddRecord_TypesCount ) )
2176 {
2177 FPrintF( stderr, "There are missing additional record parameters.\n" );
2178 err = kParamErr;
2179 goto exit;
2180 }
2181
2182 // Get flags.
2183
2184 context->flags = GetDNSSDFlagsFromOpts();
2185
2186 // Get interface index.
2187
2188 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
2189 require_noerr_quiet( err, exit );
2190
2191 // Get TXT record data.
2192
2193 if( gRegister_TXT )
2194 {
2195 err = RecordDataFromArgString( gRegister_TXT, &context->txtPtr, &context->txtLen );
2196 require_noerr_quiet( err, exit );
2197 }
2198
2199 // Set remaining parameters.
2200
2201 context->name = gRegister_Name;
2202 context->type = gRegister_Type;
2203 context->domain = gRegister_Domain;
2204 context->port = (uint16_t) gRegister_Port;
2205 context->lifetimeMs = gRegister_LifetimeMs;
2206
2207 if( gAddRecord_TypesCount > 0 )
2208 {
2209 size_t i;
2210
2211 context->extraRecords = (ExtraRecord *) calloc( gAddRecord_TypesCount, sizeof( ExtraRecord ) );
2212 require_action( context, exit, err = kNoMemoryErr );
2213 context->extraRecordsCount = gAddRecord_TypesCount;
2214
2215 for( i = 0; i < gAddRecord_TypesCount; ++i )
2216 {
2217 ExtraRecord * const extraRecord = &context->extraRecords[ i ];
2218
2219 err = RecordTypeFromArgString( gAddRecord_Types[ i ], &extraRecord->type );
2220 require_noerr( err, exit );
2221
2222 err = StringToUInt32( gAddRecord_TTLs[ i ], &extraRecord->ttl );
2223 if( err )
2224 {
2225 FPrintF( stderr, "Invalid TTL value: %s\n", gAddRecord_TTLs[ i ] );
2226 err = kParamErr;
2227 goto exit;
2228 }
2229
2230 err = RecordDataFromArgString( gAddRecord_Data[ i ], &extraRecord->dataPtr, &extraRecord->dataLen );
2231 require_noerr_quiet( err, exit );
2232 }
2233 }
2234
2235 if( gUpdateRecord_Data )
2236 {
2237 err = RecordDataFromArgString( gUpdateRecord_Data, &context->updateTXTPtr, &context->updateTXTLen );
2238 require_noerr_quiet( err, exit );
2239
2240 context->updateTTL = (uint32_t) gUpdateRecord_TTL;
2241 context->updateDelayMs = gUpdateRecord_DelayMs;
2242 }
2243
2244 // Print prologue.
2245
2246 RegisterPrintPrologue( context );
2247
2248 // Start operation.
2249
2250 err = DNSServiceRegister( &context->opRef, context->flags, context->ifIndex, context->name, context->type,
2251 context->domain, NULL, htons( context->port ), (uint16_t) context->txtLen, context->txtPtr,
2252 RegisterCallback, context );
2253 ForgetMem( &context->txtPtr );
2254 require_noerr( err, exit );
2255
2256 err = DNSServiceSetDispatchQueue( context->opRef, dispatch_get_main_queue() );
2257 require_noerr( err, exit );
2258
2259 dispatch_main();
2260
2261 exit:
2262 dispatch_source_forget( &signalSource );
2263 if( context ) RegisterContextFree( context );
2264 if( err ) exit( 1 );
2265 }
2266
2267 //===========================================================================================================================
2268 // RegisterPrintPrologue
2269 //===========================================================================================================================
2270
2271 static void RegisterPrintPrologue( const RegisterContext *inContext )
2272 {
2273 size_t i;
2274 int infinite;
2275 char ifName[ kInterfaceNameBufLen ];
2276 char time[ kTimestampBufLen ];
2277
2278 InterfaceIndexToName( inContext->ifIndex, ifName );
2279
2280 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
2281 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
2282 FPrintF( stdout, "Name: %s\n", inContext->name ? inContext->name : "<NULL>" );
2283 FPrintF( stdout, "Type: %s\n", inContext->type );
2284 FPrintF( stdout, "Domain: %s\n", inContext->domain ? inContext->domain : "<NULL> (default domains)" );
2285 FPrintF( stdout, "Port: %u\n", inContext->port );
2286 FPrintF( stdout, "TXT data: %#{txt}\n", inContext->txtPtr, inContext->txtLen );
2287 infinite = ( inContext->lifetimeMs < 0 ) ? true : false;
2288 FPrintF( stdout, "Lifetime: %?s%?d ms\n", infinite, "∞", !infinite, inContext->lifetimeMs );
2289 if( inContext->updateTXTPtr )
2290 {
2291 FPrintF( stdout, "\nUpdate record:\n" );
2292 FPrintF( stdout, " Delay: %d ms\n", ( inContext->updateDelayMs > 0 ) ? inContext->updateDelayMs : 0 );
2293 FPrintF( stdout, " TTL: %u%?s\n",
2294 inContext->updateTTL, inContext->updateTTL == 0, " (system will use a default value.)" );
2295 FPrintF( stdout, " TXT data: %#{txt}\n", inContext->updateTXTPtr, inContext->updateTXTLen );
2296 }
2297 if( inContext->extraRecordsCount > 0 ) FPrintF( stdout, "\n" );
2298 for( i = 0; i < inContext->extraRecordsCount; ++i )
2299 {
2300 const ExtraRecord * record = &inContext->extraRecords[ i ];
2301
2302 FPrintF( stdout, "Extra record %zu:\n", i + 1 );
2303 FPrintF( stdout, " Type: %s (%u)\n", RecordTypeToString( record->type ), record->type );
2304 FPrintF( stdout, " TTL: %u%?s\n", record->ttl, record->ttl == 0, " (system will use a default value.)" );
2305 FPrintF( stdout, " RData: %#H\n\n", record->dataPtr, (int) record->dataLen, INT_MAX );
2306 }
2307 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
2308 FPrintF( stdout, "---\n" );
2309 }
2310
2311 //===========================================================================================================================
2312 // RegisterContextFree
2313 //===========================================================================================================================
2314
2315 static void RegisterContextFree( RegisterContext *inContext )
2316 {
2317 ExtraRecord * record;
2318 const ExtraRecord * const end = inContext->extraRecords + inContext->extraRecordsCount;
2319
2320 DNSServiceForget( &inContext->opRef );
2321 ForgetMem( &inContext->txtPtr );
2322 for( record = inContext->extraRecords; record < end; ++record )
2323 {
2324 check( !record->recordRef );
2325 ForgetMem( &record->dataPtr );
2326 }
2327 ForgetMem( &inContext->extraRecords );
2328 ForgetMem( &inContext->updateTXTPtr );
2329 free( inContext );
2330 }
2331
2332 //===========================================================================================================================
2333 // RegisterCallback
2334 //===========================================================================================================================
2335
2336 static void DNSSD_API
2337 RegisterCallback(
2338 DNSServiceRef inSDRef,
2339 DNSServiceFlags inFlags,
2340 DNSServiceErrorType inError,
2341 const char * inName,
2342 const char * inType,
2343 const char * inDomain,
2344 void * inContext )
2345 {
2346 RegisterContext * const context = (RegisterContext *) inContext;
2347 OSStatus err;
2348 char time[ kTimestampBufLen ];
2349
2350 Unused( inSDRef );
2351
2352 GetTimestampStr( time );
2353
2354 if( !context->printedHeader )
2355 {
2356 FPrintF( stdout, "%-26s A/R Flags Service\n", "Timestamp" );
2357 context->printedHeader = true;
2358 }
2359 FPrintF( stdout, "%-26s %-3s %5X %s.%s%s %?#m\n",
2360 time, AddRmvString( inFlags ), inFlags, inName, inType, inDomain, inError, inError );
2361
2362 require_noerr_action_quiet( inError, exit, err = inError );
2363
2364 if( !context->didRegister && ( inFlags & kDNSServiceFlagsAdd ) )
2365 {
2366 context->didRegister = true;
2367 if( context->updateTXTPtr )
2368 {
2369 if( context->updateDelayMs > 0 )
2370 {
2371 dispatch_after_f( dispatch_time_milliseconds( context->updateDelayMs ), dispatch_get_main_queue(),
2372 context, RegisterUpdate );
2373 }
2374 else
2375 {
2376 RegisterUpdate( context );
2377 }
2378 }
2379 if( context->extraRecordsCount > 0 )
2380 {
2381 ExtraRecord * record;
2382 const ExtraRecord * const end = context->extraRecords + context->extraRecordsCount;
2383
2384 for( record = context->extraRecords; record < end; ++record )
2385 {
2386 err = DNSServiceAddRecord( context->opRef, &record->recordRef, 0, record->type,
2387 (uint16_t) record->dataLen, record->dataPtr, record->ttl );
2388 require_noerr( err, exit );
2389 }
2390 }
2391 if( context->lifetimeMs == 0 )
2392 {
2393 Exit( kExitReason_TimeLimit );
2394 }
2395 else if( context->lifetimeMs > 0 )
2396 {
2397 dispatch_after_f( dispatch_time_milliseconds( context->lifetimeMs ), dispatch_get_main_queue(),
2398 kExitReason_TimeLimit, Exit );
2399 }
2400 }
2401 err = kNoErr;
2402
2403 exit:
2404 if( err ) exit( 1 );
2405 }
2406
2407 //===========================================================================================================================
2408 // RegisterUpdate
2409 //===========================================================================================================================
2410
2411 static void RegisterUpdate( void *inContext )
2412 {
2413 OSStatus err;
2414 RegisterContext * const context = (RegisterContext *) inContext;
2415
2416 err = DNSServiceUpdateRecord( context->opRef, NULL, 0, (uint16_t) context->updateTXTLen, context->updateTXTPtr,
2417 context->updateTTL );
2418 require_noerr( err, exit );
2419
2420 exit:
2421 if( err ) exit( 1 );
2422 }
2423
2424 //===========================================================================================================================
2425 // RegisterRecordCmd
2426 //===========================================================================================================================
2427
2428 typedef struct
2429 {
2430 DNSServiceRef conRef; // sdRef to be initialized by DNSServiceCreateConnection().
2431 DNSRecordRef recordRef; // Registered record reference.
2432 const char * recordName; // Name of resource record.
2433 uint8_t * dataPtr; // Pointer to resource record data.
2434 size_t dataLen; // Length of resource record data.
2435 uint32_t ttl; // TTL value of resource record in seconds.
2436 uint32_t ifIndex; // Interface index argument for DNSServiceRegisterRecord().
2437 DNSServiceFlags flags; // Flags argument for DNSServiceRegisterRecord().
2438 int lifetimeMs; // Lifetime of the record registration in milliseconds.
2439 uint16_t recordType; // Resource record type.
2440 uint8_t * updateDataPtr; // Pointer to data for record update. (malloc'd)
2441 size_t updateDataLen; // Length of data for record update.
2442 uint32_t updateTTL; // TTL for updated record.
2443 int updateDelayMs; // Post-registration record update delay in milliseconds.
2444 Boolean didRegister; // True if the record was registered.
2445
2446 } RegisterRecordContext;
2447
2448 static void RegisterRecordPrintPrologue( const RegisterRecordContext *inContext );
2449 static void RegisterRecordContextFree( RegisterRecordContext *inContext );
2450 static void DNSSD_API
2451 RegisterRecordCallback(
2452 DNSServiceRef inSDRef,
2453 DNSRecordRef inRecordRef,
2454 DNSServiceFlags inFlags,
2455 DNSServiceErrorType inError,
2456 void * inContext );
2457 static void RegisterRecordUpdate( void *inContext );
2458
2459 static void RegisterRecordCmd( void )
2460 {
2461 OSStatus err;
2462 RegisterRecordContext * context = NULL;
2463 dispatch_source_t signalSource = NULL;
2464
2465 // Set up SIGINT handler.
2466
2467 signal( SIGINT, SIG_IGN );
2468 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
2469 require_noerr( err, exit );
2470 dispatch_resume( signalSource );
2471
2472 // Create context.
2473
2474 context = (RegisterRecordContext *) calloc( 1, sizeof( *context ) );
2475 require_action( context, exit, err = kNoMemoryErr );
2476
2477 // Create connection.
2478
2479 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->conRef, NULL );
2480 require_noerr_quiet( err, exit );
2481
2482 // Get flags.
2483
2484 context->flags = GetDNSSDFlagsFromOpts();
2485
2486 // Get interface.
2487
2488 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
2489 require_noerr_quiet( err, exit );
2490
2491 // Get record type.
2492
2493 err = RecordTypeFromArgString( gRegisterRecord_Type, &context->recordType );
2494 require_noerr( err, exit );
2495
2496 // Get record data.
2497
2498 if( gRegisterRecord_Data )
2499 {
2500 err = RecordDataFromArgString( gRegisterRecord_Data, &context->dataPtr, &context->dataLen );
2501 require_noerr_quiet( err, exit );
2502 }
2503
2504 // Set remaining parameters.
2505
2506 context->recordName = gRegisterRecord_Name;
2507 context->ttl = (uint32_t) gRegisterRecord_TTL;
2508 context->lifetimeMs = gRegisterRecord_LifetimeMs;
2509
2510 // Get update data.
2511
2512 if( gRegisterRecord_UpdateData )
2513 {
2514 err = RecordDataFromArgString( gRegisterRecord_UpdateData, &context->updateDataPtr, &context->updateDataLen );
2515 require_noerr_quiet( err, exit );
2516
2517 context->updateTTL = (uint32_t) gRegisterRecord_UpdateTTL;
2518 context->updateDelayMs = gRegisterRecord_UpdateDelayMs;
2519 }
2520
2521 // Print prologue.
2522
2523 RegisterRecordPrintPrologue( context );
2524
2525 // Start operation.
2526
2527 err = DNSServiceRegisterRecord( context->conRef, &context->recordRef, context->flags, context->ifIndex,
2528 context->recordName, context->recordType, kDNSServiceClass_IN, (uint16_t) context->dataLen, context->dataPtr,
2529 context->ttl, RegisterRecordCallback, context );
2530 if( err )
2531 {
2532 FPrintF( stderr, "DNSServiceRegisterRecord() returned %#m\n", err );
2533 goto exit;
2534 }
2535
2536 dispatch_main();
2537
2538 exit:
2539 dispatch_source_forget( &signalSource );
2540 if( context ) RegisterRecordContextFree( context );
2541 if( err ) exit( 1 );
2542 }
2543
2544 //===========================================================================================================================
2545 // RegisterRecordPrintPrologue
2546 //===========================================================================================================================
2547
2548 static void RegisterRecordPrintPrologue( const RegisterRecordContext *inContext )
2549 {
2550 int infinite;
2551 char time[ kTimestampBufLen ];
2552 char ifName[ kInterfaceNameBufLen ];
2553
2554 InterfaceIndexToName( inContext->ifIndex, ifName );
2555
2556 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
2557 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
2558 FPrintF( stdout, "Name: %s\n", inContext->recordName );
2559 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( inContext->recordType ), inContext->recordType );
2560 FPrintF( stdout, "TTL: %u\n", inContext->ttl );
2561 FPrintF( stdout, "Data: %#H\n", inContext->dataPtr, (int) inContext->dataLen, INT_MAX );
2562 infinite = ( inContext->lifetimeMs < 0 ) ? true : false;
2563 FPrintF( stdout, "Lifetime: %?s%?d ms\n", infinite, "∞", !infinite, inContext->lifetimeMs );
2564 if( inContext->updateDataPtr )
2565 {
2566 FPrintF( stdout, "\nUpdate record:\n" );
2567 FPrintF( stdout, " Delay: %d ms\n", ( inContext->updateDelayMs >= 0 ) ? inContext->updateDelayMs : 0 );
2568 FPrintF( stdout, " TTL: %u%?s\n",
2569 inContext->updateTTL, inContext->updateTTL == 0, " (system will use a default value.)" );
2570 FPrintF( stdout, " RData: %#H\n", inContext->updateDataPtr, (int) inContext->updateDataLen, INT_MAX );
2571 }
2572 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
2573 FPrintF( stdout, "---\n" );
2574 }
2575
2576 //===========================================================================================================================
2577 // RegisterRecordContextFree
2578 //===========================================================================================================================
2579
2580 static void RegisterRecordContextFree( RegisterRecordContext *inContext )
2581 {
2582 DNSServiceForget( &inContext->conRef );
2583 ForgetMem( &inContext->dataPtr );
2584 ForgetMem( &inContext->updateDataPtr );
2585 free( inContext );
2586 }
2587
2588 //===========================================================================================================================
2589 // RegisterRecordCallback
2590 //===========================================================================================================================
2591
2592 static void
2593 RegisterRecordCallback(
2594 DNSServiceRef inSDRef,
2595 DNSRecordRef inRecordRef,
2596 DNSServiceFlags inFlags,
2597 DNSServiceErrorType inError,
2598 void * inContext )
2599 {
2600 RegisterRecordContext * context = (RegisterRecordContext *) inContext;
2601 char time[ kTimestampBufLen ];
2602
2603 Unused( inSDRef );
2604 Unused( inRecordRef );
2605 Unused( inFlags );
2606 Unused( context );
2607
2608 GetTimestampStr( time );
2609 FPrintF( stdout, "%s Record registration result (error %#m)\n", time, inError );
2610
2611 if( !context->didRegister && !inError )
2612 {
2613 context->didRegister = true;
2614 if( context->updateDataPtr )
2615 {
2616 if( context->updateDelayMs > 0 )
2617 {
2618 dispatch_after_f( dispatch_time_milliseconds( context->updateDelayMs ), dispatch_get_main_queue(),
2619 context, RegisterRecordUpdate );
2620 }
2621 else
2622 {
2623 RegisterRecordUpdate( context );
2624 }
2625 }
2626 if( context->lifetimeMs == 0 )
2627 {
2628 Exit( kExitReason_TimeLimit );
2629 }
2630 else if( context->lifetimeMs > 0 )
2631 {
2632 dispatch_after_f( dispatch_time_milliseconds( context->lifetimeMs ), dispatch_get_main_queue(),
2633 kExitReason_TimeLimit, Exit );
2634 }
2635 }
2636 }
2637
2638 //===========================================================================================================================
2639 // RegisterRecordUpdate
2640 //===========================================================================================================================
2641
2642 static void RegisterRecordUpdate( void *inContext )
2643 {
2644 OSStatus err;
2645 RegisterRecordContext * const context = (RegisterRecordContext *) inContext;
2646
2647 err = DNSServiceUpdateRecord( context->conRef, context->recordRef, 0, (uint16_t) context->updateDataLen,
2648 context->updateDataPtr, context->updateTTL );
2649 require_noerr( err, exit );
2650
2651 exit:
2652 if( err ) exit( 1 );
2653 }
2654
2655 //===========================================================================================================================
2656 // ResolveCmd
2657 //===========================================================================================================================
2658
2659 typedef struct
2660 {
2661 DNSServiceRef mainRef; // Main sdRef for shared connections.
2662 DNSServiceRef opRef; // sdRef for the DNSServiceResolve operation.
2663 DNSServiceFlags flags; // Flags argument for DNSServiceResolve().
2664 const char * name; // Service name argument for DNSServiceResolve().
2665 const char * type; // Service type argument for DNSServiceResolve().
2666 const char * domain; // Domain argument for DNSServiceResolve().
2667 uint32_t ifIndex; // Interface index argument for DNSServiceResolve().
2668 int timeLimitSecs; // Time limit for the DNSServiceResolve operation in seconds.
2669
2670 } ResolveContext;
2671
2672 static void ResolvePrintPrologue( const ResolveContext *inContext );
2673 static void ResolveContextFree( ResolveContext *inContext );
2674 static void DNSSD_API
2675 ResolveCallback(
2676 DNSServiceRef inSDRef,
2677 DNSServiceFlags inFlags,
2678 uint32_t inInterfaceIndex,
2679 DNSServiceErrorType inError,
2680 const char * inFullName,
2681 const char * inHostname,
2682 uint16_t inPort,
2683 uint16_t inTXTLen,
2684 const unsigned char * inTXTPtr,
2685 void * inContext );
2686
2687 static void ResolveCmd( void )
2688 {
2689 OSStatus err;
2690 DNSServiceRef sdRef;
2691 ResolveContext * context = NULL;
2692 dispatch_source_t signalSource = NULL;
2693 int useMainConnection;
2694
2695 // Set up SIGINT handler.
2696
2697 signal( SIGINT, SIG_IGN );
2698 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
2699 require_noerr( err, exit );
2700 dispatch_resume( signalSource );
2701
2702 // Create context.
2703
2704 context = (ResolveContext *) calloc( 1, sizeof( *context ) );
2705 require_action( context, exit, err = kNoMemoryErr );
2706
2707 // Check command parameters.
2708
2709 if( gResolve_TimeLimitSecs < 0 )
2710 {
2711 FPrintF( stderr, "Invalid time limit: %d seconds.\n", gResolve_TimeLimitSecs );
2712 err = kParamErr;
2713 goto exit;
2714 }
2715
2716 // Create main connection.
2717
2718 if( gConnectionOpt )
2719 {
2720 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->mainRef, NULL );
2721 require_noerr_quiet( err, exit );
2722 useMainConnection = true;
2723 }
2724 else
2725 {
2726 useMainConnection = false;
2727 }
2728
2729 // Get flags.
2730
2731 context->flags = GetDNSSDFlagsFromOpts();
2732 if( useMainConnection ) context->flags |= kDNSServiceFlagsShareConnection;
2733
2734 // Get interface index.
2735
2736 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
2737 require_noerr_quiet( err, exit );
2738
2739 // Set remaining parameters.
2740
2741 context->name = gResolve_Name;
2742 context->type = gResolve_Type;
2743 context->domain = gResolve_Domain;
2744 context->timeLimitSecs = gResolve_TimeLimitSecs;
2745
2746 // Print prologue.
2747
2748 ResolvePrintPrologue( context );
2749
2750 // Start operation.
2751
2752 if( useMainConnection ) sdRef = context->mainRef;
2753 err = DNSServiceResolve( &sdRef, context->flags, context->ifIndex, context->name, context->type, context->domain,
2754 ResolveCallback, NULL );
2755 require_noerr( err, exit );
2756
2757 context->opRef = sdRef;
2758 if( !useMainConnection )
2759 {
2760 err = DNSServiceSetDispatchQueue( context->opRef, dispatch_get_main_queue() );
2761 require_noerr( err, exit );
2762 }
2763
2764 // Set time limit.
2765
2766 if( context->timeLimitSecs > 0 )
2767 {
2768 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(),
2769 kExitReason_TimeLimit, Exit );
2770 }
2771 dispatch_main();
2772
2773 exit:
2774 dispatch_source_forget( &signalSource );
2775 if( context ) ResolveContextFree( context );
2776 if( err ) exit( 1 );
2777 }
2778
2779 //===========================================================================================================================
2780 // ReconfirmCmd
2781 //===========================================================================================================================
2782
2783 static void ReconfirmCmd( void )
2784 {
2785 OSStatus err;
2786 uint8_t * rdataPtr = NULL;
2787 size_t rdataLen = 0;
2788 DNSServiceFlags flags;
2789 uint32_t ifIndex;
2790 uint16_t type, class;
2791 char ifName[ kInterfaceNameBufLen ];
2792
2793 // Get flags.
2794
2795 flags = GetDNSSDFlagsFromOpts();
2796
2797 // Get interface index.
2798
2799 err = InterfaceIndexFromArgString( gInterface, &ifIndex );
2800 require_noerr_quiet( err, exit );
2801
2802 // Get record type.
2803
2804 err = RecordTypeFromArgString( gReconfirmRecord_Type, &type );
2805 require_noerr( err, exit );
2806
2807 // Get record data.
2808
2809 if( gReconfirmRecord_Data )
2810 {
2811 err = RecordDataFromArgString( gReconfirmRecord_Data, &rdataPtr, &rdataLen );
2812 require_noerr_quiet( err, exit );
2813 }
2814
2815 // Get record class.
2816
2817 if( gReconfirmRecord_Class )
2818 {
2819 err = RecordClassFromArgString( gReconfirmRecord_Class, &class );
2820 require_noerr( err, exit );
2821 }
2822 else
2823 {
2824 class = kDNSServiceClass_IN;
2825 }
2826
2827 // Print prologue.
2828
2829 FPrintF( stdout, "Flags: %#{flags}\n", flags, kDNSServiceFlagsDescriptors );
2830 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) ifIndex, InterfaceIndexToName( ifIndex, ifName ) );
2831 FPrintF( stdout, "Name: %s\n", gReconfirmRecord_Name );
2832 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( type ), type );
2833 FPrintF( stdout, "Class: %s (%u)\n", ( class == kDNSServiceClass_IN ) ? "IN" : "???", class );
2834 FPrintF( stdout, "Data: %#H\n", rdataPtr, (int) rdataLen, INT_MAX );
2835 FPrintF( stdout, "---\n" );
2836
2837 err = DNSServiceReconfirmRecord( flags, ifIndex, gReconfirmRecord_Name, type, class, (uint16_t) rdataLen, rdataPtr );
2838 FPrintF( stdout, "Error: %#m\n", err );
2839
2840 exit:
2841 FreeNullSafe( rdataPtr );
2842 if( err ) exit( 1 );
2843 }
2844
2845 //===========================================================================================================================
2846 // ResolvePrintPrologue
2847 //===========================================================================================================================
2848
2849 static void ResolvePrintPrologue( const ResolveContext *inContext )
2850 {
2851 const int timeLimitSecs = inContext->timeLimitSecs;
2852 char ifName[ kInterfaceNameBufLen ];
2853 char time[ kTimestampBufLen ];
2854
2855 InterfaceIndexToName( inContext->ifIndex, ifName );
2856
2857 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
2858 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
2859 FPrintF( stdout, "Name: %s\n", inContext->name );
2860 FPrintF( stdout, "Type: %s\n", inContext->type );
2861 FPrintF( stdout, "Domain: %s\n", inContext->domain );
2862 FPrintF( stdout, "Time limit: " );
2863 if( timeLimitSecs > 0 ) FPrintF( stdout, "%d second%?c\n", timeLimitSecs, timeLimitSecs != 1, 's' );
2864 else FPrintF( stdout, "∞\n" );
2865 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
2866 FPrintF( stdout, "---\n" );
2867 }
2868
2869 //===========================================================================================================================
2870 // ResolveContextFree
2871 //===========================================================================================================================
2872
2873 static void ResolveContextFree( ResolveContext *inContext )
2874 {
2875 DNSServiceForget( &inContext->opRef );
2876 DNSServiceForget( &inContext->mainRef );
2877 free( inContext );
2878 }
2879
2880 //===========================================================================================================================
2881 // ResolveCallback
2882 //===========================================================================================================================
2883
2884 static void DNSSD_API
2885 ResolveCallback(
2886 DNSServiceRef inSDRef,
2887 DNSServiceFlags inFlags,
2888 uint32_t inInterfaceIndex,
2889 DNSServiceErrorType inError,
2890 const char * inFullName,
2891 const char * inHostname,
2892 uint16_t inPort,
2893 uint16_t inTXTLen,
2894 const unsigned char * inTXTPtr,
2895 void * inContext )
2896 {
2897 char time[ kTimestampBufLen ];
2898 char errorStr[ 64 ];
2899
2900 Unused( inSDRef );
2901 Unused( inFlags );
2902 Unused( inContext );
2903
2904 GetTimestampStr( time );
2905
2906 if( inError ) SNPrintF( errorStr, sizeof( errorStr ), " error %#m", inError );
2907
2908 FPrintF( stdout, "%s: %s can be reached at %s:%u (interface %d)%?s\n",
2909 time, inFullName, inHostname, ntohs( inPort ), (int32_t) inInterfaceIndex, inError, errorStr );
2910 if( inTXTLen == 1 )
2911 {
2912 FPrintF( stdout, " TXT record: %#H\n", inTXTPtr, (int) inTXTLen, INT_MAX );
2913 }
2914 else
2915 {
2916 FPrintF( stdout, " TXT record: %#{txt}\n", inTXTPtr, (size_t) inTXTLen );
2917 }
2918 }
2919
2920 //===========================================================================================================================
2921 // GetAddrInfoPOSIXCmd
2922 //===========================================================================================================================
2923
2924 #define AddressFamilyStr( X ) ( \
2925 ( (X) == AF_INET ) ? "inet" : \
2926 ( (X) == AF_INET6 ) ? "inet6" : \
2927 ( (X) == AF_UNSPEC ) ? "unspec" : \
2928 "???" )
2929
2930 typedef struct
2931 {
2932 unsigned int flag;
2933 const char * str;
2934
2935 } FlagStringPair;
2936
2937 #define CaseFlagStringify( X ) { (X), # X }
2938
2939 const FlagStringPair kGAIPOSIXFlagStringPairs[] =
2940 {
2941 #if( defined( AI_UNUSABLE ) )
2942 CaseFlagStringify( AI_UNUSABLE ),
2943 #endif
2944 CaseFlagStringify( AI_NUMERICSERV ),
2945 CaseFlagStringify( AI_V4MAPPED ),
2946 CaseFlagStringify( AI_ADDRCONFIG ),
2947 #if( defined( AI_V4MAPPED_CFG ) )
2948 CaseFlagStringify( AI_V4MAPPED_CFG ),
2949 #endif
2950 CaseFlagStringify( AI_ALL ),
2951 CaseFlagStringify( AI_NUMERICHOST ),
2952 CaseFlagStringify( AI_CANONNAME ),
2953 CaseFlagStringify( AI_PASSIVE ),
2954 { 0, NULL }
2955 };
2956
2957 static void GetAddrInfoPOSIXCmd( void )
2958 {
2959 OSStatus err;
2960 struct addrinfo hints;
2961 const struct addrinfo * addrInfo;
2962 struct addrinfo * addrInfoList = NULL;
2963 const FlagStringPair * pair;
2964 char time[ kTimestampBufLen ];
2965
2966 memset( &hints, 0, sizeof( hints ) );
2967 hints.ai_socktype = SOCK_STREAM;
2968
2969 // Set hints address family.
2970
2971 if( !gGAIPOSIX_Family ) hints.ai_family = AF_UNSPEC;
2972 else if( strcasecmp( gGAIPOSIX_Family, "inet" ) == 0 ) hints.ai_family = AF_INET;
2973 else if( strcasecmp( gGAIPOSIX_Family, "inet6" ) == 0 ) hints.ai_family = AF_INET6;
2974 else if( strcasecmp( gGAIPOSIX_Family, "unspec" ) == 0 ) hints.ai_family = AF_UNSPEC;
2975 else
2976 {
2977 FPrintF( stderr, "Invalid address family: %s.\n", gGAIPOSIX_Family );
2978 err = kParamErr;
2979 goto exit;
2980 }
2981
2982 // Set hints flags.
2983
2984 if( gGAIPOSIXFlag_AddrConfig ) hints.ai_flags |= AI_ADDRCONFIG;
2985 if( gGAIPOSIXFlag_All ) hints.ai_flags |= AI_ALL;
2986 if( gGAIPOSIXFlag_CanonName ) hints.ai_flags |= AI_CANONNAME;
2987 if( gGAIPOSIXFlag_NumericHost ) hints.ai_flags |= AI_NUMERICHOST;
2988 if( gGAIPOSIXFlag_NumericServ ) hints.ai_flags |= AI_NUMERICSERV;
2989 if( gGAIPOSIXFlag_Passive ) hints.ai_flags |= AI_PASSIVE;
2990 if( gGAIPOSIXFlag_V4Mapped ) hints.ai_flags |= AI_V4MAPPED;
2991 #if( defined( AI_V4MAPPED_CFG ) )
2992 if( gGAIPOSIXFlag_V4MappedCFG ) hints.ai_flags |= AI_V4MAPPED_CFG;
2993 #endif
2994 #if( defined( AI_DEFAULT ) )
2995 if( gGAIPOSIXFlag_Default ) hints.ai_flags |= AI_DEFAULT;
2996 #endif
2997 #if( defined( AI_UNUSABLE ) )
2998 if( gGAIPOSIXFlag_Unusable ) hints.ai_flags |= AI_UNUSABLE;
2999 #endif
3000
3001 // Print prologue.
3002
3003 FPrintF( stdout, "Hostname: %s\n", gGAIPOSIX_HostName );
3004 FPrintF( stdout, "Servname: %s\n", gGAIPOSIX_ServName );
3005 FPrintF( stdout, "Address family: %s\n", AddressFamilyStr( hints.ai_family ) );
3006 FPrintF( stdout, "Flags: 0x%X < ", hints.ai_flags );
3007 for( pair = kGAIPOSIXFlagStringPairs; pair->str != NULL; ++pair )
3008 {
3009 if( ( (unsigned int) hints.ai_flags ) & pair->flag ) FPrintF( stdout, "%s ", pair->str );
3010 }
3011 FPrintF( stdout, ">\n" );
3012 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
3013 FPrintF( stdout, "---\n" );
3014
3015 // Call getaddrinfo().
3016
3017 err = getaddrinfo( gGAIPOSIX_HostName, gGAIPOSIX_ServName, &hints, &addrInfoList );
3018 GetTimestampStr( time );
3019 if( err )
3020 {
3021 FPrintF( stderr, "Error %d: %s.\n", err, gai_strerror( err ) );
3022 }
3023 else
3024 {
3025 int addrCount = 0;
3026
3027 for( addrInfo = addrInfoList; addrInfo; addrInfo = addrInfo->ai_next ) { ++addrCount; }
3028
3029 FPrintF( stdout, "Addresses (%d total):\n", addrCount );
3030 for( addrInfo = addrInfoList; addrInfo; addrInfo = addrInfo->ai_next )
3031 {
3032 FPrintF( stdout, "%##a\n", addrInfo->ai_addr );
3033 }
3034 }
3035 FPrintF( stdout, "---\n" );
3036 FPrintF( stdout, "End time: %s\n", time );
3037
3038 exit:
3039 if( addrInfoList ) freeaddrinfo( addrInfoList );
3040 if( err ) exit( 1 );
3041 }
3042
3043 //===========================================================================================================================
3044 // ReverseLookupCmd
3045 //===========================================================================================================================
3046
3047 static void ReverseLookupCmd( void )
3048 {
3049 OSStatus err;
3050 QueryRecordContext * context = NULL;
3051 DNSServiceRef sdRef;
3052 dispatch_source_t signalSource = NULL;
3053 uint32_t ipv4Addr;
3054 uint8_t ipv6Addr[ 16 ];
3055 char recordName[ ( 16 * 4 ) + 9 + 1 ];
3056 int useMainConnection;
3057 const char * endPtr;
3058
3059 // Set up SIGINT handler.
3060
3061 signal( SIGINT, SIG_IGN );
3062 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
3063 require_noerr( err, exit );
3064 dispatch_resume( signalSource );
3065
3066 // Create context.
3067
3068 context = (QueryRecordContext *) calloc( 1, sizeof( *context ) );
3069 require_action( context, exit, err = kNoMemoryErr );
3070
3071 // Check command parameters.
3072
3073 if( gReverseLookup_TimeLimitSecs < 0 )
3074 {
3075 FPrintF( stderr, "Invalid time limit: %d s.\n", gReverseLookup_TimeLimitSecs );
3076 err = kParamErr;
3077 goto exit;
3078 }
3079
3080 // Create main connection.
3081
3082 if( gConnectionOpt )
3083 {
3084 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->mainRef, NULL );
3085 require_noerr_quiet( err, exit );
3086 useMainConnection = true;
3087 }
3088 else
3089 {
3090 useMainConnection = false;
3091 }
3092
3093 // Get flags.
3094
3095 context->flags = GetDNSSDFlagsFromOpts();
3096 if( useMainConnection ) context->flags |= kDNSServiceFlagsShareConnection;
3097
3098 // Get interface index.
3099
3100 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
3101 require_noerr_quiet( err, exit );
3102
3103 // Create reverse lookup record name.
3104
3105 err = StringToIPv4Address( gReverseLookup_IPAddr, kStringToIPAddressFlagsNoPort | kStringToIPAddressFlagsNoPrefix,
3106 &ipv4Addr, NULL, NULL, NULL, &endPtr );
3107 if( err || ( *endPtr != '\0' ) )
3108 {
3109 char * dst;
3110 int i;
3111
3112 err = StringToIPv6Address( gReverseLookup_IPAddr,
3113 kStringToIPAddressFlagsNoPort | kStringToIPAddressFlagsNoPrefix | kStringToIPAddressFlagsNoScope,
3114 ipv6Addr, NULL, NULL, NULL, &endPtr );
3115 if( err || ( *endPtr != '\0' ) )
3116 {
3117 FPrintF( stderr, "Invalid IP address: \"%s\".\n", gReverseLookup_IPAddr );
3118 err = kParamErr;
3119 goto exit;
3120 }
3121 dst = recordName;
3122 for( i = 15; i >= 0; --i )
3123 {
3124 *dst++ = kHexDigitsLowercase[ ipv6Addr[ i ] & 0x0F ];
3125 *dst++ = '.';
3126 *dst++ = kHexDigitsLowercase[ ipv6Addr[ i ] >> 4 ];
3127 *dst++ = '.';
3128 }
3129 strcpy( dst, "ip6.arpa." );
3130 check( ( strlen( recordName ) + 1 ) <= sizeof( recordName ) );
3131 }
3132 else
3133 {
3134 SNPrintF( recordName, sizeof( recordName ), "%u.%u.%u.%u.in-addr.arpa.",
3135 ipv4Addr & 0xFF,
3136 ( ipv4Addr >> 8 ) & 0xFF,
3137 ( ipv4Addr >> 16 ) & 0xFF,
3138 ( ipv4Addr >> 24 ) & 0xFF );
3139 }
3140
3141 // Set remaining parameters.
3142
3143 context->recordName = recordName;
3144 context->recordType = kDNSServiceType_PTR;
3145 context->timeLimitSecs = gReverseLookup_TimeLimitSecs;
3146 context->oneShotMode = gReverseLookup_OneShot ? true : false;
3147
3148 // Print prologue.
3149
3150 QueryRecordPrintPrologue( context );
3151
3152 // Start operation.
3153
3154 if( useMainConnection ) sdRef = context->mainRef;
3155 err = DNSServiceQueryRecord( &sdRef, context->flags, context->ifIndex, context->recordName, context->recordType,
3156 kDNSServiceClass_IN, QueryRecordCallback, context );
3157 require_noerr( err, exit );
3158
3159 context->opRef = sdRef;
3160 if( !useMainConnection )
3161 {
3162 err = DNSServiceSetDispatchQueue( context->opRef, dispatch_get_main_queue() );
3163 require_noerr( err, exit );
3164 }
3165
3166 // Set time limit.
3167
3168 if( context->timeLimitSecs > 0 )
3169 {
3170 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(),
3171 kExitReason_TimeLimit, Exit );
3172 }
3173 dispatch_main();
3174
3175 exit:
3176 dispatch_source_forget( &signalSource );
3177 if( context ) QueryRecordContextFree( context );
3178 if( err ) exit( 1 );
3179 }
3180
3181 //===========================================================================================================================
3182 // PortMappingCmd
3183 //===========================================================================================================================
3184
3185 typedef struct
3186 {
3187 DNSServiceRef mainRef; // Main sdRef for shared connection.
3188 DNSServiceRef opRef; // sdRef for the DNSServiceNATPortMappingCreate operation.
3189 DNSServiceFlags flags; // Flags for DNSServiceNATPortMappingCreate operation.
3190 uint32_t ifIndex; // Interface index argument for DNSServiceNATPortMappingCreate operation.
3191 DNSServiceProtocol protocols; // Protocols argument for DNSServiceNATPortMappingCreate operation.
3192 uint32_t ttl; // TTL argument for DNSServiceNATPortMappingCreate operation.
3193 uint16_t internalPort; // Internal port argument for DNSServiceNATPortMappingCreate operation.
3194 uint16_t externalPort; // External port argument for DNSServiceNATPortMappingCreate operation.
3195 Boolean printedHeader; // True if results header was printed.
3196
3197 } PortMappingContext;
3198
3199 static void PortMappingPrintPrologue( const PortMappingContext *inContext );
3200 static void PortMappingContextFree( PortMappingContext *inContext );
3201 static void DNSSD_API
3202 PortMappingCallback(
3203 DNSServiceRef inSDRef,
3204 DNSServiceFlags inFlags,
3205 uint32_t inInterfaceIndex,
3206 DNSServiceErrorType inError,
3207 uint32_t inExternalIPv4Address,
3208 DNSServiceProtocol inProtocol,
3209 uint16_t inInternalPort,
3210 uint16_t inExternalPort,
3211 uint32_t inTTL,
3212 void * inContext );
3213
3214 static void PortMappingCmd( void )
3215 {
3216 OSStatus err;
3217 PortMappingContext * context = NULL;
3218 DNSServiceRef sdRef;
3219 dispatch_source_t signalSource = NULL;
3220 int useMainConnection;
3221
3222 // Set up SIGINT handler.
3223
3224 signal( SIGINT, SIG_IGN );
3225 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
3226 require_noerr( err, exit );
3227 dispatch_resume( signalSource );
3228
3229 // Create context.
3230
3231 context = (PortMappingContext *) calloc( 1, sizeof( *context ) );
3232 require_action( context, exit, err = kNoMemoryErr );
3233
3234 // Check command parameters.
3235
3236 if( ( gPortMapping_InternalPort < 0 ) || ( gPortMapping_InternalPort > UINT16_MAX ) )
3237 {
3238 FPrintF( stderr, "Internal port number %d is out-of-range.\n", gPortMapping_InternalPort );
3239 err = kParamErr;
3240 goto exit;
3241 }
3242
3243 if( ( gPortMapping_ExternalPort < 0 ) || ( gPortMapping_ExternalPort > UINT16_MAX ) )
3244 {
3245 FPrintF( stderr, "External port number %d is out-of-range.\n", gPortMapping_ExternalPort );
3246 err = kParamErr;
3247 goto exit;
3248 }
3249
3250 // Create main connection.
3251
3252 if( gConnectionOpt )
3253 {
3254 err = CreateConnectionFromArgString( gConnectionOpt, dispatch_get_main_queue(), &context->mainRef, NULL );
3255 require_noerr_quiet( err, exit );
3256 useMainConnection = true;
3257 }
3258 else
3259 {
3260 useMainConnection = false;
3261 }
3262
3263 // Get flags.
3264
3265 context->flags = GetDNSSDFlagsFromOpts();
3266 if( useMainConnection ) context->flags |= kDNSServiceFlagsShareConnection;
3267
3268 // Get interface index.
3269
3270 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
3271 require_noerr_quiet( err, exit );
3272
3273 // Set remaining parameters.
3274
3275 if( gPortMapping_ProtocolTCP ) context->protocols |= kDNSServiceProtocol_TCP;
3276 if( gPortMapping_ProtocolUDP ) context->protocols |= kDNSServiceProtocol_UDP;
3277 context->ttl = (uint32_t) gPortMapping_TTL;
3278 context->internalPort = (uint16_t) gPortMapping_InternalPort;
3279 context->externalPort = (uint16_t) gPortMapping_ExternalPort;
3280
3281 // Print prologue.
3282
3283 PortMappingPrintPrologue( context );
3284
3285 // Start operation.
3286
3287 if( useMainConnection ) sdRef = context->mainRef;
3288 err = DNSServiceNATPortMappingCreate( &sdRef, context->flags, context->ifIndex, context->protocols,
3289 htons( context->internalPort ), htons( context->externalPort ), context->ttl, PortMappingCallback, context );
3290 require_noerr( err, exit );
3291
3292 context->opRef = sdRef;
3293 if( !useMainConnection )
3294 {
3295 err = DNSServiceSetDispatchQueue( context->opRef, dispatch_get_main_queue() );
3296 require_noerr( err, exit );
3297 }
3298
3299 dispatch_main();
3300
3301 exit:
3302 dispatch_source_forget( &signalSource );
3303 if( context ) PortMappingContextFree( context );
3304 if( err ) exit( 1 );
3305 }
3306
3307 //===========================================================================================================================
3308 // PortMappingPrintPrologue
3309 //===========================================================================================================================
3310
3311 static void PortMappingPrintPrologue( const PortMappingContext *inContext )
3312 {
3313 char ifName[ kInterfaceNameBufLen ];
3314 char time[ kTimestampBufLen ];
3315
3316 InterfaceIndexToName( inContext->ifIndex, ifName );
3317
3318 FPrintF( stdout, "Flags: %#{flags}\n", inContext->flags, kDNSServiceFlagsDescriptors );
3319 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
3320 FPrintF( stdout, "Protocols: %#{flags}\n", inContext->protocols, kDNSServiceProtocolDescriptors );
3321 FPrintF( stdout, "Internal Port: %u\n", inContext->internalPort );
3322 FPrintF( stdout, "External Port: %u\n", inContext->externalPort );
3323 FPrintF( stdout, "TTL: %u%?s\n", inContext->ttl, !inContext->ttl, " (system will use a default value.)" );
3324 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
3325 FPrintF( stdout, "---\n" );
3326
3327 }
3328
3329 //===========================================================================================================================
3330 // PortMappingContextFree
3331 //===========================================================================================================================
3332
3333 static void PortMappingContextFree( PortMappingContext *inContext )
3334 {
3335 DNSServiceForget( &inContext->opRef );
3336 DNSServiceForget( &inContext->mainRef );
3337 free( inContext );
3338 }
3339
3340 //===========================================================================================================================
3341 // PortMappingCallback
3342 //===========================================================================================================================
3343
3344 static void DNSSD_API
3345 PortMappingCallback(
3346 DNSServiceRef inSDRef,
3347 DNSServiceFlags inFlags,
3348 uint32_t inInterfaceIndex,
3349 DNSServiceErrorType inError,
3350 uint32_t inExternalIPv4Address,
3351 DNSServiceProtocol inProtocol,
3352 uint16_t inInternalPort,
3353 uint16_t inExternalPort,
3354 uint32_t inTTL,
3355 void * inContext )
3356 {
3357 PortMappingContext * const context = (PortMappingContext *) inContext;
3358 char time[ kTimestampBufLen ];
3359 char errorStr[ 128 ];
3360
3361 Unused( inSDRef );
3362 Unused( inFlags );
3363
3364 GetTimestampStr( time );
3365
3366 if( inError ) SNPrintF( errorStr, sizeof( errorStr ), " (error: %#m)", inError );
3367 if( !context->printedHeader )
3368 {
3369 FPrintF( stdout, "%-26s IF %7s %15s %7s %6s Protocol\n", "Timestamp", "IntPort", "ExtAddr", "ExtPort", "TTL" );
3370 context->printedHeader = true;
3371 }
3372 FPrintF( stdout, "%-26s %2u %7u %15.4a %7u %6u %#{flags}%?s\n",
3373 time, inInterfaceIndex, ntohs( inInternalPort), &inExternalIPv4Address, ntohs( inExternalPort ), inTTL,
3374 inProtocol, kDNSServiceProtocolDescriptors, inError, errorStr );
3375 }
3376
3377 //===========================================================================================================================
3378 // BrowseAllCmd
3379 //===========================================================================================================================
3380
3381 typedef struct BrowseDomain BrowseDomain;
3382 typedef struct BrowseType BrowseType;
3383 typedef struct BrowseOp BrowseOp;
3384 typedef struct BrowseInstance BrowseInstance;
3385 typedef struct BrowseIPAddr BrowseIPAddr;
3386
3387 typedef struct
3388 {
3389 int refCount;
3390 DNSServiceRef mainRef;
3391 DNSServiceRef domainsQuery;
3392 const char * domain;
3393 BrowseDomain * domainList;
3394 char ** serviceTypes;
3395 size_t serviceTypesCount;
3396 dispatch_source_t exitTimer;
3397 uint32_t ifIndex;
3398 int pendingConnectCount;
3399 int browseTimeSecs;
3400 int maxConnectTimeSecs;
3401 Boolean includeAWDL;
3402 Boolean useColoredText;
3403
3404 } BrowseAllContext;
3405
3406 struct BrowseDomain
3407 {
3408 BrowseDomain * next;
3409 char * name;
3410 DNSServiceRef servicesQuery;
3411 BrowseAllContext * context;
3412 BrowseType * typeList;
3413 };
3414
3415 struct BrowseType
3416 {
3417 BrowseType * next;
3418 char * name;
3419 BrowseOp * browseList;
3420 };
3421
3422 struct BrowseOp
3423 {
3424 BrowseOp * next;
3425 BrowseAllContext * context;
3426 DNSServiceRef browse;
3427 uint64_t startTicks;
3428 BrowseInstance * instanceList;
3429 uint32_t ifIndex;
3430 Boolean isTCP;
3431 };
3432
3433 struct BrowseInstance
3434 {
3435 BrowseInstance * next;
3436 BrowseAllContext * context;
3437 char * name;
3438 uint64_t foundTicks;
3439 DNSServiceRef resolve;
3440 uint64_t resolveStartTicks;
3441 uint64_t resolveDoneTicks;
3442 DNSServiceRef getAddr;
3443 uint64_t getAddrStartTicks;
3444 BrowseIPAddr * addrList;
3445 uint8_t * txtPtr;
3446 size_t txtLen;
3447 char * hostname;
3448 uint32_t ifIndex;
3449 uint16_t port;
3450 Boolean isTCP;
3451 };
3452
3453 typedef enum
3454 {
3455 kConnectStatus_None = 0,
3456 kConnectStatus_Pending = 1,
3457 kConnectStatus_Succeeded = 2,
3458 kConnectStatus_Failed = 3
3459
3460 } ConnectStatus;
3461
3462 struct BrowseIPAddr
3463 {
3464 BrowseIPAddr * next;
3465 sockaddr_ip sip;
3466 int refCount;
3467 BrowseAllContext * context;
3468 uint64_t foundTicks;
3469 AsyncConnectionRef connection;
3470 ConnectStatus connectStatus;
3471 CFTimeInterval connectTimeSecs;
3472 OSStatus connectError;
3473 };
3474
3475 static void BrowseAllPrintPrologue( const BrowseAllContext *inContext );
3476 static void DNSSD_API
3477 BrowseAllQueryDomainsCallback(
3478 DNSServiceRef inSDRef,
3479 DNSServiceFlags inFlags,
3480 uint32_t inInterfaceIndex,
3481 DNSServiceErrorType inError,
3482 const char * inFullName,
3483 uint16_t inType,
3484 uint16_t inClass,
3485 uint16_t inRDataLen,
3486 const void * inRDataPtr,
3487 uint32_t inTTL,
3488 void * inContext );
3489 static void DNSSD_API
3490 BrowseAllQueryCallback(
3491 DNSServiceRef inSDRef,
3492 DNSServiceFlags inFlags,
3493 uint32_t inInterfaceIndex,
3494 DNSServiceErrorType inError,
3495 const char * inFullName,
3496 uint16_t inType,
3497 uint16_t inClass,
3498 uint16_t inRDataLen,
3499 const void * inRDataPtr,
3500 uint32_t inTTL,
3501 void * inContext );
3502 static void DNSSD_API
3503 BrowseAllBrowseCallback(
3504 DNSServiceRef inSDRef,
3505 DNSServiceFlags inFlags,
3506 uint32_t inInterfaceIndex,
3507 DNSServiceErrorType inError,
3508 const char * inName,
3509 const char * inRegType,
3510 const char * inDomain,
3511 void * inContext );
3512 static void DNSSD_API
3513 BrowseAllResolveCallback(
3514 DNSServiceRef inSDRef,
3515 DNSServiceFlags inFlags,
3516 uint32_t inInterfaceIndex,
3517 DNSServiceErrorType inError,
3518 const char * inFullName,
3519 const char * inHostname,
3520 uint16_t inPort,
3521 uint16_t inTXTLen,
3522 const unsigned char * inTXTPtr,
3523 void * inContext );
3524 static void DNSSD_API
3525 BrowseAllGAICallback(
3526 DNSServiceRef inSDRef,
3527 DNSServiceFlags inFlags,
3528 uint32_t inInterfaceIndex,
3529 DNSServiceErrorType inError,
3530 const char * inHostname,
3531 const struct sockaddr * inSockAddr,
3532 uint32_t inTTL,
3533 void * inContext );
3534 static void BrowseAllConnectionProgress( int inPhase, const void *inDetails, void *inArg );
3535 static void BrowseAllConnectionHandler( SocketRef inSock, OSStatus inError, void *inArg );
3536 static void BrowseAllStop( void *inContext );
3537 static void BrowseAllExit( void *inContext );
3538 static OSStatus BrowseAllAddDomain( BrowseAllContext *inContext, const char *inName );
3539 static OSStatus BrowseAllRemoveDomain( BrowseAllContext *inContext, const char *inName );
3540 static void BrowseAllContextRelease( BrowseAllContext *inContext );
3541 static OSStatus
3542 BrowseAllAddServiceType(
3543 BrowseAllContext * inContext,
3544 BrowseDomain * inDomain,
3545 const char * inName,
3546 uint32_t inIfIndex,
3547 Boolean inIncludeAWDL );
3548 static OSStatus
3549 BrowseAllRemoveServiceType(
3550 BrowseAllContext * inContext,
3551 BrowseDomain * inDomain,
3552 const char * inName,
3553 uint32_t inIfIndex );
3554 static OSStatus
3555 BrowseAllAddServiceInstance(
3556 BrowseAllContext * inContext,
3557 BrowseOp * inBrowse,
3558 const char * inName,
3559 const char * inRegType,
3560 const char * inDomain,
3561 uint32_t inIfIndex );
3562 static OSStatus
3563 BrowseAllRemoveServiceInstance(
3564 BrowseAllContext * inContext,
3565 BrowseOp * inBrowse,
3566 const char * inName,
3567 uint32_t inIfIndex );
3568 static OSStatus
3569 BrowseAllAddIPAddress(
3570 BrowseAllContext * inContext,
3571 BrowseInstance * inInstance,
3572 const struct sockaddr * inSockAddr );
3573 static OSStatus
3574 BrowseAllRemoveIPAddress(
3575 BrowseAllContext * inContext,
3576 BrowseInstance * inInstance,
3577 const struct sockaddr * inSockAddr );
3578 static void BrowseDomainFree( BrowseDomain *inDomain );
3579 static void BrowseTypeFree( BrowseType *inType );
3580 static void BrowseOpFree( BrowseOp *inBrowse );
3581 static void BrowseInstanceFree( BrowseInstance *inInstance );
3582 static void BrowseIPAddrRelease( BrowseIPAddr *inAddr );
3583 static void BrowseIPAddrReleaseList( BrowseIPAddr *inList );
3584
3585 #define ForgetIPAddressList( X ) ForgetCustom( X, BrowseIPAddrReleaseList )
3586 #define ForgetBrowseAllContext( X ) ForgetCustom( X, BrowseAllContextRelease )
3587
3588 #define kBrowseAllOpenFileMin 4096
3589
3590 static void BrowseAllCmd( void )
3591 {
3592 OSStatus err;
3593 BrowseAllContext * context = NULL;
3594
3595 // Check command parameters.
3596
3597 if( gBrowseAll_BrowseTimeSecs <= 0 )
3598 {
3599 FPrintF( stdout, "Invalid browse time: %d seconds.\n", gBrowseAll_BrowseTimeSecs );
3600 err = kParamErr;
3601 goto exit;
3602 }
3603
3604 #if( TARGET_OS_POSIX )
3605 // Set open file minimum.
3606
3607 {
3608 struct rlimit fdLimits;
3609
3610 err = getrlimit( RLIMIT_NOFILE, &fdLimits );
3611 err = map_global_noerr_errno( err );
3612 require_noerr( err, exit );
3613
3614 if( fdLimits.rlim_cur < kBrowseAllOpenFileMin )
3615 {
3616 fdLimits.rlim_cur = kBrowseAllOpenFileMin;
3617 err = setrlimit( RLIMIT_NOFILE, &fdLimits );
3618 err = map_global_noerr_errno( err );
3619 require_noerr( err, exit );
3620 }
3621 }
3622 #endif
3623
3624 context = (BrowseAllContext *) calloc( 1, sizeof( *context ) );
3625 require_action( context, exit, err = kNoMemoryErr );
3626
3627 context->refCount = 1;
3628 context->domain = gBrowseAll_Domain;
3629 context->serviceTypes = gBrowseAll_ServiceTypes;
3630 context->serviceTypesCount = gBrowseAll_ServiceTypesCount;
3631 gBrowseAll_ServiceTypes = NULL;
3632 gBrowseAll_ServiceTypesCount = 0;
3633 context->browseTimeSecs = gBrowseAll_BrowseTimeSecs;
3634 context->maxConnectTimeSecs = gBrowseAll_MaxConnectTimeSecs;
3635 context->includeAWDL = gBrowseAll_IncludeAWDL ? true : false;
3636 #if( TARGET_OS_POSIX )
3637 context->useColoredText = isatty( STDOUT_FILENO ) ? true : false;
3638 #endif
3639
3640 err = DNSServiceCreateConnection( &context->mainRef );
3641 require_noerr( err, exit );
3642
3643 err = DNSServiceSetDispatchQueue( context->mainRef, dispatch_get_main_queue() );
3644 require_noerr( err, exit );
3645
3646 // Set interface index.
3647
3648 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
3649 require_noerr_quiet( err, exit );
3650
3651 BrowseAllPrintPrologue( context );
3652
3653 if( context->domain )
3654 {
3655 err = BrowseAllAddDomain( context, context->domain );
3656 require_noerr( err, exit );
3657 }
3658 else
3659 {
3660 DNSServiceRef sdRef;
3661
3662 sdRef = context->mainRef;
3663 err = DNSServiceQueryRecord( &sdRef, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexLocalOnly,
3664 "b._dns-sd._udp.local.", kDNSServiceType_PTR, kDNSServiceClass_IN, BrowseAllQueryDomainsCallback, context );
3665 require_noerr( err, exit );
3666
3667 context->domainsQuery = sdRef;
3668 }
3669
3670 dispatch_after_f( dispatch_time_seconds( context->browseTimeSecs ), dispatch_get_main_queue(), context, BrowseAllStop );
3671 dispatch_main();
3672
3673 exit:
3674 if( context ) BrowseAllContextRelease( context );
3675 if( err ) exit( 1 );
3676 }
3677
3678 //===========================================================================================================================
3679 // BrowseAllPrintPrologue
3680 //===========================================================================================================================
3681
3682 static void BrowseAllPrintPrologue( const BrowseAllContext *inContext )
3683 {
3684 size_t i;
3685 char ifName[ kInterfaceNameBufLen ];
3686 char time[ kTimestampBufLen ];
3687
3688 InterfaceIndexToName( inContext->ifIndex, ifName );
3689
3690 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, ifName );
3691 FPrintF( stdout, "Service types: ");
3692 if( inContext->serviceTypesCount > 0 )
3693 {
3694 FPrintF( stdout, "%s", inContext->serviceTypes[ 0 ] );
3695 for( i = 1; i < inContext->serviceTypesCount; ++i ) FPrintF( stdout, ", %s", inContext->serviceTypes[ i ] );
3696 FPrintF( stdout, "\n" );
3697 }
3698 else
3699 {
3700 FPrintF( stdout, "all services\n" );
3701 }
3702 FPrintF( stdout, "Domain: %s\n", inContext->domain ? inContext->domain : "default domains" );
3703 FPrintF( stdout, "Browse time: %d second%?c\n", inContext->browseTimeSecs, inContext->browseTimeSecs != 1, 's' );
3704 FPrintF( stdout, "Max connect time: %d second%?c\n",
3705 inContext->maxConnectTimeSecs, inContext->maxConnectTimeSecs != 1, 's' );
3706 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
3707 FPrintF( stdout, "---\n" );
3708 }
3709
3710 //===========================================================================================================================
3711 // BrowseAllQueryDomainsCallback
3712 //===========================================================================================================================
3713
3714 static void DNSSD_API
3715 BrowseAllQueryDomainsCallback(
3716 DNSServiceRef inSDRef,
3717 DNSServiceFlags inFlags,
3718 uint32_t inInterfaceIndex,
3719 DNSServiceErrorType inError,
3720 const char * inFullName,
3721 uint16_t inType,
3722 uint16_t inClass,
3723 uint16_t inRDataLen,
3724 const void * inRDataPtr,
3725 uint32_t inTTL,
3726 void * inContext )
3727 {
3728 OSStatus err;
3729 BrowseAllContext * const context = (BrowseAllContext *) inContext;
3730 char domainStr[ kDNSServiceMaxDomainName ];
3731
3732 Unused( inSDRef );
3733 Unused( inInterfaceIndex );
3734 Unused( inFullName );
3735 Unused( inType );
3736 Unused( inClass );
3737 Unused( inTTL );
3738
3739 err = inError;
3740 require_noerr( err, exit );
3741
3742 err = DomainNameToString( inRDataPtr, ( (const uint8_t *) inRDataPtr ) + inRDataLen, domainStr, NULL );
3743 require_noerr( err, exit );
3744
3745 if( inFlags & kDNSServiceFlagsAdd )
3746 {
3747 err = BrowseAllAddDomain( context, domainStr );
3748 if( err == kDuplicateErr ) err = kNoErr;
3749 require_noerr( err, exit );
3750 }
3751 else
3752 {
3753 err = BrowseAllRemoveDomain( context, domainStr );
3754 if( err == kNotFoundErr ) err = kNoErr;
3755 require_noerr( err, exit );
3756 }
3757
3758 exit:
3759 if( err ) exit( 1 );
3760 }
3761
3762 //===========================================================================================================================
3763 // BrowseAllQueryCallback
3764 //===========================================================================================================================
3765
3766 static void DNSSD_API
3767 BrowseAllQueryCallback(
3768 DNSServiceRef inSDRef,
3769 DNSServiceFlags inFlags,
3770 uint32_t inInterfaceIndex,
3771 DNSServiceErrorType inError,
3772 const char * inFullName,
3773 uint16_t inType,
3774 uint16_t inClass,
3775 uint16_t inRDataLen,
3776 const void * inRDataPtr,
3777 uint32_t inTTL,
3778 void * inContext )
3779 {
3780 OSStatus err;
3781 BrowseDomain * const domain = (BrowseDomain *) inContext;
3782 const uint8_t * firstLabel;
3783 const uint8_t * secondLabel;
3784 char * serviceTypeStr = NULL;
3785 const uint8_t * const end = ( (uint8_t * ) inRDataPtr ) + inRDataLen;
3786
3787 Unused( inSDRef );
3788 Unused( inFullName );
3789 Unused( inTTL );
3790 Unused( inType );
3791 Unused( inClass );
3792
3793 err = inError;
3794 require_noerr( err, exit );
3795
3796 check( inType == kDNSServiceType_PTR );
3797 check( inClass == kDNSServiceClass_IN );
3798 require_action( inRDataLen > 0, exit, err = kSizeErr );
3799
3800 firstLabel = inRDataPtr;
3801 require_action_quiet( ( firstLabel + 1 + firstLabel[ 0 ] ) < end , exit, err = kUnderrunErr );
3802
3803 secondLabel = firstLabel + 1 + firstLabel[ 0 ];
3804 require_action_quiet( ( secondLabel + 1 + secondLabel[ 0 ] ) < end , exit, err = kUnderrunErr );
3805
3806 ASPrintF( &serviceTypeStr, "%#s.%#s", firstLabel, secondLabel );
3807 require_action( serviceTypeStr, exit, err = kNoMemoryErr );
3808
3809 if( inFlags & kDNSServiceFlagsAdd )
3810 {
3811 err = BrowseAllAddServiceType( domain->context, domain, serviceTypeStr, inInterfaceIndex, false );
3812 if( err == kDuplicateErr ) err = kNoErr;
3813 require_noerr( err, exit );
3814 }
3815 else
3816 {
3817 err = BrowseAllRemoveServiceType( domain->context, domain, serviceTypeStr, inInterfaceIndex );
3818 if( err == kNotFoundErr ) err = kNoErr;
3819 require_noerr( err, exit );
3820 }
3821
3822 exit:
3823 FreeNullSafe( serviceTypeStr );
3824 }
3825
3826 //===========================================================================================================================
3827 // BrowseAllBrowseCallback
3828 //===========================================================================================================================
3829
3830 static void DNSSD_API
3831 BrowseAllBrowseCallback(
3832 DNSServiceRef inSDRef,
3833 DNSServiceFlags inFlags,
3834 uint32_t inInterfaceIndex,
3835 DNSServiceErrorType inError,
3836 const char * inName,
3837 const char * inRegType,
3838 const char * inDomain,
3839 void * inContext )
3840 {
3841 OSStatus err;
3842 BrowseOp * const browse = (BrowseOp *) inContext;
3843
3844 Unused( inSDRef );
3845
3846 err = inError;
3847 require_noerr( err, exit );
3848
3849 if( inFlags & kDNSServiceFlagsAdd )
3850 {
3851 err = BrowseAllAddServiceInstance( browse->context, browse, inName, inRegType, inDomain, inInterfaceIndex );
3852 if( err == kDuplicateErr ) err = kNoErr;
3853 require_noerr( err, exit );
3854 }
3855 else
3856 {
3857 err = BrowseAllRemoveServiceInstance( browse->context, browse, inName, inInterfaceIndex );
3858 if( err == kNotFoundErr ) err = kNoErr;
3859 require_noerr( err, exit );
3860 }
3861
3862 exit:
3863 return;
3864 }
3865
3866 //===========================================================================================================================
3867 // BrowseAllResolveCallback
3868 //===========================================================================================================================
3869
3870 static void DNSSD_API
3871 BrowseAllResolveCallback(
3872 DNSServiceRef inSDRef,
3873 DNSServiceFlags inFlags,
3874 uint32_t inInterfaceIndex,
3875 DNSServiceErrorType inError,
3876 const char * inFullName,
3877 const char * inHostname,
3878 uint16_t inPort,
3879 uint16_t inTXTLen,
3880 const unsigned char * inTXTPtr,
3881 void * inContext )
3882 {
3883 OSStatus err;
3884 const uint64_t nowTicks = UpTicks();
3885 BrowseInstance * const instance = (BrowseInstance *) inContext;
3886
3887 Unused( inSDRef );
3888 Unused( inFlags );
3889 Unused( inInterfaceIndex );
3890 Unused( inFullName );
3891
3892 err = inError;
3893 require_noerr( err, exit );
3894
3895 if( !MemEqual( instance->txtPtr, instance->txtLen, inTXTPtr, inTXTLen ) )
3896 {
3897 FreeNullSafe( instance->txtPtr );
3898 instance->txtPtr = malloc( inTXTLen );
3899 require_action( instance->txtPtr, exit, err = kNoMemoryErr );
3900
3901 memcpy( instance->txtPtr, inTXTPtr, inTXTLen );
3902 instance->txtLen = inTXTLen;
3903 }
3904
3905 instance->port = ntohs( inPort );
3906
3907 if( !instance->hostname || ( strcasecmp( instance->hostname, inHostname ) != 0 ) )
3908 {
3909 DNSServiceRef sdRef;
3910
3911 if( !instance->hostname ) instance->resolveDoneTicks = nowTicks;
3912 FreeNullSafe( instance->hostname );
3913 instance->hostname = strdup( inHostname );
3914 require_action( instance->hostname, exit, err = kNoMemoryErr );
3915
3916 DNSServiceForget( &instance->getAddr );
3917 ForgetIPAddressList( &instance->addrList );
3918
3919 sdRef = instance->context->mainRef;
3920 instance->getAddrStartTicks = UpTicks();
3921 err = DNSServiceGetAddrInfo( &sdRef, kDNSServiceFlagsShareConnection, instance->ifIndex,
3922 kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6, instance->hostname, BrowseAllGAICallback, instance );
3923 require_noerr( err, exit );
3924
3925 instance->getAddr = sdRef;
3926 }
3927
3928 exit:
3929 if( err ) exit( 1 );
3930 }
3931
3932 //===========================================================================================================================
3933 // BrowseAllGAICallback
3934 //===========================================================================================================================
3935
3936 static void DNSSD_API
3937 BrowseAllGAICallback(
3938 DNSServiceRef inSDRef,
3939 DNSServiceFlags inFlags,
3940 uint32_t inInterfaceIndex,
3941 DNSServiceErrorType inError,
3942 const char * inHostname,
3943 const struct sockaddr * inSockAddr,
3944 uint32_t inTTL,
3945 void * inContext )
3946 {
3947 OSStatus err;
3948 BrowseInstance * const instance = (BrowseInstance *) inContext;
3949
3950 Unused( inSDRef );
3951 Unused( inInterfaceIndex );
3952 Unused( inHostname );
3953 Unused( inTTL );
3954
3955 err = inError;
3956 require_noerr( err, exit );
3957
3958 if( ( inSockAddr->sa_family != AF_INET ) && ( inSockAddr->sa_family != AF_INET6 ) )
3959 {
3960 dlogassert( "Unexpected address family: %d", inSockAddr->sa_family );
3961 goto exit;
3962 }
3963
3964 if( inFlags & kDNSServiceFlagsAdd )
3965 {
3966 err = BrowseAllAddIPAddress( instance->context, instance, inSockAddr );
3967 if( err == kDuplicateErr ) err = kNoErr;
3968 require_noerr( err, exit );
3969 }
3970 else
3971 {
3972 err = BrowseAllRemoveIPAddress( instance->context, instance, inSockAddr );
3973 if( err == kNotFoundErr ) err = kNoErr;
3974 require_noerr( err, exit );
3975 }
3976
3977 exit:
3978 return;
3979 }
3980
3981 //===========================================================================================================================
3982 // BrowseAllConnectionProgress
3983 //===========================================================================================================================
3984
3985 static void BrowseAllConnectionProgress( int inPhase, const void *inDetails, void *inArg )
3986 {
3987 BrowseIPAddr * const addr = (BrowseIPAddr *) inArg;
3988
3989 if( inPhase == kAsyncConnectionPhase_Connected )
3990 {
3991 const AsyncConnectedInfo * const info = (AsyncConnectedInfo *) inDetails;
3992
3993 addr->connectTimeSecs = info->connectSecs;
3994 }
3995 }
3996
3997 //===========================================================================================================================
3998 // BrowseAllConnectionHandler
3999 //===========================================================================================================================
4000
4001 static void BrowseAllConnectionHandler( SocketRef inSock, OSStatus inError, void *inArg )
4002 {
4003 BrowseIPAddr * const addr = (BrowseIPAddr *) inArg;
4004 BrowseAllContext * const context = addr->context;
4005
4006 if( inError )
4007 {
4008 addr->connectStatus = kConnectStatus_Failed;
4009 addr->connectError = inError;
4010 }
4011 else
4012 {
4013 addr->connectStatus = kConnectStatus_Succeeded;
4014 }
4015
4016 check( context->pendingConnectCount > 0 );
4017 if( --context->pendingConnectCount == 0 )
4018 {
4019 if( context->exitTimer )
4020 {
4021 dispatch_source_forget( &context->exitTimer );
4022 dispatch_async_f( dispatch_get_main_queue(), context, BrowseAllExit );
4023 }
4024 }
4025
4026 ForgetSocket( &inSock );
4027 BrowseIPAddrRelease( addr );
4028 }
4029
4030 //===========================================================================================================================
4031 // BrowseAllStop
4032 //===========================================================================================================================
4033
4034 static void BrowseAllStop( void *inContext )
4035 {
4036 OSStatus err;
4037 BrowseAllContext * const context = (BrowseAllContext *) inContext;
4038 BrowseDomain * domain;
4039 BrowseType * type;
4040 BrowseOp * browse;
4041 BrowseInstance * instance;
4042
4043 DNSServiceForget( &context->domainsQuery );
4044 for( domain = context->domainList; domain; domain = domain->next )
4045 {
4046 DNSServiceForget( &domain->servicesQuery );
4047 for( type = domain->typeList; type; type = type->next )
4048 {
4049 for( browse = type->browseList; browse; browse = browse->next )
4050 {
4051 DNSServiceForget( &browse->browse );
4052 for( instance = browse->instanceList; instance; instance = instance->next )
4053 {
4054 DNSServiceForget( &instance->resolve );
4055 DNSServiceForget( &instance->getAddr );
4056 }
4057 }
4058 }
4059 }
4060 DNSServiceForget( &context->mainRef );
4061
4062 if( ( context->pendingConnectCount > 0 ) && ( context->maxConnectTimeSecs > 0 ) )
4063 {
4064 check( !context->exitTimer );
4065 err = DispatchTimerCreate( dispatch_time_seconds( context->maxConnectTimeSecs ), DISPATCH_TIME_FOREVER,
4066 100 * kNanosecondsPerMillisecond, BrowseAllExit, NULL, context, &context->exitTimer );
4067 require_noerr( err, exit );
4068 dispatch_resume( context->exitTimer );
4069 }
4070 else
4071 {
4072 dispatch_async_f( dispatch_get_main_queue(), context, BrowseAllExit );
4073 }
4074 err = kNoErr;
4075
4076 exit:
4077 if( err ) exit( 1 );
4078 }
4079
4080 //===========================================================================================================================
4081 // BrowseAllExit
4082 //===========================================================================================================================
4083
4084 #define kStatusStr_CouldConnect "connected"
4085 #define kStatusStr_CouldConnectColored kANSIGreen kStatusStr_CouldConnect kANSINormal
4086 #define kStatusStr_CouldNotConnect "could not connect"
4087 #define kStatusStr_CouldNotConnectColored kANSIRed kStatusStr_CouldNotConnect kANSINormal
4088 #define kStatusStr_NoConnectionAttempted "no connection attempted"
4089 #define kStatusStr_Unknown "unknown"
4090
4091 #define Indent( X ) ( (X) * 4 ), ""
4092
4093 static void BrowseAllExit( void *inContext )
4094 {
4095 BrowseAllContext * const context = (BrowseAllContext *) inContext;
4096 BrowseDomain * domain;
4097 BrowseType * type;
4098 BrowseOp * browse;
4099 BrowseInstance * instance;
4100 BrowseIPAddr * addr;
4101
4102 dispatch_source_forget( &context->exitTimer );
4103
4104 for( domain = context->domainList; domain; domain = domain->next )
4105 {
4106 FPrintF( stdout, "%s\n\n", domain->name );
4107
4108 for( type = domain->typeList; type; type = type->next )
4109 {
4110 const char * desc;
4111
4112 desc = ServiceTypeDescription( type->name );
4113 if( desc ) FPrintF( stdout, "%*s" "%s (%s)\n\n", Indent( 1 ), desc, type->name );
4114 else FPrintF( stdout, "%*s" "%s\n\n", Indent( 1 ), type->name );
4115
4116 for( browse = type->browseList; browse; browse = browse->next )
4117 {
4118 for( instance = browse->instanceList; instance; instance = instance->next )
4119 {
4120 char ifname[ IF_NAMESIZE + 1 ];
4121
4122 FPrintF( stdout, "%*s" "%s via ", Indent( 2 ), instance->name );
4123 if( instance->ifIndex == 0 )
4124 {
4125 FPrintF( stdout, "the Internet" );
4126 }
4127 else if( if_indextoname( instance->ifIndex, ifname ) )
4128 {
4129 NetTransportType netType;
4130
4131 SocketGetInterfaceInfo( kInvalidSocketRef, ifname, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
4132 &netType );
4133 FPrintF( stdout, "%s (%s)",
4134 ( netType == kNetTransportType_Ethernet ) ? "ethernet" : NetTransportTypeToString( netType ),
4135 ifname );
4136 }
4137 else
4138 {
4139 FPrintF( stdout, "interface index %u", instance->ifIndex );
4140 }
4141 FPrintF( stdout, "\n\n" );
4142
4143 if( instance->hostname )
4144 {
4145 char buffer[ 256 ];
4146
4147 SNPrintF( buffer, sizeof( buffer ), "%s:%u", instance->hostname, instance->port );
4148 FPrintF( stdout, "%*s" "%-51s %4llu ms\n", Indent( 3 ), buffer,
4149 UpTicksToMilliseconds( instance->resolveDoneTicks - instance->resolveStartTicks ) );
4150 }
4151 else
4152 {
4153 FPrintF( stdout, "%*s" "%s:%u\n", Indent( 3 ), instance->hostname, instance->port );
4154 }
4155
4156 for( addr = instance->addrList; addr; addr = addr->next )
4157 {
4158 AsyncConnection_Forget( &addr->connection );
4159
4160 if( addr->connectStatus == kConnectStatus_Pending )
4161 {
4162 addr->connectStatus = kConnectStatus_Failed;
4163 addr->connectError = kTimeoutErr;
4164 }
4165
4166 FPrintF( stdout, "%*s" "%-##47a %4llu ms", Indent( 4 ),
4167 &addr->sip.sa, UpTicksToMilliseconds( addr->foundTicks - instance->getAddrStartTicks ) );
4168 if( context->maxConnectTimeSecs <= 0 )
4169 {
4170 FPrintF( stdout, "\n" );
4171 continue;
4172 }
4173 switch( addr->connectStatus )
4174 {
4175 case kConnectStatus_None:
4176 FPrintF( stdout, " (%s)\n", kStatusStr_NoConnectionAttempted );
4177 break;
4178
4179 case kConnectStatus_Succeeded:
4180 FPrintF( stdout, " (%s in %.2f ms)\n",
4181 context->useColoredText ? kStatusStr_CouldConnectColored : kStatusStr_CouldConnect,
4182 addr->connectTimeSecs * 1000 );
4183 break;
4184
4185 case kConnectStatus_Failed:
4186 FPrintF( stdout, " (%s: %m)\n",
4187 context->useColoredText ? kStatusStr_CouldNotConnectColored : kStatusStr_CouldNotConnect,
4188 addr->connectError );
4189 break;
4190
4191 default:
4192 FPrintF( stdout, " (%s)\n", kStatusStr_Unknown );
4193 break;
4194 }
4195 }
4196
4197 FPrintF( stdout, "\n" );
4198 if( instance->txtLen == 0 ) continue;
4199
4200 FPrintF( stdout, "%*s" "TXT record:\n", Indent( 3 ) );
4201 if( instance->txtLen > 1 )
4202 {
4203 FPrintF( stdout, "%3{txt}", instance->txtPtr, instance->txtLen );
4204 }
4205 else
4206 {
4207 FPrintF( stdout, "%*s" "%#H\n", Indent( 3 ), instance->txtPtr, (int) instance->txtLen, INT_MAX );
4208 }
4209 FPrintF( stdout, "\n" );
4210 }
4211 }
4212 FPrintF( stdout, "\n" );
4213 }
4214 }
4215
4216 while( ( domain = context->domainList ) != NULL )
4217 {
4218 context->domainList = domain->next;
4219 BrowseDomainFree( domain );
4220 }
4221
4222 BrowseAllContextRelease( context );
4223 Exit( NULL );
4224 }
4225
4226 //===========================================================================================================================
4227 // BrowseAllAddDomain
4228 //===========================================================================================================================
4229
4230 static OSStatus BrowseAllAddDomain( BrowseAllContext *inContext, const char *inName )
4231 {
4232 OSStatus err;
4233 BrowseDomain * domain;
4234 BrowseDomain ** p;
4235 BrowseDomain * newDomain = NULL;
4236
4237 for( p = &inContext->domainList; ( domain = *p ) != NULL; p = &domain->next )
4238 {
4239 if( strcasecmp( domain->name, inName ) == 0 ) break;
4240 }
4241 require_action_quiet( !domain, exit, err = kDuplicateErr );
4242
4243 newDomain = (BrowseDomain *) calloc( 1, sizeof( *newDomain ) );
4244 require_action( newDomain, exit, err = kNoMemoryErr );
4245
4246 ++inContext->refCount;
4247 newDomain->context = inContext;
4248
4249 newDomain->name = strdup( inName );
4250 require_action( newDomain->name, exit, err = kNoMemoryErr );
4251
4252 if( inContext->serviceTypesCount > 0 )
4253 {
4254 size_t i;
4255
4256 for( i = 0; i < inContext->serviceTypesCount; ++i )
4257 {
4258 err = BrowseAllAddServiceType( inContext, newDomain, inContext->serviceTypes[ i ], inContext->ifIndex,
4259 inContext->includeAWDL );
4260 if( err == kDuplicateErr ) err = kNoErr;
4261 require_noerr( err, exit );
4262 }
4263 }
4264 else
4265 {
4266 char * recordName;
4267 DNSServiceFlags flags;
4268 DNSServiceRef sdRef;
4269
4270 ASPrintF( &recordName, "_services._dns-sd._udp.%s", newDomain->name );
4271 require_action( recordName, exit, err = kNoMemoryErr );
4272
4273 flags = kDNSServiceFlagsShareConnection;
4274 if( inContext->includeAWDL ) flags |= kDNSServiceFlagsIncludeAWDL;
4275
4276 sdRef = newDomain->context->mainRef;
4277 err = DNSServiceQueryRecord( &sdRef, flags, inContext->ifIndex, recordName, kDNSServiceType_PTR, kDNSServiceClass_IN,
4278 BrowseAllQueryCallback, newDomain );
4279 free( recordName );
4280 require_noerr( err, exit );
4281
4282 newDomain->servicesQuery = sdRef;
4283 }
4284
4285 *p = newDomain;
4286 newDomain = NULL;
4287 err = kNoErr;
4288
4289 exit:
4290 if( newDomain ) BrowseDomainFree( newDomain );
4291 return( err );
4292 }
4293
4294 //===========================================================================================================================
4295 // BrowseAllRemoveDomain
4296 //===========================================================================================================================
4297
4298 static OSStatus BrowseAllRemoveDomain( BrowseAllContext *inContext, const char *inName )
4299 {
4300 OSStatus err;
4301 BrowseDomain * domain;
4302 BrowseDomain ** p;
4303
4304 for( p = &inContext->domainList; ( domain = *p ) != NULL; p = &domain->next )
4305 {
4306 if( strcasecmp( domain->name, inName ) == 0 ) break;
4307 }
4308
4309 if( domain )
4310 {
4311 *p = domain->next;
4312 BrowseDomainFree( domain );
4313 err = kNoErr;
4314 }
4315 else
4316 {
4317 err = kNotFoundErr;
4318 }
4319
4320 return( err );
4321 }
4322
4323 //===========================================================================================================================
4324 // BrowseAllContextRelease
4325 //===========================================================================================================================
4326
4327 static void BrowseAllContextRelease( BrowseAllContext *inContext )
4328 {
4329 if( --inContext->refCount == 0 )
4330 {
4331 check( !inContext->domainsQuery );
4332 check( !inContext->domainList );
4333 check( !inContext->exitTimer );
4334 check( !inContext->pendingConnectCount );
4335 DNSServiceForget( &inContext->mainRef );
4336 if( inContext->serviceTypes )
4337 {
4338 StringArray_Free( inContext->serviceTypes, inContext->serviceTypesCount );
4339 inContext->serviceTypes = NULL;
4340 inContext->serviceTypesCount = 0;
4341 }
4342 free( inContext );
4343 }
4344 }
4345
4346 //===========================================================================================================================
4347 // BrowseAllAddServiceType
4348 //===========================================================================================================================
4349
4350 static OSStatus
4351 BrowseAllAddServiceType(
4352 BrowseAllContext * inContext,
4353 BrowseDomain * inDomain,
4354 const char * inName,
4355 uint32_t inIfIndex,
4356 Boolean inIncludeAWDL )
4357 {
4358 OSStatus err;
4359 DNSServiceRef sdRef;
4360 DNSServiceFlags flags;
4361 BrowseType * type;
4362 BrowseType ** typePtr;
4363 BrowseType * newType = NULL;
4364 BrowseOp * browse;
4365 BrowseOp ** browsePtr;
4366 BrowseOp * newBrowse = NULL;
4367
4368 for( typePtr = &inDomain->typeList; ( type = *typePtr ) != NULL; typePtr = &type->next )
4369 {
4370 if( strcasecmp( type->name, inName ) == 0 ) break;
4371 }
4372 if( !type )
4373 {
4374 newType = (BrowseType *) calloc( 1, sizeof( *newType ) );
4375 require_action( newType, exit, err = kNoMemoryErr );
4376
4377 newType->name = strdup( inName );
4378 require_action( newType->name, exit, err = kNoMemoryErr );
4379
4380 type = newType;
4381 }
4382
4383 for( browsePtr = &type->browseList; ( browse = *browsePtr ) != NULL; browsePtr = &browse->next )
4384 {
4385 if( browse->ifIndex == inIfIndex ) break;
4386 }
4387 require_action_quiet( !browse, exit, err = kDuplicateErr );
4388
4389 newBrowse = (BrowseOp *) calloc( 1, sizeof( *newBrowse ) );
4390 require_action( newBrowse, exit, err = kNoMemoryErr );
4391
4392 ++inContext->refCount;
4393 newBrowse->context = inContext;
4394 newBrowse->ifIndex = inIfIndex;
4395 if( stricmp_suffix( inName, "._tcp" ) == 0 ) newBrowse->isTCP = true;
4396
4397 flags = kDNSServiceFlagsShareConnection;
4398 if( inIncludeAWDL ) flags |= kDNSServiceFlagsIncludeAWDL;
4399
4400 newBrowse->startTicks = UpTicks();
4401
4402 sdRef = inContext->mainRef;
4403 err = DNSServiceBrowse( &sdRef, flags, newBrowse->ifIndex, type->name, inDomain->name, BrowseAllBrowseCallback,
4404 newBrowse );
4405 require_noerr( err, exit );
4406
4407 newBrowse->browse = sdRef;
4408 *browsePtr = newBrowse;
4409 newBrowse = NULL;
4410
4411 if( newType )
4412 {
4413 *typePtr = newType;
4414 newType = NULL;
4415 }
4416
4417 exit:
4418 if( newBrowse ) BrowseOpFree( newBrowse );
4419 if( newType ) BrowseTypeFree( newType );
4420 return( err );
4421 }
4422
4423 //===========================================================================================================================
4424 // BrowseAllRemoveServiceType
4425 //===========================================================================================================================
4426
4427 static OSStatus
4428 BrowseAllRemoveServiceType(
4429 BrowseAllContext * inContext,
4430 BrowseDomain * inDomain,
4431 const char * inName,
4432 uint32_t inIfIndex )
4433 {
4434 OSStatus err;
4435 BrowseType * type;
4436 BrowseType ** typePtr;
4437 BrowseOp * browse;
4438 BrowseOp ** browsePtr;
4439
4440 Unused( inContext );
4441
4442 for( typePtr = &inDomain->typeList; ( type = *typePtr ) != NULL; typePtr = &type->next )
4443 {
4444 if( strcasecmp( type->name, inName ) == 0 ) break;
4445 }
4446 require_action_quiet( type, exit, err = kNotFoundErr );
4447
4448 for( browsePtr = &type->browseList; ( browse = *browsePtr ) != NULL; browsePtr = &browse->next )
4449 {
4450 if( browse->ifIndex == inIfIndex ) break;
4451 }
4452 require_action_quiet( browse, exit, err = kNotFoundErr );
4453
4454 *browsePtr = browse->next;
4455 BrowseOpFree( browse );
4456 if( !type->browseList )
4457 {
4458 *typePtr = type->next;
4459 BrowseTypeFree( type );
4460 }
4461 err = kNoErr;
4462
4463 exit:
4464 return( err );
4465 }
4466
4467 //===========================================================================================================================
4468 // BrowseAllAddServiceInstance
4469 //===========================================================================================================================
4470
4471 static OSStatus
4472 BrowseAllAddServiceInstance(
4473 BrowseAllContext * inContext,
4474 BrowseOp * inBrowse,
4475 const char * inName,
4476 const char * inRegType,
4477 const char * inDomain,
4478 uint32_t inIfIndex )
4479 {
4480 OSStatus err;
4481 DNSServiceRef sdRef;
4482 BrowseInstance * instance;
4483 BrowseInstance ** p;
4484 const uint64_t nowTicks = UpTicks();
4485 BrowseInstance * newInstance = NULL;
4486
4487 for( p = &inBrowse->instanceList; ( instance = *p ) != NULL; p = &instance->next )
4488 {
4489 if( ( instance->ifIndex == inIfIndex ) && ( strcasecmp( instance->name, inName ) == 0 ) ) break;
4490 }
4491 require_action_quiet( !instance, exit, err = kDuplicateErr );
4492
4493 newInstance = (BrowseInstance *) calloc( 1, sizeof( *newInstance ) );
4494 require_action( newInstance, exit, err = kNoMemoryErr );
4495
4496 ++inContext->refCount;
4497 newInstance->context = inContext;
4498 newInstance->foundTicks = nowTicks;
4499 newInstance->ifIndex = inIfIndex;
4500 newInstance->isTCP = inBrowse->isTCP;
4501
4502 newInstance->name = strdup( inName );
4503 require_action( newInstance->name, exit, err = kNoMemoryErr );
4504
4505 sdRef = inContext->mainRef;
4506 newInstance->resolveStartTicks = UpTicks();
4507 err = DNSServiceResolve( &sdRef, kDNSServiceFlagsShareConnection, newInstance->ifIndex, inName, inRegType, inDomain,
4508 BrowseAllResolveCallback, newInstance );
4509 require_noerr( err, exit );
4510
4511 newInstance->resolve = sdRef;
4512 *p = newInstance;
4513 newInstance = NULL;
4514
4515 exit:
4516 if( newInstance ) BrowseInstanceFree( newInstance );
4517 return( err );
4518 }
4519
4520 //===========================================================================================================================
4521 // BrowseAllRemoveServiceInstance
4522 //===========================================================================================================================
4523
4524 static OSStatus
4525 BrowseAllRemoveServiceInstance(
4526 BrowseAllContext * inContext,
4527 BrowseOp * inBrowse,
4528 const char * inName,
4529 uint32_t inIfIndex )
4530 {
4531 OSStatus err;
4532 BrowseInstance * instance;
4533 BrowseInstance ** p;
4534
4535 Unused( inContext );
4536
4537 for( p = &inBrowse->instanceList; ( instance = *p ) != NULL; p = &instance->next )
4538 {
4539 if( ( instance->ifIndex == inIfIndex ) && ( strcasecmp( instance->name, inName ) == 0 ) ) break;
4540 }
4541 require_action_quiet( instance, exit, err = kNotFoundErr );
4542
4543 *p = instance->next;
4544 BrowseInstanceFree( instance );
4545 err = kNoErr;
4546
4547 exit:
4548 return( err );
4549 }
4550
4551 //===========================================================================================================================
4552 // BrowseAllAddIPAddress
4553 //===========================================================================================================================
4554
4555 #define kDiscardProtocolPort 9
4556
4557 static OSStatus
4558 BrowseAllAddIPAddress(
4559 BrowseAllContext * inContext,
4560 BrowseInstance * inInstance,
4561 const struct sockaddr * inSockAddr )
4562 {
4563 OSStatus err;
4564 BrowseIPAddr * addr;
4565 BrowseIPAddr ** p;
4566 const uint64_t nowTicks = UpTicks();
4567 BrowseIPAddr * newAddr = NULL;
4568
4569 if( ( inSockAddr->sa_family != AF_INET ) && ( inSockAddr->sa_family != AF_INET6 ) )
4570 {
4571 dlogassert( "Unexpected address family: %d", inSockAddr->sa_family );
4572 err = kTypeErr;
4573 goto exit;
4574 }
4575
4576 for( p = &inInstance->addrList; ( addr = *p ) != NULL; p = &addr->next )
4577 {
4578 if( SockAddrCompareAddr( &addr->sip, inSockAddr ) == 0 ) break;
4579 }
4580 require_action_quiet( !addr, exit, err = kDuplicateErr );
4581
4582 newAddr = (BrowseIPAddr *) calloc( 1, sizeof( *newAddr ) );
4583 require_action( newAddr, exit, err = kNoMemoryErr );
4584
4585 ++inContext->refCount;
4586 newAddr->refCount = 1;
4587 newAddr->context = inContext;
4588 newAddr->foundTicks = nowTicks;
4589 SockAddrCopy( inSockAddr, &newAddr->sip.sa );
4590
4591 if( ( inContext->maxConnectTimeSecs > 0 ) && inInstance->isTCP && ( inInstance->port != kDiscardProtocolPort ) )
4592 {
4593 char destination[ kSockAddrStringMaxSize ];
4594
4595 err = SockAddrToString( &newAddr->sip, kSockAddrStringFlagsNoPort, destination );
4596 require_noerr( err, exit );
4597
4598 err = AsyncConnection_Connect( &newAddr->connection, destination, -inInstance->port, kAsyncConnectionFlag_P2P,
4599 kAsyncConnectionNoTimeout, kSocketBufferSize_DontSet, kSocketBufferSize_DontSet,
4600 BrowseAllConnectionProgress, newAddr, BrowseAllConnectionHandler, newAddr, dispatch_get_main_queue() );
4601 require_noerr( err, exit );
4602
4603 ++newAddr->refCount;
4604 newAddr->connectStatus = kConnectStatus_Pending;
4605 ++inContext->pendingConnectCount;
4606 }
4607
4608 *p = newAddr;
4609 newAddr = NULL;
4610 err = kNoErr;
4611
4612 exit:
4613 if( newAddr ) BrowseIPAddrRelease( newAddr );
4614 return( err );
4615 }
4616
4617 //===========================================================================================================================
4618 // BrowseAllRemoveIPAddress
4619 //===========================================================================================================================
4620
4621 static OSStatus
4622 BrowseAllRemoveIPAddress(
4623 BrowseAllContext * inContext,
4624 BrowseInstance * inInstance,
4625 const struct sockaddr * inSockAddr )
4626 {
4627 OSStatus err;
4628 BrowseIPAddr * addr;
4629 BrowseIPAddr ** p;
4630
4631 Unused( inContext );
4632
4633 for( p = &inInstance->addrList; ( addr = *p ) != NULL; p = &addr->next )
4634 {
4635 if( SockAddrCompareAddr( &addr->sip.sa, inSockAddr ) == 0 ) break;
4636 }
4637 require_action_quiet( addr, exit, err = kNotFoundErr );
4638
4639 *p = addr->next;
4640 BrowseIPAddrRelease( addr );
4641 err = kNoErr;
4642
4643 exit:
4644 return( err );
4645 }
4646
4647 //===========================================================================================================================
4648 // BrowseDomainFree
4649 //===========================================================================================================================
4650
4651 static void BrowseDomainFree( BrowseDomain *inDomain )
4652 {
4653 BrowseType * type;
4654
4655 ForgetBrowseAllContext( &inDomain->context );
4656 ForgetMem( &inDomain->name );
4657 DNSServiceForget( &inDomain->servicesQuery );
4658 while( ( type = inDomain->typeList ) != NULL )
4659 {
4660 inDomain->typeList = type->next;
4661 BrowseTypeFree( type );
4662 }
4663 free( inDomain );
4664 }
4665
4666 //===========================================================================================================================
4667 // BrowseTypeFree
4668 //===========================================================================================================================
4669
4670 static void BrowseTypeFree( BrowseType *inType )
4671 {
4672 BrowseOp * browse;
4673
4674 ForgetMem( &inType->name );
4675 while( ( browse = inType->browseList ) != NULL )
4676 {
4677 inType->browseList = browse->next;
4678 BrowseOpFree( browse );
4679 }
4680 free( inType );
4681 }
4682
4683 //===========================================================================================================================
4684 // BrowseOpFree
4685 //===========================================================================================================================
4686
4687 static void BrowseOpFree( BrowseOp *inBrowse )
4688 {
4689 BrowseInstance * instance;
4690
4691 ForgetBrowseAllContext( &inBrowse->context );
4692 DNSServiceForget( &inBrowse->browse );
4693 while( ( instance = inBrowse->instanceList ) != NULL )
4694 {
4695 inBrowse->instanceList = instance->next;
4696 BrowseInstanceFree( instance );
4697 }
4698 free( inBrowse );
4699 }
4700
4701 //===========================================================================================================================
4702 // BrowseInstanceFree
4703 //===========================================================================================================================
4704
4705 static void BrowseInstanceFree( BrowseInstance *inInstance )
4706 {
4707 ForgetBrowseAllContext( &inInstance->context );
4708 ForgetMem( &inInstance->name );
4709 DNSServiceForget( &inInstance->resolve );
4710 DNSServiceForget( &inInstance->getAddr );
4711 ForgetMem( &inInstance->txtPtr );
4712 ForgetMem( &inInstance->hostname );
4713 ForgetIPAddressList( &inInstance->addrList );
4714 free( inInstance );
4715 }
4716
4717 //===========================================================================================================================
4718 // BrowseIPAddrRelease
4719 //===========================================================================================================================
4720
4721 static void BrowseIPAddrRelease( BrowseIPAddr *inAddr )
4722 {
4723 AsyncConnection_Forget( &inAddr->connection );
4724 if( --inAddr->refCount == 0 )
4725 {
4726 ForgetBrowseAllContext( &inAddr->context );
4727 free( inAddr );
4728 }
4729 }
4730
4731 //===========================================================================================================================
4732 // BrowseIPAddrReleaseList
4733 //===========================================================================================================================
4734
4735 static void BrowseIPAddrReleaseList( BrowseIPAddr *inList )
4736 {
4737 BrowseIPAddr * addr;
4738
4739 while( ( addr = inList ) != NULL )
4740 {
4741 inList = addr->next;
4742 BrowseIPAddrRelease( addr );
4743 }
4744 }
4745
4746 //===========================================================================================================================
4747 // GetAddrInfoStressCmd
4748 //===========================================================================================================================
4749
4750 typedef struct
4751 {
4752 DNSServiceRef mainRef;
4753 DNSServiceRef sdRef;
4754 DNSServiceFlags flags;
4755 unsigned int interfaceIndex;
4756 unsigned int connectionNumber;
4757 unsigned int requestCount;
4758 unsigned int requestCountMax;
4759 unsigned int requestCountLimit;
4760 unsigned int durationMinMs;
4761 unsigned int durationMaxMs;
4762
4763 } GAIStressContext;
4764
4765 static void GetAddrInfoStressEvent( void *inContext );
4766 static void DNSSD_API
4767 GetAddrInfoStressCallback(
4768 DNSServiceRef inSDRef,
4769 DNSServiceFlags inFlags,
4770 uint32_t inInterfaceIndex,
4771 DNSServiceErrorType inError,
4772 const char * inHostname,
4773 const struct sockaddr * inSockAddr,
4774 uint32_t inTTL,
4775 void * inContext );
4776
4777 static void GetAddrInfoStressCmd( void )
4778 {
4779 OSStatus err;
4780 GAIStressContext * context = NULL;
4781 int i;
4782 DNSServiceFlags flags;
4783 uint32_t ifIndex;
4784 char ifName[ kInterfaceNameBufLen ];
4785 char time[ kTimestampBufLen ];
4786
4787 if( gGAIStress_TestDurationSecs < 0 )
4788 {
4789 FPrintF( stdout, "Invalid test duration: %d s.\n", gGAIStress_TestDurationSecs );
4790 err = kParamErr;
4791 goto exit;
4792 }
4793 if( gGAIStress_ConnectionCount <= 0 )
4794 {
4795 FPrintF( stdout, "Invalid simultaneous connection count: %d.\n", gGAIStress_ConnectionCount );
4796 err = kParamErr;
4797 goto exit;
4798 }
4799 if( gGAIStress_DurationMinMs <= 0 )
4800 {
4801 FPrintF( stdout, "Invalid minimum DNSServiceGetAddrInfo() duration: %d ms.\n", gGAIStress_DurationMinMs );
4802 err = kParamErr;
4803 goto exit;
4804 }
4805 if( gGAIStress_DurationMaxMs <= 0 )
4806 {
4807 FPrintF( stdout, "Invalid maximum DNSServiceGetAddrInfo() duration: %d ms.\n", gGAIStress_DurationMaxMs );
4808 err = kParamErr;
4809 goto exit;
4810 }
4811 if( gGAIStress_DurationMinMs > gGAIStress_DurationMaxMs )
4812 {
4813 FPrintF( stdout, "Invalid minimum and maximum DNSServiceGetAddrInfo() durations: %d ms and %d ms.\n",
4814 gGAIStress_DurationMinMs, gGAIStress_DurationMaxMs );
4815 err = kParamErr;
4816 goto exit;
4817 }
4818 if( gGAIStress_RequestCountMax <= 0 )
4819 {
4820 FPrintF( stdout, "Invalid maximum request count: %d.\n", gGAIStress_RequestCountMax );
4821 err = kParamErr;
4822 goto exit;
4823 }
4824
4825 // Set flags.
4826
4827 flags = GetDNSSDFlagsFromOpts();
4828
4829 // Set interface index.
4830
4831 err = InterfaceIndexFromArgString( gInterface, &ifIndex );
4832 require_noerr_quiet( err, exit );
4833
4834 for( i = 0; i < gGAIStress_ConnectionCount; ++i )
4835 {
4836 context = (GAIStressContext *) calloc( 1, sizeof( *context ) );
4837 require_action( context, exit, err = kNoMemoryErr );
4838
4839 context->flags = flags;
4840 context->interfaceIndex = ifIndex;
4841 context->connectionNumber = (unsigned int)( i + 1 );
4842 context->requestCountMax = (unsigned int) gGAIStress_RequestCountMax;
4843 context->durationMinMs = (unsigned int) gGAIStress_DurationMinMs;
4844 context->durationMaxMs = (unsigned int) gGAIStress_DurationMaxMs;
4845
4846 dispatch_async_f( dispatch_get_main_queue(), context, GetAddrInfoStressEvent );
4847 context = NULL;
4848 }
4849
4850 if( gGAIStress_TestDurationSecs > 0 )
4851 {
4852 dispatch_after_f( dispatch_time_seconds( gGAIStress_TestDurationSecs ), dispatch_get_main_queue(), NULL, Exit );
4853 }
4854
4855 FPrintF( stdout, "Flags: %#{flags}\n", flags, kDNSServiceFlagsDescriptors );
4856 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) ifIndex, InterfaceIndexToName( ifIndex, ifName ) );
4857 FPrintF( stdout, "Test duration: " );
4858 if( gGAIStress_TestDurationSecs == 0 )
4859 {
4860 FPrintF( stdout, "∞\n" );
4861 }
4862 else
4863 {
4864 FPrintF( stdout, "%d s\n", gGAIStress_TestDurationSecs );
4865 }
4866 FPrintF( stdout, "Connection count: %d\n", gGAIStress_ConnectionCount );
4867 FPrintF( stdout, "Request duration min: %d ms\n", gGAIStress_DurationMinMs );
4868 FPrintF( stdout, "Request duration max: %d ms\n", gGAIStress_DurationMaxMs );
4869 FPrintF( stdout, "Request count max: %d\n", gGAIStress_RequestCountMax );
4870 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
4871 FPrintF( stdout, "---\n" );
4872
4873 dispatch_main();
4874
4875 exit:
4876 FreeNullSafe( context );
4877 if( err ) exit( 1 );
4878 }
4879
4880 //===========================================================================================================================
4881 // GetAddrInfoStressEvent
4882 //===========================================================================================================================
4883
4884 #define kStressRandStrLen 5
4885
4886 #define kLowercaseAlphaCharSet "abcdefghijklmnopqrstuvwxyz"
4887
4888 static void GetAddrInfoStressEvent( void *inContext )
4889 {
4890 GAIStressContext * const context = (GAIStressContext *) inContext;
4891 OSStatus err;
4892 DNSServiceRef sdRef;
4893 unsigned int nextMs;
4894 char randomStr[ kStressRandStrLen + 1 ];
4895 char hostname[ kStressRandStrLen + 4 + 1 ];
4896 char time[ kTimestampBufLen ];
4897 Boolean isConnectionNew = false;
4898 static Boolean printedHeader = false;
4899
4900 if( !context->mainRef || ( context->requestCount >= context->requestCountLimit ) )
4901 {
4902 DNSServiceForget( &context->mainRef );
4903 context->sdRef = NULL;
4904 context->requestCount = 0;
4905 context->requestCountLimit = RandomRange( 1, context->requestCountMax );
4906
4907 err = DNSServiceCreateConnection( &context->mainRef );
4908 require_noerr( err, exit );
4909
4910 err = DNSServiceSetDispatchQueue( context->mainRef, dispatch_get_main_queue() );
4911 require_noerr( err, exit );
4912
4913 isConnectionNew = true;
4914 }
4915
4916 RandomString( kLowercaseAlphaCharSet, sizeof_string( kLowercaseAlphaCharSet ), 2, kStressRandStrLen, randomStr );
4917 SNPrintF( hostname, sizeof( hostname ), "%s.com", randomStr );
4918
4919 nextMs = RandomRange( context->durationMinMs, context->durationMaxMs );
4920
4921 if( !printedHeader )
4922 {
4923 FPrintF( stdout, "%-26s Conn Hostname Dur (ms)\n", "Timestamp" );
4924 printedHeader = true;
4925 }
4926 FPrintF( stdout, "%-26s %3u%c %9s %8u\n",
4927 GetTimestampStr( time ), context->connectionNumber, isConnectionNew ? '*': ' ', hostname, nextMs );
4928
4929 DNSServiceForget( &context->sdRef );
4930 sdRef = context->mainRef;
4931 err = DNSServiceGetAddrInfo( &sdRef, context->flags | kDNSServiceFlagsShareConnection, context->interfaceIndex,
4932 kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6, hostname, GetAddrInfoStressCallback, NULL );
4933 require_noerr( err, exit );
4934 context->sdRef = sdRef;
4935
4936 context->requestCount++;
4937
4938 dispatch_after_f( dispatch_time_milliseconds( nextMs ), dispatch_get_main_queue(), context, GetAddrInfoStressEvent );
4939
4940 exit:
4941 if( err ) exit( 1 );
4942 }
4943
4944 //===========================================================================================================================
4945 // GetAddrInfoStressCallback
4946 //===========================================================================================================================
4947
4948 static void DNSSD_API
4949 GetAddrInfoStressCallback(
4950 DNSServiceRef inSDRef,
4951 DNSServiceFlags inFlags,
4952 uint32_t inInterfaceIndex,
4953 DNSServiceErrorType inError,
4954 const char * inHostname,
4955 const struct sockaddr * inSockAddr,
4956 uint32_t inTTL,
4957 void * inContext )
4958 {
4959 Unused( inSDRef );
4960 Unused( inFlags );
4961 Unused( inInterfaceIndex );
4962 Unused( inError );
4963 Unused( inHostname );
4964 Unused( inSockAddr );
4965 Unused( inTTL );
4966 Unused( inContext );
4967 }
4968
4969 //===========================================================================================================================
4970 // DNSQueryCmd
4971 //===========================================================================================================================
4972
4973 #define kDNSPort 53
4974
4975 typedef struct
4976 {
4977 sockaddr_ip serverAddr;
4978 uint64_t sendTicks;
4979 uint8_t * msgPtr;
4980 size_t msgLen;
4981 size_t msgOffset;
4982 const char * name;
4983 dispatch_source_t readSource;
4984 SocketRef sock;
4985 int timeLimitSecs;
4986 uint16_t queryID;
4987 uint16_t type;
4988 Boolean haveTCPLen;
4989 Boolean useTCP;
4990 Boolean printRawRData; // True if RDATA results are not to be formatted.
4991 uint8_t msgBuf[ 512 ];
4992
4993 } DNSQueryContext;
4994
4995 static void DNSQueryPrintPrologue( const DNSQueryContext *inContext );
4996 static void DNSQueryReadHandler( void *inContext );
4997 static void DNSQueryCancelHandler( void *inContext );
4998
4999 static void DNSQueryCmd( void )
5000 {
5001 OSStatus err;
5002 DNSQueryContext * context = NULL;
5003 uint8_t * msgPtr;
5004 size_t msgLen, sendLen;
5005
5006 // Check command parameters.
5007
5008 if( gDNSQuery_TimeLimitSecs < -1 )
5009 {
5010 FPrintF( stdout, "Invalid time limit: %d seconds.\n", gDNSQuery_TimeLimitSecs );
5011 err = kParamErr;
5012 goto exit;
5013 }
5014 if( ( gDNSQuery_Flags < INT16_MIN ) || ( gDNSQuery_Flags > UINT16_MAX ) )
5015 {
5016 FPrintF( stdout, "DNS flags-and-codes value is out of the unsigned 16-bit range: 0x%08X.\n", gDNSQuery_Flags );
5017 err = kParamErr;
5018 goto exit;
5019 }
5020
5021 // Create context.
5022
5023 context = (DNSQueryContext *) calloc( 1, sizeof( *context ) );
5024 require_action( context, exit, err = kNoMemoryErr );
5025
5026 context->name = gDNSQuery_Name;
5027 context->sock = kInvalidSocketRef;
5028 context->timeLimitSecs = gDNSQuery_TimeLimitSecs;
5029 context->queryID = (uint16_t) Random32();
5030 context->useTCP = gDNSQuery_UseTCP ? true : false;
5031 context->printRawRData = gDNSQuery_RawRData ? true : false;
5032
5033 #if( TARGET_OS_DARWIN )
5034 if( gDNSQuery_Server )
5035 #endif
5036 {
5037 err = StringToSockAddr( gDNSQuery_Server, &context->serverAddr, sizeof( context->serverAddr ), NULL );
5038 require_noerr( err, exit );
5039 }
5040 #if( TARGET_OS_DARWIN )
5041 else
5042 {
5043 err = GetDefaultDNSServer( &context->serverAddr );
5044 require_noerr( err, exit );
5045 }
5046 #endif
5047 if( SockAddrGetPort( &context->serverAddr ) == 0 ) SockAddrSetPort( &context->serverAddr, kDNSPort );
5048
5049 err = RecordTypeFromArgString( gDNSQuery_Type, &context->type );
5050 require_noerr( err, exit );
5051
5052 // Write query message.
5053
5054 check_compile_time_code( sizeof( context->msgBuf ) >= ( kDNSQueryMessageMaxLen + 2 ) );
5055
5056 msgPtr = context->useTCP ? &context->msgBuf[ 2 ] : context->msgBuf;
5057 err = WriteDNSQueryMessage( msgPtr, context->queryID, (uint16_t) gDNSQuery_Flags, context->name, context->type,
5058 kDNSServiceClass_IN, &msgLen );
5059 require_noerr( err, exit );
5060 check( msgLen <= UINT16_MAX );
5061
5062 if( context->useTCP )
5063 {
5064 WriteBig16( context->msgBuf, msgLen );
5065 sendLen = 2 + msgLen;
5066 }
5067 else
5068 {
5069 sendLen = msgLen;
5070 }
5071
5072 DNSQueryPrintPrologue( context );
5073
5074 if( gDNSQuery_Verbose )
5075 {
5076 FPrintF( stdout, "DNS message to send:\n\n" );
5077 PrintUDNSMessage( msgPtr, msgLen, false );
5078 FPrintF( stdout, "---\n" );
5079 }
5080
5081 if( context->useTCP )
5082 {
5083 // Create TCP socket.
5084
5085 context->sock = socket( context->serverAddr.sa.sa_family, SOCK_STREAM, IPPROTO_TCP );
5086 err = map_socket_creation_errno( context->sock );
5087 require_noerr( err, exit );
5088
5089 err = SocketConnect( context->sock, &context->serverAddr, 5 );
5090 require_noerr( err, exit );
5091 }
5092 else
5093 {
5094 // Create UDP socket.
5095
5096 err = UDPClientSocketOpen( AF_UNSPEC, &context->serverAddr, 0, -1, NULL, &context->sock );
5097 require_noerr( err, exit );
5098 }
5099
5100 context->sendTicks = UpTicks();
5101 err = SocketWriteAll( context->sock, context->msgBuf, sendLen, 5 );
5102 require_noerr( err, exit );
5103
5104 if( context->timeLimitSecs == 0 ) goto exit;
5105
5106 err = DispatchReadSourceCreate( context->sock, DNSQueryReadHandler, DNSQueryCancelHandler, context,
5107 &context->readSource );
5108 require_noerr( err, exit );
5109 dispatch_resume( context->readSource );
5110
5111 if( context->timeLimitSecs > 0 )
5112 {
5113 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(), kExitReason_Timeout,
5114 Exit );
5115 }
5116 dispatch_main();
5117
5118 exit:
5119 if( context )
5120 {
5121 dispatch_source_forget( &context->readSource );
5122 ForgetSocket( &context->sock );
5123 free( context );
5124 }
5125 if( err ) exit( 1 );
5126 }
5127
5128 //===========================================================================================================================
5129 // DNSQueryPrintPrologue
5130 //===========================================================================================================================
5131
5132 static void DNSQueryPrintPrologue( const DNSQueryContext *inContext )
5133 {
5134 const int timeLimitSecs = inContext->timeLimitSecs;
5135 char time[ kTimestampBufLen ];
5136
5137 FPrintF( stdout, "Name: %s\n", inContext->name );
5138 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( inContext->type ), inContext->type );
5139 FPrintF( stdout, "Server: %##a\n", &inContext->serverAddr );
5140 FPrintF( stdout, "Transport: %s\n", inContext->useTCP ? "TCP" : "UDP" );
5141 FPrintF( stdout, "Time limit: " );
5142 if( timeLimitSecs >= 0 ) FPrintF( stdout, "%d second%?c\n", timeLimitSecs, timeLimitSecs != 1, 's' );
5143 else FPrintF( stdout, "∞\n" );
5144 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
5145 FPrintF( stdout, "---\n" );
5146 }
5147
5148 //===========================================================================================================================
5149 // DNSQueryReadHandler
5150 //===========================================================================================================================
5151
5152 static void DNSQueryReadHandler( void *inContext )
5153 {
5154 OSStatus err;
5155 const uint64_t nowTicks = UpTicks();
5156 DNSQueryContext * const context = (DNSQueryContext *) inContext;
5157 char time[ kTimestampBufLen ];
5158
5159 GetTimestampStr( time );
5160
5161 if( context->useTCP )
5162 {
5163 if( !context->haveTCPLen )
5164 {
5165 err = SocketReadData( context->sock, &context->msgBuf, 2, &context->msgOffset );
5166 if( err == EWOULDBLOCK ) { err = kNoErr; goto exit; }
5167 require_noerr( err, exit );
5168
5169 context->msgOffset = 0;
5170 context->msgLen = ReadBig16( context->msgBuf );
5171 context->haveTCPLen = true;
5172 if( context->msgLen <= sizeof( context->msgBuf ) )
5173 {
5174 context->msgPtr = context->msgBuf;
5175 }
5176 else
5177 {
5178 context->msgPtr = (uint8_t *) malloc( context->msgLen );
5179 require_action( context->msgPtr, exit, err = kNoMemoryErr );
5180 }
5181 }
5182
5183 err = SocketReadData( context->sock, context->msgPtr, context->msgLen, &context->msgOffset );
5184 if( err == EWOULDBLOCK ) { err = kNoErr; goto exit; }
5185 require_noerr( err, exit );
5186 context->msgOffset = 0;
5187 context->haveTCPLen = false;
5188 }
5189 else
5190 {
5191 sockaddr_ip fromAddr;
5192
5193 context->msgPtr = context->msgBuf;
5194 err = SocketRecvFrom( context->sock, context->msgPtr, sizeof( context->msgBuf ), &context->msgLen, &fromAddr,
5195 sizeof( fromAddr ), NULL, NULL, NULL, NULL );
5196 require_noerr( err, exit );
5197
5198 check( SockAddrCompareAddr( &fromAddr, &context->serverAddr ) == 0 );
5199 }
5200
5201 FPrintF( stdout, "Receive time: %s\n", time );
5202 FPrintF( stdout, "Source: %##a\n", &context->serverAddr );
5203 FPrintF( stdout, "Message size: %zu\n", context->msgLen );
5204 FPrintF( stdout, "RTT: %llu ms\n\n", UpTicksToMilliseconds( nowTicks - context->sendTicks ) );
5205 PrintUDNSMessage( context->msgPtr, context->msgLen, context->printRawRData );
5206
5207 if( ( context->msgLen >= kDNSHeaderLength ) && ( DNSHeaderGetID( (DNSHeader *) context->msgPtr ) == context->queryID ) )
5208 {
5209 Exit( kExitReason_ReceivedResponse );
5210 }
5211
5212 exit:
5213 if( err ) dispatch_source_forget( &context->readSource );
5214 }
5215
5216 //===========================================================================================================================
5217 // DNSQueryCancelHandler
5218 //===========================================================================================================================
5219
5220 static void DNSQueryCancelHandler( void *inContext )
5221 {
5222 DNSQueryContext * const context = (DNSQueryContext *) inContext;
5223
5224 check( !context->readSource );
5225 ForgetSocket( &context->sock );
5226 if( context->msgPtr != context->msgBuf ) ForgetMem( &context->msgPtr );
5227 free( context );
5228 dispatch_async_f( dispatch_get_main_queue(), NULL, Exit );
5229 }
5230
5231 #if( DNSSDUTIL_INCLUDE_DNSCRYPT )
5232 //===========================================================================================================================
5233 // DNSCryptCmd
5234 //===========================================================================================================================
5235
5236 #define kDNSCryptPort 443
5237
5238 #define kDNSCryptMinPadLength 8
5239 #define kDNSCryptMaxPadLength 256
5240 #define kDNSCryptBlockSize 64
5241 #define kDNSCryptCertMinimumLength 124
5242 #define kDNSCryptClientMagicLength 8
5243 #define kDNSCryptResolverMagicLength 8
5244 #define kDNSCryptHalfNonceLength 12
5245 #define kDNSCryptCertMagicLength 4
5246
5247 check_compile_time( ( kDNSCryptHalfNonceLength * 2 ) == crypto_box_NONCEBYTES );
5248
5249 static const uint8_t kDNSCryptCertMagic[ kDNSCryptCertMagicLength ] = { 'D', 'N', 'S', 'C' };
5250 static const uint8_t kDNSCryptResolverMagic[ kDNSCryptResolverMagicLength ] =
5251 {
5252 0x72, 0x36, 0x66, 0x6e, 0x76, 0x57, 0x6a, 0x38
5253 };
5254
5255 typedef struct
5256 {
5257 uint8_t certMagic[ kDNSCryptCertMagicLength ];
5258 uint8_t esVersion[ 2 ];
5259 uint8_t minorVersion[ 2 ];
5260 uint8_t signature[ crypto_sign_BYTES ];
5261 uint8_t publicKey[ crypto_box_PUBLICKEYBYTES ];
5262 uint8_t clientMagic[ kDNSCryptClientMagicLength ];
5263 uint8_t serial[ 4 ];
5264 uint8_t startTime[ 4 ];
5265 uint8_t endTime[ 4 ];
5266 uint8_t extensions[ 1 ]; // Variably-sized extension data.
5267
5268 } DNSCryptCert;
5269
5270 check_compile_time( offsetof( DNSCryptCert, extensions ) == kDNSCryptCertMinimumLength );
5271
5272 typedef struct
5273 {
5274 uint8_t clientMagic[ kDNSCryptClientMagicLength ];
5275 uint8_t clientPublicKey[ crypto_box_PUBLICKEYBYTES ];
5276 uint8_t clientNonce[ kDNSCryptHalfNonceLength ];
5277 uint8_t poly1305MAC[ 16 ];
5278
5279 } DNSCryptQueryHeader;
5280
5281 check_compile_time( sizeof( DNSCryptQueryHeader ) == 68 );
5282 check_compile_time( sizeof( DNSCryptQueryHeader ) >= crypto_box_ZEROBYTES );
5283 check_compile_time( ( sizeof( DNSCryptQueryHeader ) - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES ) ==
5284 offsetof( DNSCryptQueryHeader, poly1305MAC ) );
5285
5286 typedef struct
5287 {
5288 uint8_t resolverMagic[ kDNSCryptResolverMagicLength ];
5289 uint8_t clientNonce[ kDNSCryptHalfNonceLength ];
5290 uint8_t resolverNonce[ kDNSCryptHalfNonceLength ];
5291 uint8_t poly1305MAC[ 16 ];
5292
5293 } DNSCryptResponseHeader;
5294
5295 check_compile_time( sizeof( DNSCryptResponseHeader ) == 48 );
5296 check_compile_time( offsetof( DNSCryptResponseHeader, poly1305MAC ) >= crypto_box_BOXZEROBYTES );
5297 check_compile_time( ( offsetof( DNSCryptResponseHeader, poly1305MAC ) - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES ) ==
5298 sizeof( DNSCryptResponseHeader ) );
5299
5300 typedef struct
5301 {
5302 sockaddr_ip serverAddr;
5303 uint64_t sendTicks;
5304 const char * providerName;
5305 const char * qname;
5306 const uint8_t * certPtr;
5307 size_t certLen;
5308 dispatch_source_t readSource;
5309 size_t msgLen;
5310 int timeLimitSecs;
5311 uint16_t queryID;
5312 uint16_t qtype;
5313 Boolean printRawRData;
5314 uint8_t serverPublicSignKey[ crypto_sign_PUBLICKEYBYTES ];
5315 uint8_t serverPublicKey[ crypto_box_PUBLICKEYBYTES ];
5316 uint8_t clientPublicKey[ crypto_box_PUBLICKEYBYTES ];
5317 uint8_t clientSecretKey[ crypto_box_SECRETKEYBYTES ];
5318 uint8_t clientMagic[ kDNSCryptClientMagicLength ];
5319 uint8_t clientNonce[ kDNSCryptHalfNonceLength ];
5320 uint8_t nmKey[ crypto_box_BEFORENMBYTES ];
5321 uint8_t msgBuf[ 512 ];
5322
5323 } DNSCryptContext;
5324
5325 static void DNSCryptReceiveCertHandler( void *inContext );
5326 static void DNSCryptReceiveResponseHandler( void *inContext );
5327 static void DNSCryptProceed( void *inContext );
5328 static OSStatus DNSCryptProcessCert( DNSCryptContext *inContext );
5329 static OSStatus DNSCryptBuildQuery( DNSCryptContext *inContext );
5330 static OSStatus DNSCryptSendQuery( DNSCryptContext *inContext );
5331 static void DNSCryptPrintCertificate( const DNSCryptCert *inCert, size_t inLen );
5332
5333 static void DNSCryptCmd( void )
5334 {
5335 OSStatus err;
5336 DNSCryptContext * context = NULL;
5337 size_t writtenBytes;
5338 size_t totalBytes;
5339 SocketContext * sockContext;
5340 SocketRef sock = kInvalidSocketRef;
5341 const char * ptr;
5342
5343 // Check command parameters.
5344
5345 if( gDNSCrypt_TimeLimitSecs < -1 )
5346 {
5347 FPrintF( stdout, "Invalid time limit: %d seconds.\n", gDNSCrypt_TimeLimitSecs );
5348 err = kParamErr;
5349 goto exit;
5350 }
5351
5352 // Create context.
5353
5354 context = (DNSCryptContext *) calloc( 1, sizeof( *context ) );
5355 require_action( context, exit, err = kNoMemoryErr );
5356
5357 context->providerName = gDNSCrypt_ProviderName;
5358 context->qname = gDNSCrypt_Name;
5359 context->timeLimitSecs = gDNSCrypt_TimeLimitSecs;
5360 context->printRawRData = gDNSCrypt_RawRData ? true : false;
5361
5362 err = crypto_box_keypair( context->clientPublicKey, context->clientSecretKey );
5363 require_noerr( err, exit );
5364
5365 err = HexToData( gDNSCrypt_ProviderKey, kSizeCString, kHexToData_DefaultFlags,
5366 context->serverPublicSignKey, sizeof( context->serverPublicSignKey ), &writtenBytes, &totalBytes, &ptr );
5367 if( err || ( *ptr != '\0' ) )
5368 {
5369 FPrintF( stderr, "Failed to parse public signing key hex string (%s).\n", gDNSCrypt_ProviderKey );
5370 goto exit;
5371 }
5372 else if( totalBytes != sizeof( context->serverPublicSignKey ) )
5373 {
5374 FPrintF( stderr, "Public signing key contains incorrect number of hex bytes (%zu != %zu)\n",
5375 totalBytes, sizeof( context->serverPublicSignKey ) );
5376 err = kSizeErr;
5377 goto exit;
5378 }
5379 check( writtenBytes == totalBytes );
5380
5381 err = StringToSockAddr( gDNSCrypt_Server, &context->serverAddr, sizeof( context->serverAddr ), NULL );
5382 require_noerr( err, exit );
5383 if( SockAddrGetPort( &context->serverAddr ) == 0 ) SockAddrSetPort( &context->serverAddr, kDNSCryptPort );
5384
5385 err = RecordTypeFromArgString( gDNSCrypt_Type, &context->qtype );
5386 require_noerr( err, exit );
5387
5388 // Write query message.
5389
5390 context->queryID = (uint16_t) Random32();
5391 err = WriteDNSQueryMessage( context->msgBuf, context->queryID, kDNSHeaderFlag_RecursionDesired, context->providerName,
5392 kDNSServiceType_TXT, kDNSServiceClass_IN, &context->msgLen );
5393 require_noerr( err, exit );
5394
5395 // Create UDP socket.
5396
5397 err = UDPClientSocketOpen( AF_UNSPEC, &context->serverAddr, 0, -1, NULL, &sock );
5398 require_noerr( err, exit );
5399
5400 // Send DNS query.
5401
5402 context->sendTicks = UpTicks();
5403 err = SocketWriteAll( sock, context->msgBuf, context->msgLen, 5 );
5404 require_noerr( err, exit );
5405
5406 sockContext = (SocketContext *) calloc( 1, sizeof( *sockContext ) );
5407 require_action( sockContext, exit, err = kNoMemoryErr );
5408
5409 err = DispatchReadSourceCreate( sock, DNSCryptReceiveCertHandler, SocketContextCancelHandler, sockContext,
5410 &context->readSource );
5411 if( err ) ForgetMem( &sockContext );
5412 require_noerr( err, exit );
5413
5414 sockContext->context = context;
5415 sockContext->sock = sock;
5416 sock = kInvalidSocketRef;
5417 dispatch_resume( context->readSource );
5418
5419 if( context->timeLimitSecs > 0 )
5420 {
5421 dispatch_after_f( dispatch_time_seconds( context->timeLimitSecs ), dispatch_get_main_queue(), kExitReason_Timeout,
5422 Exit );
5423 }
5424 dispatch_main();
5425
5426 exit:
5427 if( context ) free( context );
5428 ForgetSocket( &sock );
5429 if( err ) exit( 1 );
5430 }
5431
5432 //===========================================================================================================================
5433 // DNSCryptReceiveCertHandler
5434 //===========================================================================================================================
5435
5436 static void DNSCryptReceiveCertHandler( void *inContext )
5437 {
5438 OSStatus err;
5439 const uint64_t nowTicks = UpTicks();
5440 SocketContext * const sockContext = (SocketContext *) inContext;
5441 DNSCryptContext * const context = (DNSCryptContext *) sockContext->context;
5442 const DNSHeader * hdr;
5443 sockaddr_ip fromAddr;
5444 const uint8_t * ptr;
5445 const uint8_t * txtPtr;
5446 size_t txtLen;
5447 unsigned int answerCount, i;
5448 uint8_t targetName[ kDomainNameLengthMax ];
5449 char time[ kTimestampBufLen ];
5450
5451 GetTimestampStr( time );
5452
5453 dispatch_source_forget( &context->readSource );
5454
5455 err = SocketRecvFrom( sockContext->sock, context->msgBuf, sizeof( context->msgBuf ), &context->msgLen,
5456 &fromAddr, sizeof( fromAddr ), NULL, NULL, NULL, NULL );
5457 require_noerr( err, exit );
5458 check( SockAddrCompareAddr( &fromAddr, &context->serverAddr ) == 0 );
5459
5460 FPrintF( stdout, "Receive time: %s\n", time );
5461 FPrintF( stdout, "Source: %##a\n", &context->serverAddr );
5462 FPrintF( stdout, "Message size: %zu\n", context->msgLen );
5463 FPrintF( stdout, "RTT: %llu ms\n\n", UpTicksToMilliseconds( nowTicks - context->sendTicks ) );
5464
5465 PrintUDNSMessage( context->msgBuf, context->msgLen, context->printRawRData );
5466
5467 require_action_quiet( context->msgLen >= kDNSHeaderLength, exit, err = kSizeErr );
5468
5469 hdr = (DNSHeader *) context->msgBuf;
5470 require_action_quiet( DNSHeaderGetID( hdr ) == context->queryID, exit, err = kMismatchErr );
5471
5472 err = DNSMessageGetAnswerSection( context->msgBuf, context->msgLen, &ptr );
5473 require_noerr( err, exit );
5474
5475 err = DomainNameFromString( targetName, context->providerName, NULL );
5476 require_noerr( err, exit );
5477
5478 answerCount = DNSHeaderGetAnswerCount( hdr );
5479 for( i = 0; i < answerCount; ++i )
5480 {
5481 uint16_t type;
5482 uint16_t class;
5483 uint8_t name[ kDomainNameLengthMax ];
5484
5485 err = DNSMessageExtractRecord( context->msgBuf, context->msgLen, ptr, name, &type, &class, NULL, &txtPtr, &txtLen,
5486 &ptr );
5487 require_noerr( err, exit );
5488
5489 if( ( type == kDNSServiceType_TXT ) && ( class == kDNSServiceClass_IN ) && DomainNameEqual( name, targetName ) )
5490 {
5491 break;
5492 }
5493 }
5494
5495 if( txtLen < ( 1 + kDNSCryptCertMinimumLength ) )
5496 {
5497 FPrintF( stderr, "TXT record length is too short (%u < %u)\n", txtLen, kDNSCryptCertMinimumLength + 1 );
5498 err = kSizeErr;
5499 goto exit;
5500 }
5501 if( txtPtr[ 0 ] < kDNSCryptCertMinimumLength )
5502 {
5503 FPrintF( stderr, "TXT record value length is too short (%u < %u)\n", txtPtr[ 0 ], kDNSCryptCertMinimumLength );
5504 err = kSizeErr;
5505 goto exit;
5506 }
5507
5508 context->certLen = txtPtr[ 0 ];
5509 context->certPtr = &txtPtr[ 1 ];
5510
5511 dispatch_async_f( dispatch_get_main_queue(), context, DNSCryptProceed );
5512
5513 exit:
5514 if( err ) Exit( NULL );
5515 }
5516
5517 //===========================================================================================================================
5518 // DNSCryptReceiveResponseHandler
5519 //===========================================================================================================================
5520
5521 static void DNSCryptReceiveResponseHandler( void *inContext )
5522 {
5523 OSStatus err;
5524 const uint64_t nowTicks = UpTicks();
5525 SocketContext * const sockContext = (SocketContext *) inContext;
5526 DNSCryptContext * const context = (DNSCryptContext *) sockContext->context;
5527 sockaddr_ip fromAddr;
5528 DNSCryptResponseHeader * hdr;
5529 const uint8_t * end;
5530 uint8_t * ciphertext;
5531 uint8_t * plaintext;
5532 const uint8_t * response;
5533 char time[ kTimestampBufLen ];
5534 uint8_t nonce[ crypto_box_NONCEBYTES ];
5535
5536 GetTimestampStr( time );
5537
5538 dispatch_source_forget( &context->readSource );
5539
5540 err = SocketRecvFrom( sockContext->sock, context->msgBuf, sizeof( context->msgBuf ), &context->msgLen,
5541 &fromAddr, sizeof( fromAddr ), NULL, NULL, NULL, NULL );
5542 require_noerr( err, exit );
5543 check( SockAddrCompareAddr( &fromAddr, &context->serverAddr ) == 0 );
5544
5545 FPrintF( stdout, "Receive time: %s\n", time );
5546 FPrintF( stdout, "Source: %##a\n", &context->serverAddr );
5547 FPrintF( stdout, "Message size: %zu\n", context->msgLen );
5548 FPrintF( stdout, "RTT: %llu ms\n\n", UpTicksToMilliseconds( nowTicks - context->sendTicks ) );
5549
5550 if( context->msgLen < sizeof( DNSCryptResponseHeader ) )
5551 {
5552 FPrintF( stderr, "DNSCrypt response is too short.\n" );
5553 err = kSizeErr;
5554 goto exit;
5555 }
5556
5557 hdr = (DNSCryptResponseHeader *) context->msgBuf;
5558
5559 if( memcmp( hdr->resolverMagic, kDNSCryptResolverMagic, kDNSCryptResolverMagicLength ) != 0 )
5560 {
5561 FPrintF( stderr, "DNSCrypt response resolver magic %#H != %#H\n",
5562 hdr->resolverMagic, kDNSCryptResolverMagicLength, INT_MAX,
5563 kDNSCryptResolverMagic, kDNSCryptResolverMagicLength, INT_MAX );
5564 err = kValueErr;
5565 goto exit;
5566 }
5567
5568 if( memcmp( hdr->clientNonce, context->clientNonce, kDNSCryptHalfNonceLength ) != 0 )
5569 {
5570 FPrintF( stderr, "DNSCrypt response client nonce mismatch.\n" );
5571 err = kValueErr;
5572 goto exit;
5573 }
5574
5575 memcpy( nonce, hdr->clientNonce, crypto_box_NONCEBYTES );
5576
5577 ciphertext = hdr->poly1305MAC - crypto_box_BOXZEROBYTES;
5578 memset( ciphertext, 0, crypto_box_BOXZEROBYTES );
5579
5580 plaintext = (uint8_t *)( hdr + 1 ) - crypto_box_ZEROBYTES;
5581 check( plaintext == ciphertext );
5582
5583 end = context->msgBuf + context->msgLen;
5584
5585 err = crypto_box_open_afternm( plaintext, ciphertext, (size_t)( end - ciphertext ), nonce, context->nmKey );
5586 require_noerr( err, exit );
5587
5588 response = plaintext + crypto_box_ZEROBYTES;
5589 PrintUDNSMessage( response, (size_t)( end - response ), context->printRawRData );
5590 Exit( kExitReason_ReceivedResponse );
5591
5592 exit:
5593 if( err ) Exit( NULL );
5594 }
5595
5596 //===========================================================================================================================
5597 // DNSCryptProceed
5598 //===========================================================================================================================
5599
5600 static void DNSCryptProceed( void *inContext )
5601 {
5602 OSStatus err;
5603 DNSCryptContext * const context = (DNSCryptContext *) inContext;
5604
5605 err = DNSCryptProcessCert( context );
5606 require_noerr_quiet( err, exit );
5607
5608 err = DNSCryptBuildQuery( context );
5609 require_noerr_quiet( err, exit );
5610
5611 err = DNSCryptSendQuery( context );
5612 require_noerr_quiet( err, exit );
5613
5614 exit:
5615 if( err ) Exit( NULL );
5616 }
5617
5618 //===========================================================================================================================
5619 // DNSCryptProcessCert
5620 //===========================================================================================================================
5621
5622 static OSStatus DNSCryptProcessCert( DNSCryptContext *inContext )
5623 {
5624 OSStatus err;
5625 const DNSCryptCert * const cert = (DNSCryptCert *) inContext->certPtr;
5626 const uint8_t * const certEnd = inContext->certPtr + inContext->certLen;
5627 struct timeval now;
5628 time_t startTimeSecs, endTimeSecs;
5629 size_t signedLen;
5630 uint8_t * tempBuf;
5631 unsigned long long tempLen;
5632
5633 DNSCryptPrintCertificate( cert, inContext->certLen );
5634
5635 if( memcmp( cert->certMagic, kDNSCryptCertMagic, kDNSCryptCertMagicLength ) != 0 )
5636 {
5637 FPrintF( stderr, "DNSCrypt certificate magic %#H != %#H\n",
5638 cert->certMagic, kDNSCryptCertMagicLength, INT_MAX,
5639 kDNSCryptCertMagic, kDNSCryptCertMagicLength, INT_MAX );
5640 err = kValueErr;
5641 goto exit;
5642 }
5643
5644 startTimeSecs = (time_t) ReadBig32( cert->startTime );
5645 endTimeSecs = (time_t) ReadBig32( cert->endTime );
5646
5647 gettimeofday( &now, NULL );
5648 if( now.tv_sec < startTimeSecs )
5649 {
5650 FPrintF( stderr, "DNSCrypt certificate start time is in the future.\n" );
5651 err = kDateErr;
5652 goto exit;
5653 }
5654 if( now.tv_sec >= endTimeSecs )
5655 {
5656 FPrintF( stderr, "DNSCrypt certificate has expired.\n" );
5657 err = kDateErr;
5658 goto exit;
5659 }
5660
5661 signedLen = (size_t)( certEnd - cert->signature );
5662 tempBuf = (uint8_t *) malloc( signedLen );
5663 require_action( tempBuf, exit, err = kNoMemoryErr );
5664 err = crypto_sign_open( tempBuf, &tempLen, cert->signature, signedLen, inContext->serverPublicSignKey );
5665 free( tempBuf );
5666 if( err )
5667 {
5668 FPrintF( stderr, "DNSCrypt certificate failed verification.\n" );
5669 err = kAuthenticationErr;
5670 goto exit;
5671 }
5672
5673 memcpy( inContext->serverPublicKey, cert->publicKey, crypto_box_PUBLICKEYBYTES );
5674 memcpy( inContext->clientMagic, cert->clientMagic, kDNSCryptClientMagicLength );
5675
5676 err = crypto_box_beforenm( inContext->nmKey, inContext->serverPublicKey, inContext->clientSecretKey );
5677 require_noerr( err, exit );
5678
5679 inContext->certPtr = NULL;
5680 inContext->certLen = 0;
5681 inContext->msgLen = 0;
5682
5683 exit:
5684 return( err );
5685 }
5686
5687 //===========================================================================================================================
5688 // DNSCryptBuildQuery
5689 //===========================================================================================================================
5690
5691 static OSStatus DNSCryptPadQuery( uint8_t *inMsgPtr, size_t inMsgLen, size_t inMaxLen, size_t *outPaddedLen );
5692
5693 static OSStatus DNSCryptBuildQuery( DNSCryptContext *inContext )
5694 {
5695 OSStatus err;
5696 DNSCryptQueryHeader * const hdr = (DNSCryptQueryHeader *) inContext->msgBuf;
5697 uint8_t * const queryPtr = (uint8_t *)( hdr + 1 );
5698 size_t queryLen;
5699 size_t paddedQueryLen;
5700 const uint8_t * const msgLimit = inContext->msgBuf + sizeof( inContext->msgBuf );
5701 const uint8_t * padLimit;
5702 uint8_t nonce[ crypto_box_NONCEBYTES ];
5703
5704 check_compile_time_code( sizeof( inContext->msgBuf ) >= ( sizeof( DNSCryptQueryHeader ) + kDNSQueryMessageMaxLen ) );
5705
5706 inContext->queryID = (uint16_t) Random32();
5707 err = WriteDNSQueryMessage( queryPtr, inContext->queryID, kDNSHeaderFlag_RecursionDesired, inContext->qname,
5708 inContext->qtype, kDNSServiceClass_IN, &queryLen );
5709 require_noerr( err, exit );
5710
5711 padLimit = &queryPtr[ queryLen + kDNSCryptMaxPadLength ];
5712 if( padLimit > msgLimit ) padLimit = msgLimit;
5713
5714 err = DNSCryptPadQuery( queryPtr, queryLen, (size_t)( padLimit - queryPtr ), &paddedQueryLen );
5715 require_noerr( err, exit );
5716
5717 memset( queryPtr - crypto_box_ZEROBYTES, 0, crypto_box_ZEROBYTES );
5718 RandomBytes( inContext->clientNonce, kDNSCryptHalfNonceLength );
5719 memcpy( nonce, inContext->clientNonce, kDNSCryptHalfNonceLength );
5720 memset( &nonce[ kDNSCryptHalfNonceLength ], 0, kDNSCryptHalfNonceLength );
5721
5722 err = crypto_box_afternm( queryPtr - crypto_box_ZEROBYTES, queryPtr - crypto_box_ZEROBYTES,
5723 paddedQueryLen + crypto_box_ZEROBYTES, nonce, inContext->nmKey );
5724 require_noerr( err, exit );
5725
5726 memcpy( hdr->clientMagic, inContext->clientMagic, kDNSCryptClientMagicLength );
5727 memcpy( hdr->clientPublicKey, inContext->clientPublicKey, crypto_box_PUBLICKEYBYTES );
5728 memcpy( hdr->clientNonce, nonce, kDNSCryptHalfNonceLength );
5729
5730 inContext->msgLen = (size_t)( &queryPtr[ paddedQueryLen ] - inContext->msgBuf );
5731
5732 exit:
5733 return( err );
5734 }
5735
5736 static OSStatus DNSCryptPadQuery( uint8_t *inMsgPtr, size_t inMsgLen, size_t inMaxLen, size_t *outPaddedLen )
5737 {
5738 OSStatus err;
5739 size_t paddedLen;
5740
5741 require_action_quiet( ( inMsgLen + kDNSCryptMinPadLength ) <= inMaxLen, exit, err = kSizeErr );
5742
5743 paddedLen = inMsgLen + kDNSCryptMinPadLength +
5744 arc4random_uniform( (uint32_t)( inMaxLen - ( inMsgLen + kDNSCryptMinPadLength ) + 1 ) );
5745 paddedLen += ( kDNSCryptBlockSize - ( paddedLen % kDNSCryptBlockSize ) );
5746 if( paddedLen > inMaxLen ) paddedLen = inMaxLen;
5747
5748 inMsgPtr[ inMsgLen ] = 0x80;
5749 memset( &inMsgPtr[ inMsgLen + 1 ], 0, paddedLen - ( inMsgLen + 1 ) );
5750
5751 if( outPaddedLen ) *outPaddedLen = paddedLen;
5752 err = kNoErr;
5753
5754 exit:
5755 return( err );
5756 }
5757
5758 //===========================================================================================================================
5759 // DNSCryptSendQuery
5760 //===========================================================================================================================
5761
5762 static OSStatus DNSCryptSendQuery( DNSCryptContext *inContext )
5763 {
5764 OSStatus err;
5765 SocketContext * sockContext;
5766 SocketRef sock = kInvalidSocketRef;
5767
5768 check( inContext->msgLen > 0 );
5769 check( !inContext->readSource );
5770
5771 err = UDPClientSocketOpen( AF_UNSPEC, &inContext->serverAddr, 0, -1, NULL, &sock );
5772 require_noerr( err, exit );
5773
5774 inContext->sendTicks = UpTicks();
5775 err = SocketWriteAll( sock, inContext->msgBuf, inContext->msgLen, 5 );
5776 require_noerr( err, exit );
5777
5778 sockContext = (SocketContext *) calloc( 1, sizeof( *sockContext ) );
5779 require_action( sockContext, exit, err = kNoMemoryErr );
5780
5781 err = DispatchReadSourceCreate( sock, DNSCryptReceiveResponseHandler, SocketContextCancelHandler, sockContext,
5782 &inContext->readSource );
5783 if( err ) ForgetMem( &sockContext );
5784 require_noerr( err, exit );
5785
5786 sockContext->context = inContext;
5787 sockContext->sock = sock;
5788 sock = kInvalidSocketRef;
5789
5790 dispatch_resume( inContext->readSource );
5791
5792 exit:
5793 ForgetSocket( &sock );
5794 return( err );
5795 }
5796
5797 //===========================================================================================================================
5798 // DNSCryptPrintCertificate
5799 //===========================================================================================================================
5800
5801 #define kCertTimeStrBufLen 32
5802
5803 static char * CertTimeStr( time_t inTime, char inBuffer[ kCertTimeStrBufLen ] );
5804
5805 static void DNSCryptPrintCertificate( const DNSCryptCert *inCert, size_t inLen )
5806 {
5807 time_t startTime, endTime;
5808 int extLen;
5809 char timeBuf[ kCertTimeStrBufLen ];
5810
5811 check( inLen >= kDNSCryptCertMinimumLength );
5812
5813 startTime = (time_t) ReadBig32( inCert->startTime );
5814 endTime = (time_t) ReadBig32( inCert->endTime );
5815
5816 FPrintF( stdout, "DNSCrypt certificate (%zu bytes):\n", inLen );
5817 FPrintF( stdout, "Cert Magic: %#H\n", inCert->certMagic, kDNSCryptCertMagicLength, INT_MAX );
5818 FPrintF( stdout, "ES Version: %u\n", ReadBig16( inCert->esVersion ) );
5819 FPrintF( stdout, "Minor Version: %u\n", ReadBig16( inCert->minorVersion ) );
5820 FPrintF( stdout, "Signature: %H\n", inCert->signature, crypto_sign_BYTES / 2, INT_MAX );
5821 FPrintF( stdout, " %H\n", &inCert->signature[ crypto_sign_BYTES / 2 ], crypto_sign_BYTES / 2, INT_MAX );
5822 FPrintF( stdout, "Public Key: %H\n", inCert->publicKey, sizeof( inCert->publicKey ), INT_MAX );
5823 FPrintF( stdout, "Client Magic: %H\n", inCert->clientMagic, kDNSCryptClientMagicLength, INT_MAX );
5824 FPrintF( stdout, "Serial: %u\n", ReadBig32( inCert->serial ) );
5825 FPrintF( stdout, "Start Time: %u (%s)\n", (uint32_t) startTime, CertTimeStr( startTime, timeBuf ) );
5826 FPrintF( stdout, "End Time: %u (%s)\n", (uint32_t) endTime, CertTimeStr( endTime, timeBuf ) );
5827
5828 if( inLen > kDNSCryptCertMinimumLength )
5829 {
5830 extLen = (int)( inLen - kDNSCryptCertMinimumLength );
5831 FPrintF( stdout, "Extensions: %.1H\n", inCert->extensions, extLen, extLen );
5832 }
5833 FPrintF( stdout, "\n" );
5834 }
5835
5836 static char * CertTimeStr( time_t inTime, char inBuffer[ kCertTimeStrBufLen ] )
5837 {
5838 struct tm * tm;
5839
5840 tm = localtime( &inTime );
5841 if( !tm )
5842 {
5843 dlogassert( "localtime() returned a NULL pointer.\n" );
5844 *inBuffer = '\0';
5845 }
5846 else
5847 {
5848 strftime( inBuffer, kCertTimeStrBufLen, "%a %b %d %H:%M:%S %Z %Y", tm );
5849 }
5850
5851 return( inBuffer );
5852 }
5853
5854 #endif // DNSSDUTIL_INCLUDE_DNSCRYPT
5855
5856 //===========================================================================================================================
5857 // MDNSQueryCmd
5858 //===========================================================================================================================
5859
5860 #define kMDNSPort 5353
5861
5862 #define kDefaultMDNSMessageID 0
5863 #define kDefaultMDNSQueryFlags 0
5864
5865 typedef struct
5866 {
5867 const char * qnameStr; // Name (QNAME) of the record being queried as a C string.
5868 dispatch_source_t readSourceV4; // Read dispatch source for IPv4 socket.
5869 dispatch_source_t readSourceV6; // Read dispatch source for IPv6 socket.
5870 int localPort; // The port number to which the sockets are bound.
5871 int receiveSecs; // After send, the amount of time to spend receiving.
5872 uint32_t ifIndex; // Index of the interface over which to send the query.
5873 uint16_t qtype; // The type (QTYPE) of the record being queried.
5874 Boolean isQU; // True if the query is QU, i.e., requests unicast responses.
5875 Boolean allResponses; // True if all mDNS messages received should be printed.
5876 Boolean printRawRData; // True if RDATA should be printed as hexdumps.
5877 Boolean useIPv4; // True if the query should be sent via IPv4 multicast.
5878 Boolean useIPv6; // True if the query should be sent via IPv6 multicast.
5879 char ifName[ IF_NAMESIZE + 1 ]; // Name of the interface over which to send the query.
5880 uint8_t qname[ kDomainNameLengthMax ]; // Buffer to hold the QNAME in DNS label format.
5881 uint8_t msgBuf[ 8940 ]; // Message buffer. 8940 is max size used by mDNSResponder.
5882
5883 } MDNSQueryContext;
5884
5885 static void MDNSQueryPrintPrologue( const MDNSQueryContext *inContext );
5886 static void MDNSQueryReadHandler( void *inContext );
5887
5888 static void MDNSQueryCmd( void )
5889 {
5890 OSStatus err;
5891 MDNSQueryContext * context;
5892 struct sockaddr_in mcastAddr4;
5893 struct sockaddr_in6 mcastAddr6;
5894 SocketRef sockV4 = kInvalidSocketRef;
5895 SocketRef sockV6 = kInvalidSocketRef;
5896 ssize_t n;
5897 const char * ifNamePtr;
5898 size_t msgLen;
5899 unsigned int sendCount;
5900
5901 // Check command parameters.
5902
5903 if( gMDNSQuery_ReceiveSecs < -1 )
5904 {
5905 FPrintF( stdout, "Invalid receive time value: %d seconds.\n", gMDNSQuery_ReceiveSecs );
5906 err = kParamErr;
5907 goto exit;
5908 }
5909
5910 context = (MDNSQueryContext *) calloc( 1, sizeof( *context ) );
5911 require_action( context, exit, err = kNoMemoryErr );
5912
5913 context->qnameStr = gMDNSQuery_Name;
5914 context->receiveSecs = gMDNSQuery_ReceiveSecs;
5915 context->isQU = gMDNSQuery_IsQU ? true : false;
5916 context->allResponses = gMDNSQuery_AllResponses ? true : false;
5917 context->printRawRData = gMDNSQuery_RawRData ? true : false;
5918 context->useIPv4 = ( gMDNSQuery_UseIPv4 || !gMDNSQuery_UseIPv6 ) ? true : false;
5919 context->useIPv6 = ( gMDNSQuery_UseIPv6 || !gMDNSQuery_UseIPv4 ) ? true : false;
5920
5921 err = InterfaceIndexFromArgString( gInterface, &context->ifIndex );
5922 require_noerr_quiet( err, exit );
5923
5924 ifNamePtr = if_indextoname( context->ifIndex, context->ifName );
5925 require_action( ifNamePtr, exit, err = kNameErr );
5926
5927 err = RecordTypeFromArgString( gMDNSQuery_Type, &context->qtype );
5928 require_noerr( err, exit );
5929
5930 // Set up IPv4 socket.
5931
5932 if( context->useIPv4 )
5933 {
5934 err = ServerSocketOpen( AF_INET, SOCK_DGRAM, IPPROTO_UDP,
5935 gMDNSQuery_SourcePort ? gMDNSQuery_SourcePort : ( context->isQU ? context->localPort : kMDNSPort ),
5936 &context->localPort, kSocketBufferSize_DontSet, &sockV4 );
5937 require_noerr( err, exit );
5938
5939 err = SocketSetMulticastInterface( sockV4, ifNamePtr, context->ifIndex );
5940 require_noerr( err, exit );
5941
5942 err = setsockopt( sockV4, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &(uint8_t){ 1 }, (socklen_t) sizeof( uint8_t ) );
5943 err = map_socket_noerr_errno( sockV4, err );
5944 require_noerr( err, exit );
5945
5946 memset( &mcastAddr4, 0, sizeof( mcastAddr4 ) );
5947 SIN_LEN_SET( &mcastAddr4 );
5948 mcastAddr4.sin_family = AF_INET;
5949 mcastAddr4.sin_port = htons( kMDNSPort );
5950 mcastAddr4.sin_addr.s_addr = htonl( 0xE00000FB ); // The mDNS IPv4 multicast address is 224.0.0.251
5951
5952 if( !context->isQU && ( context->localPort == kMDNSPort ) )
5953 {
5954 err = SocketJoinMulticast( sockV4, &mcastAddr4, ifNamePtr, context->ifIndex );
5955 require_noerr( err, exit );
5956 }
5957 }
5958
5959 // Set up IPv6 socket.
5960
5961 if( context->useIPv6 )
5962 {
5963 err = ServerSocketOpen( AF_INET6, SOCK_DGRAM, IPPROTO_UDP,
5964 gMDNSQuery_SourcePort ? gMDNSQuery_SourcePort : ( context->isQU ? context->localPort : kMDNSPort ),
5965 &context->localPort, kSocketBufferSize_DontSet, &sockV6 );
5966 require_noerr( err, exit );
5967
5968 err = SocketSetMulticastInterface( sockV6, ifNamePtr, context->ifIndex );
5969 require_noerr( err, exit );
5970
5971 err = setsockopt( sockV6, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &(int){ 1 }, (socklen_t) sizeof( int ) );
5972 err = map_socket_noerr_errno( sockV6, err );
5973 require_noerr( err, exit );
5974
5975 memset( &mcastAddr6, 0, sizeof( mcastAddr6 ) );
5976 SIN6_LEN_SET( &mcastAddr6 );
5977 mcastAddr6.sin6_family = AF_INET6;
5978 mcastAddr6.sin6_port = htons( kMDNSPort );
5979 mcastAddr6.sin6_addr.s6_addr[ 0 ] = 0xFF; // mDNS IPv6 multicast address FF02::FB
5980 mcastAddr6.sin6_addr.s6_addr[ 1 ] = 0x02;
5981 mcastAddr6.sin6_addr.s6_addr[ 15 ] = 0xFB;
5982
5983 if( !context->isQU && ( context->localPort == kMDNSPort ) )
5984 {
5985 err = SocketJoinMulticast( sockV6, &mcastAddr6, ifNamePtr, context->ifIndex );
5986 require_noerr( err, exit );
5987 }
5988 }
5989
5990 // Craft mDNS query message.
5991
5992 check_compile_time_code( sizeof( context->msgBuf ) >= kDNSQueryMessageMaxLen );
5993 err = WriteDNSQueryMessage( context->msgBuf, kDefaultMDNSMessageID, kDefaultMDNSQueryFlags, context->qnameStr,
5994 context->qtype, context->isQU ? ( kDNSServiceClass_IN | kQClassUnicastResponseBit ) : kDNSServiceClass_IN, &msgLen );
5995 require_noerr( err, exit );
5996
5997 // Print prologue.
5998
5999 MDNSQueryPrintPrologue( context );
6000
6001 // Send mDNS query message.
6002
6003 sendCount = 0;
6004 if( IsValidSocket( sockV4 ) )
6005 {
6006 n = sendto( sockV4, context->msgBuf, msgLen, 0, (struct sockaddr *) &mcastAddr4, (socklen_t) sizeof( mcastAddr4 ) );
6007 err = map_socket_value_errno( sockV4, n == (ssize_t) msgLen, n );
6008 if( err )
6009 {
6010 FPrintF( stderr, "*** Failed to send query on IPv4 socket with error %#m\n", err );
6011 ForgetSocket( &sockV4 );
6012 }
6013 else
6014 {
6015 ++sendCount;
6016 }
6017 }
6018 if( IsValidSocket( sockV6 ) )
6019 {
6020 n = sendto( sockV6, context->msgBuf, msgLen, 0, (struct sockaddr *) &mcastAddr6, (socklen_t) sizeof( mcastAddr6 ) );
6021 err = map_socket_value_errno( sockV6, n == (ssize_t) msgLen, n );
6022 if( err )
6023 {
6024 FPrintF( stderr, "*** Failed to send query on IPv6 socket with error %#m\n", err );
6025 ForgetSocket( &sockV6 );
6026 }
6027 else
6028 {
6029 ++sendCount;
6030 }
6031 }
6032 require_action_quiet( sendCount > 0, exit, err = kUnexpectedErr );
6033
6034 // If there's no wait period after the send, then exit.
6035
6036 if( context->receiveSecs == 0 ) goto exit;
6037
6038 // Create dispatch read sources for socket(s).
6039
6040 if( IsValidSocket( sockV4 ) )
6041 {
6042 SocketContext * sockContext;
6043
6044 sockContext = (SocketContext *) calloc( 1, sizeof( *sockContext ) );
6045 require_action( sockContext, exit, err = kNoMemoryErr );
6046
6047 err = DispatchReadSourceCreate( sockV4, MDNSQueryReadHandler, SocketContextCancelHandler, sockContext,
6048 &context->readSourceV4 );
6049 if( err ) ForgetMem( &sockContext );
6050 require_noerr( err, exit );
6051
6052 sockContext->context = context;
6053 sockContext->sock = sockV4;
6054 sockV4 = kInvalidSocketRef;
6055 dispatch_resume( context->readSourceV4 );
6056 }
6057
6058 if( IsValidSocket( sockV6 ) )
6059 {
6060 SocketContext * sockContext;
6061
6062 sockContext = (SocketContext *) calloc( 1, sizeof( *sockContext ) );
6063 require_action( sockContext, exit, err = kNoMemoryErr );
6064
6065 err = DispatchReadSourceCreate( sockV6, MDNSQueryReadHandler, SocketContextCancelHandler, sockContext,
6066 &context->readSourceV6 );
6067 if( err ) ForgetMem( &sockContext );
6068 require_noerr( err, exit );
6069
6070 sockContext->context = context;
6071 sockContext->sock = sockV6;
6072 sockV6 = kInvalidSocketRef;
6073 dispatch_resume( context->readSourceV6 );
6074 }
6075
6076 if( context->receiveSecs > 0 )
6077 {
6078 dispatch_after_f( dispatch_time_seconds( context->receiveSecs ), dispatch_get_main_queue(), kExitReason_Timeout,
6079 Exit );
6080 }
6081 dispatch_main();
6082
6083 exit:
6084 ForgetSocket( &sockV4 );
6085 ForgetSocket( &sockV6 );
6086 if( err ) exit( 1 );
6087 }
6088
6089 //===========================================================================================================================
6090 // MDNSQueryPrintPrologue
6091 //===========================================================================================================================
6092
6093 static void MDNSQueryPrintPrologue( const MDNSQueryContext *inContext )
6094 {
6095 const int receiveSecs = inContext->receiveSecs;
6096 char time[ kTimestampBufLen ];
6097
6098 FPrintF( stdout, "Interface: %d (%s)\n", (int32_t) inContext->ifIndex, inContext->ifName );
6099 FPrintF( stdout, "Name: %s\n", inContext->qnameStr );
6100 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( inContext->qtype ), inContext->qtype );
6101 FPrintF( stdout, "Class: IN (%s)\n", inContext->isQU ? "QU" : "QM" );
6102 FPrintF( stdout, "Local port: %d\n", inContext->localPort );
6103 FPrintF( stdout, "IP protocols: %?s%?s%?s\n",
6104 inContext->useIPv4, "IPv4", ( inContext->useIPv4 && inContext->useIPv6 ), ", ", inContext->useIPv6, "IPv6" );
6105 FPrintF( stdout, "Receive duration: " );
6106 if( receiveSecs >= 0 ) FPrintF( stdout, "%d second%?c\n", receiveSecs, receiveSecs != 1, 's' );
6107 else FPrintF( stdout, "∞\n" );
6108 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
6109 }
6110
6111 //===========================================================================================================================
6112 // MDNSQueryReadHandler
6113 //===========================================================================================================================
6114
6115 static void MDNSQueryReadHandler( void *inContext )
6116 {
6117 OSStatus err;
6118 SocketContext * const sockContext = (SocketContext *) inContext;
6119 MDNSQueryContext * const context = (MDNSQueryContext *) sockContext->context;
6120 size_t msgLen;
6121 sockaddr_ip fromAddr;
6122 char time[ kTimestampBufLen ];
6123 Boolean foundAnswer = false;
6124
6125 GetTimestampStr( time );
6126
6127 err = SocketRecvFrom( sockContext->sock, context->msgBuf, sizeof( context->msgBuf ), &msgLen, &fromAddr,
6128 sizeof( fromAddr ), NULL, NULL, NULL, NULL );
6129 require_noerr( err, exit );
6130
6131 if( !context->allResponses && ( msgLen >= kDNSHeaderLength ) )
6132 {
6133 const uint8_t * ptr;
6134 const DNSHeader * const hdr = (DNSHeader *) context->msgBuf;
6135 unsigned int rrCount, i;
6136 uint16_t type, class;
6137 uint8_t name[ kDomainNameLengthMax ];
6138
6139 err = DNSMessageGetAnswerSection( context->msgBuf, msgLen, &ptr );
6140 require_noerr( err, exit );
6141
6142 if( context->qname[ 0 ] == 0 )
6143 {
6144 err = DomainNameAppendString( context->qname, context->qnameStr, NULL );
6145 require_noerr( err, exit );
6146 }
6147
6148 rrCount = DNSHeaderGetAnswerCount( hdr ) + DNSHeaderGetAuthorityCount( hdr ) + DNSHeaderGetAdditionalCount( hdr );
6149 for( i = 0; i < rrCount; ++i )
6150 {
6151 err = DNSMessageExtractRecord( context->msgBuf, msgLen, ptr, name, &type, &class, NULL, NULL, NULL, &ptr );
6152 require_noerr( err, exit );
6153
6154 if( ( ( context->qtype == kDNSServiceType_ANY ) || ( type == context->qtype ) ) &&
6155 DomainNameEqual( name, context->qname ) )
6156 {
6157 foundAnswer = true;
6158 break;
6159 }
6160 }
6161 }
6162 if( context->allResponses || foundAnswer )
6163 {
6164 FPrintF( stdout, "---\n" );
6165 FPrintF( stdout, "Receive time: %s\n", time );
6166 FPrintF( stdout, "Source: %##a\n", &fromAddr );
6167 FPrintF( stdout, "Message size: %zu\n\n", msgLen );
6168
6169 PrintMDNSMessage( context->msgBuf, msgLen, context->printRawRData );
6170 }
6171
6172 exit:
6173 if( err ) exit( 1 );
6174 }
6175
6176 //===========================================================================================================================
6177 // PIDToUUIDCmd
6178 //===========================================================================================================================
6179
6180 static void PIDToUUIDCmd( void )
6181 {
6182 OSStatus err;
6183 int n;
6184 struct proc_uniqidentifierinfo info;
6185
6186 n = proc_pidinfo( gPIDToUUID_PID, PROC_PIDUNIQIDENTIFIERINFO, 1, &info, sizeof( info ) );
6187 require_action_quiet( n == (int) sizeof( info ), exit, err = kUnknownErr );
6188
6189 FPrintF( stdout, "%#U\n", info.p_uuid );
6190 err = kNoErr;
6191
6192 exit:
6193 if( err ) exit( 1 );
6194 }
6195
6196 //===========================================================================================================================
6197 // SSDPDiscoverCmd
6198 //===========================================================================================================================
6199
6200 #define kSSDPPort 1900
6201
6202 typedef struct
6203 {
6204 HTTPHeader header; // HTTP header object for sending and receiving.
6205 dispatch_source_t readSourceV4; // Read dispatch source for IPv4 socket.
6206 dispatch_source_t readSourceV6; // Read dispatch source for IPv6 socket.
6207 int receiveSecs; // After send, the amount of time to spend receiving.
6208 uint32_t ifindex; // Index of the interface over which to send the query.
6209 Boolean useIPv4; // True if the query should be sent via IPv4 multicast.
6210 Boolean useIPv6; // True if the query should be sent via IPv6 multicast.
6211
6212 } SSDPDiscoverContext;
6213
6214 static void SSDPDiscoverPrintPrologue( const SSDPDiscoverContext *inContext );
6215 static void SSDPDiscoverReadHandler( void *inContext );
6216 static int SocketToPortNumber( SocketRef inSock );
6217 static OSStatus WriteSSDPSearchRequest( HTTPHeader *inHeader, const void *inHostSA, int inMX, const char *inST );
6218
6219 static void SSDPDiscoverCmd( void )
6220 {
6221 OSStatus err;
6222 SSDPDiscoverContext * context;
6223 dispatch_source_t signalSource = NULL;
6224 SocketRef sockV4 = kInvalidSocketRef;
6225 SocketRef sockV6 = kInvalidSocketRef;
6226 ssize_t n;
6227 int sendCount;
6228 char time[ kTimestampBufLen ];
6229
6230 // Set up SIGINT handler.
6231
6232 signal( SIGINT, SIG_IGN );
6233 err = DispatchSignalSourceCreate( SIGINT, Exit, kExitReason_SIGINT, &signalSource );
6234 require_noerr( err, exit );
6235 dispatch_resume( signalSource );
6236
6237 // Check command parameters.
6238
6239 if( gSSDPDiscover_ReceiveSecs < -1 )
6240 {
6241 FPrintF( stdout, "Invalid receive time: %d seconds.\n", gSSDPDiscover_ReceiveSecs );
6242 err = kParamErr;
6243 goto exit;
6244 }
6245
6246 // Create context.
6247
6248 context = (SSDPDiscoverContext *) calloc( 1, sizeof( *context ) );
6249 require_action( context, exit, err = kNoMemoryErr );
6250
6251 context->receiveSecs = gSSDPDiscover_ReceiveSecs;
6252 context->useIPv4 = ( gSSDPDiscover_UseIPv4 || !gSSDPDiscover_UseIPv6 ) ? true : false;
6253 context->useIPv6 = ( gSSDPDiscover_UseIPv6 || !gSSDPDiscover_UseIPv4 ) ? true : false;
6254
6255 err = InterfaceIndexFromArgString( gInterface, &context->ifindex );
6256 require_noerr_quiet( err, exit );
6257
6258 // Set up IPv4 socket.
6259
6260 if( context->useIPv4 )
6261 {
6262 int port;
6263 err = UDPClientSocketOpen( AF_INET, NULL, 0, -1, &port, &sockV4 );
6264 require_noerr( err, exit );
6265
6266 err = SocketSetMulticastInterface( sockV4, NULL, context->ifindex );
6267 require_noerr( err, exit );
6268
6269 err = setsockopt( sockV4, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &(uint8_t){ 1 }, (socklen_t) sizeof( uint8_t ) );
6270 err = map_socket_noerr_errno( sockV4, err );
6271 require_noerr( err, exit );
6272 }
6273
6274 // Set up IPv6 socket.
6275
6276 if( context->useIPv6 )
6277 {
6278 err = UDPClientSocketOpen( AF_INET6, NULL, 0, -1, NULL, &sockV6 );
6279 require_noerr( err, exit );
6280
6281 err = SocketSetMulticastInterface( sockV6, NULL, context->ifindex );
6282 require_noerr( err, exit );
6283
6284 err = setsockopt( sockV6, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &(int){ 1 }, (socklen_t) sizeof( int ) );
6285 err = map_socket_noerr_errno( sockV6, err );
6286 require_noerr( err, exit );
6287 }
6288
6289 // Print prologue.
6290
6291 SSDPDiscoverPrintPrologue( context );
6292
6293 // Send mDNS query message.
6294
6295 sendCount = 0;
6296 if( IsValidSocket( sockV4 ) )
6297 {
6298 struct sockaddr_in mcastAddr4;
6299
6300 memset( &mcastAddr4, 0, sizeof( mcastAddr4 ) );
6301 SIN_LEN_SET( &mcastAddr4 );
6302 mcastAddr4.sin_family = AF_INET;
6303 mcastAddr4.sin_port = htons( kSSDPPort );
6304 mcastAddr4.sin_addr.s_addr = htonl( 0xEFFFFFFA ); // 239.255.255.250
6305
6306 err = WriteSSDPSearchRequest( &context->header, &mcastAddr4, gSSDPDiscover_MX, gSSDPDiscover_ST );
6307 require_noerr( err, exit );
6308
6309 n = sendto( sockV4, context->header.buf, context->header.len, 0, (const struct sockaddr *) &mcastAddr4,
6310 (socklen_t) sizeof( mcastAddr4 ) );
6311 err = map_socket_value_errno( sockV4, n == (ssize_t) context->header.len, n );
6312 if( err )
6313 {
6314 FPrintF( stderr, "*** Failed to send query on IPv4 socket with error %#m\n", err );
6315 ForgetSocket( &sockV4 );
6316 }
6317 else
6318 {
6319 if( gSSDPDiscover_Verbose )
6320 {
6321 GetTimestampStr( time );
6322 FPrintF( stdout, "---\n" );
6323 FPrintF( stdout, "Send time: %s\n", time );
6324 FPrintF( stdout, "Source Port: %d\n", SocketToPortNumber( sockV4 ) );
6325 FPrintF( stdout, "Destination: %##a\n", &mcastAddr4 );
6326 FPrintF( stdout, "Message size: %zu\n", context->header.len );
6327 FPrintF( stdout, "HTTP header:\n%1{text}", context->header.buf, context->header.len );
6328 }
6329 ++sendCount;
6330 }
6331 }
6332
6333 if( IsValidSocket( sockV6 ) )
6334 {
6335 struct sockaddr_in6 mcastAddr6;
6336
6337 memset( &mcastAddr6, 0, sizeof( mcastAddr6 ) );
6338 SIN6_LEN_SET( &mcastAddr6 );
6339 mcastAddr6.sin6_family = AF_INET6;
6340 mcastAddr6.sin6_port = htons( kSSDPPort );
6341 mcastAddr6.sin6_addr.s6_addr[ 0 ] = 0xFF; // SSDP IPv6 link-local multicast address FF02::C
6342 mcastAddr6.sin6_addr.s6_addr[ 1 ] = 0x02;
6343 mcastAddr6.sin6_addr.s6_addr[ 15 ] = 0x0C;
6344
6345 err = WriteSSDPSearchRequest( &context->header, &mcastAddr6, gSSDPDiscover_MX, gSSDPDiscover_ST );
6346 require_noerr( err, exit );
6347
6348 n = sendto( sockV6, context->header.buf, context->header.len, 0, (const struct sockaddr *) &mcastAddr6,
6349 (socklen_t) sizeof( mcastAddr6 ) );
6350 err = map_socket_value_errno( sockV6, n == (ssize_t) context->header.len, n );
6351 if( err )
6352 {
6353 FPrintF( stderr, "*** Failed to send query on IPv6 socket with error %#m\n", err );
6354 ForgetSocket( &sockV6 );
6355 }
6356 else
6357 {
6358 if( gSSDPDiscover_Verbose )
6359 {
6360 GetTimestampStr( time );
6361 FPrintF( stdout, "---\n" );
6362 FPrintF( stdout, "Send time: %s\n", time );
6363 FPrintF( stdout, "Source Port: %d\n", SocketToPortNumber( sockV6 ) );
6364 FPrintF( stdout, "Destination: %##a\n", &mcastAddr6 );
6365 FPrintF( stdout, "Message size: %zu\n", context->header.len );
6366 FPrintF( stdout, "HTTP header:\n%1{text}", context->header.buf, context->header.len );
6367 }
6368 ++sendCount;
6369 }
6370 }
6371 require_action_quiet( sendCount > 0, exit, err = kUnexpectedErr );
6372
6373 // If there's no wait period after the send, then exit.
6374
6375 if( context->receiveSecs == 0 ) goto exit;
6376
6377 // Create dispatch read sources for socket(s).
6378
6379 if( IsValidSocket( sockV4 ) )
6380 {
6381 SocketContext * sockContext;
6382
6383 sockContext = (SocketContext *) calloc( 1, sizeof( *sockContext ) );
6384 require_action( sockContext, exit, err = kNoMemoryErr );
6385
6386 err = DispatchReadSourceCreate( sockV4, SSDPDiscoverReadHandler, SocketContextCancelHandler, sockContext,
6387 &context->readSourceV4 );
6388 if( err ) ForgetMem( &sockContext );
6389 require_noerr( err, exit );
6390
6391 sockContext->context = context;
6392 sockContext->sock = sockV4;
6393 sockV4 = kInvalidSocketRef;
6394 dispatch_resume( context->readSourceV4 );
6395 }
6396
6397 if( IsValidSocket( sockV6 ) )
6398 {
6399 SocketContext * sockContext;
6400
6401 sockContext = (SocketContext *) calloc( 1, sizeof( *sockContext ) );
6402 require_action( sockContext, exit, err = kNoMemoryErr );
6403
6404 err = DispatchReadSourceCreate( sockV6, SSDPDiscoverReadHandler, SocketContextCancelHandler, sockContext,
6405 &context->readSourceV6 );
6406 if( err ) ForgetMem( &sockContext );
6407 require_noerr( err, exit );
6408
6409 sockContext->context = context;
6410 sockContext->sock = sockV6;
6411 sockV6 = kInvalidSocketRef;
6412 dispatch_resume( context->readSourceV6 );
6413 }
6414
6415 if( context->receiveSecs > 0 )
6416 {
6417 dispatch_after_f( dispatch_time_seconds( context->receiveSecs ), dispatch_get_main_queue(), kExitReason_Timeout,
6418 Exit );
6419 }
6420 dispatch_main();
6421
6422 exit:
6423 ForgetSocket( &sockV4 );
6424 ForgetSocket( &sockV6 );
6425 dispatch_source_forget( &signalSource );
6426 if( err ) exit( 1 );
6427 }
6428
6429 static int SocketToPortNumber( SocketRef inSock )
6430 {
6431 OSStatus err;
6432 sockaddr_ip sip;
6433 socklen_t len;
6434
6435 len = (socklen_t) sizeof( sip );
6436 err = getsockname( inSock, &sip.sa, &len );
6437 err = map_socket_noerr_errno( inSock, err );
6438 check_noerr( err );
6439 return( err ? -1 : SockAddrGetPort( &sip ) );
6440 }
6441
6442 static OSStatus WriteSSDPSearchRequest( HTTPHeader *inHeader, const void *inHostSA, int inMX, const char *inST )
6443 {
6444 OSStatus err;
6445
6446 err = HTTPHeader_InitRequest( inHeader, "M-SEARCH", "*", "HTTP/1.1" );
6447 require_noerr( err, exit );
6448
6449 err = HTTPHeader_SetField( inHeader, "Host", "%##a", inHostSA );
6450 require_noerr( err, exit );
6451
6452 err = HTTPHeader_SetField( inHeader, "ST", "%s", inST ? inST : "ssdp:all" );
6453 require_noerr( err, exit );
6454
6455 err = HTTPHeader_SetField( inHeader, "Man", "\"ssdp:discover\"" );
6456 require_noerr( err, exit );
6457
6458 err = HTTPHeader_SetField( inHeader, "MX", "%d", inMX );
6459 require_noerr( err, exit );
6460
6461 err = HTTPHeader_Commit( inHeader );
6462 require_noerr( err, exit );
6463
6464 exit:
6465 return( err );
6466 }
6467
6468 //===========================================================================================================================
6469 // SSDPDiscoverPrintPrologue
6470 //===========================================================================================================================
6471
6472 static void SSDPDiscoverPrintPrologue( const SSDPDiscoverContext *inContext )
6473 {
6474 const int receiveSecs = inContext->receiveSecs;
6475 const char * ifName;
6476 char ifNameBuf[ IF_NAMESIZE + 1 ];
6477 NetTransportType ifType;
6478 char time[ kTimestampBufLen ];
6479
6480 ifName = if_indextoname( inContext->ifindex, ifNameBuf );
6481
6482 ifType = kNetTransportType_Undefined;
6483 if( ifName ) SocketGetInterfaceInfo( kInvalidSocketRef, ifName, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &ifType );
6484
6485 FPrintF( stdout, "Interface: %s/%d/%s\n",
6486 ifName ? ifName : "?", inContext->ifindex, NetTransportTypeToString( ifType ) );
6487 FPrintF( stdout, "IP protocols: %?s%?s%?s\n",
6488 inContext->useIPv4, "IPv4", ( inContext->useIPv4 && inContext->useIPv6 ), ", ", inContext->useIPv6, "IPv6" );
6489 FPrintF( stdout, "Receive duration: " );
6490 if( receiveSecs >= 0 ) FPrintF( stdout, "%d second%?c\n", receiveSecs, receiveSecs != 1, 's' );
6491 else FPrintF( stdout, "∞\n" );
6492 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
6493 }
6494
6495 //===========================================================================================================================
6496 // SSDPDiscoverReadHandler
6497 //===========================================================================================================================
6498
6499 static void SSDPDiscoverReadHandler( void *inContext )
6500 {
6501 OSStatus err;
6502 SocketContext * const sockContext = (SocketContext *) inContext;
6503 SSDPDiscoverContext * const context = (SSDPDiscoverContext *) sockContext->context;
6504 HTTPHeader * const header = &context->header;
6505 sockaddr_ip fromAddr;
6506 size_t msgLen;
6507 char time[ kTimestampBufLen ];
6508
6509 GetTimestampStr( time );
6510
6511 err = SocketRecvFrom( sockContext->sock, header->buf, sizeof( header->buf ), &msgLen, &fromAddr, sizeof( fromAddr ),
6512 NULL, NULL, NULL, NULL );
6513 require_noerr( err, exit );
6514
6515 FPrintF( stdout, "---\n" );
6516 FPrintF( stdout, "Receive time: %s\n", time );
6517 FPrintF( stdout, "Source: %##a\n", &fromAddr );
6518 FPrintF( stdout, "Message size: %zu\n", msgLen );
6519 header->len = msgLen;
6520 if( HTTPHeader_Validate( header ) )
6521 {
6522 FPrintF( stdout, "HTTP header:\n%1{text}", header->buf, header->len );
6523 if( header->extraDataLen > 0 )
6524 {
6525 FPrintF( stdout, "HTTP body: %1.1H", header->extraDataPtr, (int) header->extraDataLen, INT_MAX );
6526 }
6527 }
6528 else
6529 {
6530 FPrintF( stdout, "Invalid HTTP message:\n%1.1H", header->buf, (int) msgLen, INT_MAX );
6531 goto exit;
6532 }
6533
6534 exit:
6535 if( err ) exit( 1 );
6536 }
6537
6538 //===========================================================================================================================
6539 // HTTPHeader_Validate
6540 //
6541 // Parses for the end of an HTTP header and updates the HTTPHeader structure so it's ready to parse. Returns true if valid.
6542 // This assumes the "buf" and "len" fields are set. The other fields are set by this function.
6543 //
6544 // Note: This was copied from CoreUtils because the HTTPHeader_Validate function is currently not exported in the framework.
6545 //===========================================================================================================================
6546
6547 Boolean HTTPHeader_Validate( HTTPHeader *inHeader )
6548 {
6549 const char * src;
6550 const char * end;
6551
6552 // Check for interleaved binary data (4 byte header that begins with $). See RFC 2326 section 10.12.
6553
6554 require( inHeader->len < sizeof( inHeader->buf ), exit );
6555 src = inHeader->buf;
6556 end = src + inHeader->len;
6557 if( ( ( end - src ) >= 4 ) && ( src[ 0 ] == '$' ) )
6558 {
6559 src += 4;
6560 }
6561 else
6562 {
6563 // Search for an empty line (HTTP-style header/body separator). CRLFCRLF, LFCRLF, or LFLF accepted.
6564 // $$$ TO DO: Start from the last search location to avoid re-searching the same data over and over.
6565
6566 for( ;; )
6567 {
6568 while( ( src < end ) && ( src[ 0 ] != '\n' ) ) ++src;
6569 if( src >= end ) goto exit;
6570 ++src;
6571 if( ( ( end - src ) >= 2 ) && ( src[ 0 ] == '\r' ) && ( src[ 1 ] == '\n' ) ) // CFLFCRLF or LFCRLF
6572 {
6573 src += 2;
6574 break;
6575 }
6576 else if( ( ( end - src ) >= 1 ) && ( src[ 0 ] == '\n' ) ) // LFLF
6577 {
6578 src += 1;
6579 break;
6580 }
6581 }
6582 }
6583 inHeader->extraDataPtr = src;
6584 inHeader->extraDataLen = (size_t)( end - src );
6585 inHeader->len = (size_t)( src - inHeader->buf );
6586 return( true );
6587
6588 exit:
6589 return( false );
6590 }
6591
6592 #if( TARGET_OS_DARWIN )
6593 //===========================================================================================================================
6594 // ResQueryCmd
6595 //===========================================================================================================================
6596
6597 // res_query() from libresolv is actually called res_9_query (see /usr/include/resolv.h).
6598
6599 SOFT_LINK_LIBRARY_EX( "/usr/lib", resolv );
6600 SOFT_LINK_FUNCTION_EX( resolv, res_9_query,
6601 int,
6602 ( const char *dname, int class, int type, u_char *answer, int anslen ),
6603 ( dname, class, type, answer, anslen ) );
6604
6605 // res_query() from libinfo
6606
6607 SOFT_LINK_LIBRARY_EX( "/usr/lib", info );
6608 SOFT_LINK_FUNCTION_EX( info, res_query,
6609 int,
6610 ( const char *dname, int class, int type, u_char *answer, int anslen ),
6611 ( dname, class, type, answer, anslen ) );
6612
6613 typedef int ( *res_query_f )( const char *dname, int class, int type, u_char *answer, int anslen );
6614
6615 static void ResQueryCmd( void )
6616 {
6617 OSStatus err;
6618 res_query_f res_query_ptr;
6619 int n;
6620 uint16_t type, class;
6621 char time[ kTimestampBufLen ];
6622 uint8_t answer[ 1024 ];
6623
6624 // Get pointer to one of the res_query() functions.
6625
6626 if( gResQuery_UseLibInfo )
6627 {
6628 if( !SOFT_LINK_HAS_FUNCTION( info, res_query ) )
6629 {
6630 FPrintF( stderr, "Failed to soft link res_query from libinfo.\n" );
6631 err = kNotFoundErr;
6632 goto exit;
6633 }
6634 res_query_ptr = soft_res_query;
6635 }
6636 else
6637 {
6638 if( !SOFT_LINK_HAS_FUNCTION( resolv, res_9_query ) )
6639 {
6640 FPrintF( stderr, "Failed to soft link res_query from libresolv.\n" );
6641 err = kNotFoundErr;
6642 goto exit;
6643 }
6644 res_query_ptr = soft_res_9_query;
6645 }
6646
6647 // Get record type.
6648
6649 err = RecordTypeFromArgString( gResQuery_Type, &type );
6650 require_noerr( err, exit );
6651
6652 // Get record class.
6653
6654 if( gResQuery_Class )
6655 {
6656 err = RecordClassFromArgString( gResQuery_Class, &class );
6657 require_noerr( err, exit );
6658 }
6659 else
6660 {
6661 class = kDNSServiceClass_IN;
6662 }
6663
6664 // Print prologue.
6665
6666 FPrintF( stdout, "Name: %s\n", gResQuery_Name );
6667 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( type ), type );
6668 FPrintF( stdout, "Class: %s (%u)\n", ( class == kDNSServiceClass_IN ) ? "IN" : "???", class );
6669 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
6670 FPrintF( stdout, "---\n" );
6671
6672 // Call res_query().
6673
6674 n = res_query_ptr( gResQuery_Name, class, type, (u_char *) answer, (int) sizeof( answer ) );
6675 if( n < 0 )
6676 {
6677 FPrintF( stderr, "res_query() failed with error: %d (%s).\n", h_errno, hstrerror( h_errno ) );
6678 err = kUnknownErr;
6679 goto exit;
6680 }
6681
6682 // Print result.
6683
6684 FPrintF( stdout, "Message size: %d\n\n", n );
6685 PrintUDNSMessage( answer, (size_t) n, false );
6686
6687 exit:
6688 if( err ) exit( 1 );
6689 }
6690
6691 //===========================================================================================================================
6692 // ResolvDNSQueryCmd
6693 //===========================================================================================================================
6694
6695 // dns_handle_t is defined as a pointer to a privately-defined struct in /usr/include/dns.h. It's defined as a void * here to
6696 // avoid including the header file.
6697
6698 typedef void * dns_handle_t;
6699
6700 SOFT_LINK_FUNCTION_EX( resolv, dns_open, dns_handle_t, ( const char *path ), ( path ) );
6701 SOFT_LINK_FUNCTION_VOID_RETURN_EX( resolv, dns_free, ( dns_handle_t *dns ), ( dns ) );
6702 SOFT_LINK_FUNCTION_EX( resolv, dns_query,
6703 int32_t, (
6704 dns_handle_t dns,
6705 const char * name,
6706 uint32_t dnsclass,
6707 uint32_t dnstype,
6708 char * buf,
6709 uint32_t len,
6710 struct sockaddr * from,
6711 uint32_t * fromlen ),
6712 ( dns, name, dnsclass, dnstype, buf, len, from, fromlen ) );
6713
6714 static void ResolvDNSQueryCmd( void )
6715 {
6716 OSStatus err;
6717 int n;
6718 dns_handle_t dns = NULL;
6719 uint16_t type, class;
6720 sockaddr_ip from;
6721 uint32_t fromLen;
6722 char time[ kTimestampBufLen ];
6723 uint8_t answer[ 1024 ];
6724
6725 // Make sure that the required symbols are available.
6726
6727 if( !SOFT_LINK_HAS_FUNCTION( resolv, dns_open ) )
6728 {
6729 FPrintF( stderr, "Failed to soft link dns_open from libresolv.\n" );
6730 err = kNotFoundErr;
6731 goto exit;
6732 }
6733
6734 if( !SOFT_LINK_HAS_FUNCTION( resolv, dns_free ) )
6735 {
6736 FPrintF( stderr, "Failed to soft link dns_free from libresolv.\n" );
6737 err = kNotFoundErr;
6738 goto exit;
6739 }
6740
6741 if( !SOFT_LINK_HAS_FUNCTION( resolv, dns_query ) )
6742 {
6743 FPrintF( stderr, "Failed to soft link dns_query from libresolv.\n" );
6744 err = kNotFoundErr;
6745 goto exit;
6746 }
6747
6748 // Get record type.
6749
6750 err = RecordTypeFromArgString( gResolvDNSQuery_Type, &type );
6751 require_noerr( err, exit );
6752
6753 // Get record class.
6754
6755 if( gResolvDNSQuery_Class )
6756 {
6757 err = RecordClassFromArgString( gResolvDNSQuery_Class, &class );
6758 require_noerr( err, exit );
6759 }
6760 else
6761 {
6762 class = kDNSServiceClass_IN;
6763 }
6764
6765 // Get dns handle.
6766
6767 dns = soft_dns_open( gResolvDNSQuery_Path );
6768 if( !dns )
6769 {
6770 FPrintF( stderr, "dns_open( %s ) failed.\n", gResolvDNSQuery_Path );
6771 err = kUnknownErr;
6772 goto exit;
6773 }
6774
6775 // Print prologue.
6776
6777 FPrintF( stdout, "Name: %s\n", gResolvDNSQuery_Name );
6778 FPrintF( stdout, "Type: %s (%u)\n", RecordTypeToString( type ), type );
6779 FPrintF( stdout, "Class: %s (%u)\n", ( class == kDNSServiceClass_IN ) ? "IN" : "???", class );
6780 FPrintF( stdout, "Path: %s\n", gResolvDNSQuery_Path ? gResolvDNSQuery_Name : "<NULL>" );
6781 FPrintF( stdout, "Start time: %s\n", GetTimestampStr( time ) );
6782 FPrintF( stdout, "---\n" );
6783
6784 // Call dns_query().
6785
6786 memset( &from, 0, sizeof( from ) );
6787 fromLen = (uint32_t) sizeof( from );
6788 n = soft_dns_query( dns, gResolvDNSQuery_Name, class, type, (char *) answer, (uint32_t) sizeof( answer ), &from.sa,
6789 &fromLen );
6790 if( n < 0 )
6791 {
6792 FPrintF( stderr, "dns_query() failed with error: %d (%s).\n", h_errno, hstrerror( h_errno ) );
6793 err = kUnknownErr;
6794 goto exit;
6795 }
6796
6797 // Print result.
6798
6799 FPrintF( stdout, "From: %##a\n", &from );
6800 FPrintF( stdout, "Message size: %d\n\n", n );
6801 PrintUDNSMessage( answer, (size_t) n, false );
6802
6803 exit:
6804 if( dns ) soft_dns_free( dns );
6805 if( err ) exit( 1 );
6806 }
6807 #endif // TARGET_OS_DARWIN
6808
6809 //===========================================================================================================================
6810 // DaemonVersionCmd
6811 //===========================================================================================================================
6812
6813 static void DaemonVersionCmd( void )
6814 {
6815 OSStatus err;
6816 uint32_t size, version;
6817 char strBuf[ 16 ];
6818
6819 size = (uint32_t) sizeof( version );
6820 err = DNSServiceGetProperty( kDNSServiceProperty_DaemonVersion, &version, &size );
6821 require_noerr( err, exit );
6822
6823 FPrintF( stdout, "Daemon version: %s\n", SourceVersionToCString( version, strBuf ) );
6824
6825 exit:
6826 if( err ) exit( 1 );
6827 }
6828
6829 //===========================================================================================================================
6830 // Exit
6831 //===========================================================================================================================
6832
6833 static void Exit( void *inContext )
6834 {
6835 const char * const reason = (const char *) inContext;
6836 char time[ kTimestampBufLen ];
6837
6838 FPrintF( stdout, "---\n" );
6839 FPrintF( stdout, "End time: %s\n", GetTimestampStr( time ) );
6840 if( reason ) FPrintF( stdout, "End reason: %s\n", reason );
6841 exit( gExitCode );
6842 }
6843
6844 //===========================================================================================================================
6845 // GetTimestampStr
6846 //===========================================================================================================================
6847
6848 static char * GetTimestampStr( char inBuffer[ kTimestampBufLen ] )
6849 {
6850 struct timeval now;
6851 struct tm * tm;
6852 size_t len;
6853
6854 gettimeofday( &now, NULL );
6855 tm = localtime( &now.tv_sec );
6856 require_action( tm, exit, *inBuffer = '\0' );
6857
6858 len = strftime( inBuffer, kTimestampBufLen, "%Y-%m-%d %H:%M:%S", tm );
6859 SNPrintF( &inBuffer[ len ], kTimestampBufLen - len, ".%06u", (unsigned int) now.tv_usec );
6860
6861 exit:
6862 return( inBuffer );
6863 }
6864
6865 //===========================================================================================================================
6866 // GetDNSSDFlagsFromOpts
6867 //===========================================================================================================================
6868
6869 static DNSServiceFlags GetDNSSDFlagsFromOpts( void )
6870 {
6871 DNSServiceFlags flags;
6872
6873 flags = (DNSServiceFlags) gDNSSDFlags;
6874 if( flags & kDNSServiceFlagsShareConnection )
6875 {
6876 FPrintF( stderr, "*** Warning: kDNSServiceFlagsShareConnection (0x%X) is explicitly set in flag parameters.\n",
6877 kDNSServiceFlagsShareConnection );
6878 }
6879
6880 if( gDNSSDFlag_BrowseDomains ) flags |= kDNSServiceFlagsBrowseDomains;
6881 if( gDNSSDFlag_DenyCellular ) flags |= kDNSServiceFlagsDenyCellular;
6882 if( gDNSSDFlag_DenyExpensive ) flags |= kDNSServiceFlagsDenyExpensive;
6883 if( gDNSSDFlag_ForceMulticast ) flags |= kDNSServiceFlagsForceMulticast;
6884 if( gDNSSDFlag_IncludeAWDL ) flags |= kDNSServiceFlagsIncludeAWDL;
6885 if( gDNSSDFlag_NoAutoRename ) flags |= kDNSServiceFlagsNoAutoRename;
6886 if( gDNSSDFlag_PathEvaluationDone ) flags |= kDNSServiceFlagsPathEvaluationDone;
6887 if( gDNSSDFlag_RegistrationDomains ) flags |= kDNSServiceFlagsRegistrationDomains;
6888 if( gDNSSDFlag_ReturnIntermediates ) flags |= kDNSServiceFlagsReturnIntermediates;
6889 if( gDNSSDFlag_Shared ) flags |= kDNSServiceFlagsShared;
6890 if( gDNSSDFlag_SuppressUnusable ) flags |= kDNSServiceFlagsSuppressUnusable;
6891 if( gDNSSDFlag_Timeout ) flags |= kDNSServiceFlagsTimeout;
6892 if( gDNSSDFlag_UnicastResponse ) flags |= kDNSServiceFlagsUnicastResponse;
6893 if( gDNSSDFlag_Unique ) flags |= kDNSServiceFlagsUnique;
6894 if( gDNSSDFlag_WakeOnResolve ) flags |= kDNSServiceFlagsWakeOnResolve;
6895
6896 return( flags );
6897 }
6898
6899 //===========================================================================================================================
6900 // CreateConnectionFromArgString
6901 //===========================================================================================================================
6902
6903 static OSStatus
6904 CreateConnectionFromArgString(
6905 const char * inString,
6906 dispatch_queue_t inQueue,
6907 DNSServiceRef * outSDRef,
6908 ConnectionDesc * outDesc )
6909 {
6910 OSStatus err;
6911 DNSServiceRef sdRef = NULL;
6912 ConnectionType type;
6913 int32_t pid = -1; // Initializing because the analyzer claims pid may be used uninitialized.
6914 uint8_t uuid[ 16 ];
6915
6916 if( strcasecmp( inString, kConnectionArg_Normal ) == 0 )
6917 {
6918 err = DNSServiceCreateConnection( &sdRef );
6919 require_noerr( err, exit );
6920 type = kConnectionType_Normal;
6921 }
6922 else if( stricmp_prefix( inString, kConnectionArgPrefix_PID ) == 0 )
6923 {
6924 const char * const pidStr = inString + sizeof_string( kConnectionArgPrefix_PID );
6925
6926 err = StringToInt32( pidStr, &pid );
6927 if( err )
6928 {
6929 FPrintF( stderr, "Invalid delegate connection PID value: %s\n", pidStr );
6930 err = kParamErr;
6931 goto exit;
6932 }
6933
6934 memset( uuid, 0, sizeof( uuid ) );
6935 err = DNSServiceCreateDelegateConnection( &sdRef, pid, uuid );
6936 if( err )
6937 {
6938 FPrintF( stderr, "DNSServiceCreateDelegateConnection() returned %#m for PID %d\n", err, pid );
6939 goto exit;
6940 }
6941 type = kConnectionType_DelegatePID;
6942 }
6943 else if( stricmp_prefix( inString, kConnectionArgPrefix_UUID ) == 0 )
6944 {
6945 const char * const uuidStr = inString + sizeof_string( kConnectionArgPrefix_UUID );
6946
6947 check_compile_time_code( sizeof( uuid ) == sizeof( uuid_t ) );
6948
6949 err = StringToUUID( uuidStr, kSizeCString, false, uuid );
6950 if( err )
6951 {
6952 FPrintF( stderr, "Invalid delegate connection UUID value: %s\n", uuidStr );
6953 err = kParamErr;
6954 goto exit;
6955 }
6956
6957 err = DNSServiceCreateDelegateConnection( &sdRef, 0, uuid );
6958 if( err )
6959 {
6960 FPrintF( stderr, "DNSServiceCreateDelegateConnection() returned %#m for UUID %#U\n", err, uuid );
6961 goto exit;
6962 }
6963 type = kConnectionType_DelegateUUID;
6964 }
6965 else
6966 {
6967 FPrintF( stderr, "Unrecognized connection string \"%s\".\n", inString );
6968 err = kParamErr;
6969 goto exit;
6970 }
6971
6972 err = DNSServiceSetDispatchQueue( sdRef, inQueue );
6973 require_noerr( err, exit );
6974
6975 *outSDRef = sdRef;
6976 if( outDesc )
6977 {
6978 outDesc->type = type;
6979 if( type == kConnectionType_DelegatePID ) outDesc->delegate.pid = pid;
6980 else if( type == kConnectionType_DelegateUUID ) memcpy( outDesc->delegate.uuid, uuid, 16 );
6981 }
6982 sdRef = NULL;
6983
6984 exit:
6985 if( sdRef ) DNSServiceRefDeallocate( sdRef );
6986 return( err );
6987 }
6988
6989 //===========================================================================================================================
6990 // InterfaceIndexFromArgString
6991 //===========================================================================================================================
6992
6993 static OSStatus InterfaceIndexFromArgString( const char *inString, uint32_t *outIndex )
6994 {
6995 OSStatus err;
6996 uint32_t ifIndex;
6997
6998 if( inString )
6999 {
7000 ifIndex = if_nametoindex( inString );
7001 if( ifIndex == 0 )
7002 {
7003 err = StringToUInt32( inString, &ifIndex );
7004 if( err )
7005 {
7006 FPrintF( stderr, "Invalid interface value: %s\n", inString );
7007 err = kParamErr;
7008 goto exit;
7009 }
7010 }
7011 }
7012 else
7013 {
7014 ifIndex = 0;
7015 }
7016
7017 *outIndex = ifIndex;
7018 err = kNoErr;
7019
7020 exit:
7021 return( err );
7022 }
7023
7024 //===========================================================================================================================
7025 // RecordDataFromArgString
7026 //===========================================================================================================================
7027
7028 #define kRDataMaxLen UINT16_C( 0xFFFF )
7029
7030 static OSStatus StringToSRVRData( const char *inString, uint8_t **outPtr, size_t *outLen );
7031 static OSStatus StringToTXTRData( const char *inString, char inDelimiter, uint8_t **outPtr, size_t *outLen );
7032
7033 static OSStatus RecordDataFromArgString( const char *inString, uint8_t **outDataPtr, size_t *outDataLen )
7034 {
7035 OSStatus err;
7036 uint8_t * dataPtr = NULL;
7037 size_t dataLen;
7038
7039 if( 0 ) {}
7040
7041 // Domain name
7042
7043 else if( stricmp_prefix( inString, kRDataArgPrefix_Domain ) == 0 )
7044 {
7045 const char * const str = inString + sizeof_string( kRDataArgPrefix_Domain );
7046 uint8_t * end;
7047 uint8_t dname[ kDomainNameLengthMax ];
7048
7049 err = DomainNameFromString( dname, str, &end );
7050 require_noerr( err, exit );
7051
7052 dataLen = (size_t)( end - dname );
7053 dataPtr = malloc( dataLen );
7054 require_action( dataPtr, exit, err = kNoMemoryErr );
7055
7056 memcpy( dataPtr, dname, dataLen );
7057 }
7058
7059 // File path
7060
7061 else if( stricmp_prefix( inString, kRDataArgPrefix_File ) == 0 )
7062 {
7063 const char * const path = inString + sizeof_string( kRDataArgPrefix_File );
7064
7065 err = CopyFileDataByPath( path, (char **) &dataPtr, &dataLen );
7066 require_noerr( err, exit );
7067 require_action( dataLen <= kRDataMaxLen, exit, err = kSizeErr );
7068 }
7069
7070 // Hexadecimal string
7071
7072 else if( stricmp_prefix( inString, kRDataArgPrefix_HexString ) == 0 )
7073 {
7074 const char * const str = inString + sizeof_string( kRDataArgPrefix_HexString );
7075
7076 err = HexToDataCopy( str, kSizeCString, kHexToData_DefaultFlags, &dataPtr, &dataLen, NULL );
7077 require_noerr( err, exit );
7078 require_action( dataLen <= kRDataMaxLen, exit, err = kSizeErr );
7079 }
7080
7081 // IPv4 address string
7082
7083 else if( stricmp_prefix( inString, kRDataArgPrefix_IPv4 ) == 0 )
7084 {
7085 const char * const str = inString + sizeof_string( kRDataArgPrefix_IPv4 );
7086 const char * end;
7087
7088 dataLen = 4;
7089 dataPtr = (uint8_t *) malloc( dataLen );
7090 require_action( dataPtr, exit, err = kNoMemoryErr );
7091
7092 err = StringToIPv4Address( str, kStringToIPAddressFlagsNoPort | kStringToIPAddressFlagsNoPrefix,
7093 (uint32_t *) dataPtr, NULL, NULL, NULL, &end );
7094 if( !err && ( *end != '\0' ) ) err = kMalformedErr;
7095 require_noerr( err, exit );
7096
7097 *( (uint32_t *) dataPtr ) = HostToBig32( *( (uint32_t *) dataPtr ) );
7098 }
7099
7100 // IPv6 address string
7101
7102 else if( stricmp_prefix( inString, kRDataArgPrefix_IPv6 ) == 0 )
7103 {
7104 const char * const str = inString + sizeof_string( kRDataArgPrefix_IPv6 );
7105 const char * end;
7106
7107 dataLen = 16;
7108 dataPtr = (uint8_t *) malloc( dataLen );
7109 require_action( dataPtr, exit, err = kNoMemoryErr );
7110
7111 err = StringToIPv6Address( str,
7112 kStringToIPAddressFlagsNoPort | kStringToIPAddressFlagsNoPrefix | kStringToIPAddressFlagsNoScope,
7113 dataPtr, NULL, NULL, NULL, &end );
7114 if( !err && ( *end != '\0' ) ) err = kMalformedErr;
7115 require_noerr( err, exit );
7116 }
7117
7118 // SRV record
7119
7120 else if( stricmp_prefix( inString, kRDataArgPrefix_SRV ) == 0 )
7121 {
7122 const char * const str = inString + sizeof_string( kRDataArgPrefix_SRV );
7123
7124 err = StringToSRVRData( str, &dataPtr, &dataLen );
7125 require_noerr( err, exit );
7126 }
7127
7128 // String with escaped hex and octal bytes
7129
7130 else if( stricmp_prefix( inString, kRDataArgPrefix_String ) == 0 )
7131 {
7132 const char * const str = inString + sizeof_string( kRDataArgPrefix_String );
7133 const char * const end = str + strlen( str );
7134 size_t copiedLen;
7135 size_t totalLen;
7136 Boolean success;
7137
7138 if( str < end )
7139 {
7140 success = ParseQuotedEscapedString( str, end, "", NULL, 0, NULL, &totalLen, NULL );
7141 require_action( success, exit, err = kParamErr );
7142 require_action( totalLen <= kRDataMaxLen, exit, err = kSizeErr );
7143
7144 dataLen = totalLen;
7145 dataPtr = (uint8_t *) malloc( dataLen );
7146 require_action( dataPtr, exit, err = kNoMemoryErr );
7147
7148 success = ParseQuotedEscapedString( str, end, "", (char *) dataPtr, dataLen, &copiedLen, NULL, NULL );
7149 require_action( success, exit, err = kParamErr );
7150 check( copiedLen == dataLen );
7151 }
7152 else
7153 {
7154 dataPtr = NULL;
7155 dataLen = 0;
7156 }
7157 }
7158
7159 // TXT record
7160
7161 else if( stricmp_prefix( inString, kRDataArgPrefix_TXT ) == 0 )
7162 {
7163 const char * const str = inString + sizeof_string( kRDataArgPrefix_TXT );
7164
7165 err = StringToTXTRData( str, ',', &dataPtr, &dataLen );
7166 require_noerr( err, exit );
7167 }
7168
7169 // Unrecognized format
7170
7171 else
7172 {
7173 FPrintF( stderr, "Unrecognized record data string \"%s\".\n", inString );
7174 err = kParamErr;
7175 goto exit;
7176 }
7177
7178 err = kNoErr;
7179 *outDataLen = dataLen;
7180 *outDataPtr = dataPtr;
7181 dataPtr = NULL;
7182
7183 exit:
7184 FreeNullSafe( dataPtr );
7185 return( err );
7186 }
7187
7188 static OSStatus StringToSRVRData( const char *inString, uint8_t **outPtr, size_t *outLen )
7189 {
7190 OSStatus err;
7191 DataBuffer dataBuf;
7192 const char * ptr;
7193 int i;
7194 uint8_t * end;
7195 uint8_t target[ kDomainNameLengthMax ];
7196
7197 DataBuffer_Init( &dataBuf, NULL, 0, ( 3 * 2 ) + kDomainNameLengthMax );
7198
7199 // Parse and set the priority, weight, and port values (all three are unsigned 16-bit values).
7200
7201 ptr = inString;
7202 for( i = 0; i < 3; ++i )
7203 {
7204 char * next;
7205 long value;
7206 uint8_t buf[ 2 ];
7207
7208 value = strtol( ptr, &next, 0 );
7209 require_action_quiet( ( next != ptr ) && ( *next == ',' ), exit, err = kMalformedErr );
7210 require_action_quiet( ( value >= 0 ) && ( value <= UINT16_MAX ), exit, err = kRangeErr );
7211 ptr = next + 1;
7212
7213 WriteBig16( buf, value );
7214
7215 err = DataBuffer_Append( &dataBuf, buf, sizeof( buf ) );
7216 require_noerr( err, exit );
7217 }
7218
7219 // Set the target domain name.
7220
7221 err = DomainNameFromString( target, ptr, &end );
7222 require_noerr_quiet( err, exit );
7223
7224 err = DataBuffer_Append( &dataBuf, target, (size_t)( end - target ) );
7225 require_noerr( err, exit );
7226
7227 err = DataBuffer_Detach( &dataBuf, outPtr, outLen );
7228 require_noerr( err, exit );
7229
7230 exit:
7231 DataBuffer_Free( &dataBuf );
7232 return( err );
7233 }
7234
7235 static OSStatus StringToTXTRData( const char *inString, char inDelimiter, uint8_t **outPtr, size_t *outLen )
7236 {
7237 OSStatus err;
7238 DataBuffer dataBuf;
7239 const char * src;
7240 uint8_t txtStr[ 256 ]; // Buffer for single TXT string: 1 length byte + up to 255 bytes of data.
7241
7242 DataBuffer_Init( &dataBuf, NULL, 0, kRDataMaxLen );
7243
7244 src = inString;
7245 for( ;; )
7246 {
7247 uint8_t * dst = &txtStr[ 1 ];
7248 const uint8_t * const lim = &txtStr[ 256 ];
7249 int c;
7250
7251 while( *src && ( *src != inDelimiter ) )
7252 {
7253 if( ( c = *src++ ) == '\\' )
7254 {
7255 require_action_quiet( *src != '\0', exit, err = kUnderrunErr );
7256 c = *src++;
7257 }
7258 require_action_quiet( dst < lim, exit, err = kOverrunErr );
7259 *dst++ = (uint8_t) c;
7260 }
7261 txtStr[ 0 ] = (uint8_t)( dst - &txtStr[ 1 ] );
7262 err = DataBuffer_Append( &dataBuf, txtStr, 1 + txtStr[ 0 ] );
7263 require_noerr( err, exit );
7264
7265 if( *src == '\0' ) break;
7266 ++src;
7267 }
7268
7269 err = DataBuffer_Detach( &dataBuf, outPtr, outLen );
7270 require_noerr( err, exit );
7271
7272 exit:
7273 DataBuffer_Free( &dataBuf );
7274 return( err );
7275 }
7276
7277 //===========================================================================================================================
7278 // RecordTypeFromArgString
7279 //===========================================================================================================================
7280
7281 typedef struct
7282 {
7283 uint16_t value; // Record type's numeric value.
7284 const char * name; // Record type's name as a string (e.g., "A", "PTR", "SRV").
7285
7286 } RecordType;
7287
7288 static const RecordType kRecordTypes[] =
7289 {
7290 // Common types.
7291
7292 { kDNSServiceType_A, "A" },
7293 { kDNSServiceType_AAAA, "AAAA" },
7294 { kDNSServiceType_PTR, "PTR" },
7295 { kDNSServiceType_SRV, "SRV" },
7296 { kDNSServiceType_TXT, "TXT" },
7297 { kDNSServiceType_CNAME, "CNAME" },
7298 { kDNSServiceType_SOA, "SOA" },
7299 { kDNSServiceType_NSEC, "NSEC" },
7300 { kDNSServiceType_NS, "NS" },
7301 { kDNSServiceType_MX, "MX" },
7302 { kDNSServiceType_ANY, "ANY" },
7303 { kDNSServiceType_OPT, "OPT" },
7304
7305 // Less common types.
7306
7307 { kDNSServiceType_MD, "MD" },
7308 { kDNSServiceType_NS, "NS" },
7309 { kDNSServiceType_MD, "MD" },
7310 { kDNSServiceType_MF, "MF" },
7311 { kDNSServiceType_MB, "MB" },
7312 { kDNSServiceType_MG, "MG" },
7313 { kDNSServiceType_MR, "MR" },
7314 { kDNSServiceType_NULL, "NULL" },
7315 { kDNSServiceType_WKS, "WKS" },
7316 { kDNSServiceType_HINFO, "HINFO" },
7317 { kDNSServiceType_MINFO, "MINFO" },
7318 { kDNSServiceType_RP, "RP" },
7319 { kDNSServiceType_AFSDB, "AFSDB" },
7320 { kDNSServiceType_X25, "X25" },
7321 { kDNSServiceType_ISDN, "ISDN" },
7322 { kDNSServiceType_RT, "RT" },
7323 { kDNSServiceType_NSAP, "NSAP" },
7324 { kDNSServiceType_NSAP_PTR, "NSAP_PTR" },
7325 { kDNSServiceType_SIG, "SIG" },
7326 { kDNSServiceType_KEY, "KEY" },
7327 { kDNSServiceType_PX, "PX" },
7328 { kDNSServiceType_GPOS, "GPOS" },
7329 { kDNSServiceType_LOC, "LOC" },
7330 { kDNSServiceType_NXT, "NXT" },
7331 { kDNSServiceType_EID, "EID" },
7332 { kDNSServiceType_NIMLOC, "NIMLOC" },
7333 { kDNSServiceType_ATMA, "ATMA" },
7334 { kDNSServiceType_NAPTR, "NAPTR" },
7335 { kDNSServiceType_KX, "KX" },
7336 { kDNSServiceType_CERT, "CERT" },
7337 { kDNSServiceType_A6, "A6" },
7338 { kDNSServiceType_DNAME, "DNAME" },
7339 { kDNSServiceType_SINK, "SINK" },
7340 { kDNSServiceType_APL, "APL" },
7341 { kDNSServiceType_DS, "DS" },
7342 { kDNSServiceType_SSHFP, "SSHFP" },
7343 { kDNSServiceType_IPSECKEY, "IPSECKEY" },
7344 { kDNSServiceType_RRSIG, "RRSIG" },
7345 { kDNSServiceType_DNSKEY, "DNSKEY" },
7346 { kDNSServiceType_DHCID, "DHCID" },
7347 { kDNSServiceType_NSEC3, "NSEC3" },
7348 { kDNSServiceType_NSEC3PARAM, "NSEC3PARAM" },
7349 { kDNSServiceType_HIP, "HIP" },
7350 { kDNSServiceType_SPF, "SPF" },
7351 { kDNSServiceType_UINFO, "UINFO" },
7352 { kDNSServiceType_UID, "UID" },
7353 { kDNSServiceType_GID, "GID" },
7354 { kDNSServiceType_UNSPEC, "UNSPEC" },
7355 { kDNSServiceType_TKEY, "TKEY" },
7356 { kDNSServiceType_TSIG, "TSIG" },
7357 { kDNSServiceType_IXFR, "IXFR" },
7358 { kDNSServiceType_AXFR, "AXFR" },
7359 { kDNSServiceType_MAILB, "MAILB" },
7360 { kDNSServiceType_MAILA, "MAILA" }
7361 };
7362
7363 static OSStatus RecordTypeFromArgString( const char *inString, uint16_t *outValue )
7364 {
7365 OSStatus err;
7366 int32_t i32;
7367 const RecordType * type;
7368 const RecordType * const end = kRecordTypes + countof( kRecordTypes );
7369
7370 for( type = kRecordTypes; type < end; ++type )
7371 {
7372 if( strcasecmp( type->name, inString ) == 0 )
7373 {
7374 *outValue = type->value;
7375 return( kNoErr );
7376 }
7377 }
7378
7379 err = StringToInt32( inString, &i32 );
7380 require_noerr_quiet( err, exit );
7381 require_action_quiet( ( i32 >= 0 ) && ( i32 <= UINT16_MAX ), exit, err = kParamErr );
7382
7383 *outValue = (uint16_t) i32;
7384
7385 exit:
7386 return( err );
7387 }
7388
7389 //===========================================================================================================================
7390 // RecordClassFromArgString
7391 //===========================================================================================================================
7392
7393 static OSStatus RecordClassFromArgString( const char *inString, uint16_t *outValue )
7394 {
7395 OSStatus err;
7396 int32_t i32;
7397
7398 if( strcasecmp( inString, "IN" ) == 0 )
7399 {
7400 *outValue = kDNSServiceClass_IN;
7401 err = kNoErr;
7402 goto exit;
7403 }
7404
7405 err = StringToInt32( inString, &i32 );
7406 require_noerr_quiet( err, exit );
7407 require_action_quiet( ( i32 >= 0 ) && ( i32 <= UINT16_MAX ), exit, err = kParamErr );
7408
7409 *outValue = (uint16_t) i32;
7410
7411 exit:
7412 return( err );
7413 }
7414
7415 //===========================================================================================================================
7416 // InterfaceIndexToName
7417 //===========================================================================================================================
7418
7419 static char * InterfaceIndexToName( uint32_t inIfIndex, char inNameBuf[ kInterfaceNameBufLen ] )
7420 {
7421 switch( inIfIndex )
7422 {
7423 case kDNSServiceInterfaceIndexAny:
7424 strlcpy( inNameBuf, "Any", kInterfaceNameBufLen );
7425 break;
7426
7427 case kDNSServiceInterfaceIndexLocalOnly:
7428 strlcpy( inNameBuf, "LocalOnly", kInterfaceNameBufLen );
7429 break;
7430
7431 case kDNSServiceInterfaceIndexUnicast:
7432 strlcpy( inNameBuf, "Unicast", kInterfaceNameBufLen );
7433 break;
7434
7435 case kDNSServiceInterfaceIndexP2P:
7436 strlcpy( inNameBuf, "P2P", kInterfaceNameBufLen );
7437 break;
7438
7439 #if( defined( kDNSServiceInterfaceIndexBLE ) )
7440 case kDNSServiceInterfaceIndexBLE:
7441 strlcpy( inNameBuf, "BLE", kInterfaceNameBufLen );
7442 break;
7443 #endif
7444
7445 default:
7446 {
7447 const char * name;
7448
7449 name = if_indextoname( inIfIndex, inNameBuf );
7450 if( !name ) strlcpy( inNameBuf, "NO NAME", kInterfaceNameBufLen );
7451 break;
7452 }
7453 }
7454
7455 return( inNameBuf );
7456 }
7457
7458 //===========================================================================================================================
7459 // RecordTypeToString
7460 //===========================================================================================================================
7461
7462 static const char * RecordTypeToString( unsigned int inValue )
7463 {
7464 const RecordType * type;
7465 const RecordType * const end = kRecordTypes + countof( kRecordTypes );
7466
7467 for( type = kRecordTypes; type < end; ++type )
7468 {
7469 if( type->value == inValue ) return( type->name );
7470 }
7471 return( "???" );
7472 }
7473
7474 //===========================================================================================================================
7475 // DNSMessageExtractDomainName
7476 //===========================================================================================================================
7477
7478 #define IsCompressionByte( X ) ( ( ( X ) & 0xC0 ) == 0xC0 )
7479
7480 static OSStatus
7481 DNSMessageExtractDomainName(
7482 const uint8_t * inMsgPtr,
7483 size_t inMsgLen,
7484 const uint8_t * inNamePtr,
7485 uint8_t inBuf[ kDomainNameLengthMax ],
7486 const uint8_t ** outNextPtr )
7487 {
7488 OSStatus err;
7489 const uint8_t * label;
7490 uint8_t labelLen;
7491 const uint8_t * nextLabel;
7492 const uint8_t * const msgEnd = inMsgPtr + inMsgLen;
7493 uint8_t * dst = inBuf;
7494 const uint8_t * const dstLim = inBuf ? ( inBuf + kDomainNameLengthMax ) : NULL;
7495 const uint8_t * nameEnd = NULL;
7496
7497 require_action( ( inNamePtr >= inMsgPtr ) && ( inNamePtr < msgEnd ), exit, err = kRangeErr );
7498
7499 for( label = inNamePtr; ( labelLen = label[ 0 ] ) != 0; label = nextLabel )
7500 {
7501 if( labelLen <= kDomainLabelLengthMax )
7502 {
7503 nextLabel = label + 1 + labelLen;
7504 require_action( nextLabel < msgEnd, exit, err = kUnderrunErr );
7505 if( dst )
7506 {
7507 require_action( ( dstLim - dst ) > ( 1 + labelLen ), exit, err = kOverrunErr );
7508 memcpy( dst, label, 1 + labelLen );
7509 dst += ( 1 + labelLen );
7510 }
7511 }
7512 else if( IsCompressionByte( labelLen ) )
7513 {
7514 uint16_t offset;
7515
7516 require_action( ( msgEnd - label ) >= 2, exit, err = kUnderrunErr );
7517 if( !nameEnd )
7518 {
7519 nameEnd = label + 2;
7520 if( !dst ) break;
7521 }
7522 offset = (uint16_t)( ( ( label[ 0 ] & 0x3F ) << 8 ) | label[ 1 ] );
7523 nextLabel = inMsgPtr + offset;
7524 require_action( nextLabel < msgEnd, exit, err = kUnderrunErr );
7525 require_action( !IsCompressionByte( nextLabel[ 0 ] ), exit, err = kMalformedErr );
7526 }
7527 else
7528 {
7529 dlogassert( "Unhandled label length 0x%02X\n", labelLen );
7530 err = kMalformedErr;
7531 goto exit;
7532 }
7533 }
7534
7535 if( dst ) *dst = 0;
7536 if( !nameEnd ) nameEnd = label + 1;
7537
7538 if( outNextPtr ) *outNextPtr = nameEnd;
7539 err = kNoErr;
7540
7541 exit:
7542 return( err );
7543 }
7544
7545 //===========================================================================================================================
7546 // DNSMessageExtractDomainNameString
7547 //===========================================================================================================================
7548
7549 static OSStatus
7550 DNSMessageExtractDomainNameString(
7551 const void * inMsgPtr,
7552 size_t inMsgLen,
7553 const void * inNamePtr,
7554 char inBuf[ kDNSServiceMaxDomainName ],
7555 const uint8_t ** outNextPtr )
7556 {
7557 OSStatus err;
7558 const uint8_t * nextPtr;
7559 uint8_t domainName[ kDomainNameLengthMax ];
7560
7561 err = DNSMessageExtractDomainName( inMsgPtr, inMsgLen, inNamePtr, domainName, &nextPtr );
7562 require_noerr( err, exit );
7563
7564 err = DomainNameToString( domainName, NULL, inBuf, NULL );
7565 require_noerr( err, exit );
7566
7567 if( outNextPtr ) *outNextPtr = nextPtr;
7568
7569 exit:
7570 return( err );
7571 }
7572
7573 //===========================================================================================================================
7574 // DNSMessageExtractRecord
7575 //===========================================================================================================================
7576
7577 typedef struct
7578 {
7579 uint8_t type[ 2 ];
7580 uint8_t class[ 2 ];
7581 uint8_t ttl[ 4 ];
7582 uint8_t rdLength[ 2 ];
7583 uint8_t rdata[ 1 ];
7584
7585 } DNSRecordFields;
7586
7587 check_compile_time( offsetof( DNSRecordFields, rdata ) == 10 );
7588
7589 static OSStatus
7590 DNSMessageExtractRecord(
7591 const uint8_t * inMsgPtr,
7592 size_t inMsgLen,
7593 const uint8_t * inPtr,
7594 uint8_t inNameBuf[ kDomainNameLengthMax ],
7595 uint16_t * outType,
7596 uint16_t * outClass,
7597 uint32_t * outTTL,
7598 const uint8_t ** outRDataPtr,
7599 size_t * outRDataLen,
7600 const uint8_t ** outPtr )
7601 {
7602 OSStatus err;
7603 const uint8_t * const msgEnd = inMsgPtr + inMsgLen;
7604 const uint8_t * ptr;
7605 const DNSRecordFields * record;
7606 size_t rdLength;
7607
7608 err = DNSMessageExtractDomainName( inMsgPtr, inMsgLen, inPtr, inNameBuf, &ptr );
7609 require_noerr_quiet( err, exit );
7610 require_action_quiet( (size_t)( msgEnd - ptr ) >= offsetof( DNSRecordFields, rdata ), exit, err = kUnderrunErr );
7611
7612 record = (DNSRecordFields *) ptr;
7613 rdLength = ReadBig16( record->rdLength );
7614 require_action_quiet( (size_t)( msgEnd - record->rdata ) >= rdLength , exit, err = kUnderrunErr );
7615
7616 if( outType ) *outType = ReadBig16( record->type );
7617 if( outClass ) *outClass = ReadBig16( record->class );
7618 if( outTTL ) *outTTL = ReadBig32( record->ttl );
7619 if( outRDataPtr ) *outRDataPtr = record->rdata;
7620 if( outRDataLen ) *outRDataLen = rdLength;
7621 if( outPtr ) *outPtr = record->rdata + rdLength;
7622
7623 exit:
7624 return( err );
7625 }
7626
7627 //===========================================================================================================================
7628 // DNSMessageGetAnswerSection
7629 //===========================================================================================================================
7630
7631 static OSStatus DNSMessageGetAnswerSection( const uint8_t *inMsgPtr, size_t inMsgLen, const uint8_t **outPtr )
7632 {
7633 OSStatus err;
7634 const uint8_t * const msgEnd = inMsgPtr + inMsgLen;
7635 unsigned int questionCount, i;
7636 const DNSHeader * hdr;
7637 const uint8_t * ptr;
7638
7639 require_action_quiet( inMsgLen >= kDNSHeaderLength, exit, err = kSizeErr );
7640
7641 hdr = (DNSHeader *) inMsgPtr;
7642 questionCount = DNSHeaderGetQuestionCount( hdr );
7643
7644 ptr = (uint8_t *)( hdr + 1 );
7645 for( i = 0; i < questionCount; ++i )
7646 {
7647 err = DNSMessageExtractDomainName( inMsgPtr, inMsgLen, ptr, NULL, &ptr );
7648 require_noerr( err, exit );
7649 require_action_quiet( ( msgEnd - ptr ) >= 4, exit, err = kUnderrunErr );
7650 ptr += 4;
7651 }
7652
7653 if( outPtr ) *outPtr = ptr;
7654 err = kNoErr;
7655
7656 exit:
7657 return( err );
7658 }
7659
7660 //===========================================================================================================================
7661 // DNSRecordDataToString
7662 //===========================================================================================================================
7663
7664 static OSStatus
7665 DNSRecordDataToString(
7666 const void * inRDataPtr,
7667 size_t inRDataLen,
7668 unsigned int inRDataType,
7669 const void * inMsgPtr,
7670 size_t inMsgLen,
7671 char ** outString )
7672 {
7673 OSStatus err;
7674 const uint8_t * const rdataPtr = (uint8_t *) inRDataPtr;
7675 const uint8_t * const rdataEnd = rdataPtr + inRDataLen;
7676 char * rdataStr;
7677 const uint8_t * ptr;
7678 int n;
7679 char domainNameStr[ kDNSServiceMaxDomainName ];
7680
7681 rdataStr = NULL;
7682 if( inRDataType == kDNSServiceType_A )
7683 {
7684 require_action_quiet( inRDataLen == 4, exit, err = kMalformedErr );
7685
7686 ASPrintF( &rdataStr, "%.4a", rdataPtr );
7687 require_action( rdataStr, exit, err = kNoMemoryErr );
7688 }
7689 else if( inRDataType == kDNSServiceType_AAAA )
7690 {
7691 require_action_quiet( inRDataLen == 16, exit, err = kMalformedErr );
7692
7693 ASPrintF( &rdataStr, "%.16a", rdataPtr );
7694 require_action( rdataStr, exit, err = kNoMemoryErr );
7695 }
7696 else if( ( inRDataType == kDNSServiceType_PTR ) || ( inRDataType == kDNSServiceType_CNAME ) ||
7697 ( inRDataType == kDNSServiceType_NS ) )
7698 {
7699 if( inMsgPtr )
7700 {
7701 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, rdataPtr, domainNameStr, NULL );
7702 require_noerr( err, exit );
7703 }
7704 else
7705 {
7706 err = DomainNameToString( rdataPtr, rdataEnd, domainNameStr, NULL );
7707 require_noerr( err, exit );
7708 }
7709
7710 rdataStr = strdup( domainNameStr );
7711 require_action( rdataStr, exit, err = kNoMemoryErr );
7712 }
7713 else if( inRDataType == kDNSServiceType_SRV )
7714 {
7715 uint16_t priority, weight, port;
7716 const uint8_t * target;
7717
7718 require_action_quiet( ( rdataPtr + 6 ) < rdataEnd, exit, err = kMalformedErr );
7719
7720 priority = ReadBig16( rdataPtr );
7721 weight = ReadBig16( rdataPtr + 2 );
7722 port = ReadBig16( rdataPtr + 4 );
7723 target = rdataPtr + 6;
7724
7725 if( inMsgPtr )
7726 {
7727 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, target, domainNameStr, NULL );
7728 require_noerr( err, exit );
7729 }
7730 else
7731 {
7732 err = DomainNameToString( target, rdataEnd, domainNameStr, NULL );
7733 require_noerr( err, exit );
7734 }
7735
7736 ASPrintF( &rdataStr, "%u %u %u %s", priority, weight, port, domainNameStr );
7737 require_action( rdataStr, exit, err = kNoMemoryErr );
7738 }
7739 else if( inRDataType == kDNSServiceType_TXT )
7740 {
7741 require_action_quiet( inRDataLen > 0, exit, err = kMalformedErr );
7742
7743 if( inRDataLen == 1 )
7744 {
7745 ASPrintF( &rdataStr, "%#H", rdataPtr, (int) inRDataLen, INT_MAX );
7746 require_action( rdataStr, exit, err = kNoMemoryErr );
7747 }
7748 else
7749 {
7750 ASPrintF( &rdataStr, "%#{txt}", rdataPtr, inRDataLen );
7751 require_action( rdataStr, exit, err = kNoMemoryErr );
7752 }
7753 }
7754 else if( inRDataType == kDNSServiceType_SOA )
7755 {
7756 uint32_t serial, refresh, retry, expire, minimum;
7757
7758 if( inMsgPtr )
7759 {
7760 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, rdataPtr, domainNameStr, &ptr );
7761 require_noerr( err, exit );
7762
7763 require_action_quiet( ptr < rdataEnd, exit, err = kMalformedErr );
7764
7765 rdataStr = strdup( domainNameStr );
7766 require_action( rdataStr, exit, err = kNoMemoryErr );
7767
7768 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, ptr, domainNameStr, &ptr );
7769 require_noerr( err, exit );
7770 }
7771 else
7772 {
7773 err = DomainNameToString( rdataPtr, rdataEnd, domainNameStr, &ptr );
7774 require_noerr( err, exit );
7775
7776 rdataStr = strdup( domainNameStr );
7777 require_action( rdataStr, exit, err = kNoMemoryErr );
7778
7779 err = DomainNameToString( ptr, rdataEnd, domainNameStr, &ptr );
7780 require_noerr( err, exit );
7781 }
7782
7783 require_action_quiet( ( ptr + 20 ) == rdataEnd, exit, err = kMalformedErr );
7784
7785 serial = ReadBig32( ptr );
7786 refresh = ReadBig32( ptr + 4 );
7787 retry = ReadBig32( ptr + 8 );
7788 expire = ReadBig32( ptr + 12 );
7789 minimum = ReadBig32( ptr + 16 );
7790
7791 n = AppendPrintF( &rdataStr, " %s %u %u %u %u %u\n", domainNameStr, serial, refresh, retry, expire, minimum );
7792 require_action( n > 0, exit, err = kUnknownErr );
7793 }
7794 else if( inRDataType == kDNSServiceType_NSEC )
7795 {
7796 unsigned int windowBlock, bitmapLen, i, recordType;
7797 const uint8_t * bitmapPtr;
7798
7799 if( inMsgPtr )
7800 {
7801 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, rdataPtr, domainNameStr, &ptr );
7802 require_noerr( err, exit );
7803 }
7804 else
7805 {
7806 err = DomainNameToString( rdataPtr, rdataEnd, domainNameStr, &ptr );
7807 require_noerr( err, exit );
7808 }
7809
7810 require_action_quiet( ptr < rdataEnd, exit, err = kMalformedErr );
7811
7812 rdataStr = strdup( domainNameStr );
7813 require_action( rdataStr, exit, err = kNoMemoryErr );
7814
7815 for( ; ptr < rdataEnd; ptr += ( 2 + bitmapLen ) )
7816 {
7817 require_action_quiet( ( ptr + 2 ) < rdataEnd, exit, err = kMalformedErr );
7818
7819 windowBlock = ptr[ 0 ];
7820 bitmapLen = ptr[ 1 ];
7821 bitmapPtr = &ptr[ 2 ];
7822
7823 require_action_quiet( ( bitmapLen >= 1 ) && ( bitmapLen <= 32 ) , exit, err = kMalformedErr );
7824 require_action_quiet( ( bitmapPtr + bitmapLen ) <= rdataEnd, exit, err = kMalformedErr );
7825
7826 for( i = 0; i < BitArray_MaxBits( bitmapLen ); ++i )
7827 {
7828 if( BitArray_GetBit( bitmapPtr, bitmapLen, i ) )
7829 {
7830 recordType = ( windowBlock * 256 ) + i;
7831 n = AppendPrintF( &rdataStr, " %s", RecordTypeToString( recordType ) );
7832 require_action( n > 0, exit, err = kUnknownErr );
7833 }
7834 }
7835 }
7836 }
7837 else if( inRDataType == kDNSServiceType_MX )
7838 {
7839 uint16_t preference;
7840 const uint8_t * exchange;
7841
7842 require_action_quiet( ( rdataPtr + 2 ) < rdataEnd, exit, err = kMalformedErr );
7843
7844 preference = ReadBig16( rdataPtr );
7845 exchange = &rdataPtr[ 2 ];
7846
7847 if( inMsgPtr )
7848 {
7849 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, exchange, domainNameStr, NULL );
7850 require_noerr( err, exit );
7851 }
7852 else
7853 {
7854 err = DomainNameToString( exchange, rdataEnd, domainNameStr, NULL );
7855 require_noerr( err, exit );
7856 }
7857
7858 n = ASPrintF( &rdataStr, "%u %s", preference, domainNameStr );
7859 require_action( n > 0, exit, err = kUnknownErr );
7860 }
7861 else
7862 {
7863 err = kNotHandledErr;
7864 goto exit;
7865 }
7866
7867 check( rdataStr );
7868 *outString = rdataStr;
7869 rdataStr = NULL;
7870 err = kNoErr;
7871
7872 exit:
7873 FreeNullSafe( rdataStr );
7874 return( err );
7875 }
7876
7877 //===========================================================================================================================
7878 // DomainNameAppendString
7879 //===========================================================================================================================
7880
7881 static OSStatus
7882 DomainNameAppendString(
7883 uint8_t inDomainName[ kDomainNameLengthMax ],
7884 const char * inString,
7885 uint8_t ** outEndPtr )
7886 {
7887 OSStatus err;
7888 const char * src;
7889 uint8_t * root;
7890 const uint8_t * const nameLim = inDomainName + kDomainNameLengthMax;
7891
7892 for( root = inDomainName; ( root < nameLim ) && *root; root += ( 1 + *root ) ) {}
7893 require_action_quiet( root < nameLim, exit, err = kMalformedErr );
7894
7895 // If the string is a single dot, denoting the root domain, then there are no non-empty labels.
7896
7897 src = inString;
7898 if( ( src[ 0 ] == '.' ) && ( src[ 1 ] == '\0' ) ) ++src;
7899 while( *src )
7900 {
7901 uint8_t * const label = root;
7902 const uint8_t * const labelLim = Min( &label[ 1 + kDomainLabelLengthMax ], nameLim - 1 );
7903 uint8_t * dst;
7904 int c;
7905 size_t labelLen;
7906
7907 dst = &label[ 1 ];
7908 while( *src && ( ( c = *src++ ) != '.' ) )
7909 {
7910 if( c == '\\' )
7911 {
7912 require_action_quiet( *src != '\0', exit, err = kUnderrunErr );
7913 c = *src++;
7914 if( isdigit_safe( c ) && isdigit_safe( src[ 0 ] ) && isdigit_safe( src[ 1 ] ) )
7915 {
7916 const int decimal = ( ( c - '0' ) * 100 ) + ( ( src[ 0 ] - '0' ) * 10 ) + ( src[ 1 ] - '0' );
7917
7918 if( decimal <= 255 )
7919 {
7920 c = decimal;
7921 src += 2;
7922 }
7923 }
7924 }
7925 require_action_quiet( dst < labelLim, exit, err = kOverrunErr );
7926 *dst++ = (uint8_t) c;
7927 }
7928
7929 labelLen = (size_t)( dst - &label[ 1 ] );
7930 require_action_quiet( labelLen > 0, exit, err = kMalformedErr );
7931
7932 label[ 0 ] = (uint8_t) labelLen;
7933 root = dst;
7934 *root = 0;
7935 }
7936
7937 if( outEndPtr ) *outEndPtr = root + 1;
7938 err = kNoErr;
7939
7940 exit:
7941 return( err );
7942 }
7943
7944 //===========================================================================================================================
7945 // DomainNameEqual
7946 //===========================================================================================================================
7947
7948 static Boolean DomainNameEqual( const uint8_t *inName1, const uint8_t *inName2 )
7949 {
7950 const uint8_t * p1 = inName1;
7951 const uint8_t * p2 = inName2;
7952 unsigned int len;
7953
7954 for( ;; )
7955 {
7956 if( ( len = *p1++ ) != *p2++ ) return( false );
7957 if( len == 0 ) break;
7958 for( ; len > 0; ++p1, ++p2, --len )
7959 {
7960 if( tolower_safe( *p1 ) != tolower_safe( *p2 ) ) return( false );
7961 }
7962 }
7963 return( true );
7964 }
7965
7966 //===========================================================================================================================
7967 // DomainNameFromString
7968 //===========================================================================================================================
7969
7970 static OSStatus
7971 DomainNameFromString(
7972 uint8_t inDomainName[ kDomainNameLengthMax ],
7973 const char * inString,
7974 uint8_t ** outEndPtr )
7975 {
7976 inDomainName[ 0 ] = 0;
7977 return( DomainNameAppendString( inDomainName, inString, outEndPtr ) );
7978 }
7979
7980 //===========================================================================================================================
7981 // DomainNameToString
7982 //===========================================================================================================================
7983
7984 static OSStatus
7985 DomainNameToString(
7986 const uint8_t * inDomainName,
7987 const uint8_t * inEnd,
7988 char inBuf[ kDNSServiceMaxDomainName ],
7989 const uint8_t ** outNextPtr )
7990 {
7991 OSStatus err;
7992 const uint8_t * label;
7993 uint8_t labelLen;
7994 const uint8_t * nextLabel;
7995 char * dst;
7996 const uint8_t * src;
7997
7998 require_action( !inEnd || ( inDomainName < inEnd ), exit, err = kUnderrunErr );
7999
8000 // Convert each label up until the root label, i.e., the zero-length label.
8001
8002 dst = inBuf;
8003 for( label = inDomainName; ( labelLen = label[ 0 ] ) != 0; label = nextLabel )
8004 {
8005 require_action( labelLen <= kDomainLabelLengthMax, exit, err = kMalformedErr );
8006
8007 nextLabel = &label[ 1 ] + labelLen;
8008 require_action( ( nextLabel - inDomainName ) < kDomainNameLengthMax, exit, err = kMalformedErr );
8009 require_action( !inEnd || ( nextLabel < inEnd ), exit, err = kUnderrunErr );
8010
8011 for( src = &label[ 1 ]; src < nextLabel; ++src )
8012 {
8013 if( isprint_safe( *src ) )
8014 {
8015 if( ( *src == '.' ) || ( *src == '\\' ) || ( *src == ' ' ) ) *dst++ = '\\';
8016 *dst++ = (char) *src;
8017 }
8018 else
8019 {
8020 *dst++ = '\\';
8021 *dst++ = '0' + ( *src / 100 );
8022 *dst++ = '0' + ( ( *src / 10 ) % 10 );
8023 *dst++ = '0' + ( *src % 10 );
8024 }
8025 }
8026 *dst++ = '.';
8027 }
8028
8029 // At this point, label points to the root label.
8030 // If the root label was the only label, then write a dot for it.
8031
8032 if( label == inDomainName ) *dst++ = '.';
8033 *dst = '\0';
8034 if( outNextPtr ) *outNextPtr = label + 1;
8035 err = kNoErr;
8036
8037 exit:
8038 return( err );
8039 }
8040
8041 //===========================================================================================================================
8042 // PrintDNSMessage
8043 //===========================================================================================================================
8044
8045 #define DNSFlagsOpCodeToString( X ) ( \
8046 ( (X) == kDNSOpCode_Query ) ? "Query" : \
8047 ( (X) == kDNSOpCode_InverseQuery ) ? "IQuery" : \
8048 ( (X) == kDNSOpCode_Status ) ? "Status" : \
8049 ( (X) == kDNSOpCode_Notify ) ? "Notify" : \
8050 ( (X) == kDNSOpCode_Update ) ? "Update" : \
8051 "Unassigned" )
8052
8053 #define DNSFlagsRCodeToString( X ) ( \
8054 ( (X) == kDNSRCode_NoError ) ? "NoError" : \
8055 ( (X) == kDNSRCode_FormatError ) ? "FormErr" : \
8056 ( (X) == kDNSRCode_ServerFailure ) ? "ServFail" : \
8057 ( (X) == kDNSRCode_NXDomain ) ? "NXDomain" : \
8058 ( (X) == kDNSRCode_NotImplemented ) ? "NotImp" : \
8059 ( (X) == kDNSRCode_Refused ) ? "Refused" : \
8060 "???" )
8061
8062 #define DNSFlagsGetOpCode( X ) ( ( (X) >> 11 ) & 0x0F )
8063 #define DNSFlagsGetRCode( X ) ( (X) & 0x0F )
8064
8065 static OSStatus PrintDNSMessage( const uint8_t *inMsgPtr, size_t inMsgLen, const Boolean inIsMDNS, const Boolean inPrintRaw )
8066 {
8067 OSStatus err;
8068 const DNSHeader * hdr;
8069 const uint8_t * const msgEnd = inMsgPtr + inMsgLen;
8070 const uint8_t * ptr;
8071 unsigned int id, flags, opcode, rcode;
8072 unsigned int questionCount, answerCount, authorityCount, additionalCount, i, totalRRCount;
8073 char nameStr[ kDNSServiceMaxDomainName ];
8074
8075 require_action_quiet( inMsgLen >= kDNSHeaderLength, exit, err = kSizeErr );
8076
8077 hdr = (DNSHeader *) inMsgPtr;
8078 id = DNSHeaderGetID( hdr );
8079 flags = DNSHeaderGetFlags( hdr );
8080 questionCount = DNSHeaderGetQuestionCount( hdr );
8081 answerCount = DNSHeaderGetAnswerCount( hdr );
8082 authorityCount = DNSHeaderGetAuthorityCount( hdr );
8083 additionalCount = DNSHeaderGetAdditionalCount( hdr );
8084 opcode = DNSFlagsGetOpCode( flags );
8085 rcode = DNSFlagsGetRCode( flags );
8086
8087 FPrintF( stdout, "ID: 0x%04X (%u)\n", id, id );
8088 FPrintF( stdout, "Flags: 0x%04X %c/%s %cAA%cTC%cRD%cRA %s\n",
8089 flags,
8090 ( flags & kDNSHeaderFlag_Response ) ? 'R' : 'Q', DNSFlagsOpCodeToString( opcode ),
8091 ( flags & kDNSHeaderFlag_AuthAnswer ) ? ' ' : '!',
8092 ( flags & kDNSHeaderFlag_Truncation ) ? ' ' : '!',
8093 ( flags & kDNSHeaderFlag_RecursionDesired ) ? ' ' : '!',
8094 ( flags & kDNSHeaderFlag_RecursionAvailable ) ? ' ' : '!',
8095 DNSFlagsRCodeToString( rcode ) );
8096 FPrintF( stdout, "Question count: %u\n", questionCount );
8097 FPrintF( stdout, "Answer count: %u\n", answerCount );
8098 FPrintF( stdout, "Authority count: %u\n", authorityCount );
8099 FPrintF( stdout, "Additional count: %u\n", additionalCount );
8100
8101 ptr = (uint8_t *)( hdr + 1 );
8102 for( i = 0; i < questionCount; ++i )
8103 {
8104 unsigned int qType, qClass;
8105 Boolean isQU;
8106
8107 err = DNSMessageExtractDomainNameString( inMsgPtr, inMsgLen, ptr, nameStr, &ptr );
8108 require_noerr( err, exit );
8109
8110 if( ( msgEnd - ptr ) < 4 )
8111 {
8112 err = kUnderrunErr;
8113 goto exit;
8114 }
8115
8116 qType = ReadBig16( ptr );
8117 ptr += 2;
8118 qClass = ReadBig16( ptr );
8119 ptr += 2;
8120
8121 isQU = ( inIsMDNS && ( qClass & kQClassUnicastResponseBit ) ) ? true : false;
8122 if( inIsMDNS ) qClass &= ~kQClassUnicastResponseBit;
8123
8124 if( i == 0 ) FPrintF( stdout, "\nQUESTION SECTION\n" );
8125
8126 FPrintF( stdout, "%s %2s %?2s%?2u %-5s\n",
8127 nameStr, inIsMDNS ? ( isQU ? "QU" : "QM" ) : "",
8128 ( qClass == kDNSServiceClass_IN ), "IN", ( qClass != kDNSServiceClass_IN ), qClass,
8129 RecordTypeToString( qType ) );
8130 }
8131
8132 totalRRCount = answerCount + authorityCount + additionalCount;
8133 for( i = 0; i < totalRRCount; ++i )
8134 {
8135 uint16_t type;
8136 uint16_t class;
8137 uint32_t ttl;
8138 const uint8_t * rdataPtr;
8139 size_t rdataLen;
8140 char * rdataStr;
8141 Boolean cacheFlush;
8142 uint8_t name[ kDomainNameLengthMax ];
8143
8144 err = DNSMessageExtractRecord( inMsgPtr, inMsgLen, ptr, name, &type, &class, &ttl, &rdataPtr, &rdataLen, &ptr );
8145 require_noerr( err, exit );
8146
8147 err = DomainNameToString( name, NULL, nameStr, NULL );
8148 require_noerr( err, exit );
8149
8150 cacheFlush = ( inIsMDNS && ( class & kRRClassCacheFlushBit ) ) ? true : false;
8151 if( inIsMDNS ) class &= ~kRRClassCacheFlushBit;
8152
8153 rdataStr = NULL;
8154 if( !inPrintRaw ) DNSRecordDataToString( rdataPtr, rdataLen, type, inMsgPtr, inMsgLen, &rdataStr );
8155 if( !rdataStr )
8156 {
8157 ASPrintF( &rdataStr, "%#H", rdataPtr, (int) rdataLen, INT_MAX );
8158 require_action( rdataStr, exit, err = kNoMemoryErr );
8159 }
8160
8161 if( answerCount && ( i == 0 ) ) FPrintF( stdout, "\nANSWER SECTION\n" );
8162 else if( authorityCount && ( i == answerCount ) ) FPrintF( stdout, "\nAUTHORITY SECTION\n" );
8163 else if( additionalCount && ( i == ( answerCount + authorityCount ) ) ) FPrintF( stdout, "\nADDITIONAL SECTION\n" );
8164
8165 FPrintF( stdout, "%-42s %6u %2s %?2s%?2u %-5s %s\n",
8166 nameStr, ttl, cacheFlush ? "CF" : "",
8167 ( class == kDNSServiceClass_IN ), "IN", ( class != kDNSServiceClass_IN ), class,
8168 RecordTypeToString( type ), rdataStr );
8169 free( rdataStr );
8170 }
8171 FPrintF( stdout, "\n" );
8172 err = kNoErr;
8173
8174 exit:
8175 return( err );
8176 }
8177
8178 //===========================================================================================================================
8179 // WriteDNSQueryMessage
8180 //===========================================================================================================================
8181
8182 static OSStatus
8183 WriteDNSQueryMessage(
8184 uint8_t inMsg[ kDNSQueryMessageMaxLen ],
8185 uint16_t inMsgID,
8186 uint16_t inFlags,
8187 const char * inQName,
8188 uint16_t inQType,
8189 uint16_t inQClass,
8190 size_t * outMsgLen )
8191 {
8192 OSStatus err;
8193 DNSHeader * const hdr = (DNSHeader *) inMsg;
8194 uint8_t * ptr;
8195 size_t msgLen;
8196
8197 WriteBig16( hdr->id, inMsgID );
8198 WriteBig16( hdr->flags, inFlags );
8199 WriteBig16( hdr->questionCount, 1 );
8200 WriteBig16( hdr->answerCount, 0 );
8201 WriteBig16( hdr->authorityCount, 0 );
8202 WriteBig16( hdr->additionalCount, 0 );
8203
8204 ptr = (uint8_t *)( hdr + 1 );
8205 err = DomainNameFromString( ptr, inQName, &ptr );
8206 require_noerr_quiet( err, exit );
8207
8208 WriteBig16( ptr, inQType );
8209 ptr += 2;
8210 WriteBig16( ptr, inQClass );
8211 ptr += 2;
8212 msgLen = (size_t)( ptr - inMsg );
8213 check( msgLen <= kDNSQueryMessageMaxLen );
8214
8215 if( outMsgLen ) *outMsgLen = msgLen;
8216
8217 exit:
8218 return( err );
8219 }
8220
8221 //===========================================================================================================================
8222 // DispatchSignalSourceCreate
8223 //===========================================================================================================================
8224
8225 static OSStatus
8226 DispatchSignalSourceCreate(
8227 int inSignal,
8228 DispatchHandler inEventHandler,
8229 void * inContext,
8230 dispatch_source_t * outSource )
8231 {
8232 OSStatus err;
8233 dispatch_source_t source;
8234
8235 source = dispatch_source_create( DISPATCH_SOURCE_TYPE_SIGNAL, (uintptr_t) inSignal, 0, dispatch_get_main_queue() );
8236 require_action( source, exit, err = kUnknownErr );
8237
8238 dispatch_set_context( source, inContext );
8239 dispatch_source_set_event_handler_f( source, inEventHandler );
8240
8241 *outSource = source;
8242 err = kNoErr;
8243
8244 exit:
8245 return( err );
8246 }
8247
8248 //===========================================================================================================================
8249 // DispatchReadSourceCreate
8250 //===========================================================================================================================
8251
8252 static OSStatus
8253 DispatchReadSourceCreate(
8254 SocketRef inSock,
8255 DispatchHandler inEventHandler,
8256 DispatchHandler inCancelHandler,
8257 void * inContext,
8258 dispatch_source_t * outSource )
8259 {
8260 OSStatus err;
8261 dispatch_source_t source;
8262
8263 source = dispatch_source_create( DISPATCH_SOURCE_TYPE_READ, (uintptr_t) inSock, 0, dispatch_get_main_queue() );
8264 require_action( source, exit, err = kUnknownErr );
8265
8266 dispatch_set_context( source, inContext );
8267 dispatch_source_set_event_handler_f( source, inEventHandler );
8268 dispatch_source_set_cancel_handler_f( source, inCancelHandler );
8269
8270 *outSource = source;
8271 err = kNoErr;
8272
8273 exit:
8274 return( err );
8275 }
8276
8277 //===========================================================================================================================
8278 // DispatchTimerCreate
8279 //===========================================================================================================================
8280
8281 static OSStatus
8282 DispatchTimerCreate(
8283 dispatch_time_t inStart,
8284 uint64_t inIntervalNs,
8285 uint64_t inLeewayNs,
8286 DispatchHandler inEventHandler,
8287 DispatchHandler inCancelHandler,
8288 void * inContext,
8289 dispatch_source_t * outTimer )
8290 {
8291 OSStatus err;
8292 dispatch_source_t timer;
8293
8294 timer = dispatch_source_create( DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue() );
8295 require_action( timer, exit, err = kUnknownErr );
8296
8297 dispatch_source_set_timer( timer, inStart, inIntervalNs, inLeewayNs );
8298 dispatch_set_context( timer, inContext );
8299 dispatch_source_set_event_handler_f( timer, inEventHandler );
8300 dispatch_source_set_cancel_handler_f( timer, inCancelHandler );
8301
8302 *outTimer = timer;
8303 err = kNoErr;
8304
8305 exit:
8306 return( err );
8307 }
8308
8309 //===========================================================================================================================
8310 // ServiceTypeDescription
8311 //===========================================================================================================================
8312
8313 typedef struct
8314 {
8315 const char * name; // Name of the service type in two-label "_service._proto" format.
8316 const char * description; // Description of the service type.
8317
8318 } ServiceType;
8319
8320 // A Non-comprehensive table of DNS-SD service types
8321
8322 static const ServiceType kServiceTypes[] =
8323 {
8324 { "_acp-sync._tcp", "AirPort Base Station Sync" },
8325 { "_adisk._tcp", "Automatic Disk Discovery" },
8326 { "_afpovertcp._tcp", "Apple File Sharing" },
8327 { "_airdrop._tcp", "AirDrop" },
8328 { "_airplay._tcp", "AirPlay" },
8329 { "_airport._tcp", "AirPort Base Station" },
8330 { "_daap._tcp", "Digital Audio Access Protocol (iTunes)" },
8331 { "_eppc._tcp", "Remote AppleEvents" },
8332 { "_ftp._tcp", "File Transfer Protocol" },
8333 { "_home-sharing._tcp", "Home Sharing" },
8334 { "_homekit._tcp", "HomeKit" },
8335 { "_http._tcp", "World Wide Web HTML-over-HTTP" },
8336 { "_https._tcp", "HTTP over SSL/TLS" },
8337 { "_ipp._tcp", "Internet Printing Protocol" },
8338 { "_ldap._tcp", "Lightweight Directory Access Protocol" },
8339 { "_mediaremotetv._tcp", "Media Remote" },
8340 { "_net-assistant._tcp", "Apple Remote Desktop" },
8341 { "_od-master._tcp", "OpenDirectory Master" },
8342 { "_nfs._tcp", "Network File System" },
8343 { "_presence._tcp", "Peer-to-peer messaging / Link-Local Messaging" },
8344 { "_pdl-datastream._tcp", "Printer Page Description Language Data Stream" },
8345 { "_raop._tcp", "Remote Audio Output Protocol" },
8346 { "_rfb._tcp", "Remote Frame Buffer" },
8347 { "_scanner._tcp", "Bonjour Scanning" },
8348 { "_smb._tcp", "Server Message Block over TCP/IP" },
8349 { "_sftp-ssh._tcp", "Secure File Transfer Protocol over SSH" },
8350 { "_sleep-proxy._udp", "Sleep Proxy Server" },
8351 { "_ssh._tcp", "SSH Remote Login Protocol" },
8352 { "_teleport._tcp", "teleport" },
8353 { "_tftp._tcp", "Trivial File Transfer Protocol" },
8354 { "_workstation._tcp", "Workgroup Manager" },
8355 { "_webdav._tcp", "World Wide Web Distributed Authoring and Versioning (WebDAV)" },
8356 { "_webdavs._tcp", "WebDAV over SSL/TLS" }
8357 };
8358
8359 static const char * ServiceTypeDescription( const char *inName )
8360 {
8361 const ServiceType * serviceType;
8362 const ServiceType * const end = kServiceTypes + countof( kServiceTypes );
8363
8364 for( serviceType = kServiceTypes; serviceType < end; ++serviceType )
8365 {
8366 if( strcasecmp( inName, serviceType->name ) == 0 ) return( serviceType->description );
8367 }
8368 return( NULL );
8369 }
8370
8371 //===========================================================================================================================
8372 // SocketContextCancelHandler
8373 //===========================================================================================================================
8374
8375 static void SocketContextCancelHandler( void *inContext )
8376 {
8377 SocketContext * const context = (SocketContext *) inContext;
8378
8379 ForgetSocket( &context->sock );
8380 free( context );
8381 }
8382
8383 //===========================================================================================================================
8384 // StringToInt32
8385 //===========================================================================================================================
8386
8387 static OSStatus StringToInt32( const char *inString, int32_t *outValue )
8388 {
8389 OSStatus err;
8390 long value;
8391 char * endPtr;
8392
8393 value = strtol( inString, &endPtr, 0 );
8394 require_action_quiet( ( *endPtr == '\0' ) && ( endPtr != inString ), exit, err = kParamErr );
8395 require_action_quiet( ( value >= INT32_MIN ) && ( value <= INT32_MAX ), exit, err = kRangeErr );
8396
8397 *outValue = (int32_t) value;
8398 err = kNoErr;
8399
8400 exit:
8401 return( err );
8402 }
8403
8404 //===========================================================================================================================
8405 // StringToUInt32
8406 //===========================================================================================================================
8407
8408 static OSStatus StringToUInt32( const char *inString, uint32_t *outValue )
8409 {
8410 OSStatus err;
8411 uint32_t value;
8412 char * endPtr;
8413
8414 value = (uint32_t) strtol( inString, &endPtr, 0 );
8415 require_action_quiet( ( *endPtr == '\0' ) && ( endPtr != inString ), exit, err = kParamErr );
8416
8417 *outValue = value;
8418 err = kNoErr;
8419
8420 exit:
8421 return( err );
8422 }
8423
8424 #if( TARGET_OS_DARWIN )
8425 //===========================================================================================================================
8426 // GetDefaultDNSServer
8427 //===========================================================================================================================
8428
8429 static OSStatus GetDefaultDNSServer( sockaddr_ip *outAddr )
8430 {
8431 OSStatus err;
8432 dns_config_t * config;
8433 struct sockaddr * addr;
8434 int32_t i;
8435
8436 config = dns_configuration_copy();
8437 require_action( config, exit, err = kUnknownErr );
8438
8439 addr = NULL;
8440 for( i = 0; i < config->n_resolver; ++i )
8441 {
8442 const dns_resolver_t * const resolver = config->resolver[ i ];
8443
8444 if( !resolver->domain && ( resolver->n_nameserver > 0 ) )
8445 {
8446 addr = resolver->nameserver[ 0 ];
8447 break;
8448 }
8449 }
8450 require_action_quiet( addr, exit, err = kNotFoundErr );
8451
8452 SockAddrCopy( addr, outAddr );
8453 err = kNoErr;
8454
8455 exit:
8456 if( config ) dns_configuration_free( config );
8457 return( err );
8458 }
8459 #endif
8460
8461 //===========================================================================================================================
8462 // SocketWriteAll
8463 //
8464 // Note: This was copied from CoreUtils because the SocketWriteAll function is currently not exported in the framework.
8465 //===========================================================================================================================
8466
8467 OSStatus SocketWriteAll( SocketRef inSock, const void *inData, size_t inSize, int32_t inTimeoutSecs )
8468 {
8469 OSStatus err;
8470 const uint8_t * src;
8471 const uint8_t * end;
8472 fd_set writeSet;
8473 struct timeval timeout;
8474 ssize_t n;
8475
8476 FD_ZERO( &writeSet );
8477 src = (const uint8_t *) inData;
8478 end = src + inSize;
8479 while( src < end )
8480 {
8481 FD_SET( inSock, &writeSet );
8482 timeout.tv_sec = inTimeoutSecs;
8483 timeout.tv_usec = 0;
8484 n = select( (int)( inSock + 1 ), NULL, &writeSet, NULL, &timeout );
8485 if( n == 0 ) { err = kTimeoutErr; goto exit; }
8486 err = map_socket_value_errno( inSock, n > 0, n );
8487 require_noerr( err, exit );
8488
8489 n = send( inSock, (char *) src, (size_t)( end - src ), 0 );
8490 err = map_socket_value_errno( inSock, n >= 0, n );
8491 if( err == EINTR ) continue;
8492 require_noerr( err, exit );
8493
8494 src += n;
8495 }
8496 err = kNoErr;
8497
8498 exit:
8499 return( err );
8500 }
8501
8502 //===========================================================================================================================
8503 // ParseIPv4Address
8504 //
8505 // Warning: "inBuffer" may be modified even in error cases.
8506 //
8507 // Note: This was copied from CoreUtils because the StringToIPv4Address function is currently not exported in the framework.
8508 //===========================================================================================================================
8509
8510 static OSStatus ParseIPv4Address( const char *inStr, uint8_t inBuffer[ 4 ], const char **outStr )
8511 {
8512 OSStatus err;
8513 uint8_t * dst;
8514 int segments;
8515 int sawDigit;
8516 int c;
8517 int v;
8518
8519 check( inBuffer );
8520 check( outStr );
8521
8522 dst = inBuffer;
8523 *dst = 0;
8524 sawDigit = 0;
8525 segments = 0;
8526 for( ; ( c = *inStr ) != '\0'; ++inStr )
8527 {
8528 if( isdigit_safe( c ) )
8529 {
8530 v = ( *dst * 10 ) + ( c - '0' );
8531 require_action_quiet( v <= 255, exit, err = kRangeErr );
8532 *dst = (uint8_t) v;
8533 if( !sawDigit )
8534 {
8535 ++segments;
8536 require_action_quiet( segments <= 4, exit, err = kOverrunErr );
8537 sawDigit = 1;
8538 }
8539 }
8540 else if( ( c == '.' ) && sawDigit )
8541 {
8542 require_action_quiet( segments < 4, exit, err = kMalformedErr );
8543 *++dst = 0;
8544 sawDigit = 0;
8545 }
8546 else
8547 {
8548 break;
8549 }
8550 }
8551 require_action_quiet( segments == 4, exit, err = kUnderrunErr );
8552
8553 *outStr = inStr;
8554 err = kNoErr;
8555
8556 exit:
8557 return( err );
8558 }
8559
8560 //===========================================================================================================================
8561 // StringToIPv4Address
8562 //
8563 // Note: This was copied from CoreUtils because the StringToIPv4Address function is currently not exported in the framework.
8564 //===========================================================================================================================
8565
8566 OSStatus
8567 StringToIPv4Address(
8568 const char * inStr,
8569 StringToIPAddressFlags inFlags,
8570 uint32_t * outIP,
8571 int * outPort,
8572 uint32_t * outSubnet,
8573 uint32_t * outRouter,
8574 const char ** outStr )
8575 {
8576 OSStatus err;
8577 uint8_t buf[ 4 ];
8578 int c;
8579 uint32_t ip;
8580 int hasPort;
8581 int port;
8582 int hasPrefix;
8583 int prefix;
8584 uint32_t subnetMask;
8585 uint32_t router;
8586
8587 require_action( inStr, exit, err = kParamErr );
8588
8589 // Parse the address-only part of the address (e.g. "1.2.3.4").
8590
8591 err = ParseIPv4Address( inStr, buf, &inStr );
8592 require_noerr_quiet( err, exit );
8593 ip = (uint32_t)( ( buf[ 0 ] << 24 ) | ( buf[ 1 ] << 16 ) | ( buf[ 2 ] << 8 ) | buf[ 3 ] );
8594 c = *inStr;
8595
8596 // Parse the port (if any).
8597
8598 hasPort = 0;
8599 port = 0;
8600 if( c == ':' )
8601 {
8602 require_action_quiet( !( inFlags & kStringToIPAddressFlagsNoPort ), exit, err = kUnexpectedErr );
8603 while( ( ( c = *( ++inStr ) ) != '\0' ) && ( ( c >= '0' ) && ( c <= '9' ) ) ) port = ( port * 10 ) + ( c - '0' );
8604 require_action_quiet( port <= 65535, exit, err = kRangeErr );
8605 hasPort = 1;
8606 }
8607
8608 // Parse the prefix length (if any).
8609
8610 hasPrefix = 0;
8611 prefix = 0;
8612 subnetMask = 0;
8613 router = 0;
8614 if( c == '/' )
8615 {
8616 require_action_quiet( !( inFlags & kStringToIPAddressFlagsNoPrefix ), exit, err = kUnexpectedErr );
8617 while( ( ( c = *( ++inStr ) ) != '\0' ) && ( ( c >= '0' ) && ( c <= '9' ) ) ) prefix = ( prefix * 10 ) + ( c - '0' );
8618 require_action_quiet( ( prefix >= 0 ) && ( prefix <= 32 ), exit, err = kRangeErr );
8619 hasPrefix = 1;
8620
8621 subnetMask = ( prefix > 0 ) ? ( UINT32_C( 0xFFFFFFFF ) << ( 32 - prefix ) ) : 0;
8622 router = ( ip & subnetMask ) | 1;
8623 }
8624
8625 // Return the results. Only fill in port/prefix/router results if the info was found to allow for defaults.
8626
8627 if( outIP ) *outIP = ip;
8628 if( outPort && hasPort ) *outPort = port;
8629 if( outSubnet && hasPrefix ) *outSubnet = subnetMask;
8630 if( outRouter && hasPrefix ) *outRouter = router;
8631 if( outStr ) *outStr = inStr;
8632 err = kNoErr;
8633
8634 exit:
8635 return( err );
8636 }
8637
8638 //===========================================================================================================================
8639 // ParseIPv6Address
8640 //
8641 // Note: Parsed according to the rules specified in RFC 3513.
8642 // Warning: "inBuffer" may be modified even in error cases.
8643 //
8644 // Note: This was copied from CoreUtils because the StringToIPv6Address function is currently not exported in the framework.
8645 //===========================================================================================================================
8646
8647 static OSStatus ParseIPv6Address( const char *inStr, int inAllowV4Mapped, uint8_t inBuffer[ 16 ], const char **outStr )
8648 {
8649 // Table to map uppercase hex characters - '0' to their numeric values.
8650 // 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F
8651 static const uint8_t kASCIItoHexTable[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15 };
8652 OSStatus err;
8653 const char * ptr;
8654 uint8_t * dst;
8655 uint8_t * lim;
8656 uint8_t * colonPtr;
8657 int c;
8658 int sawDigit;
8659 unsigned int v;
8660 int i;
8661 int n;
8662
8663 // Pre-zero the address to simplify handling of compressed addresses (e.g. "::1").
8664
8665 for( i = 0; i < 16; ++i ) inBuffer[ i ] = 0;
8666
8667 // Special case leading :: (e.g. "::1") to simplify processing later.
8668
8669 if( *inStr == ':' )
8670 {
8671 ++inStr;
8672 require_action_quiet( *inStr == ':', exit, err = kMalformedErr );
8673 }
8674
8675 // Parse the address.
8676
8677 ptr = inStr;
8678 dst = inBuffer;
8679 lim = dst + 16;
8680 colonPtr = NULL;
8681 sawDigit = 0;
8682 v = 0;
8683 while( ( ( c = *inStr++ ) != '\0' ) && ( c != '%' ) && ( c != '/' ) && ( c != ']' ) )
8684 {
8685 if( ( c >= 'a' ) && ( c <= 'f' ) ) c -= ( 'a' - 'A' );
8686 if( ( ( c >= '0' ) && ( c <= '9' ) ) || ( ( c >= 'A' ) && ( c <= 'F' ) ) )
8687 {
8688 c -= '0';
8689 check( c < (int) countof( kASCIItoHexTable ) );
8690 v = ( v << 4 ) | kASCIItoHexTable[ c ];
8691 require_action_quiet( v <= 0xFFFF, exit, err = kRangeErr );
8692 sawDigit = 1;
8693 continue;
8694 }
8695 if( c == ':' )
8696 {
8697 ptr = inStr;
8698 if( !sawDigit )
8699 {
8700 require_action_quiet( !colonPtr, exit, err = kMalformedErr );
8701 colonPtr = dst;
8702 continue;
8703 }
8704 require_action_quiet( *inStr != '\0', exit, err = kUnderrunErr );
8705 require_action_quiet( ( dst + 2 ) <= lim, exit, err = kOverrunErr );
8706 *dst++ = (uint8_t)( ( v >> 8 ) & 0xFF );
8707 *dst++ = (uint8_t)( v & 0xFF );
8708 sawDigit = 0;
8709 v = 0;
8710 continue;
8711 }
8712
8713 // Handle IPv4-mapped/compatible addresses (e.g. ::FFFF:1.2.3.4).
8714
8715 if( inAllowV4Mapped && ( c == '.' ) && ( ( dst + 4 ) <= lim ) )
8716 {
8717 err = ParseIPv4Address( ptr, dst, &inStr );
8718 require_noerr_quiet( err, exit );
8719 dst += 4;
8720 sawDigit = 0;
8721 ++inStr; // Increment because the code below expects the end to be at "inStr - 1".
8722 }
8723 break;
8724 }
8725 if( sawDigit )
8726 {
8727 require_action_quiet( ( dst + 2 ) <= lim, exit, err = kOverrunErr );
8728 *dst++ = (uint8_t)( ( v >> 8 ) & 0xFF );
8729 *dst++ = (uint8_t)( v & 0xFF );
8730 }
8731 check( dst <= lim );
8732 if( colonPtr )
8733 {
8734 require_action_quiet( dst < lim, exit, err = kOverrunErr );
8735 n = (int)( dst - colonPtr );
8736 for( i = 1; i <= n; ++i )
8737 {
8738 lim[ -i ] = colonPtr[ n - i ];
8739 colonPtr[ n - i ] = 0;
8740 }
8741 dst = lim;
8742 }
8743 require_action_quiet( dst == lim, exit, err = kUnderrunErr );
8744
8745 *outStr = inStr - 1;
8746 err = kNoErr;
8747
8748 exit:
8749 return( err );
8750 }
8751
8752 //===========================================================================================================================
8753 // ParseIPv6Scope
8754 //
8755 // Note: This was copied from CoreUtils because the StringToIPv6Address function is currently not exported in the framework.
8756 //===========================================================================================================================
8757
8758 static OSStatus ParseIPv6Scope( const char *inStr, uint32_t *outScope, const char **outStr )
8759 {
8760 #if( TARGET_OS_POSIX )
8761 OSStatus err;
8762 char scopeStr[ 64 ];
8763 char * dst;
8764 char * lim;
8765 int c;
8766 uint32_t scope;
8767 const char * ptr;
8768
8769 // Copy into a local NULL-terminated string since that is what if_nametoindex expects.
8770
8771 dst = scopeStr;
8772 lim = dst + ( countof( scopeStr ) - 1 );
8773 while( ( ( c = *inStr ) != '\0' ) && ( c != ':' ) && ( c != '/' ) && ( c != ']' ) && ( dst < lim ) )
8774 {
8775 *dst++ = *inStr++;
8776 }
8777 *dst = '\0';
8778 check( dst <= lim );
8779
8780 // First try to map as a name and if that fails, treat it as a numeric scope.
8781
8782 scope = if_nametoindex( scopeStr );
8783 if( scope == 0 )
8784 {
8785 for( ptr = scopeStr; ( ( c = *ptr ) >= '0' ) && ( c <= '9' ); ++ptr )
8786 {
8787 scope = ( scope * 10 ) + ( ( (uint8_t) c ) - '0' );
8788 }
8789 require_action_quiet( c == '\0', exit, err = kMalformedErr );
8790 require_action_quiet( ( ptr != scopeStr ) && ( ( (int)( ptr - scopeStr ) ) <= 10 ), exit, err = kMalformedErr );
8791 }
8792
8793 *outScope = scope;
8794 *outStr = inStr;
8795 err = kNoErr;
8796
8797 exit:
8798 return( err );
8799 #else
8800 OSStatus err;
8801 uint32_t scope;
8802 const char * start;
8803 int c;
8804
8805 scope = 0;
8806 for( start = inStr; ( ( c = *inStr ) >= '0' ) && ( c <= '9' ); ++inStr )
8807 {
8808 scope = ( scope * 10 ) + ( c - '0' );
8809 }
8810 require_action_quiet( ( inStr != start ) && ( ( (int)( inStr - start ) ) <= 10 ), exit, err = kMalformedErr );
8811
8812 *outScope = scope;
8813 *outStr = inStr;
8814 err = kNoErr;
8815
8816 exit:
8817 return( err );
8818 #endif
8819 }
8820
8821 //===========================================================================================================================
8822 // StringToIPv6Address
8823 //
8824 // Note: This was copied from CoreUtils because the StringToIPv6Address function is currently not exported in the framework.
8825 //===========================================================================================================================
8826
8827 OSStatus
8828 StringToIPv6Address(
8829 const char * inStr,
8830 StringToIPAddressFlags inFlags,
8831 uint8_t outIPv6[ 16 ],
8832 uint32_t * outScope,
8833 int * outPort,
8834 int * outPrefix,
8835 const char ** outStr )
8836 {
8837 OSStatus err;
8838 uint8_t ipv6[ 16 ];
8839 int c;
8840 int hasScope;
8841 uint32_t scope;
8842 int hasPort;
8843 int port;
8844 int hasPrefix;
8845 int prefix;
8846 int hasBracket;
8847 int i;
8848
8849 require_action( inStr, exit, err = kParamErr );
8850
8851 if( *inStr == '[' ) ++inStr; // Skip a leading bracket for []-wrapped addresses (e.g. "[::1]:80").
8852
8853 // Parse the address-only part of the address (e.g. "1::1").
8854
8855 err = ParseIPv6Address( inStr, !( inFlags & kStringToIPAddressFlagsNoIPv4Mapped ), ipv6, &inStr );
8856 require_noerr_quiet( err, exit );
8857 c = *inStr;
8858
8859 // Parse the scope, port, or prefix length.
8860
8861 hasScope = 0;
8862 scope = 0;
8863 hasPort = 0;
8864 port = 0;
8865 hasPrefix = 0;
8866 prefix = 0;
8867 hasBracket = 0;
8868 for( ;; )
8869 {
8870 if( c == '%' ) // Scope (e.g. "%en0" or "%5")
8871 {
8872 require_action_quiet( !hasScope, exit, err = kMalformedErr );
8873 require_action_quiet( !( inFlags & kStringToIPAddressFlagsNoScope ), exit, err = kUnexpectedErr );
8874 ++inStr;
8875 err = ParseIPv6Scope( inStr, &scope, &inStr );
8876 require_noerr_quiet( err, exit );
8877 hasScope = 1;
8878 c = *inStr;
8879 }
8880 else if( c == ':' ) // Port (e.g. ":80")
8881 {
8882 require_action_quiet( !hasPort, exit, err = kMalformedErr );
8883 require_action_quiet( !( inFlags & kStringToIPAddressFlagsNoPort ), exit, err = kUnexpectedErr );
8884 while( ( ( c = *( ++inStr ) ) != '\0' ) && ( ( c >= '0' ) && ( c <= '9' ) ) ) port = ( port * 10 ) + ( c - '0' );
8885 require_action_quiet( port <= 65535, exit, err = kRangeErr );
8886 hasPort = 1;
8887 }
8888 else if( c == '/' ) // Prefix Length (e.g. "/64")
8889 {
8890 require_action_quiet( !hasPrefix, exit, err = kMalformedErr );
8891 require_action_quiet( !( inFlags & kStringToIPAddressFlagsNoPrefix ), exit, err = kUnexpectedErr );
8892 while( ( ( c = *( ++inStr ) ) != '\0' ) && ( ( c >= '0' ) && ( c <= '9' ) ) ) prefix = ( prefix * 10 ) + ( c - '0' );
8893 require_action_quiet( ( prefix >= 0 ) && ( prefix <= 128 ), exit, err = kRangeErr );
8894 hasPrefix = 1;
8895 }
8896 else if( c == ']' )
8897 {
8898 require_action_quiet( !hasBracket, exit, err = kMalformedErr );
8899 hasBracket = 1;
8900 c = *( ++inStr );
8901 }
8902 else
8903 {
8904 break;
8905 }
8906 }
8907
8908 // Return the results. Only fill in scope/port/prefix results if the info was found to allow for defaults.
8909
8910 if( outIPv6 ) for( i = 0; i < 16; ++i ) outIPv6[ i ] = ipv6[ i ];
8911 if( outScope && hasScope ) *outScope = scope;
8912 if( outPort && hasPort ) *outPort = port;
8913 if( outPrefix && hasPrefix ) *outPrefix = prefix;
8914 if( outStr ) *outStr = inStr;
8915 err = kNoErr;
8916
8917 exit:
8918 return( err );
8919 }
8920
8921 //===========================================================================================================================
8922 // StringArray_Append
8923 //
8924 // Note: This was copied from CoreUtils because the StringArray_Append function is currently not exported in the framework.
8925 //===========================================================================================================================
8926
8927 OSStatus StringArray_Append( char ***ioArray, size_t *ioCount, const char *inStr )
8928 {
8929 OSStatus err;
8930 char * newStr;
8931 size_t oldCount;
8932 size_t newCount;
8933 char ** oldArray;
8934 char ** newArray;
8935
8936 newStr = strdup( inStr );
8937 require_action( newStr, exit, err = kNoMemoryErr );
8938
8939 oldCount = *ioCount;
8940 newCount = oldCount + 1;
8941 newArray = (char **) malloc( newCount * sizeof( *newArray ) );
8942 require_action( newArray, exit, err = kNoMemoryErr );
8943
8944 if( oldCount > 0 )
8945 {
8946 oldArray = *ioArray;
8947 memcpy( newArray, oldArray, oldCount * sizeof( *oldArray ) );
8948 free( oldArray );
8949 }
8950 newArray[ oldCount ] = newStr;
8951 newStr = NULL;
8952
8953 *ioArray = newArray;
8954 *ioCount = newCount;
8955 err = kNoErr;
8956
8957 exit:
8958 if( newStr ) free( newStr );
8959 return( err );
8960 }
8961
8962 //===========================================================================================================================
8963 // StringArray_Free
8964 //
8965 // Note: This was copied from CoreUtils because the StringArray_Free function is currently not exported in the framework.
8966 //===========================================================================================================================
8967
8968 void StringArray_Free( char **inArray, size_t inCount )
8969 {
8970 size_t i;
8971
8972 for( i = 0; i < inCount; ++i )
8973 {
8974 free( inArray[ i ] );
8975 }
8976 if( inCount > 0 ) free( inArray );
8977 }
8978
8979 //===========================================================================================================================
8980 // ParseQuotedEscapedString
8981 //
8982 // Note: This was copied from CoreUtils because it's currently not exported in the framework.
8983 //===========================================================================================================================
8984
8985 Boolean
8986 ParseQuotedEscapedString(
8987 const char * inSrc,
8988 const char * inEnd,
8989 const char * inDelimiters,
8990 char * inBuf,
8991 size_t inMaxLen,
8992 size_t * outCopiedLen,
8993 size_t * outTotalLen,
8994 const char ** outSrc )
8995 {
8996 const unsigned char * src;
8997 const unsigned char * end;
8998 unsigned char * dst;
8999 unsigned char * lim;
9000 unsigned char c;
9001 unsigned char c2;
9002 size_t totalLen;
9003 Boolean singleQuote;
9004 Boolean doubleQuote;
9005
9006 if( inEnd == NULL ) inEnd = inSrc + strlen( inSrc );
9007 src = (const unsigned char *) inSrc;
9008 end = (const unsigned char *) inEnd;
9009 dst = (unsigned char *) inBuf;
9010 lim = dst + inMaxLen;
9011 while( ( src < end ) && isspace_safe( *src ) ) ++src; // Skip leading spaces.
9012 if( src >= end ) return( false );
9013
9014 // Parse each argument from the string.
9015 //
9016 // See <http://resources.mpi-inf.mpg.de/departments/rg1/teaching/unixffb-ss98/quoting-guide.html> for details.
9017
9018 totalLen = 0;
9019 singleQuote = false;
9020 doubleQuote = false;
9021 while( src < end )
9022 {
9023 c = *src++;
9024 if( singleQuote )
9025 {
9026 // Single quotes protect everything (even backslashes, newlines, etc.) except single quotes.
9027
9028 if( c == '\'' )
9029 {
9030 singleQuote = false;
9031 continue;
9032 }
9033 }
9034 else if( doubleQuote )
9035 {
9036 // Double quotes protect everything except double quotes and backslashes. A backslash can be
9037 // used to protect " or \ within double quotes. A backslash-newline pair disappears completely.
9038 // A backslash followed by x or X and 2 hex digits (e.g. "\x1f") is stored as that hex byte.
9039 // A backslash followed by 3 octal digits (e.g. "\377") is stored as that octal byte.
9040 // A backslash that does not precede ", \, x, X, or a newline is taken literally.
9041
9042 if( c == '"' )
9043 {
9044 doubleQuote = false;
9045 continue;
9046 }
9047 else if( c == '\\' )
9048 {
9049 if( src < end )
9050 {
9051 c2 = *src;
9052 if( ( c2 == '"' ) || ( c2 == '\\' ) )
9053 {
9054 ++src;
9055 c = c2;
9056 }
9057 else if( c2 == '\n' )
9058 {
9059 ++src;
9060 continue;
9061 }
9062 else if( ( c2 == 'x' ) || ( c2 == 'X' ) )
9063 {
9064 ++src;
9065 c = c2;
9066 if( ( ( end - src ) >= 2 ) && IsHexPair( src ) )
9067 {
9068 c = HexPairToByte( src );
9069 src += 2;
9070 }
9071 }
9072 else if( isoctal_safe( c2 ) )
9073 {
9074 if( ( ( end - src ) >= 3 ) && IsOctalTriple( src ) )
9075 {
9076 c = OctalTripleToByte( src );
9077 src += 3;
9078 }
9079 }
9080 }
9081 }
9082 }
9083 else if( strchr( inDelimiters, c ) )
9084 {
9085 break;
9086 }
9087 else if( c == '\\' )
9088 {
9089 // A backslash protects the next character, except a newline, x, X and 2 hex bytes or 3 octal bytes.
9090 // A backslash followed by a newline disappears completely.
9091 // A backslash followed by x or X and 2 hex digits (e.g. "\x1f") is stored as that hex byte.
9092 // A backslash followed by 3 octal digits (e.g. "\377") is stored as that octal byte.
9093
9094 if( src < end )
9095 {
9096 c = *src;
9097 if( c == '\n' )
9098 {
9099 ++src;
9100 continue;
9101 }
9102 else if( ( c == 'x' ) || ( c == 'X' ) )
9103 {
9104 ++src;
9105 if( ( ( end - src ) >= 2 ) && IsHexPair( src ) )
9106 {
9107 c = HexPairToByte( src );
9108 src += 2;
9109 }
9110 }
9111 else if( isoctal_safe( c ) )
9112 {
9113 if( ( ( end - src ) >= 3 ) && IsOctalTriple( src ) )
9114 {
9115 c = OctalTripleToByte( src );
9116 src += 3;
9117 }
9118 else
9119 {
9120 ++src;
9121 }
9122 }
9123 else
9124 {
9125 ++src;
9126 }
9127 }
9128 }
9129 else if( c == '\'' )
9130 {
9131 singleQuote = true;
9132 continue;
9133 }
9134 else if( c == '"' )
9135 {
9136 doubleQuote = true;
9137 continue;
9138 }
9139
9140 if( dst < lim )
9141 {
9142 if( inBuf ) *dst = c;
9143 ++dst;
9144 }
9145 ++totalLen;
9146 }
9147
9148 if( outCopiedLen ) *outCopiedLen = (size_t)( dst - ( (unsigned char *) inBuf ) );
9149 if( outTotalLen ) *outTotalLen = totalLen;
9150 if( outSrc ) *outSrc = (const char *) src;
9151 return( true );
9152 }
mirror of mDNSResponder