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