<rdar://problem/7481776> Suppress logs for "A non-blocking socket operation could...
[people/sha0/mDNSResponder.git] / mDNSCore / mDNSEmbeddedAPI.h
1 /* -*- Mode: C; tab-width: 4 -*-
2  *
3  * Copyright (c) 2002-2003 Apple Computer, 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 __mDNSClientAPI_h
55 #define __mDNSClientAPI_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 #endif
74
75 #ifdef __cplusplus
76         extern "C" {
77 #endif
78
79 // ***************************************************************************
80 // Function scope indicators
81
82 // If you see "mDNSlocal" before a function name in a C file, it means the function is not callable outside this file
83 #ifndef mDNSlocal
84 #define mDNSlocal static
85 #endif
86 // If you see "mDNSexport" before a symbol in a C file, it means the symbol is exported for use by clients
87 // For every "mDNSexport" in a C file, there needs to be a corresponding "extern" declaration in some header file
88 // (When a C file #includes a header file, the "extern" declarations tell the compiler:
89 // "This symbol exists -- but not necessarily in this C file.")
90 #ifndef mDNSexport
91 #define mDNSexport
92 #endif
93
94 // Explanation: These local/export markers are a little habit of mine for signaling the programmers' intentions.
95 // When "mDNSlocal" is just a synonym for "static", and "mDNSexport" is a complete no-op, you could be
96 // forgiven for asking what purpose they serve. The idea is that if you see "mDNSexport" in front of a
97 // function definition it means the programmer intended it to be exported and callable from other files
98 // in the project. If you see "mDNSlocal" in front of a function definition it means the programmer
99 // intended it to be private to that file. If you see neither in front of a function definition it
100 // means the programmer forgot (so you should work out which it is supposed to be, and fix it).
101 // Using "mDNSlocal" instead of "static" makes it easier to do a textual searches for one or the other.
102 // For example you can do a search for "static" to find if any functions declare any local variables as "static"
103 // (generally a bad idea unless it's also "const", because static storage usually risks being non-thread-safe)
104 // without the results being cluttered with hundreds of matches for functions declared static.
105 // - Stuart Cheshire
106
107 // ***************************************************************************
108 // Structure packing macro
109
110 // If we're not using GNUC, it's not fatal.
111 // Most compilers naturally pack the on-the-wire structures correctly anyway, so a plain "struct" is usually fine.
112 // In the event that structures are not packed correctly, mDNS_Init() will detect this and report an error, so the
113 // developer will know what's wrong, and can investigate what needs to be done on that compiler to provide proper packing.
114 #ifndef packedstruct
115  #if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))
116   #define packedstruct struct __attribute__((__packed__))
117   #define packedunion  union  __attribute__((__packed__))
118  #else
119   #define packedstruct struct
120   #define packedunion  union
121  #endif
122 #endif
123
124 // ***************************************************************************
125 #if 0
126 #pragma mark - DNS Resource Record class and type constants
127 #endif
128
129 typedef enum                                                    // From RFC 1035
130         {
131         kDNSClass_IN               = 1,         // Internet
132         kDNSClass_CS               = 2,         // CSNET
133         kDNSClass_CH               = 3,         // CHAOS
134         kDNSClass_HS               = 4,         // Hesiod
135         kDNSClass_NONE             = 254,       // Used in DNS UPDATE [RFC 2136]
136
137         kDNSClass_Mask             = 0x7FFF,// Multicast DNS uses the bottom 15 bits to identify the record class...
138         kDNSClass_UniqueRRSet      = 0x8000,// ... and the top bit indicates that all other cached records are now invalid
139
140         kDNSQClass_ANY             = 255,       // Not a DNS class, but a DNS query class, meaning "all classes"
141         kDNSQClass_UnicastResponse = 0x8000     // Top bit set in a question means "unicast response acceptable"
142         } DNS_ClassValues;
143
144 typedef enum                            // From RFC 1035
145         {
146         kDNSType_A = 1,                 //  1 Address
147         kDNSType_NS,                    //  2 Name Server
148         kDNSType_MD,                    //  3 Mail Destination
149         kDNSType_MF,                    //  4 Mail Forwarder
150         kDNSType_CNAME,                 //  5 Canonical Name
151         kDNSType_SOA,                   //  6 Start of Authority
152         kDNSType_MB,                    //  7 Mailbox
153         kDNSType_MG,                    //  8 Mail Group
154         kDNSType_MR,                    //  9 Mail Rename
155         kDNSType_NULL,                  // 10 NULL RR
156         kDNSType_WKS,                   // 11 Well-known-service
157         kDNSType_PTR,                   // 12 Domain name pointer
158         kDNSType_HINFO,                 // 13 Host information
159         kDNSType_MINFO,                 // 14 Mailbox information
160         kDNSType_MX,                    // 15 Mail Exchanger
161         kDNSType_TXT,                   // 16 Arbitrary text string
162         kDNSType_RP,                    // 17 Responsible person
163         kDNSType_AFSDB,                 // 18 AFS cell database
164         kDNSType_X25,                   // 19 X_25 calling address
165         kDNSType_ISDN,                  // 20 ISDN calling address
166         kDNSType_RT,                    // 21 Router
167         kDNSType_NSAP,                  // 22 NSAP address
168         kDNSType_NSAP_PTR,              // 23 Reverse NSAP lookup (deprecated)
169         kDNSType_SIG,                   // 24 Security signature
170         kDNSType_KEY,                   // 25 Security key
171         kDNSType_PX,                    // 26 X.400 mail mapping
172         kDNSType_GPOS,                  // 27 Geographical position (withdrawn)
173         kDNSType_AAAA,                  // 28 IPv6 Address
174         kDNSType_LOC,                   // 29 Location Information
175         kDNSType_NXT,                   // 30 Next domain (security)
176         kDNSType_EID,                   // 31 Endpoint identifier
177         kDNSType_NIMLOC,                // 32 Nimrod Locator
178         kDNSType_SRV,                   // 33 Service record
179         kDNSType_ATMA,                  // 34 ATM Address
180         kDNSType_NAPTR,                 // 35 Naming Authority PoinTeR
181         kDNSType_KX,                    // 36 Key Exchange
182         kDNSType_CERT,                  // 37 Certification record
183         kDNSType_A6,                    // 38 IPv6 Address (deprecated)
184         kDNSType_DNAME,                 // 39 Non-terminal DNAME (for IPv6)
185         kDNSType_SINK,                  // 40 Kitchen sink (experimental)
186         kDNSType_OPT,                   // 41 EDNS0 option (meta-RR)
187         kDNSType_APL,                   // 42 Address Prefix List
188         kDNSType_DS,                    // 43 Delegation Signer
189         kDNSType_SSHFP,                 // 44 SSH Key Fingerprint
190         kDNSType_IPSECKEY,              // 45 IPSECKEY
191         kDNSType_RRSIG,                 // 46 RRSIG
192         kDNSType_NSEC,                  // 47 Denial of Existence
193         kDNSType_DNSKEY,                // 48 DNSKEY
194         kDNSType_DHCID,                 // 49 DHCP Client Identifier
195         kDNSType_NSEC3,                 // 50 Hashed Authenticated Denial of Existence
196         kDNSType_NSEC3PARAM,    // 51 Hashed Authenticated Denial of Existence
197
198         kDNSType_HIP = 55,              // 55 Host Identity Protocol
199
200         kDNSType_SPF = 99,              // 99 Sender Policy Framework for E-Mail
201         kDNSType_UINFO,                 // 100 IANA-Reserved
202         kDNSType_UID,                   // 101 IANA-Reserved
203         kDNSType_GID,                   // 102 IANA-Reserved
204         kDNSType_UNSPEC,                // 103 IANA-Reserved
205
206         kDNSType_TKEY = 249,    // 249 Transaction key
207         kDNSType_TSIG,                  // 250 Transaction signature
208         kDNSType_IXFR,                  // 251 Incremental zone transfer
209         kDNSType_AXFR,                  // 252 Transfer zone of authority
210         kDNSType_MAILB,                 // 253 Transfer mailbox records
211         kDNSType_MAILA,                 // 254 Transfer mail agent records
212         kDNSQType_ANY                   // Not a DNS type, but a DNS query type, meaning "all types"
213         } DNS_TypeValues;
214
215 // ***************************************************************************
216 #if 0
217 #pragma mark -
218 #pragma mark - Simple types
219 #endif
220
221 // mDNS defines its own names for these common types to simplify portability across
222 // multiple platforms that may each have their own (different) names for these types.
223 typedef          int   mDNSBool;
224 typedef   signed char  mDNSs8;
225 typedef unsigned char  mDNSu8;
226 typedef   signed short mDNSs16;
227 typedef unsigned short mDNSu16;
228
229 // <http://gcc.gnu.org/onlinedocs/gcc-3.3.3/cpp/Common-Predefined-Macros.html> says
230 //   __LP64__ _LP64
231 //   These macros are defined, with value 1, if (and only if) the compilation is
232 //   for a target where long int and pointer both use 64-bits and int uses 32-bit.
233 // <http://www.intel.com/software/products/compilers/clin/docs/ug/lin1077.htm> says
234 //   Macro Name __LP64__ Value 1
235 // A quick Google search for "defined(__LP64__)" OR "#ifdef __LP64__" gives 2590 hits and
236 // a search for "#if __LP64__" gives only 12, so I think we'll go with the majority and use defined()
237 #if defined(_ILP64) || defined(__ILP64__)
238 typedef   signed int32 mDNSs32;
239 typedef unsigned int32 mDNSu32;
240 #elif defined(_LP64) || defined(__LP64__)
241 typedef   signed int   mDNSs32;
242 typedef unsigned int   mDNSu32;
243 #else
244 typedef   signed long  mDNSs32;
245 typedef unsigned long  mDNSu32;
246 //typedef   signed int mDNSs32;
247 //typedef unsigned int mDNSu32;
248 #endif
249
250 // To enforce useful type checking, we make mDNSInterfaceID be a pointer to a dummy struct
251 // This way, mDNSInterfaceIDs can be assigned, and compared with each other, but not with other types
252 // Declaring the type to be the typical generic "void *" would lack this type checking
253 typedef struct mDNSInterfaceID_dummystruct { void *dummy; } *mDNSInterfaceID;
254
255 // These types are for opaque two- and four-byte identifiers.
256 // The "NotAnInteger" fields of the unions allow the value to be conveniently passed around in a
257 // register for the sake of efficiency, and compared for equality or inequality, but don't forget --
258 // just because it is in a register doesn't mean it is an integer. Operations like greater than,
259 // less than, add, multiply, increment, decrement, etc., are undefined for opaque identifiers,
260 // and if you make the mistake of trying to do those using the NotAnInteger field, then you'll
261 // find you get code that doesn't work consistently on big-endian and little-endian machines.
262 #if defined(_WIN32)
263  #pragma pack(push,2)
264 #endif
265 typedef       union { mDNSu8 b[ 2]; mDNSu16 NotAnInteger; } mDNSOpaque16;
266 typedef       union { mDNSu8 b[ 4]; mDNSu32 NotAnInteger; } mDNSOpaque32;
267 typedef packedunion { mDNSu8 b[ 6]; mDNSu16 w[3]; mDNSu32 l[1]; } mDNSOpaque48;
268 typedef       union { mDNSu8 b[ 8]; mDNSu16 w[4]; mDNSu32 l[2]; } mDNSOpaque64;
269 typedef       union { mDNSu8 b[16]; mDNSu16 w[8]; mDNSu32 l[4]; } mDNSOpaque128;
270 #if defined(_WIN32)
271  #pragma pack(pop)
272 #endif
273
274 typedef mDNSOpaque16  mDNSIPPort;               // An IP port is a two-byte opaque identifier (not an integer)
275 typedef mDNSOpaque32  mDNSv4Addr;               // An IP address is a four-byte opaque identifier (not an integer)
276 typedef mDNSOpaque128 mDNSv6Addr;               // An IPv6 address is a 16-byte opaque identifier (not an integer)
277 typedef mDNSOpaque48  mDNSEthAddr;              // An Ethernet address is a six-byte opaque identifier (not an integer)
278
279 enum
280         {
281         mDNSAddrType_None    = 0,
282         mDNSAddrType_IPv4    = 4,
283         mDNSAddrType_IPv6    = 6,
284         mDNSAddrType_Unknown = ~0       // Special marker value used in known answer list recording
285         };
286
287 enum
288         {
289         mDNSTransport_None = 0,
290         mDNSTransport_UDP  = 1,
291         mDNSTransport_TCP  = 2
292         };
293
294 typedef struct
295         {
296         mDNSs32 type;
297         union { mDNSv6Addr v6; mDNSv4Addr v4; } ip;
298         } mDNSAddr;
299
300 enum { mDNSfalse = 0, mDNStrue = 1 };
301
302 #define mDNSNULL 0L
303
304 enum
305         {
306         mStatus_Waiting           = 1,
307         mStatus_NoError           = 0,
308
309         // mDNS return values are in the range FFFE FF00 (-65792) to FFFE FFFF (-65537)
310         // The top end of the range (FFFE FFFF) is used for error codes;
311         // the bottom end of the range (FFFE FF00) is used for non-error values;
312
313         // Error codes:
314         mStatus_UnknownErr                = -65537,             // First value: 0xFFFE FFFF
315         mStatus_NoSuchNameErr             = -65538,
316         mStatus_NoMemoryErr               = -65539,
317         mStatus_BadParamErr               = -65540,
318         mStatus_BadReferenceErr           = -65541,
319         mStatus_BadStateErr               = -65542,
320         mStatus_BadFlagsErr               = -65543,
321         mStatus_UnsupportedErr            = -65544,
322         mStatus_NotInitializedErr         = -65545,
323         mStatus_NoCache                   = -65546,
324         mStatus_AlreadyRegistered         = -65547,
325         mStatus_NameConflict              = -65548,
326         mStatus_Invalid                   = -65549,
327         mStatus_Firewall                  = -65550,
328         mStatus_Incompatible              = -65551,
329         mStatus_BadInterfaceErr           = -65552,
330         mStatus_Refused                   = -65553,
331         mStatus_NoSuchRecord              = -65554,
332         mStatus_NoAuth                    = -65555,
333         mStatus_NoSuchKey                 = -65556,
334         mStatus_NATTraversal              = -65557,
335         mStatus_DoubleNAT                 = -65558,
336         mStatus_BadTime                   = -65559,
337         mStatus_BadSig                    = -65560,     // while we define this per RFC 2845, BIND 9 returns Refused for bad/missing signatures
338         mStatus_BadKey                    = -65561,
339         mStatus_TransientErr              = -65562,     // transient failures, e.g. sending packets shortly after a network transition or wake from sleep
340         mStatus_ServiceNotRunning         = -65563,     // Background daemon not running
341         mStatus_NATPortMappingUnsupported = -65564,     // NAT doesn't support NAT-PMP or UPnP
342         mStatus_NATPortMappingDisabled    = -65565,     // NAT supports NAT-PMP or UPnP but it's disabled by the administrator
343         mStatus_NoRouter                  = -65566,
344         mStatus_PollingMode               = -65567,
345         // -65568 to -65786 currently unused; available for allocation
346
347         // tcp connection status
348         mStatus_ConnPending       = -65787,
349         mStatus_ConnFailed        = -65788,
350         mStatus_ConnEstablished   = -65789,
351
352         // Non-error values:
353         mStatus_GrowCache         = -65790,
354         mStatus_ConfigChanged     = -65791,
355         mStatus_MemFree           = -65792              // Last value: 0xFFFE FF00
356         // mStatus_MemFree is the last legal mDNS error code, at the end of the range allocated for mDNS
357         };
358
359 typedef mDNSs32 mStatus;
360
361 // RFC 1034/1035 specify that a domain label consists of a length byte plus up to 63 characters
362 #define MAX_DOMAIN_LABEL 63
363 typedef struct { mDNSu8 c[ 64]; } domainlabel;          // One label: length byte and up to 63 characters
364
365 // RFC 1034/1035/2181 specify that a domain name, including length bytes, data bytes, and terminating zero, may be up to 256 bytes long
366 #define MAX_DOMAIN_NAME 256
367 typedef struct { mDNSu8 c[256]; } domainname;           // Up to 256 bytes of length-prefixed domainlabels
368
369 typedef struct { mDNSu8 c[256]; } UTF8str255;           // Null-terminated C string
370
371 // The longest legal textual form of a DNS name is 1009 bytes, including the C-string terminating NULL at the end.
372 // Explanation:
373 // When a native domainname object is converted to printable textual form using ConvertDomainNameToCString(),
374 // non-printing characters are represented in the conventional DNS way, as '\ddd', where ddd is a three-digit decimal number.
375 // The longest legal domain name is 256 bytes, in the form of four labels as shown below:
376 // Length byte, 63 data bytes, length byte, 63 data bytes, length byte, 63 data bytes, length byte, 62 data bytes, zero byte.
377 // Each label is encoded textually as characters followed by a trailing dot.
378 // If every character has to be represented as a four-byte escape sequence, then this makes the maximum textual form four labels
379 // plus the C-string terminating NULL as shown below:
380 // 63*4+1 + 63*4+1 + 63*4+1 + 62*4+1 + 1 = 1009.
381 // Note that MAX_ESCAPED_DOMAIN_LABEL is not normally used: If you're only decoding a single label, escaping is usually not required.
382 // It is for domain names, where dots are used as label separators, that proper escaping is vital.
383 #define MAX_ESCAPED_DOMAIN_LABEL 254
384 #define MAX_ESCAPED_DOMAIN_NAME 1009
385
386 // MAX_REVERSE_MAPPING_NAME
387 // For IPv4: "123.123.123.123.in-addr.arpa."  30 bytes including terminating NUL
388 // 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
389
390 #define MAX_REVERSE_MAPPING_NAME_V4 30
391 #define MAX_REVERSE_MAPPING_NAME_V6 74
392 #define MAX_REVERSE_MAPPING_NAME    74
393
394 // Most records have a TTL of 75 minutes, so that their 80% cache-renewal query occurs once per hour.
395 // For records containing a hostname (in the name on the left, or in the rdata on the right),
396 // like A, AAAA, reverse-mapping PTR, and SRV, we use a two-minute TTL by default, because we don't want
397 // them to hang around for too long in the cache if the host in question crashes or otherwise goes away.
398
399 #define kStandardTTL (3600UL * 100 / 80)
400 #define kHostNameTTL 120UL
401
402 #define DefaultTTLforRRType(X) (((X) == kDNSType_A || (X) == kDNSType_AAAA || (X) == kDNSType_SRV) ? kHostNameTTL : kStandardTTL)
403
404 typedef struct AuthRecord_struct AuthRecord;
405 typedef struct ServiceRecordSet_struct ServiceRecordSet;
406 typedef struct CacheRecord_struct CacheRecord;
407 typedef struct CacheGroup_struct CacheGroup;
408 typedef struct DNSQuestion_struct DNSQuestion;
409 typedef struct ZoneData_struct ZoneData;
410 typedef struct mDNS_struct mDNS;
411 typedef struct mDNS_PlatformSupport_struct mDNS_PlatformSupport;
412 typedef struct NATTraversalInfo_struct NATTraversalInfo;
413
414 // Structure to abstract away the differences between TCP/SSL sockets, and one for UDP sockets
415 // The actual definition of these structures appear in the appropriate platform support code
416 typedef struct TCPSocket_struct TCPSocket;
417 typedef struct UDPSocket_struct UDPSocket;
418
419 // ***************************************************************************
420 #if 0
421 #pragma mark -
422 #pragma mark - DNS Message structures
423 #endif
424
425 #define mDNS_numZones   numQuestions
426 #define mDNS_numPrereqs numAnswers
427 #define mDNS_numUpdates numAuthorities
428
429 typedef packedstruct
430         {
431         mDNSOpaque16 id;
432         mDNSOpaque16 flags;
433         mDNSu16 numQuestions;
434         mDNSu16 numAnswers;
435         mDNSu16 numAuthorities;
436         mDNSu16 numAdditionals;
437         } DNSMessageHeader;
438
439 // We can send and receive packets up to 9000 bytes (Ethernet Jumbo Frame size, if that ever becomes widely used)
440 // However, in the normal case we try to limit packets to 1500 bytes so that we don't get IP fragmentation on standard Ethernet
441 // 40 (IPv6 header) + 8 (UDP header) + 12 (DNS message header) + 1440 (DNS message body) = 1500 total
442 #define AbsoluteMaxDNSMessageData 8940
443 #define NormalMaxDNSMessageData 1440
444 typedef packedstruct
445         {
446         DNSMessageHeader h;                                             // Note: Size 12 bytes
447         mDNSu8 data[AbsoluteMaxDNSMessageData]; // 40 (IPv6) + 8 (UDP) + 12 (DNS header) + 8940 (data) = 9000
448         } DNSMessage;
449
450 typedef struct tcpInfo_t
451         {
452         mDNS             *m;
453         TCPSocket        *sock;
454         DNSMessage        request;
455         int               requestLen;
456         DNSQuestion      *question;   // For queries
457         ServiceRecordSet *srs;        // For service record updates
458         AuthRecord       *rr;         // For record updates
459         mDNSAddr          Addr;
460         mDNSIPPort        Port;
461         mDNSIPPort        SrcPort;
462         DNSMessage       *reply;
463         mDNSu16           replylen;
464         unsigned long     nread;
465         int               numReplies;
466         } tcpInfo_t;
467
468 // ***************************************************************************
469 #if 0
470 #pragma mark -
471 #pragma mark - Other Packet Format Structures
472 #endif
473
474 typedef packedstruct
475         {
476         mDNSEthAddr  dst;
477         mDNSEthAddr  src;
478         mDNSOpaque16 ethertype;
479         } EthernetHeader;               // 14 bytes
480
481 typedef packedstruct
482         {
483         mDNSOpaque16 hrd;
484         mDNSOpaque16 pro;
485         mDNSu8       hln;
486         mDNSu8       pln;
487         mDNSOpaque16 op;
488         mDNSEthAddr  sha;
489         mDNSv4Addr   spa;
490         mDNSEthAddr  tha;
491         mDNSv4Addr   tpa;
492         } ARP_EthIP;                    // 28 bytes
493
494 typedef packedstruct
495         {
496         mDNSu8       vlen;
497         mDNSu8       tos;
498         mDNSu16      totlen;
499         mDNSOpaque16 id;
500         mDNSOpaque16 flagsfrags;
501         mDNSu8       ttl;
502         mDNSu8       protocol;  // Payload type: 0x06 = TCP, 0x11 = UDP
503         mDNSu16      checksum;
504         mDNSv4Addr   src;
505         mDNSv4Addr   dst;
506         } IPv4Header;                   // 20 bytes
507
508 typedef packedstruct
509         {
510         mDNSu32      vcf;               // Version, Traffic Class, Flow Label
511         mDNSu16      len;               // Payload Length
512         mDNSu8       pro;               // Type of next header: 0x06 = TCP, 0x11 = UDP, 0x3A = ICMPv6
513         mDNSu8       ttl;               // Hop Limit
514         mDNSv6Addr   src;
515         mDNSv6Addr   dst;
516         } IPv6Header;                   // 40 bytes
517
518 typedef packedstruct
519         {
520         mDNSv6Addr   src;
521         mDNSv6Addr   dst;
522         mDNSOpaque32 len;
523         mDNSOpaque32 pro;
524         } IPv6PseudoHeader;             // 40 bytes
525
526 typedef union
527         {
528         mDNSu8       bytes[20];
529         ARP_EthIP    arp;
530         IPv4Header   v4;
531         IPv6Header   v6;
532         } NetworkLayerPacket;
533
534 typedef packedstruct
535         {
536         mDNSIPPort   src;
537         mDNSIPPort   dst;
538         mDNSu32      seq;
539         mDNSu32      ack;
540         mDNSu8       offset;
541         mDNSu8       flags;
542         mDNSu16      window;
543         mDNSu16      checksum;
544         mDNSu16      urgent;
545         } TCPHeader;                    // 20 bytes; IP protocol type 0x06
546
547 typedef packedstruct
548         {
549         mDNSIPPort   src;
550         mDNSIPPort   dst;
551         mDNSu16      len;               // Length including UDP header (i.e. minimum value is 8 bytes)
552         mDNSu16      checksum;
553         } UDPHeader;                    // 8 bytes; IP protocol type 0x11
554
555 typedef packedstruct
556         {
557         mDNSu8       type;              // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement
558         mDNSu8       code;
559         mDNSu16      checksum;
560         mDNSu32      flags_res; // R/S/O flags and reserved bits
561         mDNSv6Addr   target;
562         // Typically 8 bytes of options are also present
563         } IPv6NDP;                              // 24 bytes or more; IP protocol type 0x3A
564
565 typedef union
566         {
567         mDNSu8       bytes[20];
568         TCPHeader    tcp;
569         UDPHeader    udp;
570         IPv6NDP      ndp;
571         } TransportLayerPacket;
572
573 typedef packedstruct
574         {
575         mDNSOpaque64 InitiatorCookie;
576         mDNSOpaque64 ResponderCookie;
577         mDNSu8       NextPayload;
578         mDNSu8       Version;
579         mDNSu8       ExchangeType;
580         mDNSu8       Flags;
581         mDNSOpaque32 MessageID;
582         mDNSu32      Length;
583         } IKEHeader;                    // 28 bytes
584
585 // ***************************************************************************
586 #if 0
587 #pragma mark -
588 #pragma mark - Resource Record structures
589 #endif
590
591 // Authoritative Resource Records:
592 // There are four basic types: Shared, Advisory, Unique, Known Unique
593
594 // * Shared Resource Records do not have to be unique
595 // -- Shared Resource Records are used for DNS-SD service PTRs
596 // -- It is okay for several hosts to have RRs with the same name but different RDATA
597 // -- We use a random delay on responses to reduce collisions when all the hosts respond to the same query
598 // -- These RRs typically have moderately high TTLs (e.g. one hour)
599 // -- These records are announced on startup and topology changes for the benefit of passive listeners
600 // -- These records send a goodbye packet when deregistering
601 //
602 // * Advisory Resource Records are like Shared Resource Records, except they don't send a goodbye packet
603 //
604 // * Unique Resource Records should be unique among hosts within any given mDNS scope
605 // -- The majority of Resource Records are of this type
606 // -- If two entities on the network have RRs with the same name but different RDATA, this is a conflict
607 // -- Responses may be sent immediately, because only one host should be responding to any particular query
608 // -- These RRs typically have low TTLs (e.g. a few minutes)
609 // -- On startup and after topology changes, a host issues queries to verify uniqueness
610
611 // * Known Unique Resource Records are treated like Unique Resource Records, except that mDNS does
612 // not have to verify their uniqueness because this is already known by other means (e.g. the RR name
613 // is derived from the host's IP or Ethernet address, which is already known to be a unique identifier).
614
615 // Summary of properties of different record types:
616 // Probe?    Does this record type send probes before announcing?
617 // Conflict? Does this record type react if we observe an apparent conflict?
618 // Goodbye?  Does this record type send a goodbye packet on departure?
619 //
620 //               Probe? Conflict? Goodbye? Notes
621 // Unregistered                            Should not appear in any list (sanity check value)
622 // Shared         No      No       Yes     e.g. Service PTR record
623 // Deregistering  No      No       Yes     Shared record about to announce its departure and leave the list
624 // Advisory       No      No       No
625 // Unique         Yes     Yes      No      Record intended to be unique -- will probe to verify
626 // Verified       Yes     Yes      No      Record has completed probing, and is verified unique
627 // KnownUnique    No      Yes      No      Record is assumed by other means to be unique
628
629 // Valid lifecycle of a record:
630 // Unregistered ->                   Shared      -> Deregistering -(goodbye)-> Unregistered
631 // Unregistered ->                   Advisory                               -> Unregistered
632 // Unregistered -> Unique -(probe)-> Verified                               -> Unregistered
633 // Unregistered ->                   KnownUnique                            -> Unregistered
634
635 // Each Authoritative kDNSRecordType has only one bit set. This makes it easy to quickly see if a record
636 // is one of a particular set of types simply by performing the appropriate bitwise masking operation.
637
638 // Cache Resource Records (received from the network):
639 // There are four basic types: Answer, Unique Answer, Additional, Unique Additional
640 // Bit 7 (the top bit) of kDNSRecordType is always set for Cache Resource Records; always clear for Authoritative Resource Records
641 // Bit 6 (value 0x40) is set for answer records; clear for authority/additional records
642 // Bit 5 (value 0x20) is set for records received with the kDNSClass_UniqueRRSet
643
644 enum
645         {
646         kDNSRecordTypeUnregistered     = 0x00,  // Not currently in any list
647         kDNSRecordTypeDeregistering    = 0x01,  // Shared record about to announce its departure and leave the list
648
649         kDNSRecordTypeUnique           = 0x02,  // Will become a kDNSRecordTypeVerified when probing is complete
650
651         kDNSRecordTypeAdvisory         = 0x04,  // Like Shared, but no goodbye packet
652         kDNSRecordTypeShared           = 0x08,  // Shared means record name does not have to be unique -- use random delay on responses
653
654         kDNSRecordTypeVerified         = 0x10,  // Unique means mDNS should check that name is unique (and then send immediate responses)
655         kDNSRecordTypeKnownUnique      = 0x20,  // Known Unique means mDNS can assume name is unique without checking
656                                                 // For Dynamic Update records, Known Unique means the record must already exist on the server.
657         kDNSRecordTypeUniqueMask       = (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique),
658         kDNSRecordTypeActiveMask       = (kDNSRecordTypeAdvisory | kDNSRecordTypeShared | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique),
659
660         kDNSRecordTypePacketAdd        = 0x80,  // Received in the Additional  Section of a DNS Response
661         kDNSRecordTypePacketAddUnique  = 0x90,  // Received in the Additional  Section of a DNS Response with kDNSClass_UniqueRRSet set
662         kDNSRecordTypePacketAuth       = 0xA0,  // Received in the Authorities Section of a DNS Response
663         kDNSRecordTypePacketAuthUnique = 0xB0,  // Received in the Authorities Section of a DNS Response with kDNSClass_UniqueRRSet set
664         kDNSRecordTypePacketAns        = 0xC0,  // Received in the Answer      Section of a DNS Response
665         kDNSRecordTypePacketAnsUnique  = 0xD0,  // Received in the Answer      Section of a DNS Response with kDNSClass_UniqueRRSet set
666
667         kDNSRecordTypePacketNegative   = 0xF0,  // Pseudo-RR generated to cache non-existence results like NXDomain
668
669         kDNSRecordTypePacketUniqueMask = 0x10   // True for PacketAddUnique, PacketAnsUnique, PacketAuthUnique
670         };
671
672 typedef packedstruct { mDNSu16 priority; mDNSu16 weight; mDNSIPPort port; domainname target;   } rdataSRV;
673 typedef packedstruct { mDNSu16 preference;                                domainname exchange; } rdataMX;
674 typedef packedstruct { domainname mbox; domainname txt;                                        } rdataRP;
675 typedef packedstruct { mDNSu16 preference; domainname map822; domainname mapx400;              } rdataPX;
676
677 typedef packedstruct
678         {
679         domainname mname;
680         domainname rname;
681         mDNSs32 serial;         // Modular counter; increases when zone changes
682         mDNSu32 refresh;        // Time in seconds that a slave waits after successful replication of the database before it attempts replication again
683         mDNSu32 retry;          // Time in seconds that a slave waits after an unsuccessful replication attempt before it attempts replication again
684         mDNSu32 expire;         // Time in seconds that a slave holds on to old data while replication attempts remain unsuccessful
685         mDNSu32 min;            // Nominally the minimum record TTL for this zone, in seconds; also used for negative caching.
686         } rdataSOA;
687
688 // EDNS Option Code registrations are recorded in the "DNS EDNS0 Options" section of
689 // <http://www.iana.org/assignments/dns-parameters>
690
691 #define kDNSOpt_LLQ   1
692 #define kDNSOpt_Lease 2
693 #define kDNSOpt_NSID  3
694 #define kDNSOpt_Owner 4
695
696 typedef struct
697         {
698         mDNSu16      vers;
699         mDNSu16      llqOp;
700         mDNSu16      err;       // Or UDP reply port, in setup request
701         // Note: In the in-memory form, there's typically a two-byte space here, so that the following 64-bit id is word-aligned
702         mDNSOpaque64 id;
703         mDNSu32      llqlease;
704         } LLQOptData;
705
706 typedef struct
707         {
708         mDNSu8       vers;              // Version number of this Owner OPT record
709         mDNSs8       seq;               // Sleep/wake epoch
710         mDNSEthAddr  HMAC;              // Host's primary identifier (e.g. MAC of on-board Ethernet)
711         mDNSEthAddr  IMAC;              // Interface's MAC address (if different to primary MAC)
712         mDNSOpaque48 password;  // Optional password
713         } OwnerOptData;
714
715 // Note: rdataOPT format may be repeated an arbitrary number of times in a single resource record
716 typedef packedstruct
717         {
718         mDNSu16 opt;
719         mDNSu16 optlen;
720         union { LLQOptData llq; mDNSu32 updatelease; OwnerOptData owner; } u;
721         } rdataOPT;
722
723 // Space needed to put OPT records into a packet:
724 // Header      11 bytes (name 1, type 2, class 2, TTL 4, length 2)
725 // LLQ rdata   18 bytes (opt 2, len 2, vers 2, op 2, err 2, id 8, lease 4)
726 // Lease rdata  8 bytes (opt 2, len 2, lease 4)
727 // Owner rdata 12-24    (opt 2, len 2, owner 8-20)
728
729 #define DNSOpt_Header_Space                 11
730 #define DNSOpt_LLQData_Space               (4 + 2 + 2 + 2 + 8 + 4)
731 #define DNSOpt_LeaseData_Space             (4 + 4)
732 #define DNSOpt_OwnerData_ID_Space          (4 + 2 + 6)
733 #define DNSOpt_OwnerData_ID_Wake_Space     (4 + 2 + 6 + 6)
734 #define DNSOpt_OwnerData_ID_Wake_PW4_Space (4 + 2 + 6 + 6 + 4)
735 #define DNSOpt_OwnerData_ID_Wake_PW6_Space (4 + 2 + 6 + 6 + 6)
736
737 #define ValidOwnerLength(X) (   (X) == DNSOpt_OwnerData_ID_Space          - 4 || \
738                                                                 (X) == DNSOpt_OwnerData_ID_Wake_Space     - 4 || \
739                                                                 (X) == DNSOpt_OwnerData_ID_Wake_PW4_Space - 4 || \
740                                                                 (X) == DNSOpt_OwnerData_ID_Wake_PW6_Space - 4    )
741
742 #define DNSOpt_Owner_Space(A,B) (mDNSSameEthAddress((A),(B)) ? DNSOpt_OwnerData_ID_Space : DNSOpt_OwnerData_ID_Wake_Space)
743
744 #define DNSOpt_Data_Space(O) (                                  \
745         (O)->opt == kDNSOpt_LLQ   ? DNSOpt_LLQData_Space   :        \
746         (O)->opt == kDNSOpt_Lease ? DNSOpt_LeaseData_Space :        \
747         (O)->opt == kDNSOpt_Owner ? DNSOpt_Owner_Space(&(O)->u.owner.HMAC, &(O)->u.owner.IMAC) : 0x10000)
748
749 // A maximal NSEC record is:
750 //   256 bytes domainname 'nextname'
751 // + 256 * 34 = 8704 bytes of bitmap data
752 // = 8960 bytes total
753 // For now we only support NSEC records encoding DNS types 0-255 and ignore the nextname (we always set it to be the same as the rrname),
754 // which gives us a fixed in-memory size of 32 bytes (256 bits)
755 typedef struct
756         {
757         mDNSu8 bitmap[32];
758         } rdataNSEC;
759
760 // StandardAuthRDSize is 264 (256+8), which is large enough to hold a maximum-sized SRV record (6 + 256 bytes)
761 // MaximumRDSize is 8K the absolute maximum we support (at least for now)
762 #define StandardAuthRDSize 264
763 #define MaximumRDSize 8192
764
765 // InlineCacheRDSize is 68
766 // Records received from the network with rdata this size or less have their rdata stored right in the CacheRecord object
767 // Records received from the network with rdata larger than this have additional storage allocated for the rdata
768 // A quick unscientific sample from a busy network at Apple with lots of machines revealed this:
769 // 1461 records in cache
770 // 292 were one-byte TXT records
771 // 136 were four-byte A records
772 // 184 were sixteen-byte AAAA records
773 // 780 were various PTR, TXT and SRV records from 12-64 bytes
774 // Only 69 records had rdata bigger than 64 bytes
775 // Note that since CacheRecord object and a CacheGroup object are allocated out of the same pool, it's sensible to
776 // have them both be the same size. Making one smaller without making the other smaller won't actually save any memory.
777 #define InlineCacheRDSize 68
778
779 // On 64-bit, the pointers in a CacheRecord are bigger, and that creates 8 bytes more space for the name in a CacheGroup
780 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
781         #if defined(_ILP64) || defined(__ILP64__) || defined(_LP64) || defined(__LP64__) || defined(_WIN64)
782         #define InlineCacheGroupNameSize 160
783         #else
784         #define InlineCacheGroupNameSize 148
785         #endif
786 #else
787         #if defined(_ILP64) || defined(__ILP64__) || defined(_LP64) || defined(__LP64__) || defined(_WIN64)
788         #define InlineCacheGroupNameSize 144
789         #else
790         #define InlineCacheGroupNameSize 132
791         #endif
792 #endif
793
794 // The RDataBody union defines the common rdata types that fit into our 264-byte limit
795 typedef union
796         {
797         mDNSu8      data[StandardAuthRDSize];
798         mDNSv4Addr  ipv4;               // For 'A' record
799         domainname  name;               // For PTR, NS, CNAME, DNAME
800         UTF8str255  txt;
801         rdataMX     mx;
802         mDNSv6Addr  ipv6;               // For 'AAAA' record
803         rdataSRV    srv;
804         rdataOPT    opt[2];             // For EDNS0 OPT record; RDataBody may contain multiple variable-length rdataOPT objects packed together
805         rdataNSEC   nsec;
806         } RDataBody;
807
808 // The RDataBody2 union is the same as above, except it includes fields for the larger types like soa, rp, px
809 typedef union
810         {
811         mDNSu8      data[StandardAuthRDSize];
812         mDNSv4Addr  ipv4;               // For 'A' record
813         domainname  name;               // For PTR, NS, CNAME, DNAME
814         rdataSOA    soa;                // This is large; not included in the normal RDataBody definition
815         UTF8str255  txt;
816         rdataMX     mx;
817         rdataRP     rp;                 // This is large; not included in the normal RDataBody definition
818         rdataPX     px;                 // This is large; not included in the normal RDataBody definition
819         mDNSv6Addr  ipv6;               // For 'AAAA' record
820         rdataSRV    srv;
821         rdataOPT    opt[2];             // For EDNS0 OPT record; RDataBody may contain multiple variable-length rdataOPT objects packed together
822         rdataNSEC   nsec;
823         } RDataBody2;
824
825 typedef struct
826         {
827         mDNSu16    MaxRDLength; // Amount of storage allocated for rdata (usually sizeof(RDataBody))
828         mDNSu16    padding;             // So that RDataBody is aligned on 32-bit boundary
829         RDataBody  u;
830         } RData;
831
832 // sizeofRDataHeader should be 4 bytes
833 #define sizeofRDataHeader (sizeof(RData) - sizeof(RDataBody))
834
835 // RData_small is a smaller version of the RData object, used for inline data storage embedded in a CacheRecord_struct
836 typedef struct
837         {
838         mDNSu16    MaxRDLength; // Storage allocated for data (may be greater than InlineCacheRDSize if additional storage follows this object)
839         mDNSu16    padding;             // So that data is aligned on 32-bit boundary
840         mDNSu8     data[InlineCacheRDSize];
841         } RData_small;
842
843 // Note: Within an mDNSRecordCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
844 typedef void mDNSRecordCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
845
846 // Note:
847 // Restrictions: An mDNSRecordUpdateCallback may not make any mDNS API calls.
848 // The intent of this callback is to allow the client to free memory, if necessary.
849 // The internal data structures of the mDNS code may not be in a state where mDNS API calls may be made safely.
850 typedef void mDNSRecordUpdateCallback(mDNS *const m, AuthRecord *const rr, RData *OldRData);
851
852 // ***************************************************************************
853 #if 0
854 #pragma mark -
855 #pragma mark - NAT Traversal structures and constants
856 #endif
857
858 #define NATMAP_MAX_RETRY_INTERVAL    ((mDNSPlatformOneSecond * 60) * 15)    // Max retry interval is 15 minutes
859 #define NATMAP_MIN_RETRY_INTERVAL     (mDNSPlatformOneSecond * 2)           // Min retry interval is 2 seconds
860 #define NATMAP_INIT_RETRY             (mDNSPlatformOneSecond / 4)           // start at 250ms w/ exponential decay
861 #define NATMAP_DEFAULT_LEASE          (60 * 60 * 2)                         // 2 hour lease life in seconds
862 #define NATMAP_VERS 0
863
864 typedef enum
865         {
866         NATOp_AddrRequest    = 0,
867         NATOp_MapUDP         = 1,
868         NATOp_MapTCP         = 2,
869         
870         NATOp_AddrResponse   = 0x80 | 0,
871         NATOp_MapUDPResponse = 0x80 | 1,
872         NATOp_MapTCPResponse = 0x80 | 2,
873         } NATOp_t;
874
875 enum
876         {
877         NATErr_None    = 0,
878         NATErr_Vers    = 1,
879         NATErr_Refused = 2,
880         NATErr_NetFail = 3,
881         NATErr_Res     = 4,
882         NATErr_Opcode  = 5
883         };
884
885 typedef mDNSu16 NATErr_t;
886
887 typedef packedstruct
888         {
889         mDNSu8 vers;
890         mDNSu8 opcode;
891         } NATAddrRequest;
892
893 typedef packedstruct
894         {
895         mDNSu8     vers;
896         mDNSu8     opcode;
897         mDNSu16    err;
898         mDNSu32    upseconds;           // Time since last NAT engine reboot, in seconds
899         mDNSv4Addr ExtAddr;
900         } NATAddrReply;
901
902 typedef packedstruct
903         {
904         mDNSu8 vers;
905         mDNSu8 opcode;
906         mDNSOpaque16 unused;
907         mDNSIPPort intport;
908         mDNSIPPort extport;
909         mDNSu32    NATReq_lease;
910         } NATPortMapRequest;
911
912 typedef packedstruct
913         {
914         mDNSu8     vers;
915         mDNSu8     opcode;
916         mDNSu16    err;
917         mDNSu32    upseconds;           // Time since last NAT engine reboot, in seconds
918         mDNSIPPort intport;
919         mDNSIPPort extport;
920         mDNSu32    NATRep_lease;
921         } NATPortMapReply;
922
923 typedef enum
924         {
925         LNTDiscoveryOp      = 1,
926         LNTExternalAddrOp   = 2,
927         LNTPortMapOp        = 3,
928         LNTPortMapDeleteOp  = 4
929         } LNTOp_t;
930
931 #define LNT_MAXBUFSIZE 8192
932 typedef struct tcpLNTInfo_struct tcpLNTInfo;
933 struct tcpLNTInfo_struct
934         {
935         tcpLNTInfo       *next;
936         mDNS             *m;
937         NATTraversalInfo *parentNATInfo;        // pointer back to the parent NATTraversalInfo
938         TCPSocket        *sock;
939         LNTOp_t           op;                           // operation performed using this connection
940         mDNSAddr          Address;                      // router address
941         mDNSIPPort        Port;                         // router port
942         mDNSu8           *Request;                      // xml request to router
943         int               requestLen;
944         mDNSu8           *Reply;                        // xml reply from router
945         int               replyLen;
946         unsigned long     nread;                        // number of bytes read so far
947         int               retries;                      // number of times we've tried to do this port mapping
948         };
949
950 typedef void (*NATTraversalClientCallback)(mDNS *m, NATTraversalInfo *n);
951
952 // if m->timenow <  ExpiryTime then we have an active mapping, and we'll renew halfway to expiry
953 // if m->timenow >= ExpiryTime then our mapping has expired, and we're trying to create one
954
955 struct NATTraversalInfo_struct
956         {
957         // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
958         NATTraversalInfo           *next;
959
960         mDNSs32                     ExpiryTime;                 // Time this mapping expires, or zero if no mapping
961         mDNSs32                     retryInterval;              // Current interval, between last packet we sent and the next one
962         mDNSs32                     retryPortMap;               // If Protocol is nonzero, time to send our next mapping packet
963         mStatus                     NewResult;                  // New error code; will be copied to Result just prior to invoking callback
964
965 #ifdef _LEGACY_NAT_TRAVERSAL_
966         tcpLNTInfo                  tcpInfo;                    // Legacy NAT traversal (UPnP) TCP connection
967 #endif
968
969         // Result fields: When the callback is invoked these fields contain the answers the client is looking for
970         // When the callback is invoked ExternalPort is *usually* set to be the same the same as RequestedPort, except:
971         // (a) When we're behind a NAT gateway with port mapping disabled, ExternalPort is reported as zero to
972         //     indicate that we don't currently have a working mapping (but RequestedPort retains the external port
973         //     we'd like to get, the next time we meet an accomodating NAT gateway willing to give us one).
974         // (b) When we have a routable non-RFC1918 address, we don't *need* a port mapping, so ExternalPort
975         //     is reported as the same as our InternalPort, since that is effectively our externally-visible port too.
976         //     Again, RequestedPort retains the external port we'd like to get the next time we find ourself behind a NAT gateway.
977         // To improve stability of port mappings, RequestedPort is updated any time we get a successful
978         // mapping response from the NAT-PMP or UPnP gateway. For example, if we ask for port 80, and
979         // get assigned port 81, then thereafter we'll contine asking for port 81.
980         mDNSInterfaceID             InterfaceID;
981         mDNSv4Addr                  ExternalAddress;    // Initially set to onesIPv4Addr, until first callback
982         mDNSIPPort                  ExternalPort;
983         mDNSu32                     Lifetime;
984         mStatus                     Result;
985
986         // Client API fields: The client must set up these fields *before* making any NAT traversal API calls
987         mDNSu8                      Protocol;                   // NATOp_MapUDP or NATOp_MapTCP, or zero if just requesting the external IP address
988         mDNSIPPort                  IntPort;                    // Client's internal port number (doesn't change)
989         mDNSIPPort                  RequestedPort;              // Requested external port; may be updated with actual value assigned by gateway
990         mDNSu32                     NATLease;                   // Requested lifetime in seconds (doesn't change)
991         NATTraversalClientCallback  clientCallback;
992         void                       *clientContext;
993         };
994
995 enum
996         {
997         DNSServer_Untested = 0,
998         DNSServer_Passed   = 1,
999         DNSServer_Failed   = 2,
1000         DNSServer_Disabled = 3
1001         };
1002
1003 enum
1004         {
1005         DNSServer_FlagDelete = 1,
1006         DNSServer_FlagNew    = 2
1007         };
1008
1009 typedef struct DNSServer
1010         {
1011         struct DNSServer *next;
1012         mDNSInterfaceID interface;      // For specialized uses; we can have DNS servers reachable over specific interfaces
1013         mDNSAddr        addr;
1014         mDNSIPPort      port;
1015         mDNSOpaque16    testid;
1016         mDNSu32         flags;          // Set when we're planning to delete this from the list
1017         mDNSu32         teststate;      // Have we sent bug-detection query to this server?
1018         mDNSs32         lasttest;       // Time we sent last bug-detection query to this server
1019         domainname      domain;         // name->server matching for "split dns"
1020         mDNSs32                 penaltyTime; // amount of time this server is penalized
1021         mDNSBool                scoped;         // interface should be matched against question only
1022                                                                 // if scoped is set
1023         } DNSServer;
1024
1025 typedef struct                                                  // Size is 36 bytes when compiling for 32-bit; 48 when compiling for 64-bit
1026         {
1027         mDNSu8           RecordType;            // See enum above
1028         mDNSu16          rrtype;
1029         mDNSu16          rrclass;
1030         mDNSu32          rroriginalttl;         // In seconds
1031         mDNSu16          rdlength;                      // Size of the raw rdata, in bytes, in the on-the-wire format
1032                                                                                 // (In-memory storage may be larger, for structures containing 'holes', like SOA,
1033                                                                                 // or smaller, for NSEC where we don't bother storing the nextname field)
1034         mDNSu16          rdestimate;            // Upper bound on on-the-wire size of rdata after name compression
1035         mDNSu32          namehash;                      // Name-based (i.e. case-insensitive) hash of name
1036         mDNSu32          rdatahash;                     // For rdata containing domain name (e.g. PTR, SRV, CNAME etc.), case-insensitive name hash
1037                                                                                 // else, for all other rdata, 32-bit hash of the raw rdata
1038                                                                                 // Note: This requirement is important. Various routines like AddAdditionalsToResponseList(),
1039                                                                                 // ReconfirmAntecedents(), etc., use rdatahash as a pre-flight check to see
1040                                                                                 // whether it's worth doing a full SameDomainName() call. If the rdatahash
1041                                                                                 // is not a correct case-insensitive name hash, they'll get false negatives.
1042
1043         // Grouping pointers together at the end of the structure improves the memory layout efficiency
1044         mDNSInterfaceID  InterfaceID;           // Set if this RR is specific to one interface
1045                                                                                 // For records received off the wire, InterfaceID is *always* set to the receiving interface
1046                                                                                 // For our authoritative records, InterfaceID is usually zero, except for those few records
1047                                                                                 // that are interface-specific (e.g. address records, especially linklocal addresses)
1048         const domainname *name;
1049         RData           *rdata;                         // Pointer to storage for this rdata
1050         DNSServer       *rDNSServer;            // Unicast DNS server authoritative for this entry;null for multicast
1051         } ResourceRecord;
1052
1053 // Unless otherwise noted, states may apply to either independent record registrations or service registrations
1054 typedef enum
1055         {
1056         regState_Zero              = 0,
1057         regState_FetchingZoneData  = 1,     // getting info - update not sent
1058         regState_Pending           = 2,     // update sent, reply not received
1059         regState_Registered        = 3,     // update sent, reply received
1060         regState_DeregPending      = 4,     // dereg sent, reply not received
1061         regState_DeregDeferred     = 5,     // dereg requested while in Pending state - send dereg AFTER registration is confirmed
1062         regState_Unregistered      = 8,     // not in any list
1063         regState_Refresh           = 9,     // outstanding refresh (or target change) message
1064         regState_NATMap            = 10,    // establishing NAT port mapping (service registrations only)
1065         regState_UpdatePending     = 11,    // update in flight as result of mDNS_Update call
1066         regState_NoTarget          = 12,    // service registration pending registration of hostname (ServiceRegistrations only)
1067         regState_ExtraQueued       = 13,    // extra record to be registered upon completion of service registration (RecordRegistrations only)
1068         regState_NATError          = 14     // unable to complete NAT traversal
1069         } regState_t;
1070
1071 enum
1072         {
1073         Target_Manual = 0,
1074         Target_AutoHost = 1,
1075         Target_AutoHostAndNATMAP = 2
1076         };
1077
1078 struct AuthRecord_struct
1079         {
1080         // For examples of how to set up this structure for use in mDNS_Register(),
1081         // see mDNS_AdvertiseInterface() or mDNS_RegisterService().
1082         // Basically, resrec and persistent metadata need to be set up before calling mDNS_Register().
1083         // mDNS_SetupResourceRecord() is avaliable as a helper routine to set up most fields to sensible default values for you
1084
1085         AuthRecord     *next;                           // Next in list; first element of structure for efficiency reasons
1086         // Field Group 1: Common ResourceRecord fields
1087         ResourceRecord  resrec;                         // 36 bytes when compiling for 32-bit; 48 when compiling for 64-bit
1088
1089         // Field Group 2: Persistent metadata for Authoritative Records
1090         AuthRecord     *Additional1;            // Recommended additional record to include in response (e.g. SRV for PTR record)
1091         AuthRecord     *Additional2;            // Another additional (e.g. TXT for PTR record)
1092         AuthRecord     *DependentOn;            // This record depends on another for its uniqueness checking
1093         AuthRecord     *RRSet;                          // This unique record is part of an RRSet
1094         mDNSRecordCallback *RecordCallback;     // Callback function to call for state changes, and to free memory asynchronously on deregistration
1095         void           *RecordContext;          // Context parameter for the callback function
1096         mDNSu8          AutoTarget;                     // Set if the target of this record (PTR, CNAME, SRV, etc.) is our host name
1097         mDNSu8          AllowRemoteQuery;       // Set if we allow hosts not on the local link to query this record
1098         mDNSu8          ForceMCast;                     // Set by client to advertise solely via multicast, even for apparently unicast names
1099
1100         OwnerOptData    WakeUp;                         // WakeUp.HMAC.l[0] nonzero indicates that this is a Sleep Proxy record
1101         mDNSAddr        AddressProxy;           // For reverse-mapping Sleep Proxy PTR records, address in question
1102         mDNSs32         TimeRcvd;                       // In platform time units
1103         mDNSs32         TimeExpire;                     // In platform time units
1104
1105         // Field Group 3: Transient state for Authoritative Records
1106         mDNSu8          Acknowledged;           // Set if we've given the success callback to the client
1107         mDNSu8          ProbeCount;                     // Number of probes remaining before this record is valid (kDNSRecordTypeUnique)
1108         mDNSu8          AnnounceCount;          // Number of announcements remaining (kDNSRecordTypeShared)
1109         mDNSu8          RequireGoodbye;         // Set if this RR has been announced on the wire and will require a goodbye packet
1110         mDNSu8          AnsweredLocalQ;         // Set if this AuthRecord has been delivered to any local question (LocalOnly or mDNSInterface_Any)
1111         mDNSu8          IncludeInProbe;         // Set if this RR is being put into a probe right now
1112         mDNSu8          ImmedUnicast;           // Set if we may send our response directly via unicast to the requester
1113         mDNSInterfaceID SendNSECNow;            // Set if we need to generate associated NSEC data for this rrname
1114         mDNSInterfaceID ImmedAnswer;            // Someone on this interface issued a query we need to answer (all-ones for all interfaces)
1115 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
1116         mDNSs32         ImmedAnswerMarkTime;
1117 #endif
1118         mDNSInterfaceID ImmedAdditional;        // Hint that we might want to also send this record, just to be helpful
1119         mDNSInterfaceID SendRNow;                       // The interface this query is being sent on right now
1120         mDNSv4Addr      v4Requester;            // Recent v4 query for this record, or all-ones if more than one recent query
1121         mDNSv6Addr      v6Requester;            // Recent v6 query for this record, or all-ones if more than one recent query
1122         AuthRecord     *NextResponse;           // Link to the next element in the chain of responses to generate
1123         const mDNSu8   *NR_AnswerTo;            // Set if this record was selected by virtue of being a direct answer to a question
1124         AuthRecord     *NR_AdditionalTo;        // Set if this record was selected by virtue of being additional to another
1125         mDNSs32         ThisAPInterval;         // In platform time units: Current interval for announce/probe
1126         mDNSs32         LastAPTime;                     // In platform time units: Last time we sent announcement/probe
1127         mDNSs32         LastMCTime;                     // Last time we multicast this record (used to guard against packet-storm attacks)
1128         mDNSInterfaceID LastMCInterface;        // Interface this record was multicast on at the time LastMCTime was recorded
1129         RData          *NewRData;                       // Set if we are updating this record with new rdata
1130         mDNSu16         newrdlength;            // ... and the length of the new RData
1131         mDNSRecordUpdateCallback *UpdateCallback;
1132         mDNSu32         UpdateCredits;          // Token-bucket rate limiting of excessive updates
1133         mDNSs32         NextUpdateCredit;       // Time next token is added to bucket
1134         mDNSs32         UpdateBlocked;          // Set if update delaying is in effect
1135
1136         // Field Group 4: Transient uDNS state for Authoritative Records
1137         regState_t   state;                     // Maybe combine this with resrec.RecordType state? Right now it's ambiguous and confusing.
1138                                                                 // e.g. rr->resrec.RecordType can be kDNSRecordTypeUnregistered,
1139                                                                 // and rr->state can be regState_Unregistered
1140                                                                 // What if we find one of those statements is true and the other false? What does that mean?
1141         mDNSBool     uselease;          // dynamic update contains (should contain) lease option
1142         mDNSs32      expire;            // In platform time units: expiration of lease (-1 for static)
1143         mDNSBool     Private;           // If zone is private, DNS updates may have to be encrypted to prevent eavesdropping
1144         mDNSOpaque16 updateid;          // Identifier to match update request and response -- also used when transferring records to Sleep Proxy
1145         const domainname *zone;         // the zone that is updated
1146         mDNSAddr     UpdateServer;      // DNS server that handles updates for this zone
1147         mDNSIPPort   UpdatePort;        // port on which server accepts dynamic updates
1148                                                                 // !!!KRS not technically correct to cache longer than TTL
1149                                                                 // SDC Perhaps should keep a reference to the relevant SRV record in the cache?
1150         ZoneData  *nta;
1151         struct tcpInfo_t *tcp;
1152
1153         // uDNS_UpdateRecord support fields
1154         // Do we really need all these in *addition* to NewRData and newrdlength above?
1155         mDNSu16 OrigRDLen;              // previously registered, being deleted
1156         mDNSu16 InFlightRDLen;  // currently being registered
1157         mDNSu16 QueuedRDLen;    // pending operation (re-transmitting if necessary) THEN register the queued update
1158         RData *OrigRData;
1159         RData *InFlightRData;
1160         RData *QueuedRData;
1161
1162         // Field Group 5: Large data objects go at the end
1163         domainname      namestorage;
1164         RData           rdatastorage;           // Normally the storage is right here, except for oversized records
1165         // rdatastorage MUST be the last thing in the structure -- when using oversized AuthRecords, extra bytes
1166         // are appended after the end of the AuthRecord, logically augmenting the size of the rdatastorage
1167         // DO NOT ADD ANY MORE FIELDS HERE
1168         };
1169
1170 #define AuthRecord_uDNS(R) ((R)->resrec.InterfaceID == mDNSInterface_Any && !(R)->ForceMCast && !IsLocalDomain((R)->resrec.name))
1171 #define Question_uDNS(Q)   ((Q)->InterfaceID == mDNSInterface_Any        && !(Q)->ForceMCast && !IsLocalDomain(&(Q)->qname))
1172
1173 // Wrapper struct for Auth Records for higher-level code that cannot use the AuthRecord's ->next pointer field
1174 typedef struct ARListElem
1175         {
1176         struct ARListElem *next;
1177         AuthRecord ar;          // Note: Must be last element of structure, to accomodate oversized AuthRecords
1178         } ARListElem;
1179
1180 struct CacheGroup_struct                                // Header object for a list of CacheRecords with the same name
1181         {
1182         CacheGroup     *next;                           // Next CacheGroup object in this hash table bucket
1183         mDNSu32         namehash;                       // Name-based (i.e. case insensitive) hash of name
1184         CacheRecord    *members;                        // List of CacheRecords with this same name
1185         CacheRecord   **rrcache_tail;           // Tail end of that list
1186         domainname     *name;                           // Common name for all CacheRecords in this list
1187         // Size to here is 20 bytes when compiling 32-bit; 40 bytes when compiling 64-bit
1188         mDNSu8          namestorage[InlineCacheGroupNameSize];
1189         };
1190
1191 struct CacheRecord_struct
1192         {
1193         CacheRecord    *next;                           // Next in list; first element of structure for efficiency reasons
1194         ResourceRecord  resrec;                         // 36 bytes when compiling for 32-bit; 48 when compiling for 64-bit
1195
1196         // Transient state for Cache Records
1197         CacheRecord    *NextInKAList;           // Link to the next element in the chain of known answers to send
1198         mDNSs32         TimeRcvd;                       // In platform time units
1199         mDNSs32         DelayDelivery;          // Set if we want to defer delivery of this answer to local clients
1200         mDNSs32         NextRequiredQuery;      // In platform time units
1201         mDNSs32         LastUsed;                       // In platform time units
1202         DNSQuestion    *CRActiveQuestion;       // Points to an active question referencing this answer
1203         mDNSu32         UnansweredQueries;      // Number of times we've issued a query for this record without getting an answer
1204         mDNSs32         LastUnansweredTime;     // In platform time units; last time we incremented UnansweredQueries
1205 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
1206         mDNSu32         MPUnansweredQ;          // Multi-packet query handling: Number of times we've seen a query for this record
1207         mDNSs32         MPLastUnansweredQT;     // Multi-packet query handling: Last time we incremented MPUnansweredQ
1208         mDNSu32         MPUnansweredKA;         // Multi-packet query handling: Number of times we've seen this record in a KA list
1209         mDNSBool        MPExpectingKA;          // Multi-packet query handling: Set when we increment MPUnansweredQ; allows one KA
1210 #endif
1211         CacheRecord    *NextInCFList;           // Set if this is in the list of records we just received with the cache flush bit set
1212         // Size to here is 76 bytes when compiling 32-bit; 104 bytes when compiling 64-bit
1213         RData_small     smallrdatastorage;      // Storage for small records is right here (4 bytes header + 68 bytes data = 72 bytes)
1214         };
1215
1216 // Storage sufficient to hold either a CacheGroup header or a CacheRecord
1217 // -- for best efficiency (to avoid wasted unused storage) they should be the same size
1218 typedef union CacheEntity_union CacheEntity;
1219 union CacheEntity_union { CacheEntity *next; CacheGroup cg; CacheRecord cr; };
1220
1221 typedef struct
1222         {
1223         CacheRecord r;
1224         mDNSu8 _extradata[MaximumRDSize-InlineCacheRDSize];             // Glue on the necessary number of extra bytes
1225         domainname namestorage;                                                                 // Needs to go *after* the extra rdata bytes
1226         } LargeCacheRecord;
1227
1228 typedef struct HostnameInfo
1229         {
1230         struct HostnameInfo *next;
1231         NATTraversalInfo natinfo;
1232         domainname fqdn;
1233         AuthRecord arv4;                          // registered IPv4 address record
1234         AuthRecord arv6;                          // registered IPv6 address record
1235         mDNSRecordCallback *StatusCallback;       // callback to deliver success or error code to client layer
1236         const void *StatusContext;                // Client Context
1237         } HostnameInfo;
1238
1239 typedef struct ExtraResourceRecord_struct ExtraResourceRecord;
1240 struct ExtraResourceRecord_struct
1241         {
1242         ExtraResourceRecord *next;
1243         mDNSu32 ClientID;  // Opaque ID field to be used by client to map an AddRecord call to a set of Extra records
1244         AuthRecord r;
1245         // Note: Add any additional fields *before* the AuthRecord in this structure, not at the end.
1246         // In some cases clients can allocate larger chunks of memory and set r->rdata->MaxRDLength to indicate
1247         // that this extra memory is available, which would result in any fields after the AuthRecord getting smashed
1248         };
1249
1250 // Note: Within an mDNSServiceCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
1251 typedef void mDNSServiceCallback(mDNS *const m, ServiceRecordSet *const sr, mStatus result);
1252
1253 // A ServiceRecordSet is basically a convenience structure to group together
1254 // the PTR/SRV/TXT records that make up a standard service registration
1255 // It contains its own ServiceCallback+ServiceContext to report aggregate results up to the next layer of software above
1256 // It also contains:
1257 //  * the "_services" PTR record for service enumeration
1258 //  * the optional target host name (for proxy registrations)
1259 //  * the optional list of SubType PTR records
1260 //  * the optional list of additional records attached to the service set (e.g. iChat pictures)
1261 //
1262 // ... and a bunch of stuff related to uDNS, some of which could be simplified or eliminated
1263
1264 struct ServiceRecordSet_struct
1265         {
1266         // These internal state fields are used internally by mDNSCore; the client layer needn't be concerned with them.
1267         // No fields need to be set up by the client prior to calling mDNS_RegisterService();
1268         // all required data is passed as parameters to that function.
1269
1270         // Begin uDNS info ****************
1271         // All of these fields should be eliminated
1272
1273         // Note: The current uDNS code keeps an explicit list of registered services, and handles them
1274         // differently to how individual records are treated (this is probably a mistake). What this means is
1275         // that ServiceRecordSets for uDNS are kept in a linked list, whereas ServiceRecordSets for mDNS exist
1276         // just as a convenient placeholder to group the component records together and are not kept on any list.
1277         ServiceRecordSet *uDNS_next;
1278         regState_t        state;
1279         mDNSBool          srs_uselease;                         // dynamic update contains (should contain) lease option
1280         mDNSBool          TestForSelfConflict;          // on name conflict, check if we're just seeing our own orphaned records
1281         mDNSBool          Private;                                      // If zone is private, DNS updates may have to be encrypted to prevent eavesdropping
1282         ZoneData         *srs_nta;
1283         mDNSOpaque16      id;
1284         domainname        zone;                                         // the zone that is updated
1285         mDNSAddr          SRSUpdateServer;                      // primary name server for the record's zone  !!!KRS not technically correct to cache longer than TTL
1286         mDNSIPPort        SRSUpdatePort;                        // port on which server accepts dynamic updates
1287         NATTraversalInfo  NATinfo;
1288         mDNSBool          ClientCallbackDeferred;       // invoke client callback on completion of pending operation(s)
1289         mStatus           DeferredStatus;                       // status to deliver when above flag is set
1290         mDNSBool          SRVUpdateDeferred;            // do we need to change target or port once current operation completes?
1291         mDNSBool          SRVChanged;                           // temporarily deregistered service because its SRV target or port changed
1292         struct tcpInfo_t *tcp;
1293
1294         // End uDNS info ****************
1295
1296         mDNSServiceCallback *ServiceCallback;
1297         void                *ServiceContext;
1298         mDNSBool             Conflict;  // Set if this record set was forcibly deregistered because of a conflict
1299
1300         ExtraResourceRecord *Extras;    // Optional list of extra AuthRecords attached to this service registration
1301         mDNSu32              NumSubTypes;
1302         AuthRecord          *SubTypes;
1303         AuthRecord           RR_ADV;    // e.g. _services._dns-sd._udp.local. PTR _printer._tcp.local.
1304         AuthRecord           RR_PTR;    // e.g. _printer._tcp.local.        PTR Name._printer._tcp.local.
1305         AuthRecord           RR_SRV;    // e.g. Name._printer._tcp.local.   SRV 0 0 port target
1306         AuthRecord           RR_TXT;    // e.g. Name._printer._tcp.local.   TXT PrintQueueName
1307         // Don't add any fields after AuthRecord RR_TXT.
1308         // This is where the implicit extra space goes if we allocate a ServiceRecordSet containing an oversized RR_TXT record
1309         };
1310
1311 // ***************************************************************************
1312 #if 0
1313 #pragma mark -
1314 #pragma mark - Question structures
1315 #endif
1316
1317 // We record the last eight instances of each duplicate query
1318 // This gives us v4/v6 on each of Ethernet/AirPort and Firewire, and two free slots "for future expansion"
1319 // If the host has more active interfaces that this it is not fatal -- duplicate question suppression will degrade gracefully.
1320 // Since we will still remember the last eight, the busiest interfaces will still get the effective duplicate question suppression.
1321 #define DupSuppressInfoSize 8
1322
1323 typedef struct
1324         {
1325         mDNSs32               Time;
1326         mDNSInterfaceID       InterfaceID;
1327         mDNSs32               Type;                             // v4 or v6?
1328         } DupSuppressInfo;
1329
1330 typedef enum
1331         {
1332         LLQ_InitialRequest    = 1,
1333         LLQ_SecondaryRequest  = 2,
1334         LLQ_Established       = 3,
1335         LLQ_Poll              = 4
1336         } LLQ_State;
1337
1338 // LLQ constants
1339 #define kLLQ_Vers      1
1340 #define kLLQ_DefLease  7200 // 2 hours
1341 #define kLLQ_MAX_TRIES 3    // retry an operation 3 times max
1342 #define kLLQ_INIT_RESEND 2 // resend an un-ack'd packet after 2 seconds, then double for each additional
1343 // LLQ Operation Codes
1344 #define kLLQOp_Setup     1
1345 #define kLLQOp_Refresh   2
1346 #define kLLQOp_Event     3
1347
1348 // LLQ Errror Codes
1349 enum
1350         {
1351         LLQErr_NoError    = 0,
1352         LLQErr_ServFull   = 1,
1353         LLQErr_Static     = 2,
1354         LLQErr_FormErr    = 3,
1355         LLQErr_NoSuchLLQ  = 4,
1356         LLQErr_BadVers    = 5,
1357         LLQErr_UnknownErr = 6
1358         };
1359
1360 enum { NoAnswer_Normal = 0, NoAnswer_Suspended = 1, NoAnswer_Fail = 2 };
1361
1362 #define HMAC_LEN    64
1363 #define HMAC_IPAD   0x36
1364 #define HMAC_OPAD   0x5c
1365 #define MD5_LEN     16
1366
1367 #define AutoTunnelUnregistered(X) (                                              \
1368         (X)->AutoTunnelHostRecord.resrec.RecordType == kDNSRecordTypeUnregistered && \
1369         (X)->AutoTunnelDeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered && \
1370         (X)->AutoTunnelService.   resrec.RecordType == kDNSRecordTypeUnregistered    )
1371
1372 // Internal data structure to maintain authentication information
1373 typedef struct DomainAuthInfo
1374         {
1375         struct DomainAuthInfo *next;
1376         mDNSs32          deltime;                               // If we're planning to delete this DomainAuthInfo, the time we want it deleted
1377         mDNSBool         AutoTunnel;
1378         AuthRecord       AutoTunnelHostRecord;  // User-visible hostname; used as SRV target for AutoTunnel services
1379         AuthRecord       AutoTunnelTarget;              // Opaque hostname of tunnel endpoint; used as SRV target for AutoTunnelService record
1380         AuthRecord       AutoTunnelDeviceInfo;  // Device info of tunnel endpoint
1381         AuthRecord       AutoTunnelService;             // Service record (possibly NAT-Mapped) of IKE daemon implementing tunnel endpoint
1382         NATTraversalInfo AutoTunnelNAT;
1383         domainname       domain;
1384         domainname       keyname;
1385         char             b64keydata[32];
1386         mDNSu8           keydata_ipad[HMAC_LEN];        // padded key for inner hash rounds
1387         mDNSu8           keydata_opad[HMAC_LEN];        // padded key for outer hash rounds
1388         } DomainAuthInfo;
1389
1390 // Note: Within an mDNSQuestionCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
1391 typedef enum { QC_rmv = 0, QC_add = 1, QC_addnocache = 2 } QC_result;
1392 typedef void mDNSQuestionCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord);
1393 struct DNSQuestion_struct
1394         {
1395         // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
1396         DNSQuestion          *next;
1397         mDNSu32               qnamehash;
1398         mDNSs32               DelayAnswering;   // Set if we want to defer answering this question until the cache settles
1399         mDNSs32               LastQTime;                // Last scheduled transmission of this Q on *all* applicable interfaces
1400         mDNSs32               ThisQInterval;    // LastQTime + ThisQInterval is the next scheduled transmission of this Q
1401                                                                                         // ThisQInterval > 0 for an active question;
1402                                                                                         // ThisQInterval = 0 for a suspended question that's still in the list
1403                                                                                         // ThisQInterval = -1 for a cancelled question (should not still be in list)
1404         mDNSs32               ExpectUnicastResp;// Set when we send a query with the kDNSQClass_UnicastResponse bit set
1405         mDNSs32               LastAnswerPktNum; // The sequence number of the last response packet containing an answer to this Q
1406         mDNSu32               RecentAnswerPkts; // Number of answers since the last time we sent this query
1407         mDNSu32               CurrentAnswers;   // Number of records currently in the cache that answer this question
1408         mDNSu32               LargeAnswers;             // Number of answers with rdata > 1024 bytes
1409         mDNSu32               UniqueAnswers;    // Number of answers received with kDNSClass_UniqueRRSet bit set
1410         mDNSInterfaceID       FlappingInterface1;// Set when an interface goes away, to flag if remove events are delivered for this Q
1411         mDNSInterfaceID       FlappingInterface2;// Set when an interface goes away, to flag if remove events are delivered for this Q
1412         DomainAuthInfo       *AuthInfo;                 // Non-NULL if query is currently being done using Private DNS
1413         DNSQuestion          *DuplicateOf;
1414         DNSQuestion          *NextInDQList;
1415         DupSuppressInfo       DupSuppress[DupSuppressInfoSize];
1416         mDNSInterfaceID       SendQNow;                 // The interface this query is being sent on right now
1417         mDNSBool              SendOnAll;                // Set if we're sending this question on all active interfaces
1418         mDNSu32               RequestUnicast;   // Non-zero if we want to send query with kDNSQClass_UnicastResponse bit set
1419         mDNSs32               LastQTxTime;              // Last time this Q was sent on one (but not necessarily all) interfaces
1420         mDNSu32               CNAMEReferrals;   // Count of how many CNAME redirections we've done
1421
1422         // Wide Area fields. These are used internally by the uDNS core
1423         UDPSocket            *LocalSocket;
1424         mDNSBool             deliverAddEvents;  // Change in DNSSserver requiring to deliver ADD events
1425         DNSServer            *qDNSServer;               // Caching server for this query (in the absence of an SRV saying otherwise)
1426         mDNSu8                unansweredQueries;// The number of unanswered queries to this server
1427
1428         ZoneData             *nta;                              // Used for getting zone data for private or LLQ query
1429         mDNSAddr              servAddr;                 // Address and port learned from _dns-llq, _dns-llq-tls or _dns-query-tls SRV query
1430         mDNSIPPort            servPort;
1431         struct tcpInfo_t *tcp;
1432         mDNSIPPort            tcpSrcPort;               // Local Port TCP packet received on;need this as tcp struct is disposed
1433                                                                                         // by tcpCallback before calling into mDNSCoreReceive
1434         mDNSu8                NoAnswer;                 // Set if we want to suppress answers until tunnel setup has completed
1435
1436         // LLQ-specific fields. These fields are only meaningful when LongLived flag is set
1437         LLQ_State             state;
1438         mDNSu32               ReqLease;                 // seconds (relative)
1439         mDNSs32               expire;                   // ticks (absolute)
1440         mDNSs16               ntries;           // for UDP: the number of packets sent for this LLQ state
1441                                                // for TCP: there is some ambiguity in the use of this variable, but in general, it is
1442                                                //          the number of TCP/TLS connection attempts for this LLQ state, or
1443                                                //          the number of packets sent for this TCP/TLS connection
1444         mDNSOpaque64          id;
1445
1446         // Client API fields: The client must set up these fields *before* calling mDNS_StartQuery()
1447         mDNSInterfaceID       InterfaceID;              // Non-zero if you want to issue queries only on a single specific IP interface
1448         mDNSAddr              Target;                   // Non-zero if you want to direct queries to a specific unicast target address
1449         mDNSIPPort            TargetPort;               // Must be set if Target is set
1450         mDNSOpaque16          TargetQID;                // Must be set if Target is set
1451         domainname            qname;
1452         mDNSu16               qtype;
1453         mDNSu16               qclass;
1454         mDNSBool              LongLived;        // Set by client for calls to mDNS_StartQuery to indicate LLQs to unicast layer.
1455         mDNSBool              ExpectUnique;             // Set by client if it's expecting unique RR(s) for this question, not shared RRs
1456         mDNSBool              ForceMCast;               // Set by client to force mDNS query, even for apparently uDNS names
1457         mDNSBool              ReturnIntermed;   // Set by client to request callbacks for intermediate CNAME/NXDOMAIN results
1458         mDNSQuestionCallback *QuestionCallback;
1459         void                 *QuestionContext;
1460         };
1461
1462 typedef struct
1463         {
1464         // Client API fields: The client must set up name and InterfaceID *before* calling mDNS_StartResolveService()
1465         // When the callback is invoked, ip, port, TXTlen and TXTinfo will have been filled in with the results learned from the network.
1466         domainname      name;
1467         mDNSInterfaceID InterfaceID;            // ID of the interface the response was received on
1468         mDNSAddr        ip;                                     // Remote (destination) IP address where this service can be accessed
1469         mDNSIPPort      port;                           // Port where this service can be accessed
1470         mDNSu16         TXTlen;
1471         mDNSu8          TXTinfo[2048];          // Additional demultiplexing information (e.g. LPR queue name)
1472         } ServiceInfo;
1473
1474 // Note: Within an mDNSServiceInfoQueryCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
1475 typedef struct ServiceInfoQuery_struct ServiceInfoQuery;
1476 typedef void mDNSServiceInfoQueryCallback(mDNS *const m, ServiceInfoQuery *query);
1477 struct ServiceInfoQuery_struct
1478         {
1479         // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
1480         // No fields need to be set up by the client prior to calling mDNS_StartResolveService();
1481         // all required data is passed as parameters to that function.
1482         // The ServiceInfoQuery structure memory is working storage for mDNSCore to discover the requested information
1483         // and place it in the ServiceInfo structure. After the client has called mDNS_StopResolveService(), it may
1484         // dispose of the ServiceInfoQuery structure while retaining the results in the ServiceInfo structure.
1485         DNSQuestion                   qSRV;
1486         DNSQuestion                   qTXT;
1487         DNSQuestion                   qAv4;
1488         DNSQuestion                   qAv6;
1489         mDNSu8                        GotSRV;
1490         mDNSu8                        GotTXT;
1491         mDNSu8                        GotADD;
1492         mDNSu32                       Answers;
1493         ServiceInfo                  *info;
1494         mDNSServiceInfoQueryCallback *ServiceInfoQueryCallback;
1495         void                         *ServiceInfoQueryContext;
1496         };
1497
1498 typedef enum { ZoneServiceUpdate, ZoneServiceQuery, ZoneServiceLLQ } ZoneService;
1499
1500 typedef void ZoneDataCallback(mDNS *const m, mStatus err, const ZoneData *result);
1501
1502 struct ZoneData_struct
1503         {
1504         domainname       ChildName;                     // Name for which we're trying to find the responsible server
1505         ZoneService      ZoneService;           // Which service we're seeking for this zone (update, query, or LLQ)
1506         domainname       *CurrentSOA;           // Points to somewhere within ChildName
1507         domainname       ZoneName;                      // Discovered result: Left-hand-side of SOA record
1508         mDNSu16          ZoneClass;                     // Discovered result: DNS Class from SOA record
1509         domainname       Host;                          // Discovered result: Target host from SRV record
1510         mDNSIPPort       Port;                          // Discovered result: Update port, query port, or LLQ port from SRV record
1511         mDNSAddr         Addr;                          // Discovered result: Address of Target host from SRV record
1512         mDNSBool         ZonePrivate;           // Discovered result: Does zone require encrypted queries?
1513         ZoneDataCallback *ZoneDataCallback;     // Caller-specified function to be called upon completion
1514         void             *ZoneDataContext;
1515         DNSQuestion      question;                      // Storage for any active question
1516         };
1517
1518 extern ZoneData *StartGetZoneData(mDNS *const m, const domainname *const name, const ZoneService target, ZoneDataCallback callback, void *callbackInfo);
1519 extern void CancelGetZoneData(mDNS *const m, ZoneData *nta);
1520
1521 typedef struct DNameListElem
1522         {
1523         struct DNameListElem *next;
1524         mDNSu32 uid;
1525         domainname name;
1526         } DNameListElem;
1527
1528 #if APPLE_OSX_mDNSResponder
1529 typedef struct ClientTunnel
1530         {
1531         struct ClientTunnel *next;
1532         domainname dstname;
1533         mDNSBool   MarkedForDeletion;
1534         mDNSv6Addr loc_inner;
1535         mDNSv4Addr loc_outer;
1536         mDNSv6Addr rmt_inner;
1537         mDNSv4Addr rmt_outer;
1538         mDNSIPPort rmt_outer_port;
1539         DNSQuestion q;
1540         } ClientTunnel;
1541 #endif
1542
1543 // ***************************************************************************
1544 #if 0
1545 #pragma mark -
1546 #pragma mark - NetworkInterfaceInfo_struct
1547 #endif
1548
1549 typedef struct NetworkInterfaceInfo_struct NetworkInterfaceInfo;
1550
1551 // A NetworkInterfaceInfo_struct serves two purposes:
1552 // 1. It holds the address, PTR and HINFO records to advertise a given IP address on a given physical interface
1553 // 2. It tells mDNSCore which physical interfaces are available; each physical interface has its own unique InterfaceID.
1554 //    Since there may be multiple IP addresses on a single physical interface,
1555 //    there may be multiple NetworkInterfaceInfo_structs with the same InterfaceID.
1556 //    In this case, to avoid sending the same packet n times, when there's more than one
1557 //    struct with the same InterfaceID, mDNSCore picks one member of the set to be the
1558 //    active representative of the set; all others have the 'InterfaceActive' flag unset.
1559
1560 struct NetworkInterfaceInfo_struct
1561         {
1562         // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
1563         NetworkInterfaceInfo *next;
1564
1565         mDNSu8          InterfaceActive;        // Set if interface is sending & receiving packets (see comment above)
1566         mDNSu8          IPv4Available;          // If InterfaceActive, set if v4 available on this InterfaceID
1567         mDNSu8          IPv6Available;          // If InterfaceActive, set if v6 available on this InterfaceID
1568
1569         DNSQuestion     NetWakeBrowse;
1570         DNSQuestion     NetWakeResolve[3];      // For fault-tolerance, we try up to three Sleep Proxies
1571         mDNSAddr        SPSAddr[3];
1572         mDNSIPPort      SPSPort[3];
1573         mDNSs32         NextSPSAttempt;         // -1 if we're not currently attempting to register with any Sleep Proxy
1574         mDNSs32         NextSPSAttemptTime;
1575
1576         // Standard AuthRecords that every Responder host should have (one per active IP address)
1577         AuthRecord RR_A;                                        // 'A' or 'AAAA' (address) record for our ".local" name
1578         AuthRecord RR_PTR;                                      // PTR (reverse lookup) record
1579         AuthRecord RR_HINFO;
1580
1581         // Client API fields: The client must set up these fields *before* calling mDNS_RegisterInterface()
1582         mDNSInterfaceID InterfaceID;            // Identifies physical interface; MUST NOT be 0, -1, or -2
1583         mDNSAddr        ip;                                     // The IPv4 or IPv6 address to advertise
1584         mDNSAddr        mask;
1585         mDNSEthAddr     MAC;
1586         char            ifname[64];                     // Windows uses a GUID string for the interface name, which doesn't fit in 16 bytes
1587         mDNSu8          Advertise;                      // False if you are only searching on this interface
1588         mDNSu8          McastTxRx;                      // Send/Receive multicast on this { InterfaceID, address family } ?
1589         mDNSu8          NetWake;                        // Set if Wake-On-Magic-Packet is enabled on this interface
1590         };
1591
1592 typedef struct SearchListElem
1593         {
1594         struct SearchListElem *next;
1595         domainname domain;
1596         int flag;               // -1 means delete, 0 means unchanged, +1 means newly added
1597         DNSQuestion BrowseQ;
1598         DNSQuestion DefBrowseQ;
1599         DNSQuestion AutomaticBrowseQ;
1600         DNSQuestion RegisterQ;
1601         DNSQuestion DefRegisterQ;
1602         ARListElem *AuthRecs;
1603         } SearchListElem;
1604
1605 // For domain enumeration and automatic browsing
1606 // This is the user's DNS search list.
1607 // In each of these domains we search for our special pointer records (lb._dns-sd._udp.<domain>, etc.)
1608 // to discover recommended domains for domain enumeration (browse, default browse, registration,
1609 // default registration) and possibly one or more recommended automatic browsing domains.
1610 extern SearchListElem *SearchList;              // This really ought to be part of mDNS_struct -- SC
1611
1612 // ***************************************************************************
1613 #if 0
1614 #pragma mark -
1615 #pragma mark - Main mDNS object, used to hold all the mDNS state
1616 #endif
1617
1618 typedef void mDNSCallback(mDNS *const m, mStatus result);
1619
1620 #define CACHE_HASH_SLOTS 499
1621
1622 enum
1623         {
1624         mDNS_KnownBug_PhantomInterfaces = 1,
1625         mDNS_KnownBug_LossySyslog       = 2             // <rdar://problem/6561888>
1626         };
1627
1628 enum
1629         {
1630         SleepState_Awake = 0,
1631         SleepState_Transferring = 1,
1632         SleepState_Sleeping = 2
1633         };
1634
1635 struct mDNS_struct
1636         {
1637         // Internal state fields. These hold the main internal state of mDNSCore;
1638         // the client layer needn't be concerned with them.
1639         // No fields need to be set up by the client prior to calling mDNS_Init();
1640         // all required data is passed as parameters to that function.
1641
1642         mDNS_PlatformSupport *p;                        // Pointer to platform-specific data of indeterminite size
1643         mDNSu32  KnownBugs;
1644         mDNSBool CanReceiveUnicastOn5353;
1645         mDNSBool AdvertiseLocalAddresses;
1646         mDNSBool DivertMulticastAdvertisements; // from interfaces that do not advertise local addresses to local-only
1647         mStatus mDNSPlatformStatus;
1648         mDNSIPPort UnicastPort4;
1649         mDNSIPPort UnicastPort6;
1650         mDNSEthAddr PrimaryMAC;                         // Used as unique host ID
1651         mDNSCallback *MainCallback;
1652         void         *MainContext;
1653
1654         // For debugging: To catch and report locking failures
1655         mDNSu32 mDNS_busy;                                      // Incremented between mDNS_Lock/mDNS_Unlock section
1656         mDNSu32 mDNS_reentrancy;                        // Incremented when calling a client callback
1657         mDNSu8  lock_rrcache;                           // For debugging: Set at times when these lists may not be modified
1658         mDNSu8  lock_Questions;
1659         mDNSu8  lock_Records;
1660 #ifndef MaxMsg
1661         #define MaxMsg 160
1662 #endif
1663         char MsgBuffer[MaxMsg];                         // Temp storage used while building error log messages
1664
1665         // Task Scheduling variables
1666         mDNSs32  timenow_adjust;                        // Correction applied if we ever discover time went backwards
1667         mDNSs32  timenow;                                       // The time that this particular activation of the mDNS code started
1668         mDNSs32  timenow_last;                          // The time the last time we ran
1669         mDNSs32  NextScheduledEvent;            // Derived from values below
1670         mDNSs32  ShutdownTime;                          // Set when we're shutting down; allows us to skip some unnecessary steps
1671         mDNSs32  SuppressSending;                       // Don't send *any* packets during this time
1672         mDNSs32  NextCacheCheck;                        // Next time to refresh cache record before it expires
1673         mDNSs32  NextScheduledQuery;            // Next time to send query in its exponential backoff sequence
1674         mDNSs32  NextScheduledProbe;            // Next time to probe for new authoritative record
1675         mDNSs32  NextScheduledResponse;         // Next time to send authoritative record(s) in responses
1676         mDNSs32  NextScheduledNATOp;            // Next time to send NAT-traversal packets
1677         mDNSs32  NextScheduledSPS;                      // Next time to purge expiring Sleep Proxy records
1678         mDNSs32  RandomQueryDelay;                      // For de-synchronization of query packets on the wire
1679         mDNSu32  RandomReconfirmDelay;          // For de-synchronization of reconfirmation queries on the wire
1680         mDNSs32  PktNum;                                        // Unique sequence number assigned to each received packet
1681         mDNSu8   LocalRemoveEvents;                     // Set if we may need to deliver remove events for local-only questions and/or local-only records
1682         mDNSu8   SleepState;                            // Set if we're sleeping
1683         mDNSu8   SleepSeqNum;                           // "Epoch number" of our current period of wakefulness
1684         mDNSu8   SystemWakeOnLANEnabled;        // Set if we want to register with a Sleep Proxy before going to sleep
1685         mDNSu8   SentSleepProxyRegistration;// Set if we registered (or tried to register) with a Sleep Proxy
1686         mDNSs32  AnnounceOwner;                         // After waking from sleep, include OWNER option in packets until this time
1687         mDNSs32  DelaySleep;                            // To inhibit re-sleeping too quickly right after wake
1688         mDNSs32  SleepLimit;                            // Time window to allow deregistrations, etc.,
1689                                                                                 // during which underying platform layer should inhibit system sleep
1690         mDNSs32  NextScheduledSPRetry;          // Time next sleep proxy registration action is required.
1691                                                                                 // Only valid if SleepLimit is nonzero and DelaySleep is zero.
1692
1693         // These fields only required for mDNS Searcher...
1694         DNSQuestion *Questions;                         // List of all registered questions, active and inactive
1695         DNSQuestion *NewQuestions;                      // Fresh questions not yet answered from cache
1696         DNSQuestion *CurrentQuestion;           // Next question about to be examined in AnswerLocalQuestions()
1697         DNSQuestion *LocalOnlyQuestions;        // Questions with InterfaceID set to mDNSInterface_LocalOnly
1698         DNSQuestion *NewLocalOnlyQuestions;     // Fresh local-only questions not yet answered
1699         mDNSu32 rrcache_size;                           // Total number of available cache entries
1700         mDNSu32 rrcache_totalused;                      // Number of cache entries currently occupied
1701         mDNSu32 rrcache_active;                         // Number of cache entries currently occupied by records that answer active questions
1702         mDNSu32 rrcache_report;
1703         CacheEntity *rrcache_free;
1704         CacheGroup *rrcache_hash[CACHE_HASH_SLOTS];
1705
1706         // Fields below only required for mDNS Responder...
1707         domainlabel nicelabel;                          // Rich text label encoded using canonically precomposed UTF-8
1708         domainlabel hostlabel;                          // Conforms to RFC 1034 "letter-digit-hyphen" ARPANET host name rules
1709         domainname  MulticastHostname;          // Fully Qualified "dot-local" Host Name, e.g. "Foo.local."
1710         UTF8str255  HIHardware;
1711         UTF8str255  HISoftware;
1712         AuthRecord  DeviceInfo;
1713         AuthRecord *ResourceRecords;
1714         AuthRecord *DuplicateRecords;           // Records currently 'on hold' because they are duplicates of existing records
1715         AuthRecord *NewLocalRecords;            // Fresh local-only records not yet delivered to local-only questions
1716         AuthRecord *CurrentRecord;                      // Next AuthRecord about to be examined
1717         NetworkInterfaceInfo *HostInterfaces;
1718         mDNSs32 ProbeFailTime;
1719         mDNSu32 NumFailedProbes;
1720         mDNSs32 SuppressProbes;
1721
1722         // Unicast-specific data
1723         mDNSs32           NextuDNSEvent;                // uDNS next event
1724         mDNSs32           NextSRVUpdate;        // Time to perform delayed update
1725         mDNSs32 SuppressStdPort53Queries;       // Wait before allowing the next standard unicast query to the user's configured DNS server
1726
1727         ServiceRecordSet *ServiceRegistrations;
1728         DNSServer        *DNSServers;           // list of DNS servers
1729
1730         mDNSAddr          Router;
1731         mDNSAddr          AdvertisedV4;         // IPv4 address pointed to by hostname
1732         mDNSAddr          AdvertisedV6;         // IPv6 address pointed to by hostname
1733
1734         DomainAuthInfo   *AuthInfoList;         // list of domains requiring authentication for updates
1735
1736         DNSQuestion       ReverseMap;           // Reverse-map query to find static hostname for service target
1737         DNSQuestion       AutomaticBrowseDomainQ;
1738         domainname        StaticHostname;       // Current answer to reverse-map query
1739         domainname        FQDN;
1740         HostnameInfo     *Hostnames;            // List of registered hostnames + hostname metadata
1741         mDNSv6Addr        AutoTunnelHostAddr;   // IPv6 address advertised for AutoTunnel services on this machine
1742         mDNSBool          AutoTunnelHostAddrActive;
1743         domainlabel       AutoTunnelLabel;              // Used to construct hostname for *IPv4* address of tunnel endpoints
1744
1745         mDNSBool          RegisterSearchDomains;
1746
1747         // NAT-Traversal fields
1748         NATTraversalInfo  LLQNAT;                                       // Single shared NAT Traversal to receive inbound LLQ notifications
1749         NATTraversalInfo *NATTraversals;
1750         NATTraversalInfo *CurrentNATTraversal;
1751         mDNSs32           retryIntervalGetAddr;         // delta between time sent and retry
1752         mDNSs32           retryGetAddr;                         // absolute time when we retry
1753         mDNSv4Addr        ExternalAddress;
1754
1755         UDPSocket        *NATMcastRecvskt;                      // For receiving NAT-PMP AddrReply multicasts from router on port 5350
1756         mDNSu32           LastNATupseconds;                     // NAT engine uptime in seconds, from most recent NAT packet
1757         mDNSs32           LastNATReplyLocalTime;        // Local time in ticks when most recent NAT packet was received
1758         mDNSu16           LastNATMapResultCode;         // Most recent error code for mappings
1759
1760         tcpLNTInfo        tcpAddrInfo;                          // legacy NAT traversal TCP connection info for external address
1761         tcpLNTInfo        tcpDeviceInfo;                        // legacy NAT traversal TCP connection info for device info
1762         tcpLNTInfo       *tcpInfoUnmapList;                     // list of pending unmap requests
1763         mDNSInterfaceID   UPnPInterfaceID;
1764         UDPSocket        *SSDPSocket;               // For SSDP request/response
1765         mDNSBool          SSDPWANPPPConnection;     // whether we should send the SSDP query for WANIPConnection or WANPPPConnection
1766         mDNSIPPort        UPnPRouterPort;                       // port we send discovery messages to
1767         mDNSIPPort        UPnPSOAPPort;                         // port we send SOAP messages to
1768         mDNSu8           *UPnPRouterURL;                        // router's URL string
1769         mDNSBool          UPnPWANPPPConnection;     // whether we're using WANIPConnection or WANPPPConnection
1770         mDNSu8           *UPnPSOAPURL;                          // router's SOAP control URL string
1771         mDNSu8           *UPnPRouterAddressString;      // holds both the router's address and port
1772         mDNSu8           *UPnPSOAPAddressString;        // holds both address and port for SOAP messages
1773
1774         // Sleep Proxy Server fields
1775         mDNSu8            SPSType;                                      // 0 = off, 10-99 encodes desirability metric
1776         mDNSu8            SPSPortability;                       // 10-99
1777         mDNSu8            SPSMarginalPower;                     // 10-99
1778         mDNSu8            SPSTotalPower;                        // 10-99
1779         mDNSu8            SPSState;                                     // 0 = off, 1 = running, 2 = shutting down, 3 = suspended during sleep
1780         mDNSInterfaceID   SPSProxyListChanged;
1781         UDPSocket        *SPSSocket;
1782         ServiceRecordSet  SPSRecords;
1783         mDNSQuestionCallback *SPSBrowseCallback;    // So the platform layer can do something useful with SPS browse results
1784         int               ProxyRecords;                         // Total number of records we're holding as proxy
1785         #define           MAX_PROXY_RECORDS 10000       /* DOS protection: 400 machines at 25 records each */
1786
1787 #if APPLE_OSX_mDNSResponder
1788         ClientTunnel     *TunnelClients;
1789         uuid_t           asl_uuid;                                      // uuid for ASL logging
1790 #endif
1791
1792         // Fixed storage, to avoid creating large objects on the stack
1793         // The imsg is declared as a union with a pointer type to enforce CPU-appropriate alignment
1794         union { DNSMessage m; void *p; } imsg;  // Incoming message received from wire
1795         DNSMessage        omsg;                 // Outgoing message we're building
1796         LargeCacheRecord  rec;                  // Resource Record extracted from received message
1797         };
1798
1799 #define FORALL_CACHERECORDS(SLOT,CG,CR)                           \
1800         for ((SLOT) = 0; (SLOT) < CACHE_HASH_SLOTS; (SLOT)++)         \
1801                 for ((CG)=m->rrcache_hash[(SLOT)]; (CG); (CG)=(CG)->next) \
1802                         for ((CR) = (CG)->members; (CR); (CR)=(CR)->next)
1803
1804 // ***************************************************************************
1805 #if 0
1806 #pragma mark -
1807 #pragma mark - Useful Static Constants
1808 #endif
1809
1810 extern const mDNSInterfaceID mDNSInterface_Any;                         // Zero
1811 extern const mDNSInterfaceID mDNSInterface_LocalOnly;           // Special value
1812 extern const mDNSInterfaceID mDNSInterface_Unicast;                     // Special value
1813 extern const mDNSInterfaceID mDNSInterfaceMark;                         // Special value
1814
1815 extern const mDNSIPPort   DiscardPort;
1816 extern const mDNSIPPort   SSHPort;
1817 extern const mDNSIPPort   UnicastDNSPort;
1818 extern const mDNSIPPort   SSDPPort;
1819 extern const mDNSIPPort   IPSECPort;
1820 extern const mDNSIPPort   NSIPCPort;
1821 extern const mDNSIPPort   NATPMPAnnouncementPort;
1822 extern const mDNSIPPort   NATPMPPort;
1823 extern const mDNSIPPort   DNSEXTPort;
1824 extern const mDNSIPPort   MulticastDNSPort;
1825 extern const mDNSIPPort   LoopbackIPCPort;
1826 extern const mDNSIPPort   PrivateDNSPort;
1827
1828 extern const OwnerOptData    zeroOwner;
1829
1830 extern const mDNSIPPort      zeroIPPort;
1831 extern const mDNSv4Addr      zerov4Addr;
1832 extern const mDNSv6Addr      zerov6Addr;
1833 extern const mDNSEthAddr     zeroEthAddr;
1834 extern const mDNSv4Addr      onesIPv4Addr;
1835 extern const mDNSv6Addr      onesIPv6Addr;
1836 extern const mDNSEthAddr     onesEthAddr;
1837 extern const mDNSAddr        zeroAddr;
1838
1839 extern const mDNSv4Addr   AllDNSAdminGroup;
1840 extern const mDNSv4Addr   AllHosts_v4;
1841 extern const mDNSv6Addr   AllHosts_v6;
1842 extern const mDNSv6Addr   NDP_prefix;
1843 extern const mDNSEthAddr  AllHosts_v6_Eth;
1844 extern const mDNSAddr     AllDNSLinkGroup_v4;
1845 extern const mDNSAddr     AllDNSLinkGroup_v6;
1846
1847 extern const mDNSOpaque16 zeroID;
1848 extern const mDNSOpaque16 onesID;
1849 extern const mDNSOpaque16 QueryFlags;
1850 extern const mDNSOpaque16 uQueryFlags;
1851 extern const mDNSOpaque16 ResponseFlags;
1852 extern const mDNSOpaque16 UpdateReqFlags;
1853 extern const mDNSOpaque16 UpdateRespFlags;
1854
1855 extern const mDNSOpaque64 zeroOpaque64;
1856
1857 extern mDNSBool StrictUnicastOrdering;
1858
1859 #define localdomain           (*(const domainname *)"\x5" "local")
1860 #define DeviceInfoName        (*(const domainname *)"\xC" "_device-info" "\x4" "_tcp")
1861 #define SleepProxyServiceType (*(const domainname *)"\xC" "_sleep-proxy" "\x4" "_udp")
1862
1863 // ***************************************************************************
1864 #if 0
1865 #pragma mark -
1866 #pragma mark - Inline functions
1867 #endif
1868
1869 #if (defined(_MSC_VER))
1870         #define mDNSinline static __inline
1871 #elif ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))
1872         #define mDNSinline static inline
1873 #endif
1874
1875 // If we're not doing inline functions, then this header needs to have the extern declarations
1876 #if !defined(mDNSinline)
1877 extern mDNSs32      NonZeroTime(mDNSs32 t);
1878 extern mDNSu16      mDNSVal16(mDNSOpaque16 x);
1879 extern mDNSOpaque16 mDNSOpaque16fromIntVal(mDNSu16 v);
1880 #endif
1881
1882 // If we're compiling the particular C file that instantiates our inlines, then we
1883 // define "mDNSinline" (to empty string) so that we generate code in the following section
1884 #if (!defined(mDNSinline) && mDNS_InstantiateInlines)
1885 #define mDNSinline
1886 #endif
1887
1888 #ifdef mDNSinline
1889
1890 mDNSinline mDNSs32 NonZeroTime(mDNSs32 t) { if (t) return(t); else return(1); }
1891
1892 mDNSinline mDNSu16 mDNSVal16(mDNSOpaque16 x) { return((mDNSu16)((mDNSu16)x.b[0] <<  8 | (mDNSu16)x.b[1])); }
1893
1894 mDNSinline mDNSOpaque16 mDNSOpaque16fromIntVal(mDNSu16 v)
1895         {
1896         mDNSOpaque16 x;
1897         x.b[0] = (mDNSu8)(v >> 8);
1898         x.b[1] = (mDNSu8)(v & 0xFF);
1899         return(x);
1900         }
1901
1902 #endif
1903
1904 // ***************************************************************************
1905 #if 0
1906 #pragma mark -
1907 #pragma mark - Main Client Functions
1908 #endif
1909
1910 // Every client should call mDNS_Init, passing in storage for the mDNS object and the mDNS_PlatformSupport object.
1911 //
1912 // Clients that are only advertising services should use mDNS_Init_NoCache and mDNS_Init_ZeroCacheSize.
1913 // Clients that plan to perform queries (mDNS_StartQuery, mDNS_StartBrowse, mDNS_StartResolveService, etc.)
1914 // need to provide storage for the resource record cache, or the query calls will return 'mStatus_NoCache'.
1915 // The rrcachestorage parameter is the address of memory for the resource record cache, and
1916 // the rrcachesize parameter is the number of entries in the CacheRecord array passed in.
1917 // (i.e. the size of the cache memory needs to be sizeof(CacheRecord) * rrcachesize).
1918 // OS X 10.3 Panther uses an initial cache size of 64 entries, and then mDNSCore sends an
1919 // mStatus_GrowCache message if it needs more.
1920 //
1921 // Most clients should use mDNS_Init_AdvertiseLocalAddresses. This causes mDNSCore to automatically
1922 // create the correct address records for all the hosts interfaces. If you plan to advertise
1923 // services being offered by the local machine, this is almost always what you want.
1924 // There are two cases where you might use mDNS_Init_DontAdvertiseLocalAddresses:
1925 // 1. A client-only device, that browses for services but doesn't advertise any of its own.
1926 // 2. A proxy-registration service, that advertises services being offered by other machines, and takes
1927 //    the appropriate steps to manually create the correct address records for those other machines.
1928 // In principle, a proxy-like registration service could manually create address records for its own machine too,
1929 // but this would be pointless extra effort when using mDNS_Init_AdvertiseLocalAddresses does that for you.
1930 //
1931 // Note that a client-only device that wishes to prohibit multicast advertisements (e.g. from
1932 // higher-layer API calls) must also set DivertMulticastAdvertisements in the mDNS structure and
1933 // advertise local address(es) on a loopback interface.
1934 //
1935 // When mDNS has finished setting up the client's callback is called
1936 // A client can also spin and poll the mDNSPlatformStatus field to see when it changes from mStatus_Waiting to mStatus_NoError
1937 //
1938 // Call mDNS_StartExit to tidy up before exiting
1939 // Because exiting may be an asynchronous process (e.g. if unicast records need to be deregistered)
1940 // client layer may choose to wait until mDNS_ExitNow() returns true before calling mDNS_FinalExit().
1941 //
1942 // Call mDNS_Register with a completed AuthRecord object to register a resource record
1943 // If the resource record type is kDNSRecordTypeUnique (or kDNSknownunique) then if a conflicting resource record is discovered,
1944 // the resource record's mDNSRecordCallback will be called with error code mStatus_NameConflict. The callback should deregister
1945 // the record, and may then try registering the record again after picking a new name (e.g. by automatically appending a number).
1946 // Following deregistration, the RecordCallback will be called with result mStatus_MemFree to signal that it is safe to deallocate
1947 // the record's storage (memory must be freed asynchronously to allow for goodbye packets and dynamic update deregistration).
1948 //
1949 // Call mDNS_StartQuery to initiate a query. mDNS will proceed to issue Multicast DNS query packets, and any time a response
1950 // is received containing a record which matches the question, the DNSQuestion's mDNSAnswerCallback function will be called
1951 // Call mDNS_StopQuery when no more answers are required
1952 //
1953 // Care should be taken on multi-threaded or interrupt-driven environments.
1954 // The main mDNS routines call mDNSPlatformLock() on entry and mDNSPlatformUnlock() on exit;
1955 // each platform layer needs to implement these appropriately for its respective platform.
1956 // For example, if the support code on a particular platform implements timer callbacks at interrupt time, then
1957 // mDNSPlatformLock/Unlock need to disable interrupts or do similar concurrency control to ensure that the mDNS
1958 // code is not entered by an interrupt-time timer callback while in the middle of processing a client call.
1959
1960 extern mStatus mDNS_Init      (mDNS *const m, mDNS_PlatformSupport *const p,
1961                                                                 CacheEntity *rrcachestorage, mDNSu32 rrcachesize,
1962                                                                 mDNSBool AdvertiseLocalAddresses,
1963                                                                 mDNSCallback *Callback, void *Context);
1964 // See notes above on use of NoCache/ZeroCacheSize
1965 #define mDNS_Init_NoCache                     mDNSNULL
1966 #define mDNS_Init_ZeroCacheSize               0
1967 // See notes above on use of Advertise/DontAdvertiseLocalAddresses
1968 #define mDNS_Init_AdvertiseLocalAddresses     mDNStrue
1969 #define mDNS_Init_DontAdvertiseLocalAddresses mDNSfalse
1970 #define mDNS_Init_NoInitCallback              mDNSNULL
1971 #define mDNS_Init_NoInitCallbackContext       mDNSNULL
1972
1973 extern void    mDNS_ConfigChanged(mDNS *const m);
1974 extern void    mDNS_GrowCache (mDNS *const m, CacheEntity *storage, mDNSu32 numrecords);
1975 extern void    mDNS_StartExit (mDNS *const m);
1976 extern void    mDNS_FinalExit (mDNS *const m);
1977 #define mDNS_Close(m) do { mDNS_StartExit(m); mDNS_FinalExit(m); } while(0)
1978 #define mDNS_ExitNow(m, now) ((now) - (m)->ShutdownTime >= 0 || (!(m)->ResourceRecords && !(m)->ServiceRegistrations))
1979
1980 extern mDNSs32 mDNS_Execute   (mDNS *const m);
1981
1982 extern mStatus mDNS_Register  (mDNS *const m, AuthRecord *const rr);
1983 extern mStatus mDNS_Update    (mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,
1984                                                                 const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback);
1985 extern mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr);
1986
1987 extern mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question);
1988 extern mStatus mDNS_StopQuery (mDNS *const m, DNSQuestion *const question);
1989 extern mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question);
1990 extern mStatus mDNS_Reconfirm (mDNS *const m, CacheRecord *const cacherr);
1991 extern mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr);
1992 extern void    mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr);
1993 extern mDNSs32 mDNS_TimeNow(const mDNS *const m);
1994
1995 extern mStatus mDNS_StartNATOperation(mDNS *const m, NATTraversalInfo *traversal);
1996 extern mStatus mDNS_StopNATOperation(mDNS *const m, NATTraversalInfo *traversal);
1997 extern mStatus mDNS_StopNATOperation_internal(mDNS *m, NATTraversalInfo *traversal);
1998
1999 // ***************************************************************************
2000 #if 0
2001 #pragma mark -
2002 #pragma mark - Platform support functions that are accessible to the client layer too
2003 #endif
2004
2005 extern mDNSs32  mDNSPlatformOneSecond;
2006
2007 // ***************************************************************************
2008 #if 0
2009 #pragma mark -
2010 #pragma mark - General utility and helper functions
2011 #endif
2012
2013 // mDNS_RegisterService is a single call to register the set of resource records associated with a given named service.
2014 //
2015 // mDNS_StartResolveService is single call which is equivalent to multiple calls to mDNS_StartQuery,
2016 // to find the IP address, port number, and demultiplexing information for a given named service.
2017 // As with mDNS_StartQuery, it executes asynchronously, and calls the ServiceInfoQueryCallback when the answer is
2018 // found. After the service is resolved, the client should call mDNS_StopResolveService to complete the transaction.
2019 // The client can also call mDNS_StopResolveService at any time to abort the transaction.
2020 //
2021 // mDNS_AddRecordToService adds an additional record to a Service Record Set.  This record may be deregistered
2022 // via mDNS_RemoveRecordFromService, or by deregistering the service.  mDNS_RemoveRecordFromService is passed a
2023 // callback to free the memory associated with the extra RR when it is safe to do so.  The ExtraResourceRecord
2024 // object can be found in the record's context pointer.
2025
2026 // mDNS_GetBrowseDomains is a special case of the mDNS_StartQuery call, where the resulting answers
2027 // are a list of PTR records indicating (in the rdata) domains that are recommended for browsing.
2028 // After getting the list of domains to browse, call mDNS_StopQuery to end the search.
2029 // mDNS_GetDefaultBrowseDomain returns the name of the domain that should be highlighted by default.
2030 //
2031 // mDNS_GetRegistrationDomains and mDNS_GetDefaultRegistrationDomain are the equivalent calls to get the list
2032 // of one or more domains that should be offered to the user as choices for where they may register their service,
2033 // and the default domain in which to register in the case where the user has made no selection.
2034
2035 extern void    mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
2036                mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, mDNSRecordCallback Callback, void *Context);
2037
2038 extern mStatus mDNS_RegisterService  (mDNS *const m, ServiceRecordSet *sr,
2039                const domainlabel *const name, const domainname *const type, const domainname *const domain,
2040                const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen,
2041                AuthRecord *SubTypes, mDNSu32 NumSubTypes,
2042                const mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context);
2043 extern mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl);
2044 extern mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, mDNSRecordCallback MemFreeCallback, void *Context);
2045 extern mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname);
2046 extern mStatus mDNS_DeregisterService(mDNS *const m, ServiceRecordSet *sr);
2047
2048 extern mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr,
2049                const domainlabel *const name, const domainname *const type, const domainname *const domain,
2050                const domainname *const host,
2051                const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context);
2052 #define        mDNS_DeregisterNoSuchService mDNS_Deregister
2053
2054 extern void mDNS_SetupQuestion(DNSQuestion *const q, const mDNSInterfaceID InterfaceID, const domainname *const name,
2055                const mDNSu16 qtype, mDNSQuestionCallback *const callback, void *const context);
2056
2057 extern mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,
2058                const domainname *const srv, const domainname *const domain,
2059                const mDNSInterfaceID InterfaceID, mDNSBool ForceMCast, mDNSQuestionCallback *Callback, void *Context);
2060 #define        mDNS_StopBrowse mDNS_StopQuery
2061
2062 extern mStatus mDNS_StartResolveService(mDNS *const m, ServiceInfoQuery *query, ServiceInfo *info, mDNSServiceInfoQueryCallback *Callback, void *Context);
2063 extern void    mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *query);
2064
2065 typedef enum
2066         {
2067         mDNS_DomainTypeBrowse              = 0,
2068         mDNS_DomainTypeBrowseDefault       = 1,
2069         mDNS_DomainTypeBrowseAutomatic     = 2,
2070         mDNS_DomainTypeRegistration        = 3,
2071         mDNS_DomainTypeRegistrationDefault = 4,
2072
2073         mDNS_DomainTypeMax = 4
2074         } mDNS_DomainType;
2075
2076 extern const char *const mDNS_DomainTypeNames[];
2077
2078 extern mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom,
2079                                                                 const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context);
2080 #define        mDNS_StopGetDomains mDNS_StopQuery
2081 extern mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr, mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname);
2082 #define        mDNS_StopAdvertiseDomains mDNS_Deregister
2083
2084 extern mDNSOpaque16 mDNS_NewMessageID(mDNS *const m);
2085 extern mDNSBool mDNS_AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr);
2086
2087 extern DNSServer *GetServerForName(mDNS *m, const domainname *name, DNSServer *current, mDNSInterfaceID InterfaceID);
2088
2089 // ***************************************************************************
2090 #if 0
2091 #pragma mark -
2092 #pragma mark - DNS name utility functions
2093 #endif
2094
2095 // In order to expose the full capabilities of the DNS protocol (which allows any arbitrary eight-bit values
2096 // in domain name labels, including unlikely characters like ascii nulls and even dots) all the mDNS APIs
2097 // work with DNS's native length-prefixed strings. For convenience in C, the following utility functions
2098 // are provided for converting between C's null-terminated strings and DNS's length-prefixed strings.
2099
2100 // Assignment
2101 // A simple C structure assignment of a domainname can cause a protection fault by accessing unmapped memory,
2102 // because that object is defined to be 256 bytes long, but not all domainname objects are truly the full size.
2103 // This macro uses mDNSPlatformMemCopy() to make sure it only touches the actual bytes that are valid.
2104 #define AssignDomainName(DST, SRC) do { mDNSu16 len__ = DomainNameLength((SRC)); \
2105         if (len__ <= MAX_DOMAIN_NAME) mDNSPlatformMemCopy((DST)->c, (SRC)->c, len__); else (DST)->c[0] = 0; } while(0)
2106
2107 // Comparison functions
2108 #define SameDomainLabelCS(A,B) ((A)[0] == (B)[0] && mDNSPlatformMemSame((A)+1, (B)+1, (A)[0]))
2109 extern mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b);
2110 extern mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2);
2111 extern mDNSBool SameDomainNameCS(const domainname *const d1, const domainname *const d2);
2112 extern mDNSBool IsLocalDomain(const domainname *d);     // returns true for domains that by default should be looked up using link-local multicast
2113
2114 #define StripFirstLabel(X) ((const domainname *)&(X)->c[(X)->c[0] ? 1 + (X)->c[0] : 0])
2115
2116 #define FirstLabel(X)  ((const domainlabel *)(X))
2117 #define SecondLabel(X) ((const domainlabel *)StripFirstLabel(X))
2118 #define ThirdLabel(X)  ((const domainlabel *)StripFirstLabel(StripFirstLabel(X)))
2119
2120 extern const mDNSu8 *LastLabel(const domainname *d);
2121
2122 // Get total length of domain name, in native DNS format, including terminal root label
2123 //   (e.g. length of "com." is 5 (length byte, three data bytes, final zero)
2124 extern mDNSu16  DomainNameLengthLimit(const domainname *const name, const mDNSu8 *limit);
2125 #define DomainNameLength(name) DomainNameLengthLimit((name), (name)->c + MAX_DOMAIN_NAME)
2126
2127 // Append functions to append one or more labels to an existing native format domain name:
2128 //   AppendLiteralLabelString adds a single label from a literal C string, with no escape character interpretation.
2129 //   AppendDNSNameString      adds zero or more labels from a C string using conventional DNS dots-and-escaping interpretation
2130 //   AppendDomainLabel        adds a single label from a native format domainlabel
2131 //   AppendDomainName         adds zero or more labels from a native format domainname
2132 extern mDNSu8  *AppendLiteralLabelString(domainname *const name, const char *cstr);
2133 extern mDNSu8  *AppendDNSNameString     (domainname *const name, const char *cstr);
2134 extern mDNSu8  *AppendDomainLabel       (domainname *const name, const domainlabel *const label);
2135 extern mDNSu8  *AppendDomainName        (domainname *const name, const domainname *const append);
2136
2137 // Convert from null-terminated string to native DNS format:
2138 //   The DomainLabel form makes a single label from a literal C string, with no escape character interpretation.
2139 //   The DomainName form makes native format domain name from a C string using conventional DNS interpretation:
2140 //     dots separate labels, and within each label, '\.' represents a literal dot, '\\' represents a literal
2141 //     backslash and backslash with three decimal digits (e.g. \000) represents an arbitrary byte value.
2142 extern mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr);
2143 extern mDNSu8  *MakeDomainNameFromDNSNameString (domainname  *const name,  const char *cstr);
2144
2145 // Convert native format domainlabel or domainname back to C string format
2146 // IMPORTANT:
2147 // When using ConvertDomainLabelToCString, the target buffer must be MAX_ESCAPED_DOMAIN_LABEL (254) bytes long
2148 // to guarantee there will be no buffer overrun. It is only safe to use a buffer shorter than this in rare cases
2149 // where the label is known to be constrained somehow (for example, if the label is known to be either "_tcp" or "_udp").
2150 // Similarly, when using ConvertDomainNameToCString, the target buffer must be MAX_ESCAPED_DOMAIN_NAME (1009) bytes long.
2151 // See definitions of MAX_ESCAPED_DOMAIN_LABEL and MAX_ESCAPED_DOMAIN_NAME for more detailed explanation.
2152 extern char    *ConvertDomainLabelToCString_withescape(const domainlabel *const name, char *cstr, char esc);
2153 #define         ConvertDomainLabelToCString_unescaped(D,C) ConvertDomainLabelToCString_withescape((D), (C), 0)
2154 #define         ConvertDomainLabelToCString(D,C)           ConvertDomainLabelToCString_withescape((D), (C), '\\')
2155 extern char    *ConvertDomainNameToCString_withescape(const domainname *const name, char *cstr, char esc);
2156 #define         ConvertDomainNameToCString_unescaped(D,C) ConvertDomainNameToCString_withescape((D), (C), 0)
2157 #define         ConvertDomainNameToCString(D,C)           ConvertDomainNameToCString_withescape((D), (C), '\\')
2158
2159 extern void     ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel);
2160
2161 extern mDNSu8  *ConstructServiceName(domainname *const fqdn, const domainlabel *name, const domainname *type, const domainname *const domain);
2162 extern mDNSBool DeconstructServiceName(const domainname *const fqdn, domainlabel *const name, domainname *const type, domainname *const domain);
2163
2164 // Note: Some old functions have been replaced by more sensibly-named versions.
2165 // You can uncomment the hash-defines below if you don't want to have to change your source code right away.
2166 // When updating your code, note that (unlike the old versions) *all* the new routines take the target object
2167 // as their first parameter.
2168 //#define ConvertCStringToDomainName(SRC,DST)  MakeDomainNameFromDNSNameString((DST),(SRC))
2169 //#define ConvertCStringToDomainLabel(SRC,DST) MakeDomainLabelFromLiteralString((DST),(SRC))
2170 //#define AppendStringLabelToName(DST,SRC)     AppendLiteralLabelString((DST),(SRC))
2171 //#define AppendStringNameToName(DST,SRC)      AppendDNSNameString((DST),(SRC))
2172 //#define AppendDomainLabelToName(DST,SRC)     AppendDomainLabel((DST),(SRC))
2173 //#define AppendDomainNameToName(DST,SRC)      AppendDomainName((DST),(SRC))
2174
2175 // ***************************************************************************
2176 #if 0
2177 #pragma mark -
2178 #pragma mark - Other utility functions and macros
2179 #endif
2180
2181 // mDNS_vsnprintf/snprintf return the number of characters written, excluding the final terminating null.
2182 // The output is always null-terminated: for example, if the output turns out to be exactly buflen long,
2183 // then the output will be truncated by one character to allow space for the terminating null.
2184 // Unlike standard C vsnprintf/snprintf, they return the number of characters *actually* written,
2185 // not the number of characters that *would* have been printed were buflen unlimited.
2186 extern mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg);
2187 extern mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...) IS_A_PRINTF_STYLE_FUNCTION(3,4);
2188 extern mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id);
2189 extern char *DNSTypeName(mDNSu16 rrtype);
2190 extern char *GetRRDisplayString_rdb(const ResourceRecord *const rr, const RDataBody *const rd1, char *const buffer);
2191 #define RRDisplayString(m, rr) GetRRDisplayString_rdb(rr, &(rr)->rdata->u, (m)->MsgBuffer)
2192 #define ARDisplayString(m, rr) GetRRDisplayString_rdb(&(rr)->resrec, &(rr)->resrec.rdata->u, (m)->MsgBuffer)
2193 #define CRDisplayString(m, rr) GetRRDisplayString_rdb(&(rr)->resrec, &(rr)->resrec.rdata->u, (m)->MsgBuffer)
2194 extern mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2);
2195 extern void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText);
2196 extern mDNSBool mDNSv4AddrIsRFC1918(mDNSv4Addr *addr);  // returns true for RFC1918 private addresses
2197 #define mDNSAddrIsRFC1918(X) ((X)->type == mDNSAddrType_IPv4 && mDNSv4AddrIsRFC1918(&(X)->ip.v4))
2198
2199 #define mDNSSameIPPort(A,B)      ((A).NotAnInteger == (B).NotAnInteger)
2200 #define mDNSSameOpaque16(A,B)    ((A).NotAnInteger == (B).NotAnInteger)
2201 #define mDNSSameOpaque32(A,B)    ((A).NotAnInteger == (B).NotAnInteger)
2202 #define mDNSSameOpaque64(A,B)    ((A)->l[0] == (B)->l[0] && (A)->l[1] == (B)->l[1])
2203
2204 #define mDNSSameIPv4Address(A,B) ((A).NotAnInteger == (B).NotAnInteger)
2205 #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])
2206 #define mDNSSameEthAddress(A,B)  ((A)->w[0] == (B)->w[0] && (A)->w[1] == (B)->w[1] && (A)->w[2] == (B)->w[2])
2207
2208 #define mDNSIPPortIsZero(A)      ((A).NotAnInteger                            == 0)
2209 #define mDNSOpaque16IsZero(A)    ((A).NotAnInteger                            == 0)
2210 #define mDNSOpaque64IsZero(A)    (((A)->l[0] | (A)->l[1]                    ) == 0)
2211 #define mDNSIPv4AddressIsZero(A) ((A).NotAnInteger                            == 0)
2212 #define mDNSIPv6AddressIsZero(A) (((A).l[0] | (A).l[1] | (A).l[2] | (A).l[3]) == 0)
2213 #define mDNSEthAddressIsZero(A)  (((A).w[0] | (A).w[1] | (A).w[2]           ) == 0)
2214
2215 #define mDNSIPv4AddressIsOnes(A) ((A).NotAnInteger == 0xFFFFFFFF)
2216 #define mDNSIPv6AddressIsOnes(A) (((A).l[0] & (A).l[1] & (A).l[2] & (A).l[3]) == 0xFFFFFFFF)
2217
2218 #define mDNSAddressIsAllDNSLinkGroup(X) (                                                            \
2219         ((X)->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address((X)->ip.v4, AllDNSLinkGroup_v4.ip.v4)) || \
2220         ((X)->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address((X)->ip.v6, AllDNSLinkGroup_v6.ip.v6))    )
2221
2222 #define mDNSAddressIsZero(X) (                                                \
2223         ((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsZero((X)->ip.v4))  || \
2224         ((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsZero((X)->ip.v6))     )
2225
2226 #define mDNSAddressIsValidNonZero(X) (                                        \
2227         ((X)->type == mDNSAddrType_IPv4 && !mDNSIPv4AddressIsZero((X)->ip.v4)) || \
2228         ((X)->type == mDNSAddrType_IPv6 && !mDNSIPv6AddressIsZero((X)->ip.v6))    )
2229
2230 #define mDNSAddressIsOnes(X) (                                                \
2231         ((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsOnes((X)->ip.v4))  || \
2232         ((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsOnes((X)->ip.v6))     )
2233
2234 #define mDNSAddressIsValid(X) (                                                                                             \
2235         ((X)->type == mDNSAddrType_IPv4) ? !(mDNSIPv4AddressIsZero((X)->ip.v4) || mDNSIPv4AddressIsOnes((X)->ip.v4)) :          \
2236         ((X)->type == mDNSAddrType_IPv6) ? !(mDNSIPv6AddressIsZero((X)->ip.v6) || mDNSIPv6AddressIsOnes((X)->ip.v6)) : mDNSfalse)
2237
2238 #define mDNSv4AddressIsLinkLocal(X) ((X)->b[0] ==  169 &&  (X)->b[1]         ==  254)
2239 #define mDNSv6AddressIsLinkLocal(X) ((X)->b[0] == 0xFE && ((X)->b[1] & 0xC0) == 0x80)
2240
2241 #define mDNSAddressIsLinkLocal(X)  (                                                    \
2242         ((X)->type == mDNSAddrType_IPv4) ? mDNSv4AddressIsLinkLocal(&(X)->ip.v4) :          \
2243         ((X)->type == mDNSAddrType_IPv6) ? mDNSv6AddressIsLinkLocal(&(X)->ip.v6) : mDNSfalse)
2244
2245 // ***************************************************************************
2246 #if 0
2247 #pragma mark -
2248 #pragma mark - Authentication Support
2249 #endif
2250
2251 // Unicast DNS and Dynamic Update specific Client Calls
2252 //
2253 // mDNS_SetSecretForDomain tells the core to authenticate (via TSIG with an HMAC_MD5 hash of the shared secret)
2254 // when dynamically updating a given zone (and its subdomains).  The key used in authentication must be in
2255 // domain name format.  The shared secret must be a null-terminated base64 encoded string.  A minimum size of
2256 // 16 bytes (128 bits) is recommended for an MD5 hash as per RFC 2485.
2257 // Calling this routine multiple times for a zone replaces previously entered values.  Call with a NULL key
2258 // to dissable authentication for the zone.
2259
2260 extern mStatus mDNS_SetSecretForDomain(mDNS *m, DomainAuthInfo *info,
2261         const domainname *domain, const domainname *keyname, const char *b64keydata, mDNSBool AutoTunnel);
2262
2263 extern void RecreateNATMappings(mDNS *const m);
2264
2265 // Hostname/Unicast Interface Configuration
2266
2267 // All hostnames advertised point to one IPv4 address and/or one IPv6 address, set via SetPrimaryInterfaceInfo.  Invoking this routine
2268 // updates all existing hostnames to point to the new address.
2269
2270 // A hostname is added via AddDynDNSHostName, which points to the primary interface's v4 and/or v6 addresss
2271
2272 // The status callback is invoked to convey success or failure codes - the callback should not modify the AuthRecord or free memory.
2273 // Added hostnames may be removed (deregistered) via mDNS_RemoveDynDNSHostName.
2274
2275 // Host domains added prior to specification of the primary interface address and computer name will be deferred until
2276 // these values are initialized.
2277
2278 // DNS servers used to resolve unicast queries are specified by mDNS_AddDNSServer.
2279 // For "split" DNS configurations, in which queries for different domains are sent to different servers (e.g. VPN and external),
2280 // a domain may be associated with a DNS server.  For standard configurations, specify the root label (".") or NULL.
2281
2282 extern void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *StatusContext);
2283 extern void mDNS_RemoveDynDNSHostName(mDNS *m, const domainname *fqdn);
2284 extern void mDNS_SetPrimaryInterfaceInfo(mDNS *m, const mDNSAddr *v4addr,  const mDNSAddr *v6addr, const mDNSAddr *router);
2285 extern DNSServer *mDNS_AddDNSServer(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, const mDNSAddr *addr, const mDNSIPPort port, mDNSBool scoped);
2286 extern void PenalizeDNSServer(mDNS *const m, DNSQuestion *q, mDNSBool QueryFail);
2287 extern void mDNS_AddSearchDomain(const domainname *const domain);
2288
2289 // We use ((void *)0) here instead of mDNSNULL to avoid compile warnings on gcc 4.2
2290 #define mDNS_AddSearchDomain_CString(X) \
2291         do { domainname d__; if (((X) != (void*)0) && MakeDomainNameFromDNSNameString(&d__, (X)) && d__.c[0]) mDNS_AddSearchDomain(&d__); } while(0)
2292
2293 // Routines called by the core, exported by DNSDigest.c
2294
2295 // Convert an arbitrary base64 encoded key key into an HMAC key (stored in AuthInfo struct)
2296 extern mDNSs32 DNSDigest_ConstructHMACKeyfromBase64(DomainAuthInfo *info, const char *b64key);
2297
2298 // sign a DNS message.  The message must be complete, with all values in network byte order.  end points to the end
2299 // of the message, and is modified by this routine.  numAdditionals is a pointer to the number of additional
2300 // records in HOST byte order, which is incremented upon successful completion of this routine.  The function returns
2301 // the new end pointer on success, and NULL on failure.
2302 extern void DNSDigest_SignMessage(DNSMessage *msg, mDNSu8 **end, DomainAuthInfo *info, mDNSu16 tcode);
2303
2304 #define SwapDNSHeaderBytes(M) do { \
2305     (M)->h.numQuestions   = (mDNSu16)((mDNSu8 *)&(M)->h.numQuestions  )[0] << 8 | ((mDNSu8 *)&(M)->h.numQuestions  )[1]; \
2306     (M)->h.numAnswers     = (mDNSu16)((mDNSu8 *)&(M)->h.numAnswers    )[0] << 8 | ((mDNSu8 *)&(M)->h.numAnswers    )[1]; \
2307     (M)->h.numAuthorities = (mDNSu16)((mDNSu8 *)&(M)->h.numAuthorities)[0] << 8 | ((mDNSu8 *)&(M)->h.numAuthorities)[1]; \
2308     (M)->h.numAdditionals = (mDNSu16)((mDNSu8 *)&(M)->h.numAdditionals)[0] << 8 | ((mDNSu8 *)&(M)->h.numAdditionals)[1]; \
2309     } while (0)
2310
2311 #define DNSDigest_SignMessageHostByteOrder(M,E,INFO) \
2312         do { SwapDNSHeaderBytes(M); DNSDigest_SignMessage((M), (E), (INFO), 0); SwapDNSHeaderBytes(M); } while (0)
2313
2314 // verify a DNS message.  The message must be complete, with all values in network byte order.  end points to the
2315 // end of the record.  tsig is a pointer to the resource record that contains the TSIG OPT record.  info is
2316 // the matching key to use for verifying the message.  This function expects that the additionals member
2317 // of the DNS message header has already had one subtracted from it.
2318 extern mDNSBool DNSDigest_VerifyMessage(DNSMessage *msg, mDNSu8 *end, LargeCacheRecord *tsig, DomainAuthInfo *info, mDNSu16 *rcode, mDNSu16 *tcode);
2319
2320 // ***************************************************************************
2321 #if 0
2322 #pragma mark -
2323 #pragma mark - PlatformSupport interface
2324 #endif
2325
2326 // This section defines the interface to the Platform Support layer.
2327 // Normal client code should not use any of types defined here, or directly call any of the functions defined here.
2328 // The definitions are placed here because sometimes clients do use these calls indirectly, via other supported client operations.
2329 // For example, AssignDomainName is a macro defined using mDNSPlatformMemCopy()
2330
2331 // Every platform support module must provide the following functions.
2332 // mDNSPlatformInit() typically opens a communication endpoint, and starts listening for mDNS packets.
2333 // When Setup is complete, the platform support layer calls mDNSCoreInitComplete().
2334 // mDNSPlatformSendUDP() sends one UDP packet
2335 // When a packet is received, the PlatformSupport code calls mDNSCoreReceive()
2336 // mDNSPlatformClose() tidies up on exit
2337 //
2338 // Note: mDNSPlatformMemAllocate/mDNSPlatformMemFree are only required for handling oversized resource records and unicast DNS.
2339 // If your target platform has a well-defined specialized application, and you know that all the records it uses
2340 // are InlineCacheRDSize or less, then you can just make a simple mDNSPlatformMemAllocate() stub that always returns
2341 // NULL. InlineCacheRDSize is a compile-time constant, which is set by default to 68. If you need to handle records
2342 // a little larger than this and you don't want to have to implement run-time allocation and freeing, then you
2343 // can raise the value of this constant to a suitable value (at the expense of increased memory usage).
2344 //
2345 // USE CAUTION WHEN CALLING mDNSPlatformRawTime: The m->timenow_adjust correction factor needs to be added
2346 // Generally speaking:
2347 // Code that's protected by the main mDNS lock should just use the m->timenow value
2348 // Code outside the main mDNS lock should use mDNS_TimeNow(m) to get properly adjusted time
2349 // In certain cases there may be reasons why it's necessary to get the time without taking the lock first
2350 // (e.g. inside the routines that are doing the locking and unlocking, where a call to get the lock would result in a
2351 // recursive loop); in these cases use mDNS_TimeNow_NoLock(m) to get mDNSPlatformRawTime with the proper correction factor added.
2352 //
2353 // mDNSPlatformUTC returns the time, in seconds, since Jan 1st 1970 UTC and is required for generating TSIG records
2354
2355 extern mStatus  mDNSPlatformInit        (mDNS *const m);
2356 extern void     mDNSPlatformClose       (mDNS *const m);
2357 extern mStatus  mDNSPlatformSendUDP(const mDNS *const m, const void *const msg, const mDNSu8 *const end,
2358 mDNSInterfaceID InterfaceID, UDPSocket *src, const mDNSAddr *dst, mDNSIPPort dstport);
2359
2360 extern void     mDNSPlatformLock        (const mDNS *const m);
2361 extern void     mDNSPlatformUnlock      (const mDNS *const m);
2362
2363 extern void     mDNSPlatformStrCopy     (      void *dst, const void *src);
2364 extern mDNSu32  mDNSPlatformStrLen      (                 const void *src);
2365 extern void     mDNSPlatformMemCopy     (      void *dst, const void *src, mDNSu32 len);
2366 extern mDNSBool mDNSPlatformMemSame     (const void *dst, const void *src, mDNSu32 len);
2367 extern void     mDNSPlatformMemZero     (      void *dst,                  mDNSu32 len);
2368 #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
2369 #define         mDNSPlatformMemAllocate(X) mallocL(#X, X)
2370 #else
2371 extern void *   mDNSPlatformMemAllocate (mDNSu32 len);
2372 #endif
2373 extern void     mDNSPlatformMemFree     (void *mem);
2374
2375 // If the platform doesn't have a strong PRNG, we define a naive multiply-and-add based on a seed
2376 // from the platform layer.  Long-term, we should embed an arc4 implementation, but the strength
2377 // will still depend on the randomness of the seed.
2378 #if !defined(_PLATFORM_HAS_STRONG_PRNG_) && (_BUILDING_XCODE_PROJECT_ || defined(_WIN32))
2379 #define _PLATFORM_HAS_STRONG_PRNG_ 1
2380 #endif
2381 #if _PLATFORM_HAS_STRONG_PRNG_
2382 extern mDNSu32  mDNSPlatformRandomNumber(void);
2383 #else
2384 extern mDNSu32  mDNSPlatformRandomSeed  (void);
2385 #endif // _PLATFORM_HAS_STRONG_PRNG_
2386
2387 extern mStatus  mDNSPlatformTimeInit    (void);
2388 extern mDNSs32  mDNSPlatformRawTime     (void);
2389 extern mDNSs32  mDNSPlatformUTC         (void);
2390 #define mDNS_TimeNow_NoLock(m) (mDNSPlatformRawTime() + (m)->timenow_adjust)
2391
2392 #if MDNS_DEBUGMSGS
2393 extern void     mDNSPlatformWriteDebugMsg(const char *msg);
2394 #endif
2395 extern void     mDNSPlatformWriteLogMsg(const char *ident, const char *msg, mDNSLogLevel_t loglevel);
2396
2397 #if APPLE_OSX_mDNSResponder
2398 // Utility function for ASL logging
2399 mDNSexport void mDNSASLLog(uuid_t *uuid, const char *subdomain, const char *result, const char *signature, const char *fmt, ...);
2400 #endif
2401
2402 // Platform support modules should provide the following functions to map between opaque interface IDs
2403 // and interface indexes in order to support the DNS-SD API. If your target platform does not support
2404 // multiple interfaces and/or does not support the DNS-SD API, these functions can be empty.
2405 extern mDNSInterfaceID mDNSPlatformInterfaceIDfromInterfaceIndex(mDNS *const m, mDNSu32 ifindex);
2406 extern mDNSu32 mDNSPlatformInterfaceIndexfromInterfaceID(mDNS *const m, mDNSInterfaceID id);
2407
2408 // Every platform support module must provide the following functions if it is to support unicast DNS
2409 // and Dynamic Update.
2410 // All TCP socket operations implemented by the platform layer MUST NOT BLOCK.
2411 // mDNSPlatformTCPConnect initiates a TCP connection with a peer, adding the socket descriptor to the
2412 // main event loop.  The return value indicates whether the connection succeeded, failed, or is pending
2413 // (i.e. the call would block.)  On return, the descriptor parameter is set to point to the connected socket.
2414 // The TCPConnectionCallback is subsequently invoked when the connection
2415 // completes (in which case the ConnectionEstablished parameter is true), or data is available for
2416 // reading on the socket (indicated by the ConnectionEstablished parameter being false.)  If the connection
2417 // asynchronously fails, the TCPConnectionCallback should be invoked as usual, with the error being
2418 // returned in subsequent calls to PlatformReadTCP or PlatformWriteTCP.  (This allows for platforms
2419 // with limited asynchronous error detection capabilities.)  PlatformReadTCP and PlatformWriteTCP must
2420 // return the number of bytes read/written, 0 if the call would block, and -1 if an error.  PlatformReadTCP
2421 // should set the closed argument if the socket has been closed.
2422 // PlatformTCPCloseConnection must close the connection to the peer and remove the descriptor from the
2423 // event loop.  CloseConnectin may be called at any time, including in a ConnectionCallback.
2424
2425 typedef enum
2426         {
2427         kTCPSocketFlags_Zero   = 0,
2428         kTCPSocketFlags_UseTLS = (1 << 0)
2429         } TCPSocketFlags;
2430
2431 typedef void (*TCPConnectionCallback)(TCPSocket *sock, void *context, mDNSBool ConnectionEstablished, mStatus err);
2432 extern TCPSocket *mDNSPlatformTCPSocket(mDNS *const m, TCPSocketFlags flags, mDNSIPPort *port); // creates a TCP socket
2433 extern TCPSocket *mDNSPlatformTCPAccept(TCPSocketFlags flags, int sd);
2434 extern int        mDNSPlatformTCPGetFD(TCPSocket *sock);
2435 extern mStatus    mDNSPlatformTCPConnect(TCPSocket *sock, const mDNSAddr *dst, mDNSOpaque16 dstport, mDNSInterfaceID InterfaceID,
2436                                          TCPConnectionCallback callback, void *context);
2437 extern void       mDNSPlatformTCPCloseConnection(TCPSocket *sock);
2438 extern long       mDNSPlatformReadTCP(TCPSocket *sock, void *buf, unsigned long buflen, mDNSBool *closed);
2439 extern long       mDNSPlatformWriteTCP(TCPSocket *sock, const char *msg, unsigned long len);
2440 extern UDPSocket *mDNSPlatformUDPSocket(mDNS *const m, const mDNSIPPort requestedport);
2441 extern void       mDNSPlatformUDPClose(UDPSocket *sock);
2442 extern void       mDNSPlatformReceiveBPF_fd(mDNS *const m, int fd);
2443 extern void       mDNSPlatformUpdateProxyList(mDNS *const m, const mDNSInterfaceID InterfaceID);
2444 extern void       mDNSPlatformSendRawPacket(const void *const msg, const mDNSu8 *const end, mDNSInterfaceID InterfaceID);
2445 extern void       mDNSPlatformSetLocalAddressCacheEntry(mDNS *const m, const mDNSAddr *const tpa, const mDNSEthAddr *const tha, mDNSInterfaceID InterfaceID);
2446 extern void       mDNSPlatformSourceAddrForDest(mDNSAddr *const src, const mDNSAddr *const dst);
2447
2448 // mDNSPlatformTLSSetupCerts/mDNSPlatformTLSTearDownCerts used by dnsextd
2449 extern mStatus    mDNSPlatformTLSSetupCerts(void);
2450 extern void       mDNSPlatformTLSTearDownCerts(void);
2451
2452 // Platforms that support unicast browsing and dynamic update registration for clients who do not specify a domain
2453 // in browse/registration calls must implement these routines to get the "default" browse/registration list.
2454
2455 extern void       mDNSPlatformSetDNSConfig(mDNS *const m, mDNSBool setservers, mDNSBool setsearch, domainname *const fqdn, DNameListElem **RegDomains, DNameListElem **BrowseDomains);
2456 extern mStatus    mDNSPlatformGetPrimaryInterface(mDNS *const m, mDNSAddr *v4, mDNSAddr *v6, mDNSAddr *router);
2457 extern void       mDNSPlatformDynDNSHostNameStatusChanged(const domainname *const dname, const mStatus status);
2458
2459 #ifdef _LEGACY_NAT_TRAVERSAL_
2460 // Support for legacy NAT traversal protocols, implemented by the platform layer and callable by the core.
2461 extern void     LNT_SendDiscoveryMsg(mDNS *m);
2462 extern void     LNT_ConfigureRouterInfo(mDNS *m, const mDNSInterfaceID InterfaceID, const mDNSu8 *const data, const mDNSu16 len);
2463 extern mStatus  LNT_GetExternalAddress(mDNS *m);
2464 extern mStatus  LNT_MapPort(mDNS *m, NATTraversalInfo *n);
2465 extern mStatus  LNT_UnmapPort(mDNS *m, NATTraversalInfo *n);
2466 extern void     LNT_ClearState(mDNS *const m);
2467 #endif // _LEGACY_NAT_TRAVERSAL_
2468
2469 // The core mDNS code provides these functions, for the platform support code to call at appropriate times
2470 //
2471 // mDNS_SetFQDN() is called once on startup (typically from mDNSPlatformInit())
2472 // and then again on each subsequent change of the host name.
2473 //
2474 // mDNS_RegisterInterface() is used by the platform support layer to inform mDNSCore of what
2475 // physical and/or logical interfaces are available for sending and receiving packets.
2476 // Typically it is called on startup for each available interface, but register/deregister may be
2477 // called again later, on multiple occasions, to inform the core of interface configuration changes.
2478 // If set->Advertise is set non-zero, then mDNS_RegisterInterface() also registers the standard
2479 // resource records that should be associated with every publicised IP address/interface:
2480 // -- Name-to-address records (A/AAAA)
2481 // -- Address-to-name records (PTR)
2482 // -- Host information (HINFO)
2483 // IMPORTANT: The specified mDNSInterfaceID MUST NOT be 0, -1, or -2; these values have special meaning
2484 // mDNS_RegisterInterface does not result in the registration of global hostnames via dynamic update -
2485 // see mDNS_SetPrimaryInterfaceInfo, mDNS_AddDynDNSHostName, etc. for this purpose.
2486 // Note that the set may be deallocated immediately after it is deregistered via mDNS_DeegisterInterface.
2487 //
2488 // mDNS_RegisterDNS() is used by the platform support layer to provide the core with the addresses of
2489 // available domain name servers for unicast queries/updates.  RegisterDNS() should be called once for
2490 // each name server, typically at startup, or when a new name server becomes available.  DeregiterDNS()
2491 // must be called whenever a registered name server becomes unavailable.  DeregisterDNSList deregisters
2492 // all registered servers.  mDNS_DNSRegistered() returns true if one or more servers are registered in the core.
2493 //
2494 // mDNSCoreInitComplete() is called when the platform support layer is finished.
2495 // Typically this is at the end of mDNSPlatformInit(), but may be later
2496 // (on platforms like OT that allow asynchronous initialization of the networking stack).
2497 //
2498 // mDNSCoreReceive() is called when a UDP packet is received
2499 //
2500 // mDNSCoreMachineSleep() is called when the machine sleeps or wakes
2501 // (This refers to heavyweight laptop-style sleep/wake that disables network access,
2502 // not lightweight second-by-second CPU power management modes.)
2503
2504 extern void     mDNS_SetFQDN(mDNS *const m);
2505 extern void     mDNS_ActivateNetWake_internal  (mDNS *const m, NetworkInterfaceInfo *set);
2506 extern void     mDNS_DeactivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set);
2507 extern mStatus  mDNS_RegisterInterface  (mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping);
2508 extern void     mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping);
2509 extern void     mDNSCoreInitComplete(mDNS *const m, mStatus result);
2510 extern void     mDNSCoreReceive(mDNS *const m, void *const msg, const mDNSu8 *const end,
2511                                                                 const mDNSAddr *const srcaddr, const mDNSIPPort srcport,
2512                                                                 const mDNSAddr *dstaddr, const mDNSIPPort dstport, const mDNSInterfaceID InterfaceID);
2513 extern void     mDNSCoreRestartQueries(mDNS *const m);
2514 extern mDNSBool mDNSCoreHaveAdvertisedMulticastServices(mDNS *const m);
2515 extern void     mDNSCoreMachineSleep(mDNS *const m, mDNSBool wake);
2516 extern mDNSBool mDNSCoreReadyForSleep(mDNS *m, mDNSs32 now);
2517 extern mDNSs32  mDNSCoreIntervalToNextWake(mDNS *const m, mDNSs32 now);
2518
2519 extern void     mDNSCoreBeSleepProxyServer_internal(mDNS *const m, mDNSu8 sps, mDNSu8 port, mDNSu8 marginalpower, mDNSu8 totpower);
2520 #define mDNSCoreBeSleepProxyServer(M,S,P,MP,TP) \
2521         do { mDNS_Lock(m); mDNSCoreBeSleepProxyServer_internal((M),(S),(P),(MP),(TP)); mDNS_Unlock(m); } while(0)
2522 extern void     mDNSCoreReceiveRawPacket  (mDNS *const m, const mDNSu8 *const p, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID);
2523
2524 extern mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip);
2525
2526 extern CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg);
2527 extern void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease);
2528 extern void MakeNegativeCacheRecord(mDNS *const m, CacheRecord *const cr,
2529         const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds,
2530         mDNSInterfaceID InterfaceID, DNSServer *dnsserver);
2531 extern void CompleteDeregistration(mDNS *const m, AuthRecord *rr);
2532 extern void FindSPSInCache(mDNS *const m, const DNSQuestion *const q, const CacheRecord *sps[3]);
2533 #define PrototypeSPSName(X) ((X)[0] >= 11 && (X)[3] == '-' && (X)[ 4] == '9' && (X)[ 5] == '9' && \
2534                                              (X)[6] == '-' && (X)[ 7] == '9' && (X)[ 8] == '9' && \
2535                                              (X)[9] == '-' && (X)[10] == '9' && (X)[11] == '9'    )
2536 #define ValidSPSName(X) ((X)[0] >= 5 && mDNSIsDigit((X)[1]) && mDNSIsDigit((X)[2]) && mDNSIsDigit((X)[4]) && mDNSIsDigit((X)[5]))
2537 #define SPSMetric(X) (!ValidSPSName(X) || PrototypeSPSName(X) ? 1000000 : \
2538         ((X)[1]-'0') * 100000 + ((X)[2]-'0') * 10000 + ((X)[4]-'0') * 1000 + ((X)[5]-'0') * 100 + ((X)[7]-'0') * 10 + ((X)[8]-'0'))
2539 extern void AnswerCurrentQuestionWithResourceRecord(mDNS *const m, CacheRecord *const rr, const QC_result AddRecord);
2540 extern char *InterfaceNameForID(mDNS *const m, const mDNSInterfaceID InterfaceID);
2541 extern void DNSServerChangeForQuestion(mDNS *const m, DNSQuestion *q, DNSServer *new);
2542
2543 // For now this AutoTunnel stuff is specific to Mac OS X.
2544 // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer
2545 #if APPLE_OSX_mDNSResponder
2546 extern void AutoTunnelCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord);
2547 extern void AddNewClientTunnel(mDNS *const m, DNSQuestion *const q);
2548 extern void SetupLocalAutoTunnelInterface_internal(mDNS *const m);
2549 extern void UpdateAutoTunnelDomainStatuses(const mDNS *const m);
2550 extern mStatus ActivateLocalProxy(mDNS *const m, char *ifname);
2551 #endif
2552
2553 // ***************************************************************************
2554 #if 0
2555 #pragma mark -
2556 #pragma mark - Compile-Time assertion checks
2557 #endif
2558
2559 // Some C compiler cleverness. We can make the compiler check certain things for
2560 // us, and report compile-time errors if anything is wrong. The usual way to do
2561 // this would be to use a run-time "if" statement, but then you don't find out
2562 // what's wrong until you run the software. This way, if the assertion condition
2563 // is false, the array size is negative, and the complier complains immediately.
2564
2565 struct CompileTimeAssertionChecks_mDNS
2566         {
2567         // Check that the compiler generated our on-the-wire packet format structure definitions
2568         // properly packed, without adding padding bytes to align fields on 32-bit or 64-bit boundaries.
2569         char assert0[(sizeof(rdataSRV)         == 262                          ) ? 1 : -1];
2570         char assert1[(sizeof(DNSMessageHeader) ==  12                          ) ? 1 : -1];
2571         char assert2[(sizeof(DNSMessage)       ==  12+AbsoluteMaxDNSMessageData) ? 1 : -1];
2572         char assert3[(sizeof(mDNSs8)           ==   1                          ) ? 1 : -1];
2573         char assert4[(sizeof(mDNSu8)           ==   1                          ) ? 1 : -1];
2574         char assert5[(sizeof(mDNSs16)          ==   2                          ) ? 1 : -1];
2575         char assert6[(sizeof(mDNSu16)          ==   2                          ) ? 1 : -1];
2576         char assert7[(sizeof(mDNSs32)          ==   4                          ) ? 1 : -1];
2577         char assert8[(sizeof(mDNSu32)          ==   4                          ) ? 1 : -1];
2578         char assert9[(sizeof(mDNSOpaque16)     ==   2                          ) ? 1 : -1];
2579         char assertA[(sizeof(mDNSOpaque32)     ==   4                          ) ? 1 : -1];
2580         char assertB[(sizeof(mDNSOpaque128)    ==  16                          ) ? 1 : -1];
2581         char assertC[(sizeof(CacheRecord  )    ==  sizeof(CacheGroup)          ) ? 1 : -1];
2582         char assertD[(sizeof(int)              >=  4                           ) ? 1 : -1];
2583         char assertE[(StandardAuthRDSize       >=  256                         ) ? 1 : -1];
2584         char assertF[(sizeof(EthernetHeader)   ==   14                         ) ? 1 : -1];
2585         char assertG[(sizeof(ARP_EthIP     )   ==   28                         ) ? 1 : -1];
2586         char assertH[(sizeof(IPv4Header    )   ==   20                         ) ? 1 : -1];
2587         char assertI[(sizeof(IPv6Header    )   ==   40                         ) ? 1 : -1];
2588         char assertJ[(sizeof(IPv6NDP       )   ==   24                         ) ? 1 : -1];
2589         char assertK[(sizeof(UDPHeader     )   ==    8                         ) ? 1 : -1];
2590         char assertL[(sizeof(IKEHeader     )   ==   28                         ) ? 1 : -1];
2591         char assertM[(sizeof(TCPHeader     )   ==   20                         ) ? 1 : -1];
2592
2593         // Check our structures are reasonable sizes. Including overly-large buffers, or embedding
2594         // other overly-large structures instead of having a pointer to them, can inadvertently
2595         // cause structure sizes (and therefore memory usage) to balloon unreasonably.
2596         char sizecheck_RDataBody           [(sizeof(RDataBody)            ==   264) ? 1 : -1];
2597         char sizecheck_ResourceRecord      [(sizeof(ResourceRecord)       <=    64) ? 1 : -1];
2598         char sizecheck_AuthRecord          [(sizeof(AuthRecord)           <=  1000) ? 1 : -1];
2599         char sizecheck_CacheRecord         [(sizeof(CacheRecord)          <=   184) ? 1 : -1];
2600         char sizecheck_CacheGroup          [(sizeof(CacheGroup)           <=   184) ? 1 : -1];
2601         char sizecheck_DNSQuestion         [(sizeof(DNSQuestion)          <=   736) ? 1 : -1];
2602         char sizecheck_ZoneData            [(sizeof(ZoneData)             <=  1568) ? 1 : -1];
2603         char sizecheck_NATTraversalInfo    [(sizeof(NATTraversalInfo)     <=   192) ? 1 : -1];
2604         char sizecheck_HostnameInfo        [(sizeof(HostnameInfo)         <=  2800) ? 1 : -1];
2605         char sizecheck_DNSServer           [(sizeof(DNSServer)            <=   320) ? 1 : -1];
2606         char sizecheck_NetworkInterfaceInfo[(sizeof(NetworkInterfaceInfo) <=  6000) ? 1 : -1];
2607         char sizecheck_ServiceRecordSet    [(sizeof(ServiceRecordSet)     <=  5500) ? 1 : -1];
2608         char sizecheck_DomainAuthInfo      [(sizeof(DomainAuthInfo)       <=  5500) ? 1 : -1];
2609         char sizecheck_ServiceInfoQuery    [(sizeof(ServiceInfoQuery)     <=  2976) ? 1 : -1];
2610 #if APPLE_OSX_mDNSResponder
2611         char sizecheck_ClientTunnel        [(sizeof(ClientTunnel)         <=  1072) ? 1 : -1];
2612 #endif
2613         };
2614
2615 // ***************************************************************************
2616
2617 #ifdef __cplusplus
2618         }
2619 #endif
2620
2621 #endif