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