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