1 /* -*- Mode: C; tab-width: 4 -*-
2  *
3  * Copyright (c) 2002-2018 Apple Inc. All rights reserved.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16 
17    NOTE:
18    If you're building an application that uses DNS Service Discovery
19    this is probably NOT the header file you're looking for.
20    In most cases you will want to use /usr/include/dns_sd.h instead.
21 
22    This header file defines the lowest level raw interface to mDNSCore,
23    which is appropriate *only* on tiny embedded systems where everything
24    runs in a single address space and memory is extremely constrained.
25    All the APIs here are malloc-free, which means that the caller is
26    responsible for passing in a pointer to the relevant storage that
27    will be used in the execution of that call, and (when called with
28    correct parameters) all the calls are guaranteed to succeed. There
29    is never a case where a call can suffer intermittent failures because
30    the implementation calls malloc() and sometimes malloc() returns NULL
31    because memory is so limited that no more is available.
32    This is primarily for devices that need to have precisely known fixed
33    memory requirements, with absolutely no uncertainty or run-time variation,
34    but that certainty comes at a cost of more difficult programming.
35 
36    For applications running on general-purpose desktop operating systems
37    (Mac OS, Linux, Solaris, Windows, etc.) the API you should use is
38    /usr/include/dns_sd.h, which defines the API by which multiple
39    independent client processes communicate their DNS Service Discovery
40    requests to a single "mdnsd" daemon running in the background.
41 
42    Even on platforms that don't run multiple independent processes in
43    multiple independent address spaces, you can still use the preferred
44    dns_sd.h APIs by linking in "dnssd_clientshim.c", which implements
45    the standard "dns_sd.h" API calls, allocates any required storage
46    using malloc(), and then calls through to the low-level malloc-free
47    mDNSCore routines defined here. This has the benefit that even though
48    you're running on a small embedded system with a single address space,
49    you can still use the exact same client C code as you'd use on a
50    general-purpose desktop system.
51 
52  */
53 
54 #ifndef __mDNSEmbeddedAPI_h
55 #define __mDNSEmbeddedAPI_h
56 
57 #if defined(EFI32) || defined(EFI64) || defined(EFIX64)
58 // EFI doesn't have stdarg.h unless it's building with GCC.
59 #include "Tiano.h"
60 #if !defined(__GNUC__)
61 #define va_list         VA_LIST
62 #define va_start(a, b)  VA_START(a, b)
63 #define va_end(a)       VA_END(a)
64 #define va_arg(a, b)    VA_ARG(a, b)
65 #endif
66 #else
67 #include <stdarg.h>     // stdarg.h is required for for va_list support for the mDNS_vsnprintf declaration
68 #endif
69 
70 #include "mDNSDebug.h"
71 #if APPLE_OSX_mDNSResponder
72 #include <uuid/uuid.h>
73 #include <TargetConditionals.h>
74 #endif
75 
76 #ifdef __cplusplus
77 extern "C" {
78 #endif
79 
80 // ***************************************************************************
81 // Feature removal compile options & limited resource targets
82 
83 // The following compile options are responsible for removing certain features from mDNSCore to reduce the
84 // memory footprint for use in embedded systems with limited resources.
85 
86 // UNICAST_DISABLED - disables unicast DNS functionality, including Wide Area Bonjour
87 // ANONYMOUS_DISABLED - disables anonymous functionality
88 // DNSSEC_DISABLED - disables DNSSEC functionality
89 // SPC_DISABLED - disables Bonjour Sleep Proxy client
90 // IDLESLEEPCONTROL_DISABLED - disables sleep control for Bonjour Sleep Proxy clients
91 
92 // In order to disable the above features pass the option to your compiler, e.g. -D UNICAST_DISABLED
93 
94 // Additionally, the LIMITED_RESOURCES_TARGET compile option will reduce the maximum DNS message sizes.
95 
96 #ifdef LIMITED_RESOURCES_TARGET
97 // Don't support jumbo frames
98 // 40 (IPv6 header) + 8 (UDP header) + 12 (DNS message header) + 1440 (DNS message body) = 1500 total
99 #define AbsoluteMaxDNSMessageData   1440
100 // StandardAuthRDSize is 264 (256+8), which is large enough to hold a maximum-sized SRV record (6 + 256 bytes)
101 #define MaximumRDSize               264
102 #endif
103 
104 #if !defined(MDNSRESPONDER_BTMM_SUPPORT)
105 #define MDNSRESPONDER_BTMM_SUPPORT 0
106 #endif
107 
108 // ***************************************************************************
109 // Function scope indicators
110 
111 // If you see "mDNSlocal" before a function name in a C file, it means the function is not callable outside this file
112 #ifndef mDNSlocal
113 #define mDNSlocal static
114 #endif
115 // If you see "mDNSexport" before a symbol in a C file, it means the symbol is exported for use by clients
116 // For every "mDNSexport" in a C file, there needs to be a corresponding "extern" declaration in some header file
117 // (When a C file #includes a header file, the "extern" declarations tell the compiler:
118 // "This symbol exists -- but not necessarily in this C file.")
119 #ifndef mDNSexport
120 #define mDNSexport
121 #endif
122 
123 // Explanation: These local/export markers are a little habit of mine for signaling the programmers' intentions.
124 // When "mDNSlocal" is just a synonym for "static", and "mDNSexport" is a complete no-op, you could be
125 // forgiven for asking what purpose they serve. The idea is that if you see "mDNSexport" in front of a
126 // function definition it means the programmer intended it to be exported and callable from other files
127 // in the project. If you see "mDNSlocal" in front of a function definition it means the programmer
128 // intended it to be private to that file. If you see neither in front of a function definition it
129 // means the programmer forgot (so you should work out which it is supposed to be, and fix it).
130 // Using "mDNSlocal" instead of "static" makes it easier to do a textual searches for one or the other.
131 // For example you can do a search for "static" to find if any functions declare any local variables as "static"
132 // (generally a bad idea unless it's also "const", because static storage usually risks being non-thread-safe)
133 // without the results being cluttered with hundreds of matches for functions declared static.
134 // - Stuart Cheshire
135 
136 // ***************************************************************************
137 // Structure packing macro
138 
139 // If we're not using GNUC, it's not fatal.
140 // Most compilers naturally pack the on-the-wire structures correctly anyway, so a plain "struct" is usually fine.
141 // In the event that structures are not packed correctly, mDNS_Init() will detect this and report an error, so the
142 // developer will know what's wrong, and can investigate what needs to be done on that compiler to provide proper packing.
143 #ifndef packedstruct
144  #if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))
145   #define packedstruct struct __attribute__((__packed__))
146   #define packedunion  union  __attribute__((__packed__))
147  #else
148   #define packedstruct struct
149   #define packedunion  union
150  #endif
151 #endif
152 
153 // ***************************************************************************
154 #if 0
155 #pragma mark - DNS Resource Record class and type constants
156 #endif
157 
158 typedef enum                            // From RFC 1035
159 {
160     kDNSClass_IN               = 1,     // Internet
161     kDNSClass_CS               = 2,     // CSNET
162     kDNSClass_CH               = 3,     // CHAOS
163     kDNSClass_HS               = 4,     // Hesiod
164     kDNSClass_NONE             = 254,   // Used in DNS UPDATE [RFC 2136]
165 
166     kDNSClass_Mask             = 0x7FFF, // Multicast DNS uses the bottom 15 bits to identify the record class...
167     kDNSClass_UniqueRRSet      = 0x8000, // ... and the top bit indicates that all other cached records are now invalid
168 
169     kDNSQClass_ANY             = 255,   // Not a DNS class, but a DNS query class, meaning "all classes"
170     kDNSQClass_UnicastResponse = 0x8000 // Top bit set in a question means "unicast response acceptable"
171 } DNS_ClassValues;
172 
173 typedef enum                // From RFC 1035
174 {
175     kDNSType_A = 1,         //  1 Address
176     kDNSType_NS,            //  2 Name Server
177     kDNSType_MD,            //  3 Mail Destination
178     kDNSType_MF,            //  4 Mail Forwarder
179     kDNSType_CNAME,         //  5 Canonical Name
180     kDNSType_SOA,           //  6 Start of Authority
181     kDNSType_MB,            //  7 Mailbox
182     kDNSType_MG,            //  8 Mail Group
183     kDNSType_MR,            //  9 Mail Rename
184     kDNSType_NULL,          // 10 NULL RR
185     kDNSType_WKS,           // 11 Well-known-service
186     kDNSType_PTR,           // 12 Domain name pointer
187     kDNSType_HINFO,         // 13 Host information
188     kDNSType_MINFO,         // 14 Mailbox information
189     kDNSType_MX,            // 15 Mail Exchanger
190     kDNSType_TXT,           // 16 Arbitrary text string
191     kDNSType_RP,            // 17 Responsible person
192     kDNSType_AFSDB,         // 18 AFS cell database
193     kDNSType_X25,           // 19 X_25 calling address
194     kDNSType_ISDN,          // 20 ISDN calling address
195     kDNSType_RT,            // 21 Router
196     kDNSType_NSAP,          // 22 NSAP address
197     kDNSType_NSAP_PTR,      // 23 Reverse NSAP lookup (deprecated)
198     kDNSType_SIG,           // 24 Security signature
199     kDNSType_KEY,           // 25 Security key
200     kDNSType_PX,            // 26 X.400 mail mapping
201     kDNSType_GPOS,          // 27 Geographical position (withdrawn)
202     kDNSType_AAAA,          // 28 IPv6 Address
203     kDNSType_LOC,           // 29 Location Information
204     kDNSType_NXT,           // 30 Next domain (security)
205     kDNSType_EID,           // 31 Endpoint identifier
206     kDNSType_NIMLOC,        // 32 Nimrod Locator
207     kDNSType_SRV,           // 33 Service record
208     kDNSType_ATMA,          // 34 ATM Address
209     kDNSType_NAPTR,         // 35 Naming Authority PoinTeR
210     kDNSType_KX,            // 36 Key Exchange
211     kDNSType_CERT,          // 37 Certification record
212     kDNSType_A6,            // 38 IPv6 Address (deprecated)
213     kDNSType_DNAME,         // 39 Non-terminal DNAME (for IPv6)
214     kDNSType_SINK,          // 40 Kitchen sink (experimental)
215     kDNSType_OPT,           // 41 EDNS0 option (meta-RR)
216     kDNSType_APL,           // 42 Address Prefix List
217     kDNSType_DS,            // 43 Delegation Signer
218     kDNSType_SSHFP,         // 44 SSH Key Fingerprint
219     kDNSType_IPSECKEY,      // 45 IPSECKEY
220     kDNSType_RRSIG,         // 46 RRSIG
221     kDNSType_NSEC,          // 47 Denial of Existence
222     kDNSType_DNSKEY,        // 48 DNSKEY
223     kDNSType_DHCID,         // 49 DHCP Client Identifier
224     kDNSType_NSEC3,         // 50 Hashed Authenticated Denial of Existence
225     kDNSType_NSEC3PARAM,    // 51 Hashed Authenticated Denial of Existence
226 
227     kDNSType_HIP = 55,      // 55 Host Identity Protocol
228 
229     kDNSType_SPF = 99,      // 99 Sender Policy Framework for E-Mail
230     kDNSType_UINFO,         // 100 IANA-Reserved
231     kDNSType_UID,           // 101 IANA-Reserved
232     kDNSType_GID,           // 102 IANA-Reserved
233     kDNSType_UNSPEC,        // 103 IANA-Reserved
234 
235     kDNSType_TKEY = 249,    // 249 Transaction key
236     kDNSType_TSIG,          // 250 Transaction signature
237     kDNSType_IXFR,          // 251 Incremental zone transfer
238     kDNSType_AXFR,          // 252 Transfer zone of authority
239     kDNSType_MAILB,         // 253 Transfer mailbox records
240     kDNSType_MAILA,         // 254 Transfer mail agent records
241     kDNSQType_ANY           // Not a DNS type, but a DNS query type, meaning "all types"
242 } DNS_TypeValues;
243 
244 // ***************************************************************************
245 #if 0
246 #pragma mark -
247 #pragma mark - Simple types
248 #endif
249 
250 // mDNS defines its own names for these common types to simplify portability across
251 // multiple platforms that may each have their own (different) names for these types.
252 typedef unsigned char mDNSBool;
253 typedef   signed char mDNSs8;
254 typedef unsigned char mDNSu8;
255 typedef   signed short mDNSs16;
256 typedef unsigned short mDNSu16;
257 
258 // Source: http://www.unix.org/version2/whatsnew/lp64_wp.html
259 // http://software.intel.com/sites/products/documentation/hpc/mkl/lin/MKL_UG_structure/Support_for_ILP64_Programming.htm
260 // It can be safely assumed that int is 32bits on the platform
261 #if defined(_ILP64) || defined(__ILP64__)
262 typedef   signed int32 mDNSs32;
263 typedef unsigned int32 mDNSu32;
264 #else
265 typedef   signed int mDNSs32;
266 typedef unsigned int mDNSu32;
267 #endif
268 
269 // To enforce useful type checking, we make mDNSInterfaceID be a pointer to a dummy struct
270 // This way, mDNSInterfaceIDs can be assigned, and compared with each other, but not with other types
271 // Declaring the type to be the typical generic "void *" would lack this type checking
272 typedef struct mDNSInterfaceID_dummystruct { void *dummy; } *mDNSInterfaceID;
273 
274 // These types are for opaque two- and four-byte identifiers.
275 // The "NotAnInteger" fields of the unions allow the value to be conveniently passed around in a
276 // register for the sake of efficiency, and compared for equality or inequality, but don't forget --
277 // just because it is in a register doesn't mean it is an integer. Operations like greater than,
278 // less than, add, multiply, increment, decrement, etc., are undefined for opaque identifiers,
279 // and if you make the mistake of trying to do those using the NotAnInteger field, then you'll
280 // find you get code that doesn't work consistently on big-endian and little-endian machines.
281 #if defined(_WIN32)
282  #pragma pack(push,2)
283 #elif !defined(__GNUC__)
284  #pragma pack(1)
285 #endif
286 typedef       union { mDNSu8 b[ 2]; mDNSu16 NotAnInteger; } mDNSOpaque16;
287 typedef       union { mDNSu8 b[ 4]; mDNSu32 NotAnInteger; } mDNSOpaque32;
288 typedef packedunion { mDNSu8 b[ 6]; mDNSu16 w[3]; mDNSu32 l[1]; } mDNSOpaque48;
289 typedef       union { mDNSu8 b[ 8]; mDNSu16 w[4]; mDNSu32 l[2]; } mDNSOpaque64;
290 typedef       union { mDNSu8 b[16]; mDNSu16 w[8]; mDNSu32 l[4]; } mDNSOpaque128;
291 #if defined(_WIN32)
292  #pragma pack(pop)
293 #elif !defined(__GNUC__)
294  #pragma pack()
295 #endif
296 
297 typedef mDNSOpaque16 mDNSIPPort;        // An IP port is a two-byte opaque identifier (not an integer)
298 typedef mDNSOpaque32 mDNSv4Addr;        // An IP address is a four-byte opaque identifier (not an integer)
299 typedef mDNSOpaque128 mDNSv6Addr;       // An IPv6 address is a 16-byte opaque identifier (not an integer)
300 typedef mDNSOpaque48 mDNSEthAddr;       // An Ethernet address is a six-byte opaque identifier (not an integer)
301 
302 // Bit operations for opaque 64 bit quantity. Uses the 32 bit quantity(l[2]) to set and clear bits
303 #define mDNSNBBY 8
304 #define bit_set_opaque64(op64, index) (op64.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] |= (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
305 #define bit_clr_opaque64(op64, index) (op64.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] &= ~(1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
306 #define bit_get_opaque64(op64, index) (op64.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] & (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
307 
308 // Bit operations for opaque 128 bit quantity. Uses the 32 bit quantity(l[4]) to set and clear bits
309 #define bit_set_opaque128(op128, index) (op128.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] |= (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
310 #define bit_clr_opaque128(op128, index) (op128.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] &= ~(1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
311 #define bit_get_opaque128(op128, index) (op128.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] & (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
312 
313 typedef enum
314 {
315     mDNSAddrType_None    = 0,
316     mDNSAddrType_IPv4    = 4,
317     mDNSAddrType_IPv6    = 6,
318     mDNSAddrType_Unknown = ~0   // Special marker value used in known answer list recording
319 } mDNSAddr_Type;
320 
321 typedef enum
322 {
323     mDNSTransport_None = 0,
324     mDNSTransport_UDP  = 1,
325     mDNSTransport_TCP  = 2
326 } mDNSTransport_Type;
327 
328 typedef struct
329 {
330     mDNSs32 type;
331     union { mDNSv6Addr v6; mDNSv4Addr v4; } ip;
332 } mDNSAddr;
333 
334 enum { mDNSfalse = 0, mDNStrue = 1 };
335 
336 #define mDNSNULL 0L
337 
338 enum
339 {
340     mStatus_Waiting           = 1,
341     mStatus_NoError           = 0,
342 
343     // mDNS return values are in the range FFFE FF00 (-65792) to FFFE FFFF (-65537)
344     // The top end of the range (FFFE FFFF) is used for error codes;
345     // the bottom end of the range (FFFE FF00) is used for non-error values;
346 
347     // Error codes:
348     mStatus_UnknownErr                = -65537,     // First value: 0xFFFE FFFF
349     mStatus_NoSuchNameErr             = -65538,
350     mStatus_NoMemoryErr               = -65539,
351     mStatus_BadParamErr               = -65540,
352     mStatus_BadReferenceErr           = -65541,
353     mStatus_BadStateErr               = -65542,
354     mStatus_BadFlagsErr               = -65543,
355     mStatus_UnsupportedErr            = -65544,
356     mStatus_NotInitializedErr         = -65545,
357     mStatus_NoCache                   = -65546,
358     mStatus_AlreadyRegistered         = -65547,
359     mStatus_NameConflict              = -65548,
360     mStatus_Invalid                   = -65549,
361     mStatus_Firewall                  = -65550,
362     mStatus_Incompatible              = -65551,
363     mStatus_BadInterfaceErr           = -65552,
364     mStatus_Refused                   = -65553,
365     mStatus_NoSuchRecord              = -65554,
366     mStatus_NoAuth                    = -65555,
367     mStatus_NoSuchKey                 = -65556,
368     mStatus_NATTraversal              = -65557,
369     mStatus_DoubleNAT                 = -65558,
370     mStatus_BadTime                   = -65559,
371     mStatus_BadSig                    = -65560,     // while we define this per RFC 2845, BIND 9 returns Refused for bad/missing signatures
372     mStatus_BadKey                    = -65561,
373     mStatus_TransientErr              = -65562,     // transient failures, e.g. sending packets shortly after a network transition or wake from sleep
374     mStatus_ServiceNotRunning         = -65563,     // Background daemon not running
375     mStatus_NATPortMappingUnsupported = -65564,     // NAT doesn't support PCP, NAT-PMP or UPnP
376     mStatus_NATPortMappingDisabled    = -65565,     // NAT supports PCP, NAT-PMP or UPnP, but it's disabled by the administrator
377     mStatus_NoRouter                  = -65566,
378     mStatus_PollingMode               = -65567,
379     mStatus_Timeout                   = -65568,
380     mStatus_HostUnreachErr            = -65569,
381     // -65570 to -65786 currently unused; available for allocation
382 
383     // tcp connection status
384     mStatus_ConnPending       = -65787,
385     mStatus_ConnFailed        = -65788,
386     mStatus_ConnEstablished   = -65789,
387 
388     // Non-error values:
389     mStatus_GrowCache         = -65790,
390     mStatus_ConfigChanged     = -65791,
391     mStatus_MemFree           = -65792      // Last value: 0xFFFE FF00
392                                 // mStatus_MemFree is the last legal mDNS error code, at the end of the range allocated for mDNS
393 };
394 
395 typedef mDNSs32 mStatus;
396 #define MaxIp 5 // Needs to be consistent with MaxInputIf in dns_services.h
397 
398 typedef enum { q_stop = 0, q_start } q_state;
399 typedef enum { reg_stop = 0, reg_start } reg_state;
400 
401 // RFC 1034/1035 specify that a domain label consists of a length byte plus up to 63 characters
402 #define MAX_DOMAIN_LABEL 63
403 typedef struct { mDNSu8 c[ 64]; } domainlabel;      // One label: length byte and up to 63 characters
404 
405 // RFC 1034/1035/2181 specify that a domain name (length bytes and data bytes) may be up to 255 bytes long,
406 // plus the terminating zero at the end makes 256 bytes total in the on-the-wire format.
407 #define MAX_DOMAIN_NAME 256
408 typedef struct { mDNSu8 c[256]; } domainname;       // Up to 256 bytes of length-prefixed domainlabels
409 
410 typedef struct { mDNSu8 c[256]; } UTF8str255;       // Null-terminated C string
411 
412 // The longest legal textual form of a DNS name is 1009 bytes, including the C-string terminating NULL at the end.
413 // Explanation:
414 // When a native domainname object is converted to printable textual form using ConvertDomainNameToCString(),
415 // non-printing characters are represented in the conventional DNS way, as '\ddd', where ddd is a three-digit decimal number.
416 // The longest legal domain name is 256 bytes, in the form of four labels as shown below:
417 // Length byte, 63 data bytes, length byte, 63 data bytes, length byte, 63 data bytes, length byte, 62 data bytes, zero byte.
418 // Each label is encoded textually as characters followed by a trailing dot.
419 // If every character has to be represented as a four-byte escape sequence, then this makes the maximum textual form four labels
420 // plus the C-string terminating NULL as shown below:
421 // 63*4+1 + 63*4+1 + 63*4+1 + 62*4+1 + 1 = 1009.
422 // Note that MAX_ESCAPED_DOMAIN_LABEL is not normally used: If you're only decoding a single label, escaping is usually not required.
423 // It is for domain names, where dots are used as label separators, that proper escaping is vital.
424 #define MAX_ESCAPED_DOMAIN_LABEL 254
425 #define MAX_ESCAPED_DOMAIN_NAME 1009
426 
427 // MAX_REVERSE_MAPPING_NAME
428 // For IPv4: "123.123.123.123.in-addr.arpa."  30 bytes including terminating NUL
429 // For IPv6: "x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.ip6.arpa."  74 bytes including terminating NUL
430 
431 #define MAX_REVERSE_MAPPING_NAME_V4 30
432 #define MAX_REVERSE_MAPPING_NAME_V6 74
433 #define MAX_REVERSE_MAPPING_NAME    74
434 
435 // Most records have a TTL of 75 minutes, so that their 80% cache-renewal query occurs once per hour.
436 // For records containing a hostname (in the name on the left, or in the rdata on the right),
437 // like A, AAAA, reverse-mapping PTR, and SRV, we use a two-minute TTL by default, because we don't want
438 // them to hang around for too long in the cache if the host in question crashes or otherwise goes away.
439 
440 #define kStandardTTL (3600UL * 100 / 80)
441 #define kHostNameTTL 120UL
442 
443 // Some applications want to register their SRV records with a lower ttl so that in case the server
444 // using a dynamic port number restarts, the clients will not have stale information for more than
445 // 10 seconds
446 
447 #define kHostNameSmallTTL 10UL
448 
449 
450 // Multicast DNS uses announcements (gratuitous responses) to update peer caches.
451 // This means it is feasible to use relatively larger TTL values than we might otherwise
452 // use, because we have a cache coherency protocol to keep the peer caches up to date.
453 // With Unicast DNS, once an authoritative server gives a record with a certain TTL value to a client
454 // or caching server, that client or caching server is entitled to hold onto the record until its TTL
455 // expires, and has no obligation to contact the authoritative server again until that time arrives.
456 // This means that whereas Multicast DNS can use announcements to pre-emptively update stale data
457 // before it would otherwise have expired, standard Unicast DNS (not using LLQs) has no equivalent
458 // mechanism, and TTL expiry is the *only* mechanism by which stale data gets deleted. Because of this,
459 // we currently limit the TTL to ten seconds in such cases where no dynamic cache updating is possible.
460 #define kStaticCacheTTL 10
461 
462 #define DefaultTTLforRRType(X) (((X) == kDNSType_A || (X) == kDNSType_AAAA || (X) == kDNSType_SRV) ? kHostNameTTL : kStandardTTL)
463 #define mDNS_KeepaliveRecord(rr) ((rr)->rrtype == kDNSType_NULL && SameDomainLabel(SecondLabel((rr)->name)->c, (mDNSu8 *)"\x0A_keepalive"))
464 
465 // Number of times keepalives are sent if no ACK is received before waking up the system
466 // this is analogous to net.inet.tcp.keepcnt
467 #define kKeepaliveRetryCount    10
468 // The frequency at which keepalives are retried if no ACK is received
469 #define kKeepaliveRetryInterval 30
470 
471 typedef struct AuthRecord_struct AuthRecord;
472 typedef struct ServiceRecordSet_struct ServiceRecordSet;
473 typedef struct CacheRecord_struct CacheRecord;
474 typedef struct CacheGroup_struct CacheGroup;
475 typedef struct AuthGroup_struct AuthGroup;
476 typedef struct DNSQuestion_struct DNSQuestion;
477 typedef struct ZoneData_struct ZoneData;
478 typedef struct mDNS_struct mDNS;
479 typedef struct mDNS_PlatformSupport_struct mDNS_PlatformSupport;
480 typedef struct NATTraversalInfo_struct NATTraversalInfo;
481 typedef struct ResourceRecord_struct ResourceRecord;
482 
483 // Structure to abstract away the differences between TCP/SSL sockets, and one for UDP sockets
484 // The actual definition of these structures appear in the appropriate platform support code
485 typedef struct TCPSocket_struct TCPSocket;
486 typedef struct UDPSocket_struct UDPSocket;
487 
488 // ***************************************************************************
489 #if 0
490 #pragma mark -
491 #pragma mark - DNS Message structures
492 #endif
493 
494 #define mDNS_numZones   numQuestions
495 #define mDNS_numPrereqs numAnswers
496 #define mDNS_numUpdates numAuthorities
497 
498 typedef struct
499 {
500     mDNSOpaque16 id;
501     mDNSOpaque16 flags;
502     mDNSu16 numQuestions;
503     mDNSu16 numAnswers;
504     mDNSu16 numAuthorities;
505     mDNSu16 numAdditionals;
506 } DNSMessageHeader;
507 
508 // We can send and receive packets up to 9000 bytes (Ethernet Jumbo Frame size, if that ever becomes widely used)
509 // However, in the normal case we try to limit packets to 1500 bytes so that we don't get IP fragmentation on standard Ethernet
510 // 40 (IPv6 header) + 8 (UDP header) + 12 (DNS message header) + 1440 (DNS message body) = 1500 total
511 #ifndef AbsoluteMaxDNSMessageData
512 #define AbsoluteMaxDNSMessageData 8940
513 #endif
514 #define NormalMaxDNSMessageData 1440
515 typedef struct
516 {
517     DNSMessageHeader h;                     // Note: Size 12 bytes
518     mDNSu8 data[AbsoluteMaxDNSMessageData]; // 40 (IPv6) + 8 (UDP) + 12 (DNS header) + 8940 (data) = 9000
519 } DNSMessage;
520 
521 typedef struct tcpInfo_t
522 {
523     mDNS             *m;
524     TCPSocket        *sock;
525     DNSMessage request;
526     int requestLen;
527     DNSQuestion      *question;   // For queries
528     AuthRecord       *rr;         // For record updates
529     mDNSAddr Addr;
530     mDNSIPPort Port;
531     mDNSIPPort SrcPort;
532     DNSMessage       *reply;
533     mDNSu16 replylen;
534     unsigned long nread;
535     int numReplies;
536 } tcpInfo_t;
537 
538 // ***************************************************************************
539 #if 0
540 #pragma mark -
541 #pragma mark - Other Packet Format Structures
542 #endif
543 
544 typedef packedstruct
545 {
546     mDNSEthAddr dst;
547     mDNSEthAddr src;
548     mDNSOpaque16 ethertype;
549 } EthernetHeader;           // 14 bytes
550 
551 typedef packedstruct
552 {
553     mDNSOpaque16 hrd;
554     mDNSOpaque16 pro;
555     mDNSu8 hln;
556     mDNSu8 pln;
557     mDNSOpaque16 op;
558     mDNSEthAddr sha;
559     mDNSv4Addr spa;
560     mDNSEthAddr tha;
561     mDNSv4Addr tpa;
562 } ARP_EthIP;                // 28 bytes
563 
564 typedef packedstruct
565 {
566     mDNSu8 vlen;
567     mDNSu8 tos;
568     mDNSOpaque16 totlen;
569     mDNSOpaque16 id;
570     mDNSOpaque16 flagsfrags;
571     mDNSu8 ttl;
572     mDNSu8 protocol;        // Payload type: 0x06 = TCP, 0x11 = UDP
573     mDNSu16 checksum;
574     mDNSv4Addr src;
575     mDNSv4Addr dst;
576 } IPv4Header;               // 20 bytes
577 
578 typedef packedstruct
579 {
580     mDNSu32 vcf;            // Version, Traffic Class, Flow Label
581     mDNSu16 len;            // Payload Length
582     mDNSu8 pro;             // Type of next header: 0x06 = TCP, 0x11 = UDP, 0x3A = ICMPv6
583     mDNSu8 ttl;             // Hop Limit
584     mDNSv6Addr src;
585     mDNSv6Addr dst;
586 } IPv6Header;               // 40 bytes
587 
588 typedef packedstruct
589 {
590     mDNSv6Addr src;
591     mDNSv6Addr dst;
592     mDNSOpaque32 len;
593     mDNSOpaque32 pro;
594 } IPv6PseudoHeader;         // 40 bytes
595 
596 typedef union
597 {
598     mDNSu8 bytes[20];
599     ARP_EthIP arp;
600     IPv4Header v4;
601     IPv6Header v6;
602 } NetworkLayerPacket;
603 
604 typedef packedstruct
605 {
606     mDNSIPPort src;
607     mDNSIPPort dst;
608     mDNSu32 seq;
609     mDNSu32 ack;
610     mDNSu8 offset;
611     mDNSu8 flags;
612     mDNSu16 window;
613     mDNSu16 checksum;
614     mDNSu16 urgent;
615 } TCPHeader;                // 20 bytes; IP protocol type 0x06
616 
617 typedef struct
618 {
619     mDNSInterfaceID IntfId;
620     mDNSu32 seq;
621     mDNSu32 ack;
622     mDNSu16 window;
623 } mDNSTCPInfo;
624 
625 typedef packedstruct
626 {
627     mDNSIPPort src;
628     mDNSIPPort dst;
629     mDNSu16 len;            // Length including UDP header (i.e. minimum value is 8 bytes)
630     mDNSu16 checksum;
631 } UDPHeader;                // 8 bytes; IP protocol type 0x11
632 
633 typedef struct
634 {
635     mDNSu8 type;            // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement
636     mDNSu8 code;
637     mDNSu16 checksum;
638     mDNSu32 flags_res;      // R/S/O flags and reserved bits
639     mDNSv6Addr target;
640     // Typically 8 bytes of options are also present
641 } IPv6NDP;                  // 24 bytes or more; IP protocol type 0x3A
642 
643 typedef struct
644 {
645     mDNSAddr    ipaddr;
646     char        ethaddr[18];
647 } IPAddressMACMapping;
648 
649 #define NDP_Sol 0x87
650 #define NDP_Adv 0x88
651 
652 #define NDP_Router    0x80
653 #define NDP_Solicited 0x40
654 #define NDP_Override  0x20
655 
656 #define NDP_SrcLL 1
657 #define NDP_TgtLL 2
658 
659 typedef union
660 {
661     mDNSu8 bytes[20];
662     TCPHeader tcp;
663     UDPHeader udp;
664     IPv6NDP ndp;
665 } TransportLayerPacket;
666 
667 typedef packedstruct
668 {
669     mDNSOpaque64 InitiatorCookie;
670     mDNSOpaque64 ResponderCookie;
671     mDNSu8 NextPayload;
672     mDNSu8 Version;
673     mDNSu8 ExchangeType;
674     mDNSu8 Flags;
675     mDNSOpaque32 MessageID;
676     mDNSu32 Length;
677 } IKEHeader;                // 28 bytes
678 
679 // ***************************************************************************
680 #if 0
681 #pragma mark -
682 #pragma mark - Resource Record structures
683 #endif
684 
685 // Authoritative Resource Records:
686 // There are four basic types: Shared, Advisory, Unique, Known Unique
687 
688 // * Shared Resource Records do not have to be unique
689 // -- Shared Resource Records are used for DNS-SD service PTRs
690 // -- It is okay for several hosts to have RRs with the same name but different RDATA
691 // -- We use a random delay on responses to reduce collisions when all the hosts respond to the same query
692 // -- These RRs typically have moderately high TTLs (e.g. one hour)
693 // -- These records are announced on startup and topology changes for the benefit of passive listeners
694 // -- These records send a goodbye packet when deregistering
695 //
696 // * Advisory Resource Records are like Shared Resource Records, except they don't send a goodbye packet
697 //
698 // * Unique Resource Records should be unique among hosts within any given mDNS scope
699 // -- The majority of Resource Records are of this type
700 // -- If two entities on the network have RRs with the same name but different RDATA, this is a conflict
701 // -- Responses may be sent immediately, because only one host should be responding to any particular query
702 // -- These RRs typically have low TTLs (e.g. a few minutes)
703 // -- On startup and after topology changes, a host issues queries to verify uniqueness
704 
705 // * Known Unique Resource Records are treated like Unique Resource Records, except that mDNS does
706 // not have to verify their uniqueness because this is already known by other means (e.g. the RR name
707 // is derived from the host's IP or Ethernet address, which is already known to be a unique identifier).
708 
709 // Summary of properties of different record types:
710 // Probe?    Does this record type send probes before announcing?
711 // Conflict? Does this record type react if we observe an apparent conflict?
712 // Goodbye?  Does this record type send a goodbye packet on departure?
713 //
714 //               Probe? Conflict? Goodbye? Notes
715 // Unregistered                            Should not appear in any list (sanity check value)
716 // Shared         No      No       Yes     e.g. Service PTR record
717 // Deregistering  No      No       Yes     Shared record about to announce its departure and leave the list
718 // Advisory       No      No       No
719 // Unique         Yes     Yes      No      Record intended to be unique -- will probe to verify
720 // Verified       Yes     Yes      No      Record has completed probing, and is verified unique
721 // KnownUnique    No      Yes      No      Record is assumed by other means to be unique
722 
723 // Valid lifecycle of a record:
724 // Unregistered ->                   Shared      -> Deregistering -(goodbye)-> Unregistered
725 // Unregistered ->                   Advisory                               -> Unregistered
726 // Unregistered -> Unique -(probe)-> Verified                               -> Unregistered
727 // Unregistered ->                   KnownUnique                            -> Unregistered
728 
729 // Each Authoritative kDNSRecordType has only one bit set. This makes it easy to quickly see if a record
730 // is one of a particular set of types simply by performing the appropriate bitwise masking operation.
731 
732 // Cache Resource Records (received from the network):
733 // There are four basic types: Answer, Unique Answer, Additional, Unique Additional
734 // Bit 7 (the top bit) of kDNSRecordType is always set for Cache Resource Records; always clear for Authoritative Resource Records
735 // Bit 6 (value 0x40) is set for answer records; clear for authority/additional records
736 // Bit 5 (value 0x20) is set for records received with the kDNSClass_UniqueRRSet
737 
738 typedef enum
739 {
740     kDNSRecordTypeUnregistered     = 0x00,  // Not currently in any list
741     kDNSRecordTypeDeregistering    = 0x01,  // Shared record about to announce its departure and leave the list
742 
743     kDNSRecordTypeUnique           = 0x02,  // Will become a kDNSRecordTypeVerified when probing is complete
744 
745     kDNSRecordTypeAdvisory         = 0x04,  // Like Shared, but no goodbye packet
746     kDNSRecordTypeShared           = 0x08,  // Shared means record name does not have to be unique -- use random delay on responses
747 
748     kDNSRecordTypeVerified         = 0x10,  // Unique means mDNS should check that name is unique (and then send immediate responses)
749     kDNSRecordTypeKnownUnique      = 0x20,  // Known Unique means mDNS can assume name is unique without checking
750                                             // For Dynamic Update records, Known Unique means the record must already exist on the server.
751     kDNSRecordTypeUniqueMask       = (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique),
752     kDNSRecordTypeActiveSharedMask = (kDNSRecordTypeAdvisory         | kDNSRecordTypeShared),
753     kDNSRecordTypeActiveUniqueMask = (kDNSRecordTypeVerified         | kDNSRecordTypeKnownUnique),
754     kDNSRecordTypeActiveMask       = (kDNSRecordTypeActiveSharedMask | kDNSRecordTypeActiveUniqueMask),
755 
756     kDNSRecordTypePacketAdd        = 0x80,  // Received in the Additional  Section of a DNS Response
757     kDNSRecordTypePacketAddUnique  = 0x90,  // Received in the Additional  Section of a DNS Response with kDNSClass_UniqueRRSet set
758     kDNSRecordTypePacketAuth       = 0xA0,  // Received in the Authorities Section of a DNS Response
759     kDNSRecordTypePacketAuthUnique = 0xB0,  // Received in the Authorities Section of a DNS Response with kDNSClass_UniqueRRSet set
760     kDNSRecordTypePacketAns        = 0xC0,  // Received in the Answer      Section of a DNS Response
761     kDNSRecordTypePacketAnsUnique  = 0xD0,  // Received in the Answer      Section of a DNS Response with kDNSClass_UniqueRRSet set
762 
763     kDNSRecordTypePacketNegative   = 0xF0,  // Pseudo-RR generated to cache non-existence results like NXDomain
764 
765     kDNSRecordTypePacketUniqueMask = 0x10   // True for PacketAddUnique, PacketAnsUnique, PacketAuthUnique, kDNSRecordTypePacketNegative
766 } kDNSRecordTypes;
767 
768 typedef packedstruct { mDNSu16 priority; mDNSu16 weight; mDNSIPPort port; domainname target;   } rdataSRV;
769 typedef packedstruct { mDNSu16 preference;                                domainname exchange; } rdataMX;
770 typedef packedstruct { domainname mbox; domainname txt;                                        } rdataRP;
771 typedef packedstruct { mDNSu16 preference; domainname map822; domainname mapx400;              } rdataPX;
772 
773 typedef packedstruct
774 {
775     domainname mname;
776     domainname rname;
777     mDNSs32 serial;     // Modular counter; increases when zone changes
778     mDNSu32 refresh;    // Time in seconds that a slave waits after successful replication of the database before it attempts replication again
779     mDNSu32 retry;      // Time in seconds that a slave waits after an unsuccessful replication attempt before it attempts replication again
780     mDNSu32 expire;     // Time in seconds that a slave holds on to old data while replication attempts remain unsuccessful
781     mDNSu32 min;        // Nominally the minimum record TTL for this zone, in seconds; also used for negative caching.
782 } rdataSOA;
783 
784 // http://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
785 // Algorithm used for RRSIG, DS and DNS KEY
786 #define CRYPTO_RSA_SHA1             0x05
787 #define CRYPTO_DSA_NSEC3_SHA1       0x06
788 #define CRYPTO_RSA_NSEC3_SHA1       0x07
789 #define CRYPTO_RSA_SHA256           0x08
790 #define CRYPTO_RSA_SHA512           0x0A
791 
792 #define CRYPTO_ALG_MAX              0x0B
793 
794 // alg - same as in RRSIG, DNS KEY or DS.
795 // RFC 4034 defines SHA1
796 // RFC 4509 defines SHA256
797 // Note: NSEC3 also uses 1 for SHA1 and hence we will reuse for now till a new
798 // value is assigned.
799 //
800 #define SHA1_DIGEST_TYPE        1
801 #define SHA256_DIGEST_TYPE      2
802 #define DIGEST_TYPE_MAX         3
803 
804 // We need support for base64 and base32 encoding for displaying KEY, NSEC3
805 // To make this platform agnostic, we define two types which the platform
806 // needs to support
807 #define ENC_BASE32              1
808 #define ENC_BASE64              2
809 #define ENC_ALG_MAX             3
810 
811 #define DS_FIXED_SIZE           4
812 typedef packedstruct
813 {
814     mDNSu16 keyTag;
815     mDNSu8 alg;
816     mDNSu8 digestType;
817     mDNSu8  *digest;
818 } rdataDS;
819 
820 typedef struct TrustAnchor
821 {
822     struct TrustAnchor *next;
823     int digestLen;
824     mDNSu32 validFrom;
825     mDNSu32 validUntil;
826     domainname zone;
827     rdataDS rds;
828 } TrustAnchor;
829 
830 //size of rdataRRSIG excluding signerName and signature (which are variable fields)
831 #define RRSIG_FIXED_SIZE      18
832 typedef struct
833 {
834     mDNSu16 typeCovered;
835     mDNSu8 alg;
836     mDNSu8 labels;
837     mDNSu32 origTTL;
838     mDNSu32 sigExpireTime;
839     mDNSu32 sigInceptTime;
840     mDNSu16 keyTag;
841     mDNSu8  signerName[1]; // signerName is a dynamically-sized array
842     // mDNSu8 *signature
843 } rdataRRSig;
844 
845 // RFC 4034: For DNS Key RR
846 // flags - the valid value for DNSSEC is 256 (Zone signing key - ZSK) and 257 (Secure Entry Point) which also
847 // includes the ZSK bit
848 //
849 #define DNSKEY_ZONE_SIGN_KEY        0x100
850 #define DNSKEY_SECURE_ENTRY_POINT   0x101
851 
852 // proto - the only valid value for protocol is 3 (See RFC 4034)
853 #define DNSKEY_VALID_PROTO_VALUE    0x003
854 
855 // alg - The only mandatory algorithm that we support is RSA/SHA-1
856 // DNSSEC_RSA_SHA1_ALG
857 
858 #define DNSKEY_FIXED_SIZE          4
859 typedef packedstruct
860 {
861     mDNSu16 flags;
862     mDNSu8 proto;
863     mDNSu8 alg;
864     mDNSu8  *data;
865 } rdataDNSKey;
866 
867 #define NSEC3_FIXED_SIZE          5
868 #define NSEC3_FLAGS_OPTOUT        1
869 #define NSEC3_MAX_ITERATIONS      2500
870 typedef packedstruct
871 {
872     mDNSu8 alg;
873     mDNSu8 flags;
874     mDNSu16 iterations;
875     mDNSu8 saltLength;
876     mDNSu8 *salt;
877     // hashLength, nxt, bitmap
878 } rdataNSEC3;
879 
880 // In the multicast usage of NSEC3, we know the actual size of RData
881 // 4 bytes : HashAlg, Flags,Iterations
882 // 5 bytes : Salt Length 1 byte, Salt 4 bytes
883 // 21 bytes : HashLength 1 byte, Hash 20 bytes
884 // 34 bytes : Window number, Bitmap length, Type bit map to include the first 256 types
885 #define MCAST_NSEC3_RDLENGTH (4 + 5 + 21 + 34)
886 #define SHA1_HASH_LENGTH 20
887 
888 // Base32 encoding takes 5 bytes of the input and encodes as 8 bytes of output.
889 // For example, SHA-1 hash of 20 bytes will be encoded as 20/5 * 8 = 32 base32
890 // bytes. For a max domain name size of 255 bytes of base32 encoding : (255/8)*5
891 // is the max hash length possible.
892 #define NSEC3_MAX_HASH_LEN  155
893 // In NSEC3, the names are hashed and stored in the first label and hence cannot exceed label
894 // size.
895 #define NSEC3_MAX_B32_LEN   MAX_DOMAIN_LABEL
896 
897 // We define it here instead of dnssec.h so that these values can be used
898 // in files without bringing in all of dnssec.h unnecessarily.
899 typedef enum
900 {
901     DNSSEC_Secure = 1,      // Securely validated and has a chain up to the trust anchor
902     DNSSEC_Insecure,        // Cannot build a chain up to the trust anchor
903     DNSSEC_Indeterminate,   // Not used currently
904     DNSSEC_Bogus,           // failed to validate signatures
905     DNSSEC_NoResponse       // No DNSSEC records to start with
906 } DNSSECStatus;
907 
908 #define DNSSECRecordType(rrtype) (((rrtype) == kDNSType_RRSIG) || ((rrtype) == kDNSType_NSEC) || ((rrtype) == kDNSType_DNSKEY) || ((rrtype) == kDNSType_DS) || \
909                                   ((rrtype) == kDNSType_NSEC3))
910 
911 typedef enum
912 {
913     platform_OSX = 1,   // OSX Platform
914     platform_iOS,       // iOS Platform
915     platform_Atv,       // Atv Platform
916     platform_NonApple   // Non-Apple (Windows, POSIX) Platform
917 } Platform_t;
918 
919 // EDNS Option Code registrations are recorded in the "DNS EDNS0 Options" section of
920 // <http://www.iana.org/assignments/dns-parameters>
921 
922 #define kDNSOpt_LLQ   1
923 #define kDNSOpt_Lease 2
924 #define kDNSOpt_NSID  3
925 #define kDNSOpt_Owner 4
926 #define kDNSOpt_Trace 65001  // 65001-65534 Reserved for Local/Experimental Use
927 
928 typedef struct
929 {
930     mDNSu16 vers;
931     mDNSu16 llqOp;
932     mDNSu16 err;        // Or UDP reply port, in setup request
933     // Note: In the in-memory form, there's typically a two-byte space here, so that the following 64-bit id is word-aligned
934     mDNSOpaque64 id;
935     mDNSu32 llqlease;
936 } LLQOptData;
937 
938 typedef struct
939 {
940     mDNSu8 vers;            // Version number of this Owner OPT record
941     mDNSs8 seq;             // Sleep/wake epoch
942     mDNSEthAddr HMAC;       // Host's primary identifier (e.g. MAC of on-board Ethernet)
943     mDNSEthAddr IMAC;       // Interface's MAC address (if different to primary MAC)
944     mDNSOpaque48 password;  // Optional password
945 } OwnerOptData;
946 
947 typedef struct
948 {
949     mDNSu8    platf;      // Running platform (see enum Platform_t)
950     mDNSu32   mDNSv;      // mDNSResponder Version (DNS_SD_H defined in dns_sd.h)
951 } TracerOptData;
952 
953 // Note: rdataOPT format may be repeated an arbitrary number of times in a single resource record
954 typedef struct
955 {
956     mDNSu16 opt;
957     mDNSu16 optlen;
958     union { LLQOptData llq; mDNSu32 updatelease; OwnerOptData owner; TracerOptData tracer; } u;
959 } rdataOPT;
960 
961 // Space needed to put OPT records into a packet:
962 // Header         11  bytes (name 1, type 2, class 2, TTL 4, length 2)
963 // LLQ   rdata    18  bytes (opt 2, len 2, vers 2, op 2, err 2, id 8, lease 4)
964 // Lease rdata     8  bytes (opt 2, len 2, lease 4)
965 // Owner rdata 12-24  bytes (opt 2, len 2, owner 8-20)
966 // Trace rdata     9  bytes (opt 2, len 2, platf 1, mDNSv 4)
967 
968 
969 #define DNSOpt_Header_Space                 11
970 #define DNSOpt_LLQData_Space               (4 + 2 + 2 + 2 + 8 + 4)
971 #define DNSOpt_LeaseData_Space             (4 + 4)
972 #define DNSOpt_OwnerData_ID_Space          (4 + 2 + 6)
973 #define DNSOpt_OwnerData_ID_Wake_Space     (4 + 2 + 6 + 6)
974 #define DNSOpt_OwnerData_ID_Wake_PW4_Space (4 + 2 + 6 + 6 + 4)
975 #define DNSOpt_OwnerData_ID_Wake_PW6_Space (4 + 2 + 6 + 6 + 6)
976 #define DNSOpt_TraceData_Space             (4 + 1 + 4)
977 
978 #define ValidOwnerLength(X) (   (X) == DNSOpt_OwnerData_ID_Space          - 4 || \
979                                 (X) == DNSOpt_OwnerData_ID_Wake_Space     - 4 || \
980                                 (X) == DNSOpt_OwnerData_ID_Wake_PW4_Space - 4 || \
981                                 (X) == DNSOpt_OwnerData_ID_Wake_PW6_Space - 4    )
982 
983 #define DNSOpt_Owner_Space(A,B) (mDNSSameEthAddress((A),(B)) ? DNSOpt_OwnerData_ID_Space : DNSOpt_OwnerData_ID_Wake_Space)
984 
985 #define DNSOpt_Data_Space(O) (                                  \
986         (O)->opt == kDNSOpt_LLQ   ? DNSOpt_LLQData_Space   :        \
987         (O)->opt == kDNSOpt_Lease ? DNSOpt_LeaseData_Space :        \
988         (O)->opt == kDNSOpt_Trace ? DNSOpt_TraceData_Space :        \
989         (O)->opt == kDNSOpt_Owner ? DNSOpt_Owner_Space(&(O)->u.owner.HMAC, &(O)->u.owner.IMAC) : 0x10000)
990 
991 // NSEC record is defined in RFC 4034.
992 // 16 bit RRTYPE space is split into 256 windows and each window has 256 bits (32 bytes).
993 // If we create a structure for NSEC, it's size would be:
994 //
995 //   256 bytes domainname 'nextname'
996 // + 256 * 34 = 8704 bytes of bitmap data
997 // = 8960 bytes total
998 //
999 // This would be a waste, as types about 256 are not very common. But it would be odd, if we receive
1000 // a type above 256 (.US zone had TYPE65534 when this code was written) and not able to handle it.
1001 // Hence, we handle any size by not fixing a strucure in place. The following is just a placeholder
1002 // and never used anywhere.
1003 //
1004 #define NSEC_MCAST_WINDOW_SIZE 32
1005 typedef struct
1006 {
1007     domainname *next; //placeholders are uncommented because C89 in Windows requires that a struct has at least a member.
1008     char bitmap[32];
1009 } rdataNSEC;
1010 
1011 // StandardAuthRDSize is 264 (256+8), which is large enough to hold a maximum-sized SRV record (6 + 256 bytes)
1012 // MaximumRDSize is 8K the absolute maximum we support (at least for now)
1013 #define StandardAuthRDSize 264
1014 #ifndef MaximumRDSize
1015 #define MaximumRDSize 8192
1016 #endif
1017 
1018 // InlineCacheRDSize is 68
1019 // Records received from the network with rdata this size or less have their rdata stored right in the CacheRecord object
1020 // Records received from the network with rdata larger than this have additional storage allocated for the rdata
1021 // A quick unscientific sample from a busy network at Apple with lots of machines revealed this:
1022 // 1461 records in cache
1023 // 292 were one-byte TXT records
1024 // 136 were four-byte A records
1025 // 184 were sixteen-byte AAAA records
1026 // 780 were various PTR, TXT and SRV records from 12-64 bytes
1027 // Only 69 records had rdata bigger than 64 bytes
1028 // Note that since CacheRecord object and a CacheGroup object are allocated out of the same pool, it's sensible to
1029 // have them both be the same size. Making one smaller without making the other smaller won't actually save any memory.
1030 #define InlineCacheRDSize 68
1031 
1032 // The RDataBody union defines the common rdata types that fit into our 264-byte limit
1033 typedef union
1034 {
1035     mDNSu8 data[StandardAuthRDSize];
1036     mDNSv4Addr ipv4;        // For 'A' record
1037     domainname name;        // For PTR, NS, CNAME, DNAME
1038     UTF8str255 txt;
1039     rdataMX mx;
1040     mDNSv6Addr ipv6;        // For 'AAAA' record
1041     rdataSRV srv;
1042     rdataOPT opt[2];        // For EDNS0 OPT record; RDataBody may contain multiple variable-length rdataOPT objects packed together
1043 } RDataBody;
1044 
1045 // The RDataBody2 union is the same as above, except it includes fields for the larger types like soa, rp, px
1046 typedef union
1047 {
1048     mDNSu8 data[StandardAuthRDSize];
1049     mDNSv4Addr ipv4;        // For 'A' record
1050     domainname name;        // For PTR, NS, CNAME, DNAME
1051     rdataSOA soa;           // This is large; not included in the normal RDataBody definition
1052     UTF8str255 txt;
1053     rdataMX mx;
1054     rdataRP rp;             // This is large; not included in the normal RDataBody definition
1055     rdataPX px;             // This is large; not included in the normal RDataBody definition
1056     mDNSv6Addr ipv6;        // For 'AAAA' record
1057     rdataSRV srv;
1058     rdataOPT opt[2];        // For EDNS0 OPT record; RDataBody may contain multiple variable-length rdataOPT objects packed together
1059     rdataDS ds;
1060     rdataDNSKey key;
1061     rdataRRSig rrsig;
1062 } RDataBody2;
1063 
1064 typedef struct
1065 {
1066     mDNSu16 MaxRDLength;    // Amount of storage allocated for rdata (usually sizeof(RDataBody))
1067     mDNSu16 padding;        // So that RDataBody is aligned on 32-bit boundary
1068     RDataBody u;
1069 } RData;
1070 
1071 // sizeofRDataHeader should be 4 bytes
1072 #define sizeofRDataHeader (sizeof(RData) - sizeof(RDataBody))
1073 
1074 // RData_small is a smaller version of the RData object, used for inline data storage embedded in a CacheRecord_struct
1075 typedef struct
1076 {
1077     mDNSu16 MaxRDLength;    // Storage allocated for data (may be greater than InlineCacheRDSize if additional storage follows this object)
1078     mDNSu16 padding;        // So that data is aligned on 32-bit boundary
1079     mDNSu8 data[InlineCacheRDSize];
1080 } RData_small;
1081 
1082 // Note: Within an mDNSRecordCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
1083 typedef void mDNSRecordCallback (mDNS *const m, AuthRecord *const rr, mStatus result);
1084 
1085 // Note:
1086 // Restrictions: An mDNSRecordUpdateCallback may not make any mDNS API calls.
1087 // The intent of this callback is to allow the client to free memory, if necessary.
1088 // The internal data structures of the mDNS code may not be in a state where mDNS API calls may be made safely.
1089 typedef void mDNSRecordUpdateCallback (mDNS *const m, AuthRecord *const rr, RData *OldRData, mDNSu16 OldRDLen);
1090 
1091 // ***************************************************************************
1092 #if 0
1093 #pragma mark -
1094 #pragma mark - NAT Traversal structures and constants
1095 #endif
1096 
1097 #define NATMAP_MAX_RETRY_INTERVAL    ((mDNSPlatformOneSecond * 60) * 15)    // Max retry interval is 15 minutes
1098 #define NATMAP_MIN_RETRY_INTERVAL     (mDNSPlatformOneSecond * 2)           // Min retry interval is 2 seconds
1099 #define NATMAP_INIT_RETRY             (mDNSPlatformOneSecond / 4)           // start at 250ms w/ exponential decay
1100 #define NATMAP_DEFAULT_LEASE          (60 * 60 * 2)                         // 2 hour lease life in seconds
1101 #define NATMAP_VERS 0
1102 
1103 typedef enum
1104 {
1105     NATOp_AddrRequest    = 0,
1106     NATOp_MapUDP         = 1,
1107     NATOp_MapTCP         = 2,
1108 
1109     NATOp_AddrResponse   = 0x80 | 0,
1110     NATOp_MapUDPResponse = 0x80 | 1,
1111     NATOp_MapTCPResponse = 0x80 | 2,
1112 } NATOp_t;
1113 
1114 enum
1115 {
1116     NATErr_None    = 0,
1117     NATErr_Vers    = 1,
1118     NATErr_Refused = 2,
1119     NATErr_NetFail = 3,
1120     NATErr_Res     = 4,
1121     NATErr_Opcode  = 5
1122 };
1123 
1124 typedef mDNSu16 NATErr_t;
1125 
1126 typedef packedstruct
1127 {
1128     mDNSu8 vers;
1129     mDNSu8 opcode;
1130 } NATAddrRequest;
1131 
1132 typedef packedstruct
1133 {
1134     mDNSu8 vers;
1135     mDNSu8 opcode;
1136     mDNSu16 err;
1137     mDNSu32 upseconds;          // Time since last NAT engine reboot, in seconds
1138     mDNSv4Addr ExtAddr;
1139 } NATAddrReply;
1140 
1141 typedef packedstruct
1142 {
1143     mDNSu8 vers;
1144     mDNSu8 opcode;
1145     mDNSOpaque16 unused;
1146     mDNSIPPort intport;
1147     mDNSIPPort extport;
1148     mDNSu32 NATReq_lease;
1149 } NATPortMapRequest;
1150 
1151 typedef packedstruct
1152 {
1153     mDNSu8 vers;
1154     mDNSu8 opcode;
1155     mDNSu16 err;
1156     mDNSu32 upseconds;          // Time since last NAT engine reboot, in seconds
1157     mDNSIPPort intport;
1158     mDNSIPPort extport;
1159     mDNSu32 NATRep_lease;
1160 } NATPortMapReply;
1161 
1162 // PCP Support for IPv4 mappings
1163 
1164 #define PCP_VERS 0x02
1165 #define PCP_WAITSECS_AFTER_EPOCH_INVALID 5
1166 
1167 typedef enum
1168 {
1169     PCPOp_Announce = 0,
1170     PCPOp_Map      = 1
1171 } PCPOp_t;
1172 
1173 typedef enum
1174 {
1175     PCPProto_All = 0,
1176     PCPProto_TCP = 6,
1177     PCPProto_UDP = 17
1178 } PCPProto_t;
1179 
1180 typedef enum
1181 {
1182     PCPResult_Success         = 0,
1183     PCPResult_UnsuppVersion   = 1,
1184     PCPResult_NotAuthorized   = 2,
1185     PCPResult_MalformedReq    = 3,
1186     PCPResult_UnsuppOpcode    = 4,
1187     PCPResult_UnsuppOption    = 5,
1188     PCPResult_MalformedOption = 6,
1189     PCPResult_NetworkFailure  = 7,
1190     PCPResult_NoResources     = 8,
1191     PCPResult_UnsuppProtocol  = 9,
1192     PCPResult_UserExQuota     = 10,
1193     PCPResult_CantProvideExt  = 11,
1194     PCPResult_AddrMismatch    = 12,
1195     PCPResult_ExcesRemotePeer = 13
1196 } PCPResult_t;
1197 
1198 typedef struct
1199 {
1200     mDNSu8       version;
1201     mDNSu8       opCode;
1202     mDNSOpaque16 reserved;
1203     mDNSu32      lifetime;
1204     mDNSv6Addr   clientAddr;
1205     mDNSu32      nonce[3];
1206     mDNSu8       protocol;
1207     mDNSu8       reservedMapOp[3];
1208     mDNSIPPort   intPort;
1209     mDNSIPPort   extPort;
1210     mDNSv6Addr   extAddress;
1211 } PCPMapRequest;
1212 
1213 typedef struct
1214 {
1215     mDNSu8     version;
1216     mDNSu8     opCode;
1217     mDNSu8     reserved;
1218     mDNSu8     result;
1219     mDNSu32    lifetime;
1220     mDNSu32    epoch;
1221     mDNSu32    clientAddrParts[3];
1222     mDNSu32    nonce[3];
1223     mDNSu8     protocol;
1224     mDNSu8     reservedMapOp[3];
1225     mDNSIPPort intPort;
1226     mDNSIPPort extPort;
1227     mDNSv6Addr extAddress;
1228 } PCPMapReply;
1229 
1230 // LNT Support
1231 
1232 typedef enum
1233 {
1234     LNTDiscoveryOp      = 1,
1235     LNTExternalAddrOp   = 2,
1236     LNTPortMapOp        = 3,
1237     LNTPortMapDeleteOp  = 4
1238 } LNTOp_t;
1239 
1240 #define LNT_MAXBUFSIZE 8192
1241 typedef struct tcpLNTInfo_struct tcpLNTInfo;
1242 struct tcpLNTInfo_struct
1243 {
1244     tcpLNTInfo       *next;
1245     mDNS             *m;
1246     NATTraversalInfo *parentNATInfo;    // pointer back to the parent NATTraversalInfo
1247     TCPSocket        *sock;
1248     LNTOp_t op;                         // operation performed using this connection
1249     mDNSAddr Address;                   // router address
1250     mDNSIPPort Port;                    // router port
1251     mDNSu8           *Request;          // xml request to router
1252     int requestLen;
1253     mDNSu8           *Reply;            // xml reply from router
1254     int replyLen;
1255     unsigned long nread;                // number of bytes read so far
1256     int retries;                        // number of times we've tried to do this port mapping
1257 };
1258 
1259 typedef void (*NATTraversalClientCallback)(mDNS *m, NATTraversalInfo *n);
1260 
1261 // if m->timenow <  ExpiryTime then we have an active mapping, and we'll renew halfway to expiry
1262 // if m->timenow >= ExpiryTime then our mapping has expired, and we're trying to create one
1263 
1264 typedef enum
1265 {
1266     NATTProtocolNone    = 0,
1267     NATTProtocolNATPMP  = 1,
1268     NATTProtocolUPNPIGD = 2,
1269     NATTProtocolPCP     = 3,
1270 } NATTProtocol;
1271 
1272 struct NATTraversalInfo_struct
1273 {
1274     // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
1275     NATTraversalInfo           *next;
1276 
1277     mDNSs32 ExpiryTime;                             // Time this mapping expires, or zero if no mapping
1278     mDNSs32 retryInterval;                          // Current interval, between last packet we sent and the next one
1279     mDNSs32 retryPortMap;                           // If Protocol is nonzero, time to send our next mapping packet
1280     mStatus NewResult;                              // New error code; will be copied to Result just prior to invoking callback
1281     NATTProtocol lastSuccessfulProtocol;            // To send correct deletion request & update non-PCP external address operations
1282     mDNSBool sentNATPMP;                            // Whether we just sent a NAT-PMP packet, so we won't send another if
1283                                                     //    we receive another NAT-PMP "Unsupported Version" packet
1284 
1285 #ifdef _LEGACY_NAT_TRAVERSAL_
1286     tcpLNTInfo tcpInfo;                             // Legacy NAT traversal (UPnP) TCP connection
1287 #endif
1288 
1289     // Result fields: When the callback is invoked these fields contain the answers the client is looking for
1290     // When the callback is invoked ExternalPort is *usually* set to be the same the same as RequestedPort, except:
1291     // (a) When we're behind a NAT gateway with port mapping disabled, ExternalPort is reported as zero to
1292     //     indicate that we don't currently have a working mapping (but RequestedPort retains the external port
1293     //     we'd like to get, the next time we meet an accomodating NAT gateway willing to give us one).
1294     // (b) When we have a routable non-RFC1918 address, we don't *need* a port mapping, so ExternalPort
1295     //     is reported as the same as our InternalPort, since that is effectively our externally-visible port too.
1296     //     Again, RequestedPort retains the external port we'd like to get the next time we find ourself behind a NAT gateway.
1297     // To improve stability of port mappings, RequestedPort is updated any time we get a successful
1298     // mapping response from the PCP, NAT-PMP or UPnP gateway. For example, if we ask for port 80, and
1299     // get assigned port 81, then thereafter we'll contine asking for port 81.
1300     mDNSInterfaceID InterfaceID;
1301     mDNSv4Addr ExternalAddress;                     // Initially set to onesIPv4Addr, until first callback
1302     mDNSv4Addr NewAddress;                          // May be updated with actual value assigned by gateway
1303     mDNSIPPort ExternalPort;
1304     mDNSu32 Lifetime;
1305     mStatus Result;
1306 
1307     // Client API fields: The client must set up these fields *before* making any NAT traversal API calls
1308     mDNSu8 Protocol;                                // NATOp_MapUDP or NATOp_MapTCP, or zero if just requesting the external IP address
1309     mDNSIPPort IntPort;                             // Client's internal port number (doesn't change)
1310     mDNSIPPort RequestedPort;                       // Requested external port; may be updated with actual value assigned by gateway
1311     mDNSu32 NATLease;                               // Requested lifetime in seconds (doesn't change)
1312     NATTraversalClientCallback clientCallback;
1313     void                       *clientContext;
1314 };
1315 
1316 // ***************************************************************************
1317 #if 0
1318 #pragma mark -
1319 #pragma mark - DNSServer & McastResolver structures and constants
1320 #endif
1321 
1322 enum
1323 {
1324     DNSServer_FlagDelete      = 0x1,
1325     DNSServer_FlagNew         = 0x2,
1326 #if APPLE_OSX_mDNSResponder
1327     DNSServer_FlagUnreachable = 0x4,
1328 #endif
1329 };
1330 
1331 enum
1332 {
1333     McastResolver_FlagDelete = 1,
1334     McastResolver_FlagNew    = 2
1335 };
1336 
1337 typedef struct McastResolver
1338 {
1339     struct McastResolver *next;
1340     mDNSInterfaceID interface;
1341     mDNSu32 flags;              // Set when we're planning to delete this from the list
1342     domainname domain;
1343     mDNSu32 timeout;            // timeout value for questions
1344 } McastResolver;
1345 
1346 enum {
1347     Mortality_Mortal      = 0,          // This cache record can expire and get purged
1348     Mortality_Immortal    = 1,          // Allow this record to remain in the cache indefinitely
1349     Mortality_Ghost       = 2           // An immortal record that has expired and can linger in the cache
1350 };
1351 typedef mDNSu8 MortalityState;
1352 
1353 // scoped values for DNSServer matching
1354 enum
1355 {
1356     kScopeNone         = 0,        // DNS server used by unscoped questions
1357     kScopeInterfaceID  = 1,        // Scoped DNS server used only by scoped questions
1358     kScopeServiceID    = 2,         // Service specific DNS server used only by questions
1359                                    // have a matching serviceID
1360     kScopesMaxCount    = 3         // Max count for scopes enum
1361 };
1362 
1363 // Note: DNSSECAware is set if we are able to get a valid response to
1364 // a DNSSEC question. In some cases it is possible that the proxy
1365 // strips the EDNS0 option and we just get a plain response with no
1366 // signatures. But we still mark DNSSECAware in that case. As DNSSECAware
1367 // is only used to determine whether DNSSEC_VALIDATION_SECURE_OPTIONAL
1368 // should be turned off or not, it is sufficient that we are getting
1369 // responses back.
1370 typedef struct DNSServer
1371 {
1372     struct DNSServer *next;
1373     mDNSInterfaceID interface;  // DNS requests should be sent on this interface
1374     mDNSs32 serviceID;
1375     mDNSAddr addr;
1376     mDNSIPPort port;
1377     mDNSu32 flags;              // Set when we're planning to delete this from the list
1378     domainname domain;          // name->server matching for "split dns"
1379     mDNSs32 penaltyTime;        // amount of time this server is penalized
1380     mDNSu32 scoped;             // See the scoped enum above
1381     mDNSu32 timeout;            // timeout value for questions
1382     mDNSu16 resGroupID;         // ID of the resolver group that contains this DNSServer
1383     mDNSu8 retransDO;           // Total Retransmissions for queries sent with DO option
1384     mDNSBool cellIntf;          // Resolver from Cellular Interface?
1385     mDNSBool req_A;             // If set, send v4 query (DNSConfig allows A queries)
1386     mDNSBool req_AAAA;          // If set, send v6 query (DNSConfig allows AAAA queries)
1387     mDNSBool req_DO;            // If set, okay to send DNSSEC queries (EDNS DO bit is supported)
1388     mDNSBool DNSSECAware;       // Set if we are able to receive a response to a request sent with DO option.
1389     mDNSBool isExpensive;       // True if the interface to this server is expensive.
1390     mDNSBool isCLAT46;          // True if the interface to this server is CLAT46.
1391 } DNSServer;
1392 
1393 typedef struct
1394 {
1395     mDNSu8 *AnonData;
1396     int AnonDataLen;
1397     mDNSu32 salt;
1398     ResourceRecord *nsec3RR;
1399     mDNSInterfaceID SendNow;     // The interface ID that this record should be sent on
1400 } AnonymousInfo;
1401 
1402 struct ResourceRecord_struct
1403 {
1404     mDNSu8 RecordType;                  // See kDNSRecordTypes enum.
1405     MortalityState mortality;           // Mortality of this resource record (See MortalityState enum)
1406     mDNSu16 rrtype;                     // See DNS_TypeValues enum.
1407     mDNSu16 rrclass;                    // See DNS_ClassValues enum.
1408     mDNSu32 rroriginalttl;              // In seconds
1409     mDNSu16 rdlength;                   // Size of the raw rdata, in bytes, in the on-the-wire format
1410                                         // (In-memory storage may be larger, for structures containing 'holes', like SOA)
1411     mDNSu16 rdestimate;                 // Upper bound on on-the-wire size of rdata after name compression
1412     mDNSu32 namehash;                   // Name-based (i.e. case-insensitive) hash of name
1413     mDNSu32 rdatahash;                  // For rdata containing domain name (e.g. PTR, SRV, CNAME etc.), case-insensitive name hash
1414                                         // else, for all other rdata, 32-bit hash of the raw rdata
1415                                         // Note: This requirement is important. Various routines like AddAdditionalsToResponseList(),
1416                                         // ReconfirmAntecedents(), etc., use rdatahash as a pre-flight check to see
1417                                         // whether it's worth doing a full SameDomainName() call. If the rdatahash
1418                                         // is not a correct case-insensitive name hash, they'll get false negatives.
1419     // Grouping pointers together at the end of the structure improves the memory layout efficiency
1420     mDNSInterfaceID InterfaceID;        // Set if this RR is specific to one interface
1421                                         // For records received off the wire, InterfaceID is *always* set to the receiving interface
1422                                         // For our authoritative records, InterfaceID is usually zero, except for those few records
1423                                         // that are interface-specific (e.g. address records, especially linklocal addresses)
1424     const domainname *name;
1425     RData           *rdata;             // Pointer to storage for this rdata
1426     DNSServer       *rDNSServer;        // Unicast DNS server authoritative for this entry; null for multicast
1427     AnonymousInfo   *AnonInfo;          // Anonymous Information
1428 };
1429 
1430 
1431 // Unless otherwise noted, states may apply to either independent record registrations or service registrations
1432 typedef enum
1433 {
1434     regState_Zero              = 0,
1435     regState_Pending           = 1,     // update sent, reply not received
1436     regState_Registered        = 2,     // update sent, reply received
1437     regState_DeregPending      = 3,     // dereg sent, reply not received
1438     regState_Unregistered      = 4,     // not in any list
1439     regState_Refresh           = 5,     // outstanding refresh (or target change) message
1440     regState_NATMap            = 6,     // establishing NAT port mapping
1441     regState_UpdatePending     = 7,     // update in flight as result of mDNS_Update call
1442     regState_NoTarget          = 8,     // SRV Record registration pending registration of hostname
1443     regState_NATError          = 9     // unable to complete NAT traversal
1444 } regState_t;
1445 
1446 enum
1447 {
1448     Target_Manual = 0,
1449     Target_AutoHost = 1,
1450     Target_AutoHostAndNATMAP = 2
1451 };
1452 
1453 typedef enum
1454 {
1455     mergeState_Zero = 0,
1456     mergeState_DontMerge = 1  // Set on fatal error conditions to disable merging
1457 } mergeState_t;
1458 
1459 #define AUTH_GROUP_NAME_SIZE    128
1460 struct AuthGroup_struct             // Header object for a list of AuthRecords with the same name
1461 {
1462     AuthGroup      *next;               // Next AuthGroup object in this hash table bucket
1463     mDNSu32 namehash;                   // Name-based (i.e. case insensitive) hash of name
1464     AuthRecord     *members;            // List of CacheRecords with this same name
1465     AuthRecord    **rrauth_tail;        // Tail end of that list
1466     domainname     *name;               // Common name for all AuthRecords in this list
1467     AuthRecord     *NewLocalOnlyRecords;
1468     mDNSu8 namestorage[AUTH_GROUP_NAME_SIZE];
1469 };
1470 
1471 #ifndef AUTH_HASH_SLOTS
1472 #define AUTH_HASH_SLOTS 499
1473 #endif
1474 #define FORALL_AUTHRECORDS(SLOT,AG,AR)                              \
1475     for ((SLOT) = 0; (SLOT) < AUTH_HASH_SLOTS; (SLOT)++)                                                                     \
1476         for ((AG)=m->rrauth.rrauth_hash[(SLOT)]; (AG); (AG)=(AG)->next)                                                                         \
1477             for ((AR) = (AG)->members; (AR); (AR)=(AR)->next)
1478 
1479 typedef union AuthEntity_union AuthEntity;
1480 union AuthEntity_union { AuthEntity *next; AuthGroup ag; };
1481 typedef struct {
1482     mDNSu32 rrauth_size;                // Total number of available auth entries
1483     mDNSu32 rrauth_totalused;           // Number of auth entries currently occupied
1484     mDNSu32 rrauth_report;
1485     mDNSu8 rrauth_lock;                 // For debugging: Set at times when these lists may not be modified
1486     AuthEntity *rrauth_free;
1487     AuthGroup *rrauth_hash[AUTH_HASH_SLOTS];
1488 }AuthHash;
1489 
1490 // AuthRecordAny includes mDNSInterface_Any and interface specific auth records.
1491 typedef enum
1492 {
1493     AuthRecordAny,              // registered for *Any, NOT including P2P interfaces
1494     AuthRecordAnyIncludeP2P,    // registered for *Any, including P2P interfaces
1495     AuthRecordAnyIncludeAWDL,   // registered for *Any, including AWDL interface
1496     AuthRecordAnyIncludeAWDLandP2P, // registered for *Any, including AWDL and P2P interfaces
1497     AuthRecordLocalOnly,
1498     AuthRecordP2P               // discovered over D2D/P2P framework
1499 } AuthRecType;
1500 
1501 typedef enum
1502 {
1503     AuthFlagsWakeOnly = 0x1     // WakeOnly service
1504 } AuthRecordFlags;
1505 
1506 struct AuthRecord_struct
1507 {
1508     // For examples of how to set up this structure for use in mDNS_Register(),
1509     // see mDNS_AdvertiseInterface() or mDNS_RegisterService().
1510     // Basically, resrec and persistent metadata need to be set up before calling mDNS_Register().
1511     // mDNS_SetupResourceRecord() is avaliable as a helper routine to set up most fields to sensible default values for you
1512 
1513     AuthRecord     *next;               // Next in list; first element of structure for efficiency reasons
1514     // Field Group 1: Common ResourceRecord fields
1515     ResourceRecord resrec;              // 36 bytes when compiling for 32-bit; 48 when compiling for 64-bit (now 44/64)
1516 
1517     // Field Group 2: Persistent metadata for Authoritative Records
1518     AuthRecord     *Additional1;        // Recommended additional record to include in response (e.g. SRV for PTR record)
1519     AuthRecord     *Additional2;        // Another additional (e.g. TXT for PTR record)
1520     AuthRecord     *DependentOn;        // This record depends on another for its uniqueness checking
1521     AuthRecord     *RRSet;              // This unique record is part of an RRSet
1522     mDNSRecordCallback *RecordCallback; // Callback function to call for state changes, and to free memory asynchronously on deregistration
1523     void           *RecordContext;      // Context parameter for the callback function
1524     mDNSu8 AutoTarget;                  // Set if the target of this record (PTR, CNAME, SRV, etc.) is our host name
1525     mDNSu8 AllowRemoteQuery;            // Set if we allow hosts not on the local link to query this record
1526     mDNSu8 ForceMCast;                  // Set by client to advertise solely via multicast, even for apparently unicast names
1527     mDNSu8 AuthFlags;
1528 
1529     OwnerOptData WakeUp;                // WakeUp.HMAC.l[0] nonzero indicates that this is a Sleep Proxy record
1530     mDNSAddr AddressProxy;              // For reverse-mapping Sleep Proxy PTR records, address in question
1531     mDNSs32 TimeRcvd;                   // In platform time units
1532     mDNSs32 TimeExpire;                 // In platform time units
1533     AuthRecType ARType;                 // LocalOnly, P2P or Normal ?
1534     mDNSs32 KATimeExpire;               // In platform time units: time to send keepalive packet for the proxy record
1535 
1536     // Field Group 3: Transient state for Authoritative Records
1537     mDNSu8 Acknowledged;                // Set if we've given the success callback to the client
1538     mDNSu8 ProbeRestartCount;           // Number of times we have restarted probing
1539     mDNSu8 ProbeCount;                  // Number of probes remaining before this record is valid (kDNSRecordTypeUnique)
1540     mDNSu8 AnnounceCount;               // Number of announcements remaining (kDNSRecordTypeShared)
1541     mDNSu8 RequireGoodbye;              // Set if this RR has been announced on the wire and will require a goodbye packet
1542     mDNSu8 AnsweredLocalQ;              // Set if this AuthRecord has been delivered to any local question (LocalOnly or mDNSInterface_Any)
1543     mDNSu8 IncludeInProbe;              // Set if this RR is being put into a probe right now
1544     mDNSu8 ImmedUnicast;                // Set if we may send our response directly via unicast to the requester
1545     mDNSInterfaceID SendNSECNow;        // Set if we need to generate associated NSEC data for this rrname
1546     mDNSInterfaceID ImmedAnswer;        // Someone on this interface issued a query we need to answer (all-ones for all interfaces)
1547 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
1548     mDNSs32 ImmedAnswerMarkTime;
1549 #endif
1550     mDNSInterfaceID ImmedAdditional;    // Hint that we might want to also send this record, just to be helpful
1551     mDNSInterfaceID SendRNow;           // The interface this query is being sent on right now
1552     mDNSv4Addr v4Requester;             // Recent v4 query for this record, or all-ones if more than one recent query
1553     mDNSv6Addr v6Requester;             // Recent v6 query for this record, or all-ones if more than one recent query
1554     AuthRecord     *NextResponse;       // Link to the next element in the chain of responses to generate
1555     const mDNSu8   *NR_AnswerTo;        // Set if this record was selected by virtue of being a direct answer to a question
1556     AuthRecord     *NR_AdditionalTo;    // Set if this record was selected by virtue of being additional to another
1557     mDNSs32 ThisAPInterval;             // In platform time units: Current interval for announce/probe
1558     mDNSs32 LastAPTime;                 // In platform time units: Last time we sent announcement/probe
1559     mDNSs32 LastMCTime;                 // Last time we multicast this record (used to guard against packet-storm attacks)
1560     mDNSInterfaceID LastMCInterface;    // Interface this record was multicast on at the time LastMCTime was recorded
1561     RData          *NewRData;           // Set if we are updating this record with new rdata
1562     mDNSu16 newrdlength;                // ... and the length of the new RData
1563     mDNSRecordUpdateCallback *UpdateCallback;
1564     mDNSu32 UpdateCredits;              // Token-bucket rate limiting of excessive updates
1565     mDNSs32 NextUpdateCredit;           // Time next token is added to bucket
1566     mDNSs32 UpdateBlocked;              // Set if update delaying is in effect
1567 
1568     // Field Group 4: Transient uDNS state for Authoritative Records
1569     regState_t state;           // Maybe combine this with resrec.RecordType state? Right now it's ambiguous and confusing.
1570                                 // e.g. rr->resrec.RecordType can be kDNSRecordTypeUnregistered,
1571                                 // and rr->state can be regState_Unregistered
1572                                 // What if we find one of those statements is true and the other false? What does that mean?
1573     mDNSBool uselease;          // dynamic update contains (should contain) lease option
1574     mDNSs32 expire;             // In platform time units: expiration of lease (-1 for static)
1575     mDNSBool Private;           // If zone is private, DNS updates may have to be encrypted to prevent eavesdropping
1576     mDNSOpaque16 updateid;      // Identifier to match update request and response -- also used when transferring records to Sleep Proxy
1577     mDNSOpaque64 updateIntID;   // Interface IDs (one bit per interface index)to which updates have been sent
1578     const domainname *zone;     // the zone that is updated
1579     ZoneData  *nta;
1580     struct tcpInfo_t *tcp;
1581     NATTraversalInfo NATinfo;
1582     mDNSBool SRVChanged;       // temporarily deregistered service because its SRV target or port changed
1583     mergeState_t mState;       // Unicast Record Registrations merge state
1584     mDNSu8 refreshCount;        // Number of refreshes to the server
1585     mStatus updateError;        // Record update resulted in Error ?
1586 
1587     // uDNS_UpdateRecord support fields
1588     // Do we really need all these in *addition* to NewRData and newrdlength above?
1589     void *UpdateContext;    // Context parameter for the update callback function
1590     mDNSu16 OrigRDLen;      // previously registered, being deleted
1591     mDNSu16 InFlightRDLen;  // currently being registered
1592     mDNSu16 QueuedRDLen;    // pending operation (re-transmitting if necessary) THEN register the queued update
1593     RData *OrigRData;
1594     RData *InFlightRData;
1595     RData *QueuedRData;
1596 
1597     // Field Group 5: Large data objects go at the end
1598     domainname namestorage;
1599     RData rdatastorage;                 // Normally the storage is right here, except for oversized records
1600     // rdatastorage MUST be the last thing in the structure -- when using oversized AuthRecords, extra bytes
1601     // are appended after the end of the AuthRecord, logically augmenting the size of the rdatastorage
1602     // DO NOT ADD ANY MORE FIELDS HERE
1603 };
1604 
1605 // IsLocalDomain alone is not sufficient to determine that a record is mDNS or uDNS. By default domain names within
1606 // the "local" pseudo-TLD (and within the IPv4 and IPv6 link-local reverse mapping domains) are automatically treated
1607 // as mDNS records, but it is also possible to force any record (even those not within one of the inherently local
1608 // domains) to be handled as an mDNS record by setting the ForceMCast flag, or by setting a non-zero InterfaceID.
1609 // For example, the reverse-mapping PTR record created in AdvertiseInterface sets the ForceMCast flag, since it points to
1610 // a dot-local hostname, and therefore it would make no sense to register this record with a wide-area Unicast DNS server.
1611 // The same applies to Sleep Proxy records, which we will answer for when queried via mDNS, but we never want to try
1612 // to register them with a wide-area Unicast DNS server -- and we probably don't have the required credentials anyway.
1613 // Currently we have no concept of a wide-area uDNS record scoped to a particular interface, so if the InterfaceID is
1614 // nonzero we treat this the same as ForceMCast.
1615 // Note: Question_uDNS(Q) is used in *only* one place -- on entry to mDNS_StartQuery_internal, to decide whether to set TargetQID.
1616 // Everywhere else in the code, the determination of whether a question is unicast is made by checking to see if TargetQID is nonzero.
1617 #define AuthRecord_uDNS(R) ((R)->resrec.InterfaceID == mDNSInterface_Any && !(R)->ForceMCast && !IsLocalDomain((R)->resrec.name))
1618 #define Question_uDNS(Q)   ((Q)->InterfaceID == mDNSInterface_Unicast || (Q)->ProxyQuestion || \
1619                             ((Q)->InterfaceID != mDNSInterface_LocalOnly && (Q)->InterfaceID != mDNSInterface_P2P && (Q)->InterfaceID != mDNSInterface_BLE && !(Q)->ForceMCast && !IsLocalDomain(&(Q)->qname)))
1620 
1621 // AuthRecordLocalOnly records are registered using mDNSInterface_LocalOnly and
1622 // AuthRecordP2P records are created by D2DServiceFound events.  Both record types are kept on the same list.
1623 #define RRLocalOnly(rr) ((rr)->ARType == AuthRecordLocalOnly || (rr)->ARType == AuthRecordP2P)
1624 
1625 // All other auth records, not including those defined as RRLocalOnly().
1626 #define RRAny(rr) ((rr)->ARType == AuthRecordAny || (rr)->ARType == AuthRecordAnyIncludeP2P || (rr)->ARType == AuthRecordAnyIncludeAWDL || (rr)->ARType == AuthRecordAnyIncludeAWDLandP2P)
1627 
1628 // Question (A or AAAA) that is suppressed currently because IPv4 or IPv6 address
1629 // is not available locally for A or AAAA question respectively. Also, if the
1630 // query is disallowed for the "pid" that we are sending on behalf of, suppress it.
1631 #define QuerySuppressed(Q) (((Q)->SuppressUnusable && (Q)->SuppressQuery) || ((Q)->DisallowPID))
1632 
1633 #define PrivateQuery(Q) ((Q)->AuthInfo && (Q)->AuthInfo->AutoTunnel)
1634 
1635 // Normally we always lookup the cache and /etc/hosts before sending the query on the wire. For single label
1636 // queries (A and AAAA) that are unqualified (indicated by AppendSearchDomains), we want to append search
1637 // domains before we try them as such
1638 #define ApplySearchDomainsFirst(q) ((q)->AppendSearchDomains && (CountLabels(&((q)->qname))) == 1)
1639 
1640 // Wrapper struct for Auth Records for higher-level code that cannot use the AuthRecord's ->next pointer field
1641 typedef struct ARListElem
1642 {
1643     struct ARListElem *next;
1644     AuthRecord ar;          // Note: Must be last element of structure, to accomodate oversized AuthRecords
1645 } ARListElem;
1646 
1647 struct CacheRecord_struct
1648 {
1649     CacheRecord    *next;               // Next in list; first element of structure for efficiency reasons
1650     ResourceRecord resrec;              // 36 bytes when compiling for 32-bit; 48 when compiling for 64-bit (now 44/64)
1651 
1652     // Transient state for Cache Records
1653     CacheRecord    *NextInKAList;       // Link to the next element in the chain of known answers to send
1654     mDNSs32 TimeRcvd;                   // In platform time units
1655     mDNSs32 DelayDelivery;              // Set if we want to defer delivery of this answer to local clients
1656     mDNSs32 NextRequiredQuery;          // In platform time units
1657     // Extra four bytes here (on 64bit)
1658     DNSQuestion    *CRActiveQuestion;   // Points to an active question referencing this answer. Can never point to a NewQuestion.
1659     mDNSs32 LastUnansweredTime;         // In platform time units; last time we incremented UnansweredQueries
1660     mDNSu8  UnansweredQueries;          // Number of times we've issued a query for this record without getting an answer
1661     mDNSu8  CRDNSSECQuestion;           // Set to 1 if this was created in response to a DNSSEC question
1662     mDNSOpaque16 responseFlags;         // Second 16 bit in the DNS response
1663     CacheRecord    *NextInCFList;       // Set if this is in the list of records we just received with the cache flush bit set
1664     CacheRecord    *nsec;               // NSEC records needed for non-existence proofs
1665     CacheRecord    *soa;                // SOA record to return for proxy questions
1666 
1667     mDNSAddr sourceAddress;             // node from which we received this record
1668     // Size to here is 76 bytes when compiling 32-bit; 104 bytes when compiling 64-bit (now 160 bytes for 64-bit)
1669     RData_small smallrdatastorage;      // Storage for small records is right here (4 bytes header + 68 bytes data = 72 bytes)
1670 };
1671 
1672 // Should match the CacheGroup_struct members, except namestorage[].  Only used to calculate
1673 // the size of the namestorage array in CacheGroup_struct so that sizeof(CacheGroup) == sizeof(CacheRecord)
1674 struct CacheGroup_base
1675 {
1676     CacheGroup     *next;
1677     mDNSu32         namehash;
1678     CacheRecord    *members;
1679     CacheRecord   **rrcache_tail;
1680     domainname     *name;
1681 };
1682 
1683 struct CacheGroup_struct                // Header object for a list of CacheRecords with the same name
1684 {
1685     CacheGroup     *next;               // Next CacheGroup object in this hash table bucket
1686     mDNSu32         namehash;           // Name-based (i.e. case insensitive) hash of name
1687     CacheRecord    *members;            // List of CacheRecords with this same name
1688     CacheRecord   **rrcache_tail;       // Tail end of that list
1689     domainname     *name;               // Common name for all CacheRecords in this list
1690     mDNSu8 namestorage[sizeof(CacheRecord) - sizeof(struct CacheGroup_base)];  // match sizeof(CacheRecord)
1691 };
1692 
1693 // Storage sufficient to hold either a CacheGroup header or a CacheRecord
1694 // -- for best efficiency (to avoid wasted unused storage) they should be the same size
1695 typedef union CacheEntity_union CacheEntity;
1696 union CacheEntity_union { CacheEntity *next; CacheGroup cg; CacheRecord cr; };
1697 
1698 typedef struct
1699 {
1700     CacheRecord r;
1701     mDNSu8 _extradata[MaximumRDSize-InlineCacheRDSize];     // Glue on the necessary number of extra bytes
1702     domainname namestorage;                                 // Needs to go *after* the extra rdata bytes
1703 } LargeCacheRecord;
1704 
1705 typedef struct HostnameInfo
1706 {
1707     struct HostnameInfo *next;
1708     NATTraversalInfo natinfo;
1709     domainname fqdn;
1710     AuthRecord arv4;                          // registered IPv4 address record
1711     AuthRecord arv6;                          // registered IPv6 address record
1712     mDNSRecordCallback *StatusCallback;       // callback to deliver success or error code to client layer
1713     const void *StatusContext;                // Client Context
1714 } HostnameInfo;
1715 
1716 typedef struct ExtraResourceRecord_struct ExtraResourceRecord;
1717 struct ExtraResourceRecord_struct
1718 {
1719     ExtraResourceRecord *next;
1720     mDNSu32 ClientID;  // Opaque ID field to be used by client to map an AddRecord call to a set of Extra records
1721     AuthRecord r;
1722     // Note: Add any additional fields *before* the AuthRecord in this structure, not at the end.
1723     // In some cases clients can allocate larger chunks of memory and set r->rdata->MaxRDLength to indicate
1724     // that this extra memory is available, which would result in any fields after the AuthRecord getting smashed
1725 };
1726 
1727 // Note: Within an mDNSServiceCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
1728 typedef void mDNSServiceCallback (mDNS *const m, ServiceRecordSet *const sr, mStatus result);
1729 
1730 // A ServiceRecordSet has no special meaning to the core code of the Multicast DNS protocol engine;
1731 // it is just a convenience structure to group together the records that make up a standard service
1732 // registration so that they can be allocted and deallocted together as a single memory object.
1733 // It contains its own ServiceCallback+ServiceContext to report aggregate results up to the next layer of software above.
1734 // It also contains:
1735 //  * the basic PTR/SRV/TXT triplet used to represent any DNS-SD service
1736 //  * the "_services" PTR record for service enumeration
1737 //  * the optional list of SubType PTR records
1738 //  * the optional list of additional records attached to the service set (e.g. iChat pictures)
1739 
1740 struct ServiceRecordSet_struct
1741 {
1742     // These internal state fields are used internally by mDNSCore; the client layer needn't be concerned with them.
1743     // No fields need to be set up by the client prior to calling mDNS_RegisterService();
1744     // all required data is passed as parameters to that function.
1745     mDNSServiceCallback *ServiceCallback;
1746     void                *ServiceContext;
1747     mDNSBool Conflict;              // Set if this record set was forcibly deregistered because of a conflict
1748 
1749     ExtraResourceRecord *Extras;    // Optional list of extra AuthRecords attached to this service registration
1750     mDNSu32 NumSubTypes;
1751     AuthRecord          *SubTypes;
1752     const mDNSu8        *AnonData;
1753     mDNSu32             flags;      // saved for subsequent calls to mDNS_RegisterService() if records
1754                                     // need to be re-registered.
1755     AuthRecord RR_ADV;              // e.g. _services._dns-sd._udp.local. PTR _printer._tcp.local.
1756     AuthRecord RR_PTR;              // e.g. _printer._tcp.local.        PTR Name._printer._tcp.local.
1757     AuthRecord RR_SRV;              // e.g. Name._printer._tcp.local.   SRV 0 0 port target
1758     AuthRecord RR_TXT;              // e.g. Name._printer._tcp.local.   TXT PrintQueueName
1759     // Don't add any fields after AuthRecord RR_TXT.
1760     // This is where the implicit extra space goes if we allocate a ServiceRecordSet containing an oversized RR_TXT record
1761 };
1762 
1763 // ***************************************************************************
1764 #if 0
1765 #pragma mark -
1766 #pragma mark - Question structures
1767 #endif
1768 
1769 // We record the last eight instances of each duplicate query
1770 // This gives us v4/v6 on each of Ethernet, AirPort and Firewire, and two free slots "for future expansion"
1771 // If the host has more active interfaces that this it is not fatal -- duplicate question suppression will degrade gracefully.
1772 // Since we will still remember the last eight, the busiest interfaces will still get the effective duplicate question suppression.
1773 #define DupSuppressInfoSize 8
1774 
1775 typedef struct
1776 {
1777     mDNSs32 Time;
1778     mDNSInterfaceID InterfaceID;
1779     mDNSs32 Type;                           // v4 or v6?
1780 } DupSuppressInfo;
1781 
1782 typedef enum
1783 {
1784     LLQ_InitialRequest    = 1,
1785     LLQ_SecondaryRequest  = 2,
1786     LLQ_Established       = 3,
1787     LLQ_Poll              = 4
1788 } LLQ_State;
1789 
1790 // LLQ constants
1791 #define kLLQ_Vers      1
1792 #define kLLQ_DefLease  7200 // 2 hours
1793 #define kLLQ_MAX_TRIES 3    // retry an operation 3 times max
1794 #define kLLQ_INIT_RESEND 2 // resend an un-ack'd packet after 2 seconds, then double for each additional
1795 // LLQ Operation Codes
1796 #define kLLQOp_Setup     1
1797 #define kLLQOp_Refresh   2
1798 #define kLLQOp_Event     3
1799 
1800 // LLQ Errror Codes
1801 enum
1802 {
1803     LLQErr_NoError    = 0,
1804     LLQErr_ServFull   = 1,
1805     LLQErr_Static     = 2,
1806     LLQErr_FormErr    = 3,
1807     LLQErr_NoSuchLLQ  = 4,
1808     LLQErr_BadVers    = 5,
1809     LLQErr_UnknownErr = 6
1810 };
1811 
1812 enum { NoAnswer_Normal = 0, NoAnswer_Suspended = 1, NoAnswer_Fail = 2 };
1813 
1814 // DNS Push Notification
1815 typedef enum
1816 {
1817     DNSPUSH_NOERROR  = 0,
1818     DNSPUSH_FORMERR  = 1,
1819     DNSPUSH_SERVFAIL = 2,
1820     DNSPUSH_NOTIMP   = 4,
1821     DNSPUSH_REFUSED  = 5
1822 } DNSPUSH_ErrorCode;
1823 
1824 typedef enum {
1825     DNSPUSH_INIT         = 1,
1826     DNSPUSH_NOSERVER     = 2,
1827     DNSPUSH_SERVERFOUND  = 3,
1828     DNSPUSH_ESTABLISHED  = 4
1829 } DNSPush_State;
1830 
1831 enum {
1832     AllowExpired_None = 0,                  // Don't allow expired answers or mark answers immortal (behave normally)
1833     AllowExpired_MakeAnswersImmortal = 1,   // Any answers to this question get marked as immortal
1834     AllowExpired_AllowExpiredAnswers = 2    // Allow already expired answers from the cache
1835 };
1836 typedef mDNSu8 AllowExpiredState;
1837 
1838 #define HMAC_LEN    64
1839 #define HMAC_IPAD   0x36
1840 #define HMAC_OPAD   0x5c
1841 #define MD5_LEN     16
1842 
1843 #define AutoTunnelUnregistered(X) (                                               \
1844         (X)->AutoTunnelHostRecord.resrec.RecordType == kDNSRecordTypeUnregistered && \
1845         (X)->AutoTunnelTarget.resrec.RecordType == kDNSRecordTypeUnregistered && \
1846         (X)->AutoTunnelDeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered && \
1847         (X)->AutoTunnelService.resrec.RecordType == kDNSRecordTypeUnregistered && \
1848         (X)->AutoTunnel6Record.resrec.RecordType == kDNSRecordTypeUnregistered )
1849 
1850 // Internal data structure to maintain authentication information
1851 typedef struct DomainAuthInfo
1852 {
1853     struct DomainAuthInfo *next;
1854     mDNSs32 deltime;                        // If we're planning to delete this DomainAuthInfo, the time we want it deleted
1855     mDNSBool   AutoTunnel;                  // Whether this is AutoTunnel
1856     AuthRecord AutoTunnelHostRecord;        // User-visible hostname; used as SRV target for AutoTunnel services
1857     AuthRecord AutoTunnelTarget;            // Opaque hostname of tunnel endpoint; used as SRV target for AutoTunnelService record
1858     AuthRecord AutoTunnelDeviceInfo;        // Device info of tunnel endpoint
1859     AuthRecord AutoTunnelService;           // Service record (possibly NAT-Mapped) of IKE daemon implementing tunnel endpoint
1860     AuthRecord AutoTunnel6Record;           // AutoTunnel AAAA Record obtained from awacsd
1861     mDNSBool AutoTunnelServiceStarted;         // Whether a service has been registered in this domain
1862     mDNSv6Addr AutoTunnelInnerAddress;
1863     domainname domain;
1864     domainname keyname;
1865     domainname hostname;
1866     mDNSIPPort port;
1867     char b64keydata[32];
1868     mDNSu8 keydata_ipad[HMAC_LEN];              // padded key for inner hash rounds
1869     mDNSu8 keydata_opad[HMAC_LEN];              // padded key for outer hash rounds
1870 } DomainAuthInfo;
1871 
1872 // Note: Within an mDNSQuestionCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
1873 // Note: Any value other than QC_rmv i.e., any non-zero value will result in kDNSServiceFlagsAdd to the application
1874 // layer. These values are used within mDNSResponder and not sent across to the application. QC_addnocache is for
1875 // delivering a response without adding to the cache. QC_forceresponse is superset of QC_addnocache where in
1876 // addition to not entering in the cache, it also forces the negative response through.
1877 typedef enum { QC_rmv = 0, QC_add, QC_addnocache, QC_forceresponse, QC_dnssec , QC_nodnssec, QC_suppressed } QC_result;
1878 typedef void mDNSQuestionCallback (mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord);
1879 typedef void AsyncDispatchFunc(mDNS *const m, void *context);
1880 typedef void DNSSECAuthInfoFreeCallback(mDNS *const m, void *context);
1881 extern void mDNSPlatformDispatchAsync(mDNS *const m, void *context, AsyncDispatchFunc func);
1882 
1883 #define NextQSendTime(Q)  ((Q)->LastQTime + (Q)->ThisQInterval)
1884 #define ActiveQuestion(Q) ((Q)->ThisQInterval > 0 && !(Q)->DuplicateOf)
1885 #define TimeToSendThisQuestion(Q,time) (ActiveQuestion(Q) && (time) - NextQSendTime(Q) >= 0)
1886 
1887 // q->ValidationStatus is either DNSSECValNotRequired or DNSSECValRequired and then moves onto DNSSECValInProgress.
1888 // When Validation is done, we mark all "DNSSECValInProgress" questions "DNSSECValDone". If we are answering
1889 // questions from /etc/hosts, then we go straight to DNSSECValDone from the initial state.
1890 typedef enum { DNSSECValNotRequired = 0, DNSSECValRequired, DNSSECValInProgress, DNSSECValDone } DNSSECValState;
1891 
1892 // ValidationRequired can be set to the following values:
1893 //
1894 // SECURE validation is set to determine whether something is secure or bogus
1895 // INSECURE validation is set internally by dnssec code to indicate that it is currently proving something
1896 // is insecure
1897 #define DNSSEC_VALIDATION_NONE              0x00
1898 #define DNSSEC_VALIDATION_SECURE            0x01
1899 #define DNSSEC_VALIDATION_SECURE_OPTIONAL   0x02
1900 #define DNSSEC_VALIDATION_INSECURE          0x03
1901 
1902 // For both ValidationRequired and ValidatingResponse question, we validate DNSSEC responses.
1903 // For ProxyQuestion with DNSSECOK, we just receive the DNSSEC records to pass them along without
1904 // validation and if the CD bit is not set, we also validate.
1905 #define DNSSECQuestion(q) ((q)->ValidationRequired || (q)->ValidatingResponse || ((q)->ProxyQuestion && (q)->ProxyDNSSECOK))
1906 
1907 // ValidatingQuestion is used when we need to know whether we are validating the DNSSEC responses for a question
1908 #define ValidatingQuestion(q) ((q)->ValidationRequired || (q)->ValidatingResponse)
1909 
1910 #define DNSSECOptionalQuestion(q) ((q)->ValidationRequired == DNSSEC_VALIDATION_SECURE_OPTIONAL)
1911 
1912 // Given the resource record and the question, should we follow the CNAME ?
1913 #define FollowCNAME(q, rr, AddRecord)   (AddRecord && (q)->qtype != kDNSType_CNAME && \
1914                                          (rr)->RecordType != kDNSRecordTypePacketNegative && \
1915                                          (rr)->rrtype == kDNSType_CNAME)
1916 
1917 // RFC 4122 defines it to be 16 bytes
1918 #define UUID_SIZE       16
1919 
1920 #define AWD_METRICS (USE_AWD && TARGET_OS_IOS)
1921 
1922 #if AWD_METRICS
1923 
1924 enum
1925 {
1926     ExpiredAnswer_None = 0,                  // No expired answers used
1927     ExpiredAnswer_Allowed = 1,               // An expired answer is allowed by this request
1928     ExpiredAnswer_AnsweredWithExpired = 2,   // Question was answered with an expired answer
1929     ExpiredAnswer_ExpiredAnswerChanged = 3,  // Expired answer changed on refresh
1930 
1931     ExpiredAnswer_EnumCount
1932 };
1933 typedef mDNSu8 ExpiredAnswerMetric;
1934 
1935 typedef struct
1936 {
1937     domainname *        originalQName;          // Name of original A/AAAA record if this question is for a CNAME record.
1938     mDNSu32             querySendCount;         // Number of queries that have been sent to DNS servers so far.
1939     mDNSs32             firstQueryTime;         // The time when the first query was sent to a DNS server.
1940     mDNSBool            answered;               // Has this question been answered?
1941     ExpiredAnswerMetric expiredAnswerState;     // Expired answer state (see ExpiredAnswerMetric above)
1942 
1943 }   uDNSMetrics;
1944 #endif
1945 
1946 // DNS64 code is only for iOS, which is currently the only Apple OS that supports DNS proxy network extensions.
1947 #define USE_DNS64 (HAVE_DNS64 && TARGET_OS_IOS)
1948 
1949 #if USE_DNS64
1950 #include "DNS64State.h"
1951 #endif
1952 
1953 #if TARGET_OS_EMBEDDED
1954 extern mDNSu32 curr_num_regservices; // tracks the current number of services registered
1955 extern mDNSu32 max_num_regservices;  // tracks the max number of simultaneous services registered by the device
1956 #endif
1957 
1958 struct DNSQuestion_struct
1959 {
1960     // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
1961     DNSQuestion          *next;
1962     mDNSu32 qnamehash;
1963     mDNSs32 DelayAnswering;                 // Set if we want to defer answering this question until the cache settles
1964     mDNSs32 LastQTime;                      // Last scheduled transmission of this Q on *all* applicable interfaces
1965     mDNSs32 ThisQInterval;                  // LastQTime + ThisQInterval is the next scheduled transmission of this Q
1966                                             // ThisQInterval > 0 for an active question;
1967                                             // ThisQInterval = 0 for a suspended question that's still in the list
1968                                             // ThisQInterval = -1 for a cancelled question (should not still be in list)
1969     mDNSs32 ExpectUnicastResp;              // Set when we send a query with the kDNSQClass_UnicastResponse bit set
1970     mDNSs32 LastAnswerPktNum;               // The sequence number of the last response packet containing an answer to this Q
1971     mDNSu32 RecentAnswerPkts;               // Number of answers since the last time we sent this query
1972     mDNSu32 CurrentAnswers;                 // Number of records currently in the cache that answer this question
1973     mDNSu32 BrowseThreshold;                // If we have received at least this number of answers,
1974                                             // set the next question interval to MaxQuestionInterval
1975     mDNSu32 LargeAnswers;                   // Number of answers with rdata > 1024 bytes
1976     mDNSu32 UniqueAnswers;                  // Number of answers received with kDNSClass_UniqueRRSet bit set
1977     mDNSInterfaceID FlappingInterface1;     // Set when an interface goes away, to flag if remove events are delivered for this Q
1978     mDNSInterfaceID FlappingInterface2;     // Set when an interface goes away, to flag if remove events are delivered for this Q
1979     DomainAuthInfo       *AuthInfo;         // Non-NULL if query is currently being done using Private DNS
1980     DNSQuestion          *DuplicateOf;
1981     DNSQuestion          *NextInDQList;
1982     AnonymousInfo        *AnonInfo;         // Anonymous Information
1983     DupSuppressInfo DupSuppress[DupSuppressInfoSize];
1984     mDNSInterfaceID SendQNow;               // The interface this query is being sent on right now
1985     mDNSBool SendOnAll;                     // Set if we're sending this question on all active interfaces
1986     mDNSBool CachedAnswerNeedsUpdate;       // See SendQueries().  Set if we're sending this question
1987                                             // because a cached answer needs to be refreshed.
1988     mDNSu32 RequestUnicast;                 // Non-zero if we want to send query with kDNSQClass_UnicastResponse bit set
1989     mDNSs32 LastQTxTime;                    // Last time this Q was sent on one (but not necessarily all) interfaces
1990     mDNSu32 CNAMEReferrals;                 // Count of how many CNAME redirections we've done
1991     mDNSBool SuppressQuery;                 // This query should be suppressed and not sent on the wire
1992     mDNSu8 LOAddressAnswers;                // Number of answers from the local only auth records that are
1993                                             // answering A, AAAA, CNAME, or PTR (/etc/hosts)
1994     mDNSu8 WakeOnResolveCount;              // Number of wakes that should be sent on resolve
1995     mDNSs32 StopTime;                       // Time this question should be stopped by giving them a negative answer
1996 
1997     // DNSSEC fields
1998     DNSSECValState ValidationState;            // Current state of the Validation process
1999     DNSSECStatus ValidationStatus;             // Validation status for "ValidationRequired" questions (dnssec)
2000     mDNSu8 ValidatingResponse;                 // Question trying to validate a response (dnssec) on behalf of
2001                                                // ValidationRequired question
2002     void *DNSSECAuthInfo;
2003     DNSSECAuthInfoFreeCallback *DAIFreeCallback;
2004 
2005     // Wide Area fields. These are used internally by the uDNS core (Unicast)
2006     UDPSocket            *LocalSocket;
2007 
2008     // |-> DNS Configuration related fields used in uDNS (Subset of Wide Area/Unicast fields)
2009     DNSServer            *qDNSServer;       // Caching server for this query (in the absence of an SRV saying otherwise)
2010     mDNSOpaque128 validDNSServers;          // Valid DNSServers for this question
2011     mDNSu16 noServerResponse;               // At least one server did not respond.
2012     mDNSu16 triedAllServersOnce;            // Tried all DNS servers once
2013     mDNSu8 unansweredQueries;               // The number of unanswered queries to this server
2014     AllowExpiredState allowExpired;         // Allow expired answers state (see enum AllowExpired_None, etc. above)
2015 
2016     ZoneData             *nta;              // Used for getting zone data for private or LLQ query
2017     mDNSAddr servAddr;                      // Address and port learned from _dns-llq, _dns-llq-tls or _dns-query-tls SRV query
2018     mDNSIPPort servPort;
2019     struct tcpInfo_t *tcp;
2020     mDNSIPPort tcpSrcPort;                  // Local Port TCP packet received on;need this as tcp struct is disposed
2021                                             // by tcpCallback before calling into mDNSCoreReceive
2022     mDNSu8 NoAnswer;                        // Set if we want to suppress answers until tunnel setup has completed
2023     mDNSu8 Restart;                         // This question should be restarted soon
2024 
2025     // LLQ-specific fields. These fields are only meaningful when LongLived flag is set
2026     LLQ_State state;
2027     mDNSu32 ReqLease;                       // seconds (relative)
2028     mDNSs32 expire;                         // ticks (absolute)
2029     mDNSs16 ntries;                         // for UDP: the number of packets sent for this LLQ state
2030                                             // for TCP: there is some ambiguity in the use of this variable, but in general, it is
2031                                             //          the number of TCP/TLS connection attempts for this LLQ state, or
2032                                             //          the number of packets sent for this TCP/TLS connection
2033 
2034     // DNS Push Notification fields. These fields are only meaningful when LongLived flag is set
2035     DNSPush_State dnsPushState;             // The state of the DNS push notification negotiation
2036     mDNSAddr      dnsPushServerAddr;        // Address of the system acting as the DNS Push Server
2037     mDNSIPPort    dnsPushServerPort;        // Port on which the DNS Push Server is being advertised.
2038 
2039     mDNSOpaque64 id;
2040 
2041     // DNS Proxy fields
2042     mDNSOpaque16 responseFlags;             // Temporary place holder for the error we get back from the DNS server
2043                                             // till we populate in the cache
2044     mDNSBool     DisallowPID;               // Is the query allowed for the "PID" that we are sending on behalf of ?
2045     mDNSs32      ServiceID;                 // Service identifier to match against the DNS server
2046 
2047     // Client API fields: The client must set up these fields *before* calling mDNS_StartQuery()
2048     mDNSInterfaceID InterfaceID;            // Non-zero if you want to issue queries only on a single specific IP interface
2049     mDNSu32  flags;                         // flags from original DNSService*() API request.
2050     mDNSAddr Target;                        // Non-zero if you want to direct queries to a specific unicast target address
2051     mDNSIPPort TargetPort;                  // Must be set if Target is set
2052     mDNSOpaque16 TargetQID;                 // Must be set if Target is set
2053     domainname qname;
2054     domainname firstExpiredQname;           // first expired qname in request chain
2055     mDNSu16 qtype;
2056     mDNSu16 qclass;
2057     mDNSBool LongLived;                     // Set by client for calls to mDNS_StartQuery to indicate LLQs to unicast layer.
2058     mDNSBool ExpectUnique;                  // Set by client if it's expecting unique RR(s) for this question, not shared RRs
2059     mDNSBool ForceMCast;                    // Set by client to force mDNS query, even for apparently uDNS names
2060     mDNSBool ReturnIntermed;                // Set by client to request callbacks for intermediate CNAME/NXDOMAIN results
2061     mDNSBool SuppressUnusable;              // Set by client to suppress unusable queries to be sent on the wire
2062     mDNSu8 RetryWithSearchDomains;          // Retry with search domains if there is no entry in the cache or AuthRecords
2063     mDNSu8 TimeoutQuestion;                 // Timeout this question if there is no reply in configured time
2064     mDNSu8 WakeOnResolve;                   // Send wakeup on resolve
2065     mDNSu8 UseBackgroundTrafficClass;       // Set by client to use background traffic class for request
2066     mDNSs8 SearchListIndex;                 // Index into SearchList; Used by the client layer but not touched by core
2067     mDNSs8 AppendSearchDomains;             // Search domains can be appended for this query
2068     mDNSs8 AppendLocalSearchDomains;        // Search domains ending in .local can be appended for this query
2069     mDNSu8 ValidationRequired;              // Requires DNSSEC validation.
2070     mDNSu8 ProxyQuestion;                   // Proxy Question
2071     mDNSu8 ProxyDNSSECOK;                   // Proxy Question with EDNS0 DNSSEC OK bit set
2072     mDNSs32 pid;                            // Process ID of the client that is requesting the question
2073     mDNSu8  uuid[UUID_SIZE];                // Unique ID of the client that is requesting the question (valid only if pid is zero)
2074     mDNSu32 euid;                           // Effective User Id of the client that is requesting the question
2075     domainname           *qnameOrig;        // Copy of the original question name if it is not fully qualified
2076     mDNSQuestionCallback *QuestionCallback;
2077     void                 *QuestionContext;
2078 #if AWD_METRICS
2079     uDNSMetrics metrics;                    // Data used for collecting unicast DNS query metrics.
2080 #endif
2081 #if USE_DNS64
2082     DNS64 dns64;                            // DNS64 state for performing IPv6 address synthesis on networks with NAT64.
2083 #endif
2084 };
2085 
2086 typedef enum { ZoneServiceUpdate, ZoneServiceQuery, ZoneServiceLLQ, ZoneServiceDNSPush } ZoneService;
2087 
2088 typedef void ZoneDataCallback (mDNS *const m, mStatus err, const ZoneData *result);
2089 
2090 struct ZoneData_struct
2091 {
2092     domainname ChildName;               // Name for which we're trying to find the responsible server
2093     ZoneService ZoneService;            // Which service we're seeking for this zone (update, query, or LLQ)
2094     domainname       *CurrentSOA;       // Points to somewhere within ChildName
2095     domainname ZoneName;                // Discovered result: Left-hand-side of SOA record
2096     mDNSu16 ZoneClass;                  // Discovered result: DNS Class from SOA record
2097     domainname Host;                    // Discovered result: Target host from SRV record
2098     mDNSIPPort Port;                    // Discovered result: Update port, query port, or LLQ port from SRV record
2099     mDNSAddr Addr;                      // Discovered result: Address of Target host from SRV record
2100     mDNSBool ZonePrivate;               // Discovered result: Does zone require encrypted queries?
2101     ZoneDataCallback *ZoneDataCallback; // Caller-specified function to be called upon completion
2102     void             *ZoneDataContext;
2103     DNSQuestion question;               // Storage for any active question
2104 };
2105 
2106 extern ZoneData *StartGetZoneData(mDNS *const m, const domainname *const name, const ZoneService target, ZoneDataCallback callback, void *callbackInfo);
2107 extern void CancelGetZoneData(mDNS *const m, ZoneData *nta);
2108 extern mDNSBool IsGetZoneDataQuestion(DNSQuestion *q);
2109 
2110 typedef struct DNameListElem
2111 {
2112     struct DNameListElem *next;
2113     mDNSu32 uid;
2114     domainname name;
2115 } DNameListElem;
2116 
2117 #if APPLE_OSX_mDNSResponder
2118 // Different states that we go through locating the peer
2119 #define TC_STATE_AAAA_PEER          0x000000001     /* Peer's BTMM IPv6 address */
2120 #define TC_STATE_AAAA_PEER_RELAY    0x000000002     /* Peer's IPv6 Relay address */
2121 #define TC_STATE_SRV_PEER           0x000000003     /* Peer's SRV Record corresponding to IPv4 address */
2122 #define TC_STATE_ADDR_PEER          0x000000004     /* Peer's IPv4 address */
2123 
2124 typedef struct ClientTunnel
2125 {
2126     struct ClientTunnel *next;
2127     domainname dstname;
2128     mDNSBool MarkedForDeletion;
2129     mDNSv6Addr loc_inner;
2130     mDNSv4Addr loc_outer;
2131     mDNSv6Addr loc_outer6;
2132     mDNSv6Addr rmt_inner;
2133     mDNSv4Addr rmt_outer;
2134     mDNSv6Addr rmt_outer6;
2135     mDNSIPPort rmt_outer_port;
2136     mDNSu16 tc_state;
2137     DNSQuestion q;
2138 } ClientTunnel;
2139 #endif
2140 
2141 // ***************************************************************************
2142 #if 0
2143 #pragma mark -
2144 #pragma mark - NetworkInterfaceInfo_struct
2145 #endif
2146 
2147 typedef struct NetworkInterfaceInfo_struct NetworkInterfaceInfo;
2148 
2149 // A NetworkInterfaceInfo_struct serves two purposes:
2150 // 1. It holds the address, PTR and HINFO records to advertise a given IP address on a given physical interface
2151 // 2. It tells mDNSCore which physical interfaces are available; each physical interface has its own unique InterfaceID.
2152 //    Since there may be multiple IP addresses on a single physical interface,
2153 //    there may be multiple NetworkInterfaceInfo_structs with the same InterfaceID.
2154 //    In this case, to avoid sending the same packet n times, when there's more than one
2155 //    struct with the same InterfaceID, mDNSCore picks one member of the set to be the
2156 //    active representative of the set; all others have the 'InterfaceActive' flag unset.
2157 
2158 struct NetworkInterfaceInfo_struct
2159 {
2160     // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
2161     NetworkInterfaceInfo *next;
2162 
2163     mDNSu8 InterfaceActive;             // Set if interface is sending & receiving packets (see comment above)
2164     mDNSu8 IPv4Available;               // If InterfaceActive, set if v4 available on this InterfaceID
2165     mDNSu8 IPv6Available;               // If InterfaceActive, set if v6 available on this InterfaceID
2166 
2167     DNSQuestion NetWakeBrowse;
2168     DNSQuestion NetWakeResolve[3];      // For fault-tolerance, we try up to three Sleep Proxies
2169     mDNSAddr SPSAddr[3];
2170     mDNSIPPort SPSPort[3];
2171     mDNSs32 NextSPSAttempt;             // -1 if we're not currently attempting to register with any Sleep Proxy
2172     mDNSs32 NextSPSAttemptTime;
2173 
2174     // Standard AuthRecords that every Responder host should have (one per active IP address)
2175     AuthRecord RR_A;                    // 'A' or 'AAAA' (address) record for our ".local" name
2176     AuthRecord RR_PTR;                  // PTR (reverse lookup) record
2177     AuthRecord RR_HINFO;
2178 
2179     // Client API fields: The client must set up these fields *before* calling mDNS_RegisterInterface()
2180     mDNSInterfaceID InterfaceID;        // Identifies physical interface; MUST NOT be 0, -1, or -2
2181     mDNSAddr ip;                        // The IPv4 or IPv6 address to advertise
2182     mDNSAddr mask;
2183     mDNSEthAddr MAC;
2184     char ifname[64];                    // Windows uses a GUID string for the interface name, which doesn't fit in 16 bytes
2185     mDNSu8 Advertise;                   // False if you are only searching on this interface
2186     mDNSu8 McastTxRx;                   // Send/Receive multicast on this { InterfaceID, address family } ?
2187     mDNSu8 NetWake;                     // Set if Wake-On-Magic-Packet is enabled on this interface
2188     mDNSu8 Loopback;                    // Set if this is the loopback interface
2189     mDNSu8 IgnoreIPv4LL;                // Set if IPv4 Link-Local addresses have to be ignored.
2190     mDNSu8 SendGoodbyes;                // Send goodbyes on this interface while sleeping
2191     mDNSBool DirectLink;                // a direct link, indicating we can skip the probe for
2192                                         // address records
2193     mDNSBool SupportsUnicastMDNSResponse;  // Indicates that the interface supports unicast responses
2194                                         // to Bonjour queries.  Generally true for an interface.
2195 };
2196 
2197 #define SLE_DELETE                      0x00000001
2198 #define SLE_WAB_BROWSE_QUERY_STARTED    0x00000002
2199 #define SLE_WAB_LBROWSE_QUERY_STARTED   0x00000004
2200 #define SLE_WAB_REG_QUERY_STARTED       0x00000008
2201 
2202 typedef struct SearchListElem
2203 {
2204     struct SearchListElem *next;
2205     domainname domain;
2206     int flag;
2207     mDNSInterfaceID InterfaceID;
2208     DNSQuestion BrowseQ;
2209     DNSQuestion DefBrowseQ;
2210     DNSQuestion AutomaticBrowseQ;
2211     DNSQuestion RegisterQ;
2212     DNSQuestion DefRegisterQ;
2213     int numCfAnswers;
2214     ARListElem *AuthRecs;
2215 } SearchListElem;
2216 
2217 // For domain enumeration and automatic browsing
2218 // This is the user's DNS search list.
2219 // In each of these domains we search for our special pointer records (lb._dns-sd._udp.<domain>, etc.)
2220 // to discover recommended domains for domain enumeration (browse, default browse, registration,
2221 // default registration) and possibly one or more recommended automatic browsing domains.
2222 extern SearchListElem *SearchList;      // This really ought to be part of mDNS_struct -- SC
2223 
2224 // ***************************************************************************
2225 #if 0
2226 #pragma mark -
2227 #pragma mark - Main mDNS object, used to hold all the mDNS state
2228 #endif
2229 
2230 typedef void mDNSCallback (mDNS *const m, mStatus result);
2231 
2232 #ifndef CACHE_HASH_SLOTS
2233 #define CACHE_HASH_SLOTS 499
2234 #endif
2235 
2236 enum
2237 {
2238     SleepState_Awake = 0,
2239     SleepState_Transferring = 1,
2240     SleepState_Sleeping = 2
2241 };
2242 
2243 typedef enum
2244 {
2245     kStatsActionIncrement,
2246     kStatsActionDecrement,
2247     kStatsActionClear,
2248     kStatsActionSet
2249 } DNSSECStatsAction;
2250 
2251 typedef enum
2252 {
2253     kStatsTypeMemoryUsage,
2254     kStatsTypeLatency,
2255     kStatsTypeExtraPackets,
2256     kStatsTypeStatus,
2257     kStatsTypeProbe,
2258     kStatsTypeMsgSize
2259 } DNSSECStatsType;
2260 
2261 typedef struct
2262 {
2263     mDNSu32 TotalMemUsed;
2264     mDNSu32 Latency0;           // 0 to 4 ms
2265     mDNSu32 Latency5;           // 5 to  9 ms
2266     mDNSu32 Latency10;          // 10 to 19 ms
2267     mDNSu32 Latency20;          // 20 to 49 ms
2268     mDNSu32 Latency50;          // 50 to 99 ms
2269     mDNSu32 Latency100;         // >= 100 ms
2270     mDNSu32 ExtraPackets0;      // 0 to 2 packets
2271     mDNSu32 ExtraPackets3;      // 3 to 6 packets
2272     mDNSu32 ExtraPackets7;      // 7 to 9 packets
2273     mDNSu32 ExtraPackets10;     // >= 10 packets
2274     mDNSu32 SecureStatus;
2275     mDNSu32 InsecureStatus;
2276     mDNSu32 IndeterminateStatus;
2277     mDNSu32 BogusStatus;
2278     mDNSu32 NoResponseStatus;
2279     mDNSu32 NumProbesSent;      // Number of probes sent
2280     mDNSu32 MsgSize0;           // DNSSEC message size <= 1024
2281     mDNSu32 MsgSize1;           // DNSSEC message size <= 2048
2282     mDNSu32 MsgSize2;           // DNSSEC message size > 2048
2283 } DNSSECStatistics;
2284 
2285 typedef struct
2286 {
2287     mDNSu32 NameConflicts;                  // Normal Name conflicts
2288     mDNSu32 KnownUniqueNameConflicts;       // Name Conflicts for KnownUnique Records
2289     mDNSu32 DupQuerySuppressions;           // Duplicate query suppressions
2290     mDNSu32 KnownAnswerSuppressions;        // Known Answer suppressions
2291     mDNSu32 KnownAnswerMultiplePkts;        // Known Answer in queries spannign multiple packets
2292     mDNSu32 PoofCacheDeletions;             // Number of times the cache was deleted due to POOF
2293     mDNSu32 UnicastBitInQueries;            // Queries with QU bit set
2294     mDNSu32 NormalQueries;                  // Queries with QU bit not set
2295     mDNSu32 MatchingAnswersForQueries;      // Queries for which we had a response
2296     mDNSu32 UnicastResponses;               // Unicast responses to queries
2297     mDNSu32 MulticastResponses;             // Multicast responses to queries
2298     mDNSu32 UnicastDemotedToMulticast;      // Number of times unicast demoted to multicast
2299     mDNSu32 Sleeps;                         // Total sleeps
2300     mDNSu32 Wakes;                          // Total wakes
2301     mDNSu32 InterfaceUp;                    // Total Interface UP events
2302     mDNSu32 InterfaceUpFlap;                // Total Interface UP events with flaps
2303     mDNSu32 InterfaceDown;                  // Total Interface Down events
2304     mDNSu32 InterfaceDownFlap;              // Total Interface Down events with flaps
2305     mDNSu32 CacheRefreshQueries;            // Number of queries that we sent for refreshing cache
2306     mDNSu32 CacheRefreshed;                 // Number of times the cache was refreshed due to a response
2307     mDNSu32 WakeOnResolves;                 // Number of times we did a wake on resolve
2308 } mDNSStatistics;
2309 
2310 extern void LogMDNSStatistics(mDNS *const m);
2311 
2312 typedef struct mDNS_DNSPushNotificationServer DNSPushNotificationServer;
2313 typedef struct mDNS_DNSPushNotificationZone   DNSPushNotificationZone;
2314 
2315 struct mDNS_DNSPushNotificationServer
2316 {
2317     mDNSAddr   serverAddr;        // Server Address
2318     tcpInfo_t *connection;        // TCP Connection pointer
2319     mDNSu32    numberOfQuestions; // Number of questions for this server
2320     DNSPushNotificationServer *next;
2321 } ;
2322 
2323 struct mDNS_DNSPushNotificationZone
2324 {
2325     domainname zoneName;
2326     DNSPushNotificationServer *servers; // DNS Push Notification Servers for this zone
2327     mDNSu32 numberOfQuestions;          // Number of questions for this zone
2328     DNSPushNotificationZone *next;
2329 } ;
2330 
2331 
2332 // Time constant (~= 260 hours ~= 10 days and 21 hours) used to set
2333 // various time values to a point well into the future.
2334 #define FutureTime   0x38000000
2335 
2336 struct mDNS_struct
2337 {
2338     // Internal state fields. These hold the main internal state of mDNSCore;
2339     // the client layer needn't be concerned with them.
2340     // No fields need to be set up by the client prior to calling mDNS_Init();
2341     // all required data is passed as parameters to that function.
2342 
2343     mDNS_PlatformSupport *p;            // Pointer to platform-specific data of indeterminite size
2344     mDNSs32 NetworkChanged;
2345     mDNSBool CanReceiveUnicastOn5353;
2346     mDNSBool AdvertiseLocalAddresses;
2347     mDNSBool DivertMulticastAdvertisements; // from interfaces that do not advertise local addresses to local-only
2348     mStatus mDNSPlatformStatus;
2349     mDNSIPPort UnicastPort4;
2350     mDNSIPPort UnicastPort6;
2351     mDNSEthAddr PrimaryMAC;             // Used as unique host ID
2352     mDNSCallback *MainCallback;
2353     void         *MainContext;
2354 
2355     // For debugging: To catch and report locking failures
2356     mDNSu32 mDNS_busy;                  // Incremented between mDNS_Lock/mDNS_Unlock section
2357     mDNSu32 mDNS_reentrancy;            // Incremented when calling a client callback
2358     mDNSu8 lock_rrcache;                // For debugging: Set at times when these lists may not be modified
2359     mDNSu8 lock_Questions;
2360     mDNSu8 lock_Records;
2361 #ifndef MaxMsg
2362     #define MaxMsg 512
2363 #endif
2364     char MsgBuffer[MaxMsg];             // Temp storage used while building error log messages
2365 
2366     // Task Scheduling variables
2367     mDNSs32 timenow_adjust;             // Correction applied if we ever discover time went backwards
2368     mDNSs32 timenow;                    // The time that this particular activation of the mDNS code started
2369     mDNSs32 timenow_last;               // The time the last time we ran
2370     mDNSs32 NextScheduledEvent;         // Derived from values below
2371     mDNSs32 ShutdownTime;               // Set when we're shutting down; allows us to skip some unnecessary steps
2372     mDNSs32 SuppressSending;            // Don't send local-link mDNS packets during this time
2373     mDNSs32 NextCacheCheck;             // Next time to refresh cache record before it expires
2374     mDNSs32 NextScheduledQuery;         // Next time to send query in its exponential backoff sequence
2375     mDNSs32 NextScheduledProbe;         // Next time to probe for new authoritative record
2376     mDNSs32 NextScheduledResponse;      // Next time to send authoritative record(s) in responses
2377     mDNSs32 NextScheduledNATOp;         // Next time to send NAT-traversal packets
2378     mDNSs32 NextScheduledSPS;           // Next time to purge expiring Sleep Proxy records
2379     mDNSs32 NextScheduledKA;            // Next time to send Keepalive packets (SPS)
2380 #if BONJOUR_ON_DEMAND
2381     mDNSs32 NextBonjourDisableTime;     // Next time to leave multicast group if Bonjour on Demand is enabled
2382     mDNSu8 BonjourEnabled;              // Non zero if Bonjour is currently enabled by the Bonjour on Demand logic
2383 #endif // BONJOUR_ON_DEMAND
2384     mDNSs32 DelayConflictProcessing;    // To prevent spurious confilcts due to stale packets on the wire/air.
2385     mDNSs32 RandomQueryDelay;           // For de-synchronization of query packets on the wire
2386     mDNSu32 RandomReconfirmDelay;       // For de-synchronization of reconfirmation queries on the wire
2387     mDNSs32 PktNum;                     // Unique sequence number assigned to each received packet
2388     mDNSs32 MPktNum;                    // Unique sequence number assigned to each received Multicast packet
2389     mDNSu8 LocalRemoveEvents;           // Set if we may need to deliver remove events for local-only questions and/or local-only records
2390     mDNSu8 SleepState;                  // Set if we're sleeping
2391     mDNSu8 SleepSeqNum;                 // "Epoch number" of our current period of wakefulness
2392     mDNSu8 SystemWakeOnLANEnabled;      // Set if we want to register with a Sleep Proxy before going to sleep
2393     mDNSu8 SentSleepProxyRegistration;  // Set if we registered (or tried to register) with a Sleep Proxy
2394     mDNSu8 SystemSleepOnlyIfWakeOnLAN;  // Set if we may only sleep if we managed to register with a Sleep Proxy
2395     mDNSs32 AnnounceOwner;              // After waking from sleep, include OWNER option in packets until this time
2396     mDNSs32 DelaySleep;                 // To inhibit re-sleeping too quickly right after wake
2397     mDNSs32 SleepLimit;                 // Time window to allow deregistrations, etc.,
2398                                         // during which underying platform layer should inhibit system sleep
2399     mDNSs32 TimeSlept;                  // Time we went to sleep.
2400 
2401     mDNSs32 UnicastPacketsSent;         // Number of unicast packets sent.
2402     mDNSs32 MulticastPacketsSent;       // Number of multicast packets sent.
2403     mDNSs32 RemoteSubnet;               // Multicast packets received from outside our subnet.
2404 
2405     mDNSs32 NextScheduledSPRetry;       // Time next sleep proxy registration action is required.
2406                                         // Only valid if SleepLimit is nonzero and DelaySleep is zero.
2407 
2408     mDNSs32 NextScheduledStopTime;      // Next time to stop a question
2409 
2410     mDNSs32 NextBLEServiceTime;         // Next time to call the BLE discovery management layer.  Non zero when active.
2411 
2412     // These fields only required for mDNS Searcher...
2413     DNSQuestion *Questions;             // List of all registered questions, active and inactive
2414     DNSQuestion *NewQuestions;          // Fresh questions not yet answered from cache
2415     DNSQuestion *CurrentQuestion;       // Next question about to be examined in AnswerLocalQuestions()
2416     DNSQuestion *LocalOnlyQuestions;    // Questions with InterfaceID set to mDNSInterface_LocalOnly or mDNSInterface_P2P
2417     DNSQuestion *NewLocalOnlyQuestions; // Fresh local-only or P2P questions not yet answered
2418     DNSQuestion *RestartQuestion;       // Questions that are being restarted (stop followed by start)
2419     DNSQuestion *ValidationQuestion;    // Questions that are being validated (dnssec)
2420     mDNSu32 rrcache_size;               // Total number of available cache entries
2421     mDNSu32 rrcache_totalused;          // Number of cache entries currently occupied
2422     mDNSu32 rrcache_totalused_unicast;  // Number of cache entries currently occupied by unicast
2423     mDNSu32 rrcache_active;             // Number of cache entries currently occupied by records that answer active questions
2424     mDNSu32 rrcache_report;
2425     CacheEntity *rrcache_free;
2426     CacheGroup *rrcache_hash[CACHE_HASH_SLOTS];
2427     mDNSs32 rrcache_nextcheck[CACHE_HASH_SLOTS];
2428 
2429     AuthHash rrauth;
2430 
2431     // Fields below only required for mDNS Responder...
2432     domainlabel nicelabel;              // Rich text label encoded using canonically precomposed UTF-8
2433     domainlabel hostlabel;              // Conforms to RFC 1034 "letter-digit-hyphen" ARPANET host name rules
2434     domainname MulticastHostname;       // Fully Qualified "dot-local" Host Name, e.g. "Foo.local."
2435     UTF8str255 HIHardware;
2436     UTF8str255 HISoftware;
2437     AuthRecord DeviceInfo;
2438     AuthRecord *ResourceRecords;
2439     AuthRecord *DuplicateRecords;       // Records currently 'on hold' because they are duplicates of existing records
2440     AuthRecord *NewLocalRecords;        // Fresh AuthRecords (public) not yet delivered to our local-only questions
2441     AuthRecord *CurrentRecord;          // Next AuthRecord about to be examined
2442     mDNSBool NewLocalOnlyRecords;       // Fresh AuthRecords (local only) not yet delivered to our local questions
2443     NetworkInterfaceInfo *HostInterfaces;
2444     mDNSs32 ProbeFailTime;
2445     mDNSu32 NumFailedProbes;
2446     mDNSs32 SuppressProbes;
2447     Platform_t mDNS_plat;               // Why is this here in the “only required for mDNS Responder” section? -- SC
2448 
2449     // Unicast-specific data
2450     mDNSs32 NextuDNSEvent;                  // uDNS next event
2451     mDNSs32 NextSRVUpdate;                  // Time to perform delayed update
2452 
2453     DNSServer        *DNSServers;           // list of DNS servers
2454     McastResolver    *McastResolvers;       // list of Mcast Resolvers
2455 
2456     mDNSAddr Router;
2457     mDNSAddr AdvertisedV4;                  // IPv4 address pointed to by hostname
2458     mDNSAddr AdvertisedV6;                  // IPv6 address pointed to by hostname
2459 
2460     DomainAuthInfo   *AuthInfoList;         // list of domains requiring authentication for updates
2461 
2462     DNSQuestion ReverseMap;                 // Reverse-map query to find static hostname for service target
2463     DNSQuestion AutomaticBrowseDomainQ;
2464     domainname StaticHostname;              // Current answer to reverse-map query
2465     domainname FQDN;
2466     HostnameInfo     *Hostnames;            // List of registered hostnames + hostname metadata
2467     NATTraversalInfo AutoTunnelNAT;         // Shared between all AutoTunnel DomainAuthInfo structs
2468     mDNSv6Addr AutoTunnelRelayAddr;
2469 
2470     mDNSu32 WABBrowseQueriesCount;          // Number of WAB Browse domain enumeration queries (b, db) callers
2471     mDNSu32 WABLBrowseQueriesCount;         // Number of legacy WAB Browse domain enumeration queries (lb) callers
2472     mDNSu32 WABRegQueriesCount;             // Number of WAB Registration domain enumeration queries (r, dr) callers
2473     mDNSu8 SearchDomainsHash[MD5_LEN];
2474 
2475     // NAT-Traversal fields
2476     NATTraversalInfo LLQNAT;                    // Single shared NAT Traversal to receive inbound LLQ notifications
2477     NATTraversalInfo *NATTraversals;
2478     NATTraversalInfo *CurrentNATTraversal;
2479     mDNSs32 retryIntervalGetAddr;               // delta between time sent and retry for NAT-PMP & UPnP/IGD external address request
2480     mDNSs32 retryGetAddr;                       // absolute time when we retry for NAT-PMP & UPnP/IGD external address request
2481     mDNSv4Addr ExtAddress;                      // the external address discovered via NAT-PMP or UPnP/IGD
2482     mDNSu32 PCPNonce[3];                        // the nonce if using PCP
2483 
2484     UDPSocket        *NATMcastRecvskt;          // For receiving PCP & NAT-PMP announcement multicasts from router on port 5350
2485     mDNSu32 LastNATupseconds;                   // NAT engine uptime in seconds, from most recent NAT packet
2486     mDNSs32 LastNATReplyLocalTime;              // Local time in ticks when most recent NAT packet was received
2487     mDNSu16 LastNATMapResultCode;               // Most recent error code for mappings
2488 
2489     tcpLNTInfo tcpAddrInfo;                     // legacy NAT traversal TCP connection info for external address
2490     tcpLNTInfo tcpDeviceInfo;                   // legacy NAT traversal TCP connection info for device info
2491     tcpLNTInfo       *tcpInfoUnmapList;         // list of pending unmap requests
2492     mDNSInterfaceID UPnPInterfaceID;
2493     UDPSocket        *SSDPSocket;               // For SSDP request/response
2494     mDNSBool SSDPWANPPPConnection;              // whether we should send the SSDP query for WANIPConnection or WANPPPConnection
2495     mDNSIPPort UPnPRouterPort;                  // port we send discovery messages to
2496     mDNSIPPort UPnPSOAPPort;                    // port we send SOAP messages to
2497     char             *UPnPRouterURL;            // router's URL string
2498     mDNSBool UPnPWANPPPConnection;              // whether we're using WANIPConnection or WANPPPConnection
2499     char             *UPnPSOAPURL;              // router's SOAP control URL string
2500     char             *UPnPRouterAddressString;  // holds both the router's address and port
2501     char             *UPnPSOAPAddressString;    // holds both address and port for SOAP messages
2502 
2503     // DNS Push Notification fields
2504     DNSPushNotificationServer *DNSPushServers;  // DNS Push Notification Servers
2505     DNSPushNotificationZone   *DNSPushZones;
2506 
2507     // Sleep Proxy client fields
2508     AuthRecord *SPSRRSet;                       // To help the client keep track of the records registered with the sleep proxy
2509 
2510     // Sleep Proxy Server fields
2511     mDNSu8 SPSType;                             // 0 = off, 10-99 encodes desirability metric
2512     mDNSu8 SPSPortability;                      // 10-99
2513     mDNSu8 SPSMarginalPower;                    // 10-99
2514     mDNSu8 SPSTotalPower;                       // 10-99
2515     mDNSu8 SPSFeatureFlags;                     // Features supported. Currently 1 = TCP KeepAlive supported.
2516     mDNSu8 SPSState;                            // 0 = off, 1 = running, 2 = shutting down, 3 = suspended during sleep
2517     mDNSInterfaceID SPSProxyListChanged;
2518     UDPSocket        *SPSSocket;
2519 #ifndef SPC_DISABLED
2520     ServiceRecordSet SPSRecords;
2521 #endif
2522     mDNSQuestionCallback *SPSBrowseCallback;    // So the platform layer can do something useful with SPS browse results
2523     int ProxyRecords;                           // Total number of records we're holding as proxy
2524     #define           MAX_PROXY_RECORDS 10000   /* DOS protection: 400 machines at 25 records each */
2525 
2526 #if APPLE_OSX_mDNSResponder
2527     ClientTunnel     *TunnelClients;
2528     void            *WCF;
2529 #endif
2530     // DNS Proxy fields
2531     mDNSu32 dp_ipintf[MaxIp];                   // input interface index list from the DNS Proxy Client
2532     mDNSu32 dp_opintf;                          // output interface index from the DNS Proxy Client
2533 
2534     TrustAnchor     *TrustAnchors;
2535     int             notifyToken;
2536     int             uds_listener_skt;           // Listening socket for incoming UDS clients. This should not be here -- it's private to uds_daemon.c and nothing to do with mDNSCore -- SC
2537     mDNSu32         AutoTargetServices;         // # of services that have AutoTarget set
2538 
2539 #if BONJOUR_ON_DEMAND
2540     // Counters used in Bonjour on Demand logic.
2541     mDNSu32         NumAllInterfaceRecords;     // Right now we count *all* multicast records here. Later we may want to change to count interface-specific records separately. (This count includes records on the DuplicateRecords list too.)
2542     mDNSu32         NumAllInterfaceQuestions;   // Right now we count *all* multicast questions here. Later we may want to change to count interface-specific questions separately.
2543 #endif // BONJOUR_ON_DEMAND
2544 
2545     DNSSECStatistics DNSSECStats;
2546     mDNSStatistics   mDNSStats;
2547 
2548     // Fixed storage, to avoid creating large objects on the stack
2549     // The imsg is declared as a union with a pointer type to enforce CPU-appropriate alignment
2550     union { DNSMessage m; void *p; } imsg;  // Incoming message received from wire
2551     DNSMessage omsg;                        // Outgoing message we're building
2552     LargeCacheRecord rec;                   // Resource Record extracted from received message
2553 };
2554 
2555 #define FORALL_CACHERECORDS(SLOT,CG,CR)                           \
2556     for ((SLOT) = 0; (SLOT) < CACHE_HASH_SLOTS; (SLOT)++)         \
2557         for ((CG)=m->rrcache_hash[(SLOT)]; (CG); (CG)=(CG)->next) \
2558             for ((CR) = (CG)->members; (CR); (CR)=(CR)->next)
2559 
2560 // ***************************************************************************
2561 #if 0
2562 #pragma mark -
2563 #pragma mark - Useful Static Constants
2564 #endif
2565 
2566 extern const mDNSInterfaceID mDNSInterface_Any;             // Zero
2567 extern const mDNSInterfaceID mDNSInterface_LocalOnly;       // Special value
2568 extern const mDNSInterfaceID mDNSInterface_Unicast;         // Special value
2569 extern const mDNSInterfaceID mDNSInterfaceMark;             // Special value
2570 extern const mDNSInterfaceID mDNSInterface_P2P;             // Special value
2571 extern const mDNSInterfaceID uDNSInterfaceMark;             // Special value
2572 extern const mDNSInterfaceID mDNSInterface_BLE;             // Special value
2573 
2574 #define LocalOnlyOrP2PInterface(INTERFACE)  ((INTERFACE == mDNSInterface_LocalOnly) || (INTERFACE == mDNSInterface_P2P) || (INTERFACE == mDNSInterface_BLE))
2575 
2576 extern const mDNSIPPort DiscardPort;
2577 extern const mDNSIPPort SSHPort;
2578 extern const mDNSIPPort UnicastDNSPort;
2579 extern const mDNSIPPort SSDPPort;
2580 extern const mDNSIPPort IPSECPort;
2581 extern const mDNSIPPort NSIPCPort;
2582 extern const mDNSIPPort NATPMPAnnouncementPort;
2583 extern const mDNSIPPort NATPMPPort;
2584 extern const mDNSIPPort DNSEXTPort;
2585 extern const mDNSIPPort MulticastDNSPort;
2586 extern const mDNSIPPort LoopbackIPCPort;
2587 extern const mDNSIPPort PrivateDNSPort;
2588 
2589 extern const OwnerOptData zeroOwner;
2590 
2591 extern const mDNSIPPort zeroIPPort;
2592 extern const mDNSv4Addr zerov4Addr;
2593 extern const mDNSv6Addr zerov6Addr;
2594 extern const mDNSEthAddr zeroEthAddr;
2595 extern const mDNSv4Addr onesIPv4Addr;
2596 extern const mDNSv6Addr onesIPv6Addr;
2597 extern const mDNSEthAddr onesEthAddr;
2598 extern const mDNSAddr zeroAddr;
2599 
2600 extern const mDNSv4Addr AllDNSAdminGroup;
2601 extern const mDNSv4Addr AllHosts_v4;
2602 extern const mDNSv6Addr AllHosts_v6;
2603 extern const mDNSv6Addr NDP_prefix;
2604 extern const mDNSEthAddr AllHosts_v6_Eth;
2605 extern const mDNSAddr AllDNSLinkGroup_v4;
2606 extern const mDNSAddr AllDNSLinkGroup_v6;
2607 
2608 extern const mDNSOpaque16 zeroID;
2609 extern const mDNSOpaque16 onesID;
2610 extern const mDNSOpaque16 QueryFlags;
2611 extern const mDNSOpaque16 uQueryFlags;
2612 extern const mDNSOpaque16 DNSSecQFlags;
2613 extern const mDNSOpaque16 ResponseFlags;
2614 extern const mDNSOpaque16 UpdateReqFlags;
2615 extern const mDNSOpaque16 UpdateRespFlags;
2616 extern const mDNSOpaque16 SubscribeFlags;
2617 extern const mDNSOpaque16 UnSubscribeFlags;
2618 
2619 extern const mDNSOpaque64 zeroOpaque64;
2620 extern const mDNSOpaque128 zeroOpaque128;
2621 
2622 extern mDNSBool StrictUnicastOrdering;
2623 extern mDNSu8 NumUnicastDNSServers;
2624 #if APPLE_OSX_mDNSResponder
2625 extern mDNSu8 NumUnreachableDNSServers;
2626 #endif
2627 
2628 #define localdomain           (*(const domainname *)"\x5" "local")
2629 #define DeviceInfoName        (*(const domainname *)"\xC" "_device-info" "\x4" "_tcp")
2630 #define LocalDeviceInfoName   (*(const domainname *)"\xC" "_device-info" "\x4" "_tcp" "\x5" "local")
2631 #define SleepProxyServiceType (*(const domainname *)"\xC" "_sleep-proxy" "\x4" "_udp")
2632 
2633 // ***************************************************************************
2634 #if 0
2635 #pragma mark -
2636 #pragma mark - Inline functions
2637 #endif
2638 
2639 #if (defined(_MSC_VER))
2640     #define mDNSinline static __inline
2641 #elif ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))
2642     #define mDNSinline static inline
2643 #else
2644     #define mDNSinline static inline
2645 #endif
2646 
2647 // If we're not doing inline functions, then this header needs to have the extern declarations
2648 #if !defined(mDNSinline)
2649 extern mDNSs32      NonZeroTime(mDNSs32 t);
2650 extern mDNSu16      mDNSVal16(mDNSOpaque16 x);
2651 extern mDNSOpaque16 mDNSOpaque16fromIntVal(mDNSu16 v);
2652 #endif
2653 
2654 // If we're compiling the particular C file that instantiates our inlines, then we
2655 // define "mDNSinline" (to empty string) so that we generate code in the following section
2656 #if (!defined(mDNSinline) && mDNS_InstantiateInlines)
2657 #define mDNSinline
2658 #endif
2659 
2660 #ifdef mDNSinline
2661 
NonZeroTime(mDNSs32 t)2662 mDNSinline mDNSs32 NonZeroTime(mDNSs32 t) { if (t) return(t);else return(1);}
2663 
mDNSVal16(mDNSOpaque16 x)2664 mDNSinline mDNSu16 mDNSVal16(mDNSOpaque16 x) { return((mDNSu16)((mDNSu16)x.b[0] <<  8 | (mDNSu16)x.b[1])); }
2665 
mDNSOpaque16fromIntVal(mDNSu16 v)2666 mDNSinline mDNSOpaque16 mDNSOpaque16fromIntVal(mDNSu16 v)
2667 {
2668     mDNSOpaque16 x;
2669     x.b[0] = (mDNSu8)(v >> 8);
2670     x.b[1] = (mDNSu8)(v & 0xFF);
2671     return(x);
2672 }
2673 
2674 #endif
2675 
2676 // ***************************************************************************
2677 #if 0
2678 #pragma mark -
2679 #pragma mark - Main Client Functions
2680 #endif
2681 
2682 // Every client should call mDNS_Init, passing in storage for the mDNS object and the mDNS_PlatformSupport object.
2683 //
2684 // Clients that are only advertising services should use mDNS_Init_NoCache and mDNS_Init_ZeroCacheSize.
2685 // Clients that plan to perform queries (mDNS_StartQuery, mDNS_StartBrowse, etc.)
2686 // need to provide storage for the resource record cache, or the query calls will return 'mStatus_NoCache'.
2687 // The rrcachestorage parameter is the address of memory for the resource record cache, and
2688 // the rrcachesize parameter is the number of entries in the CacheRecord array passed in.
2689 // (i.e. the size of the cache memory needs to be sizeof(CacheRecord) * rrcachesize).
2690 // OS X 10.3 Panther uses an initial cache size of 64 entries, and then mDNSCore sends an
2691 // mStatus_GrowCache message if it needs more.
2692 //
2693 // Most clients should use mDNS_Init_AdvertiseLocalAddresses. This causes mDNSCore to automatically
2694 // create the correct address records for all the hosts interfaces. If you plan to advertise
2695 // services being offered by the local machine, this is almost always what you want.
2696 // There are two cases where you might use mDNS_Init_DontAdvertiseLocalAddresses:
2697 // 1. A client-only device, that browses for services but doesn't advertise any of its own.
2698 // 2. A proxy-registration service, that advertises services being offered by other machines, and takes
2699 //    the appropriate steps to manually create the correct address records for those other machines.
2700 // In principle, a proxy-like registration service could manually create address records for its own machine too,
2701 // but this would be pointless extra effort when using mDNS_Init_AdvertiseLocalAddresses does that for you.
2702 //
2703 // Note that a client-only device that wishes to prohibit multicast advertisements (e.g. from
2704 // higher-layer API calls) must also set DivertMulticastAdvertisements in the mDNS structure and
2705 // advertise local address(es) on a loopback interface.
2706 //
2707 // When mDNS has finished setting up the client's callback is called
2708 // A client can also spin and poll the mDNSPlatformStatus field to see when it changes from mStatus_Waiting to mStatus_NoError
2709 //
2710 // Call mDNS_StartExit to tidy up before exiting
2711 // Because exiting may be an asynchronous process (e.g. if unicast records need to be deregistered)
2712 // client layer may choose to wait until mDNS_ExitNow() returns true before calling mDNS_FinalExit().
2713 //
2714 // Call mDNS_Register with a completed AuthRecord object to register a resource record
2715 // If the resource record type is kDNSRecordTypeUnique (or kDNSknownunique) then if a conflicting resource record is discovered,
2716 // the resource record's mDNSRecordCallback will be called with error code mStatus_NameConflict. The callback should deregister
2717 // the record, and may then try registering the record again after picking a new name (e.g. by automatically appending a number).
2718 // Following deregistration, the RecordCallback will be called with result mStatus_MemFree to signal that it is safe to deallocate
2719 // the record's storage (memory must be freed asynchronously to allow for goodbye packets and dynamic update deregistration).
2720 //
2721 // Call mDNS_StartQuery to initiate a query. mDNS will proceed to issue Multicast DNS query packets, and any time a response
2722 // is received containing a record which matches the question, the DNSQuestion's mDNSAnswerCallback function will be called
2723 // Call mDNS_StopQuery when no more answers are required
2724 //
2725 // Care should be taken on multi-threaded or interrupt-driven environments.
2726 // The main mDNS routines call mDNSPlatformLock() on entry and mDNSPlatformUnlock() on exit;
2727 // each platform layer needs to implement these appropriately for its respective platform.
2728 // For example, if the support code on a particular platform implements timer callbacks at interrupt time, then
2729 // mDNSPlatformLock/Unlock need to disable interrupts or do similar concurrency control to ensure that the mDNS
2730 // code is not entered by an interrupt-time timer callback while in the middle of processing a client call.
2731 
2732 extern mStatus mDNS_Init      (mDNS *const m, mDNS_PlatformSupport *const p,
2733                                CacheEntity *rrcachestorage, mDNSu32 rrcachesize,
2734                                mDNSBool AdvertiseLocalAddresses,
2735                                mDNSCallback *Callback, void *Context);
2736 // See notes above on use of NoCache/ZeroCacheSize
2737 #define mDNS_Init_NoCache                     mDNSNULL
2738 #define mDNS_Init_ZeroCacheSize               0
2739 // See notes above on use of Advertise/DontAdvertiseLocalAddresses
2740 #define mDNS_Init_AdvertiseLocalAddresses     mDNStrue
2741 #define mDNS_Init_DontAdvertiseLocalAddresses mDNSfalse
2742 #define mDNS_Init_NoInitCallback              mDNSNULL
2743 #define mDNS_Init_NoInitCallbackContext       mDNSNULL
2744 
2745 extern void    mDNS_ConfigChanged(mDNS *const m);
2746 extern void    mDNS_GrowCache (mDNS *const m, CacheEntity *storage, mDNSu32 numrecords);
2747 extern void    mDNS_StartExit (mDNS *const m);
2748 extern void    mDNS_FinalExit (mDNS *const m);
2749 #define mDNS_Close(m) do { mDNS_StartExit(m); mDNS_FinalExit(m); } while(0)
2750 #define mDNS_ExitNow(m, now) ((now) - (m)->ShutdownTime >= 0 || (!(m)->ResourceRecords))
2751 
2752 extern mDNSs32 mDNS_Execute   (mDNS *const m);
2753 
2754 extern mStatus mDNS_Register  (mDNS *const m, AuthRecord *const rr);
2755 extern mStatus mDNS_Update    (mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,
2756                                const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback);
2757 extern mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr);
2758 
2759 extern mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question);
2760 extern mStatus mDNS_StopQuery (mDNS *const m, DNSQuestion *const question);
2761 extern mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question);
2762 extern mStatus mDNS_Reconfirm (mDNS *const m, CacheRecord *const cacherr);
2763 extern mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval);
2764 extern mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr);
2765 extern void    mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr);
2766 extern mDNSs32 mDNS_TimeNow(const mDNS *const m);
2767 
2768 extern mStatus mDNS_StartNATOperation(mDNS *const m, NATTraversalInfo *traversal);
2769 extern mStatus mDNS_StopNATOperation(mDNS *const m, NATTraversalInfo *traversal);
2770 extern mStatus mDNS_StopNATOperation_internal(mDNS *m, NATTraversalInfo *traversal);
2771 
2772 extern DomainAuthInfo *GetAuthInfoForName(mDNS *m, const domainname *const name);
2773 
2774 extern void    mDNS_UpdateAllowSleep(mDNS *const m);
2775 
2776 // ***************************************************************************
2777 #if 0
2778 #pragma mark -
2779 #pragma mark - Platform support functions that are accessible to the client layer too
2780 #endif
2781 
2782 extern mDNSs32 mDNSPlatformOneSecond;
2783 
2784 // ***************************************************************************
2785 #if 0
2786 #pragma mark -
2787 #pragma mark - General utility and helper functions
2788 #endif
2789 
2790 // mDNS_Dereg_normal is used for most calls to mDNS_Deregister_internal
2791 // mDNS_Dereg_rapid is used to send one goodbye instead of three, when we want the memory available for reuse sooner
2792 // mDNS_Dereg_conflict is used to indicate that this record is being forcibly deregistered because of a conflict
2793 // mDNS_Dereg_repeat is used when cleaning up, for records that may have already been forcibly deregistered
2794 typedef enum { mDNS_Dereg_normal, mDNS_Dereg_rapid, mDNS_Dereg_conflict, mDNS_Dereg_repeat } mDNS_Dereg_type;
2795 
2796 // mDNS_RegisterService is a single call to register the set of resource records associated with a given named service.
2797 //
2798 //
2799 // mDNS_AddRecordToService adds an additional record to a Service Record Set.  This record may be deregistered
2800 // via mDNS_RemoveRecordFromService, or by deregistering the service.  mDNS_RemoveRecordFromService is passed a
2801 // callback to free the memory associated with the extra RR when it is safe to do so.  The ExtraResourceRecord
2802 // object can be found in the record's context pointer.
2803 
2804 // mDNS_GetBrowseDomains is a special case of the mDNS_StartQuery call, where the resulting answers
2805 // are a list of PTR records indicating (in the rdata) domains that are recommended for browsing.
2806 // After getting the list of domains to browse, call mDNS_StopQuery to end the search.
2807 // mDNS_GetDefaultBrowseDomain returns the name of the domain that should be highlighted by default.
2808 //
2809 // mDNS_GetRegistrationDomains and mDNS_GetDefaultRegistrationDomain are the equivalent calls to get the list
2810 // of one or more domains that should be offered to the user as choices for where they may register their service,
2811 // and the default domain in which to register in the case where the user has made no selection.
2812 
2813 extern void    mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
2814                                         mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, AuthRecType artype, mDNSRecordCallback Callback, void *Context);
2815 
2816 extern mDNSu32 deriveD2DFlagsFromAuthRecType(AuthRecType authRecType);
2817 extern mStatus mDNS_RegisterService  (mDNS *const m, ServiceRecordSet *sr,
2818                                       const domainlabel *const name, const domainname *const type, const domainname *const domain,
2819                                       const domainname *const host, mDNSIPPort port, RData *txtrdata, const mDNSu8 txtinfo[], mDNSu16 txtlen,
2820                                       AuthRecord *SubTypes, mDNSu32 NumSubTypes,
2821                                       mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context, mDNSu32 flags);
2822 extern mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl,  mDNSu32 flags);
2823 extern mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, mDNSRecordCallback MemFreeCallback, void *Context);
2824 extern mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname);
2825 extern mStatus mDNS_DeregisterService_drt(mDNS *const m, ServiceRecordSet *sr, mDNS_Dereg_type drt);
2826 #define mDNS_DeregisterService(M,S) mDNS_DeregisterService_drt((M), (S), mDNS_Dereg_normal)
2827 
2828 extern mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr,
2829                                           const domainlabel *const name, const domainname *const type, const domainname *const domain,
2830                                           const domainname *const host,
2831                                           const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context, mDNSu32 flags);
2832 #define        mDNS_DeregisterNoSuchService mDNS_Deregister
2833 
2834 extern void mDNS_SetupQuestion(DNSQuestion *const q, const mDNSInterfaceID InterfaceID, const domainname *const name,
2835                                const mDNSu16 qtype, mDNSQuestionCallback *const callback, void *const context);
2836 
2837 extern mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,
2838                                 const domainname *const srv, const domainname *const domain, const mDNSu8 *anondata,
2839                                 const mDNSInterfaceID InterfaceID, mDNSu32 flags,
2840                                 mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass,
2841                                 mDNSQuestionCallback *Callback, void *Context);
2842 #define        mDNS_StopBrowse mDNS_StopQuery
2843 
2844 
2845 typedef enum
2846 {
2847     mDNS_DomainTypeBrowse              = 0,
2848     mDNS_DomainTypeBrowseDefault       = 1,
2849     mDNS_DomainTypeBrowseAutomatic     = 2,
2850     mDNS_DomainTypeRegistration        = 3,
2851     mDNS_DomainTypeRegistrationDefault = 4,
2852 
2853     mDNS_DomainTypeMax = 4
2854 } mDNS_DomainType;
2855 
2856 extern const char *const mDNS_DomainTypeNames[];
2857 
2858 extern mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom,
2859                                const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context);
2860 #define        mDNS_StopGetDomains mDNS_StopQuery
2861 extern mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr, mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname);
2862 #define        mDNS_StopAdvertiseDomains mDNS_Deregister
2863 
2864 extern mDNSOpaque16 mDNS_NewMessageID(mDNS *const m);
2865 extern mDNSBool mDNS_AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr);
2866 
2867 extern DNSServer *GetServerForQuestion(mDNS *m, DNSQuestion *question);
2868 extern mDNSu32 SetValidDNSServers(mDNS *m, DNSQuestion *question);
2869 
2870 // ***************************************************************************
2871 #if 0
2872 #pragma mark -
2873 #pragma mark - DNS name utility functions
2874 #endif
2875 
2876 // In order to expose the full capabilities of the DNS protocol (which allows any arbitrary eight-bit values
2877 // in domain name labels, including unlikely characters like ascii nulls and even dots) all the mDNS APIs
2878 // work with DNS's native length-prefixed strings. For convenience in C, the following utility functions
2879 // are provided for converting between C's null-terminated strings and DNS's length-prefixed strings.
2880 
2881 // Assignment
2882 // A simple C structure assignment of a domainname can cause a protection fault by accessing unmapped memory,
2883 // because that object is defined to be 256 bytes long, but not all domainname objects are truly the full size.
2884 // This macro uses mDNSPlatformMemCopy() to make sure it only touches the actual bytes that are valid.
2885 #define AssignDomainName(DST, SRC) do { mDNSu16 len__ = DomainNameLength((SRC)); \
2886     if (len__ <= MAX_DOMAIN_NAME) mDNSPlatformMemCopy((DST)->c, (SRC)->c, len__); else (DST)->c[0] = 0; } while(0)
2887 
2888 // Comparison functions
2889 #define SameDomainLabelCS(A,B) ((A)[0] == (B)[0] && mDNSPlatformMemSame((A)+1, (B)+1, (A)[0]))
2890 extern mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b);
2891 extern mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2);
2892 extern mDNSBool SameDomainNameCS(const domainname *const d1, const domainname *const d2);
2893 typedef mDNSBool DomainNameComparisonFn (const domainname *const d1, const domainname *const d2);
2894 extern mDNSBool IsLocalDomain(const domainname *d);     // returns true for domains that by default should be looked up using link-local multicast
2895 
2896 #define StripFirstLabel(X) ((const domainname *)& (X)->c[(X)->c[0] ? 1 + (X)->c[0] : 0])
2897 
2898 #define FirstLabel(X)  ((const domainlabel *)(X))
2899 #define SecondLabel(X) ((const domainlabel *)StripFirstLabel(X))
2900 #define ThirdLabel(X)  ((const domainlabel *)StripFirstLabel(StripFirstLabel(X)))
2901 
2902 extern const mDNSu8 *LastLabel(const domainname *d);
2903 
2904 // Get total length of domain name, in native DNS format, including terminal root label
2905 //   (e.g. length of "com." is 5 (length byte, three data bytes, final zero)
2906 extern mDNSu16  DomainNameLengthLimit(const domainname *const name, const mDNSu8 *limit);
2907 #define DomainNameLength(name) DomainNameLengthLimit((name), (name)->c + MAX_DOMAIN_NAME)
2908 
2909 // Append functions to append one or more labels to an existing native format domain name:
2910 //   AppendLiteralLabelString adds a single label from a literal C string, with no escape character interpretation.
2911 //   AppendDNSNameString      adds zero or more labels from a C string using conventional DNS dots-and-escaping interpretation
2912 //   AppendDomainLabel        adds a single label from a native format domainlabel
2913 //   AppendDomainName         adds zero or more labels from a native format domainname
2914 extern mDNSu8  *AppendLiteralLabelString(domainname *const name, const char *cstr);
2915 extern mDNSu8  *AppendDNSNameString     (domainname *const name, const char *cstr);
2916 extern mDNSu8  *AppendDomainLabel       (domainname *const name, const domainlabel *const label);
2917 extern mDNSu8  *AppendDomainName        (domainname *const name, const domainname *const append);
2918 
2919 // Convert from null-terminated string to native DNS format:
2920 //   The DomainLabel form makes a single label from a literal C string, with no escape character interpretation.
2921 //   The DomainName form makes native format domain name from a C string using conventional DNS interpretation:
2922 //     dots separate labels, and within each label, '\.' represents a literal dot, '\\' represents a literal
2923 //     backslash and backslash with three decimal digits (e.g. \000) represents an arbitrary byte value.
2924 extern mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr);
2925 extern mDNSu8  *MakeDomainNameFromDNSNameString (domainname  *const name,  const char *cstr);
2926 
2927 // Convert native format domainlabel or domainname back to C string format
2928 // IMPORTANT:
2929 // When using ConvertDomainLabelToCString, the target buffer must be MAX_ESCAPED_DOMAIN_LABEL (254) bytes long
2930 // to guarantee there will be no buffer overrun. It is only safe to use a buffer shorter than this in rare cases
2931 // where the label is known to be constrained somehow (for example, if the label is known to be either "_tcp" or "_udp").
2932 // Similarly, when using ConvertDomainNameToCString, the target buffer must be MAX_ESCAPED_DOMAIN_NAME (1009) bytes long.
2933 // See definitions of MAX_ESCAPED_DOMAIN_LABEL and MAX_ESCAPED_DOMAIN_NAME for more detailed explanation.
2934 extern char    *ConvertDomainLabelToCString_withescape(const domainlabel *const name, char *cstr, char esc);
2935 #define         ConvertDomainLabelToCString_unescaped(D,C) ConvertDomainLabelToCString_withescape((D), (C), 0)
2936 #define         ConvertDomainLabelToCString(D,C)           ConvertDomainLabelToCString_withescape((D), (C), '\\')
2937 extern char    *ConvertDomainNameToCString_withescape(const domainname *const name, char *cstr, char esc);
2938 #define         ConvertDomainNameToCString_unescaped(D,C) ConvertDomainNameToCString_withescape((D), (C), 0)
2939 #define         ConvertDomainNameToCString(D,C)           ConvertDomainNameToCString_withescape((D), (C), '\\')
2940 
2941 extern void     ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel);
2942 
2943 #define ValidTransportProtocol(X) ( (X)[0] == 4 && (X)[1] == '_' && \
2944                                     ((((X)[2] | 0x20) == 'u' && ((X)[3] | 0x20) == 'd') || (((X)[2] | 0x20) == 't' && ((X)[3] | 0x20) == 'c')) && \
2945                                     ((X)[4] | 0x20) == 'p')
2946 
2947 extern mDNSu8  *ConstructServiceName(domainname *const fqdn, const domainlabel *name, const domainname *type, const domainname *const domain);
2948 extern mDNSBool DeconstructServiceName(const domainname *const fqdn, domainlabel *const name, domainname *const type, domainname *const domain);
2949 
2950 // Note: Some old functions have been replaced by more sensibly-named versions.
2951 // You can uncomment the hash-defines below if you don't want to have to change your source code right away.
2952 // When updating your code, note that (unlike the old versions) *all* the new routines take the target object
2953 // as their first parameter.
2954 //#define ConvertCStringToDomainName(SRC,DST)  MakeDomainNameFromDNSNameString((DST),(SRC))
2955 //#define ConvertCStringToDomainLabel(SRC,DST) MakeDomainLabelFromLiteralString((DST),(SRC))
2956 //#define AppendStringLabelToName(DST,SRC)     AppendLiteralLabelString((DST),(SRC))
2957 //#define AppendStringNameToName(DST,SRC)      AppendDNSNameString((DST),(SRC))
2958 //#define AppendDomainLabelToName(DST,SRC)     AppendDomainLabel((DST),(SRC))
2959 //#define AppendDomainNameToName(DST,SRC)      AppendDomainName((DST),(SRC))
2960 
2961 // ***************************************************************************
2962 #if 0
2963 #pragma mark -
2964 #pragma mark - Other utility functions and macros
2965 #endif
2966 
2967 // mDNS_vsnprintf/snprintf return the number of characters written, excluding the final terminating null.
2968 // The output is always null-terminated: for example, if the output turns out to be exactly buflen long,
2969 // then the output will be truncated by one character to allow space for the terminating null.
2970 // Unlike standard C vsnprintf/snprintf, they return the number of characters *actually* written,
2971 // not the number of characters that *would* have been printed were buflen unlimited.
2972 extern mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg) IS_A_PRINTF_STYLE_FUNCTION(3,0);
2973 extern mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...) IS_A_PRINTF_STYLE_FUNCTION(3,4);
2974 extern mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id);
2975 extern char *DNSTypeName(mDNSu16 rrtype);
2976 extern char *GetRRDisplayString_rdb(const ResourceRecord *const rr, const RDataBody *const rd1, char *const buffer);
2977 #define RRDisplayString(m, rr) GetRRDisplayString_rdb(rr, &(rr)->rdata->u, (m)->MsgBuffer)
2978 #define ARDisplayString(m, rr) GetRRDisplayString_rdb(&(rr)->resrec, &(rr)->resrec.rdata->u, (m)->MsgBuffer)
2979 #define CRDisplayString(m, rr) GetRRDisplayString_rdb(&(rr)->resrec, &(rr)->resrec.rdata->u, (m)->MsgBuffer)
2980 #define MortalityDisplayString(M) (M == Mortality_Mortal ? "mortal" : (M == Mortality_Immortal ? "immortal" : "ghost"))
2981 extern mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2);
2982 extern void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText);
2983 extern mDNSBool mDNSv4AddrIsRFC1918(const mDNSv4Addr * const addr);  // returns true for RFC1918 private addresses
2984 #define mDNSAddrIsRFC1918(X) ((X)->type == mDNSAddrType_IPv4 && mDNSv4AddrIsRFC1918(&(X)->ip.v4))
2985 
2986 // For PCP
2987 extern void mDNSAddrMapIPv4toIPv6(mDNSv4Addr* in, mDNSv6Addr* out);
2988 extern mDNSBool mDNSAddrIPv4FromMappedIPv6(mDNSv6Addr *in, mDNSv4Addr *out);
2989 
2990 #define mDNSSameIPPort(A,B)      ((A).NotAnInteger == (B).NotAnInteger)
2991 #define mDNSSameOpaque16(A,B)    ((A).NotAnInteger == (B).NotAnInteger)
2992 #define mDNSSameOpaque32(A,B)    ((A).NotAnInteger == (B).NotAnInteger)
2993 #define mDNSSameOpaque64(A,B)    ((A)->l[0] == (B)->l[0] && (A)->l[1] == (B)->l[1])
2994 
2995 #define mDNSSameIPv4Address(A,B) ((A).NotAnInteger == (B).NotAnInteger)
2996 #define mDNSSameIPv6Address(A,B) ((A).l[0] == (B).l[0] && (A).l[1] == (B).l[1] && (A).l[2] == (B).l[2] && (A).l[3] == (B).l[3])
2997 #define mDNSSameIPv6NetworkPart(A,B) ((A).l[0] == (B).l[0] && (A).l[1] == (B).l[1])
2998 #define mDNSSameEthAddress(A,B)  ((A)->w[0] == (B)->w[0] && (A)->w[1] == (B)->w[1] && (A)->w[2] == (B)->w[2])
2999 
3000 #define mDNSIPPortIsZero(A)      ((A).NotAnInteger                            == 0)
3001 #define mDNSOpaque16IsZero(A)    ((A).NotAnInteger                            == 0)
3002 #define mDNSOpaque64IsZero(A)    (((A)->l[0] | (A)->l[1]                    ) == 0)
3003 #define mDNSOpaque128IsZero(A)   (((A)->l[0] | (A)->l[1] | (A)->l[2] | (A)->l[3]) == 0)
3004 #define mDNSIPv4AddressIsZero(A) ((A).NotAnInteger                            == 0)
3005 #define mDNSIPv6AddressIsZero(A) (((A).l[0] | (A).l[1] | (A).l[2] | (A).l[3]) == 0)
3006 #define mDNSEthAddressIsZero(A)  (((A).w[0] | (A).w[1] | (A).w[2]           ) == 0)
3007 
3008 #define mDNSIPv4AddressIsOnes(A) ((A).NotAnInteger == 0xFFFFFFFF)
3009 #define mDNSIPv6AddressIsOnes(A) (((A).l[0] & (A).l[1] & (A).l[2] & (A).l[3]) == 0xFFFFFFFF)
3010 
3011 #define mDNSAddressIsAllDNSLinkGroup(X) (                                                            \
3012         ((X)->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address((X)->ip.v4, AllDNSLinkGroup_v4.ip.v4)) || \
3013         ((X)->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address((X)->ip.v6, AllDNSLinkGroup_v6.ip.v6))    )
3014 
3015 #define mDNSAddressIsZero(X) (                                                \
3016         ((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsZero((X)->ip.v4))  || \
3017         ((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsZero((X)->ip.v6))     )
3018 
3019 #define mDNSAddressIsValidNonZero(X) (                                        \
3020         ((X)->type == mDNSAddrType_IPv4 && !mDNSIPv4AddressIsZero((X)->ip.v4)) || \
3021         ((X)->type == mDNSAddrType_IPv6 && !mDNSIPv6AddressIsZero((X)->ip.v6))    )
3022 
3023 #define mDNSAddressIsOnes(X) (                                                \
3024         ((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsOnes((X)->ip.v4))  || \
3025         ((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsOnes((X)->ip.v6))     )
3026 
3027 #define mDNSAddressIsValid(X) (                                                                                             \
3028         ((X)->type == mDNSAddrType_IPv4) ? !(mDNSIPv4AddressIsZero((X)->ip.v4) || mDNSIPv4AddressIsOnes((X)->ip.v4)) :          \
3029         ((X)->type == mDNSAddrType_IPv6) ? !(mDNSIPv6AddressIsZero((X)->ip.v6) || mDNSIPv6AddressIsOnes((X)->ip.v6)) : mDNSfalse)
3030 
3031 #define mDNSv4AddressIsLinkLocal(X) ((X)->b[0] ==  169 &&  (X)->b[1]         ==  254)
3032 #define mDNSv6AddressIsLinkLocal(X) ((X)->b[0] == 0xFE && ((X)->b[1] & 0xC0) == 0x80)
3033 
3034 #define mDNSAddressIsLinkLocal(X)  (                                                    \
3035         ((X)->type == mDNSAddrType_IPv4) ? mDNSv4AddressIsLinkLocal(&(X)->ip.v4) :          \
3036         ((X)->type == mDNSAddrType_IPv6) ? mDNSv6AddressIsLinkLocal(&(X)->ip.v6) : mDNSfalse)
3037 
3038 
3039 // ***************************************************************************
3040 #if 0
3041 #pragma mark -
3042 #pragma mark - Authentication Support
3043 #endif
3044 
3045 // Unicast DNS and Dynamic Update specific Client Calls
3046 //
3047 // mDNS_SetSecretForDomain tells the core to authenticate (via TSIG with an HMAC_MD5 hash of the shared secret)
3048 // when dynamically updating a given zone (and its subdomains).  The key used in authentication must be in
3049 // domain name format.  The shared secret must be a null-terminated base64 encoded string.  A minimum size of
3050 // 16 bytes (128 bits) is recommended for an MD5 hash as per RFC 2485.
3051 // Calling this routine multiple times for a zone replaces previously entered values.  Call with a NULL key
3052 // to disable authentication for the zone.  A non-NULL autoTunnelPrefix means this is an AutoTunnel domain,
3053 // and the value is prepended to the IPSec identifier (used for key lookup)
3054 
3055 extern mStatus mDNS_SetSecretForDomain(mDNS *m, DomainAuthInfo *info,
3056                                        const domainname *domain, const domainname *keyname, const char *b64keydata, const domainname *hostname, mDNSIPPort *port, mDNSBool autoTunnel);
3057 
3058 extern void RecreateNATMappings(mDNS *const m, const mDNSu32 waitTicks);
3059 
3060 // Hostname/Unicast Interface Configuration
3061 
3062 // All hostnames advertised point to one IPv4 address and/or one IPv6 address, set via SetPrimaryInterfaceInfo.  Invoking this routine
3063 // updates all existing hostnames to point to the new address.
3064 
3065 // A hostname is added via AddDynDNSHostName, which points to the primary interface's v4 and/or v6 addresss
3066 
3067 // The status callback is invoked to convey success or failure codes - the callback should not modify the AuthRecord or free memory.
3068 // Added hostnames may be removed (deregistered) via mDNS_RemoveDynDNSHostName.
3069 
3070 // Host domains added prior to specification of the primary interface address and computer name will be deferred until
3071 // these values are initialized.
3072 
3073 // DNS servers used to resolve unicast queries are specified by mDNS_AddDNSServer.
3074 // For "split" DNS configurations, in which queries for different domains are sent to different servers (e.g. VPN and external),
3075 // a domain may be associated with a DNS server.  For standard configurations, specify the root label (".") or NULL.
3076 
3077 extern void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *