14b22b933Srs /* -*- Mode: C; tab-width: 4 -*-
24b22b933Srs  *
3*3b436d06SToomas Soome  * Copyright (c) 2002-2018 Apple Inc. All rights reserved.
44b22b933Srs  *
54b22b933Srs  * Licensed under the Apache License, Version 2.0 (the "License");
64b22b933Srs  * you may not use this file except in compliance with the License.
74b22b933Srs  * You may obtain a copy of the License at
85ffb0c9bSToomas Soome  *
94b22b933Srs  *     http://www.apache.org/licenses/LICENSE-2.0
105ffb0c9bSToomas Soome  *
114b22b933Srs  * Unless required by applicable law or agreed to in writing, software
124b22b933Srs  * distributed under the License is distributed on an "AS IS" BASIS,
134b22b933Srs  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
144b22b933Srs  * See the License for the specific language governing permissions and
154b22b933Srs  * limitations under the License.
164b22b933Srs 
174b22b933Srs    NOTE:
184b22b933Srs    If you're building an application that uses DNS Service Discovery
194b22b933Srs    this is probably NOT the header file you're looking for.
204b22b933Srs    In most cases you will want to use /usr/include/dns_sd.h instead.
214b22b933Srs 
224b22b933Srs    This header file defines the lowest level raw interface to mDNSCore,
234b22b933Srs    which is appropriate *only* on tiny embedded systems where everything
244b22b933Srs    runs in a single address space and memory is extremely constrained.
254b22b933Srs    All the APIs here are malloc-free, which means that the caller is
264b22b933Srs    responsible for passing in a pointer to the relevant storage that
274b22b933Srs    will be used in the execution of that call, and (when called with
284b22b933Srs    correct parameters) all the calls are guaranteed to succeed. There
294b22b933Srs    is never a case where a call can suffer intermittent failures because
304b22b933Srs    the implementation calls malloc() and sometimes malloc() returns NULL
314b22b933Srs    because memory is so limited that no more is available.
324b22b933Srs    This is primarily for devices that need to have precisely known fixed
334b22b933Srs    memory requirements, with absolutely no uncertainty or run-time variation,
344b22b933Srs    but that certainty comes at a cost of more difficult programming.
355ffb0c9bSToomas Soome 
364b22b933Srs    For applications running on general-purpose desktop operating systems
374b22b933Srs    (Mac OS, Linux, Solaris, Windows, etc.) the API you should use is
384b22b933Srs    /usr/include/dns_sd.h, which defines the API by which multiple
394b22b933Srs    independent client processes communicate their DNS Service Discovery
404b22b933Srs    requests to a single "mdnsd" daemon running in the background.
415ffb0c9bSToomas Soome 
424b22b933Srs    Even on platforms that don't run multiple independent processes in
434b22b933Srs    multiple independent address spaces, you can still use the preferred
444b22b933Srs    dns_sd.h APIs by linking in "dnssd_clientshim.c", which implements
454b22b933Srs    the standard "dns_sd.h" API calls, allocates any required storage
464b22b933Srs    using malloc(), and then calls through to the low-level malloc-free
474b22b933Srs    mDNSCore routines defined here. This has the benefit that even though
484b22b933Srs    you're running on a small embedded system with a single address space,
494b22b933Srs    you can still use the exact same client C code as you'd use on a
504b22b933Srs    general-purpose desktop system.
514b22b933Srs 
525ffb0c9bSToomas Soome  */
534b22b933Srs 
545ffb0c9bSToomas Soome #ifndef __mDNSEmbeddedAPI_h
555ffb0c9bSToomas Soome #define __mDNSEmbeddedAPI_h
564b22b933Srs 
575ffb0c9bSToomas Soome #if defined(EFI32) || defined(EFI64) || defined(EFIX64)
585ffb0c9bSToomas Soome // EFI doesn't have stdarg.h unless it's building with GCC.
595ffb0c9bSToomas Soome #include "Tiano.h"
605ffb0c9bSToomas Soome #if !defined(__GNUC__)
615ffb0c9bSToomas Soome #define va_list         VA_LIST
625ffb0c9bSToomas Soome #define va_start(a, b)  VA_START(a, b)
635ffb0c9bSToomas Soome #define va_end(a)       VA_END(a)
645ffb0c9bSToomas Soome #define va_arg(a, b)    VA_ARG(a, b)
655ffb0c9bSToomas Soome #endif
665ffb0c9bSToomas Soome #else
675ffb0c9bSToomas Soome #include <stdarg.h>     // stdarg.h is required for for va_list support for the mDNS_vsnprintf declaration
685ffb0c9bSToomas Soome #endif
694b22b933Srs 
705ffb0c9bSToomas Soome #include "mDNSDebug.h"
715ffb0c9bSToomas Soome #if APPLE_OSX_mDNSResponder
725ffb0c9bSToomas Soome #include <uuid/uuid.h>
73cda73f64SToomas Soome #include <TargetConditionals.h>
745ffb0c9bSToomas Soome #endif
754b22b933Srs 
765ffb0c9bSToomas Soome #ifdef __cplusplus
775ffb0c9bSToomas Soome extern "C" {
785ffb0c9bSToomas Soome #endif
794b22b933Srs 
805ffb0c9bSToomas Soome // ***************************************************************************
815ffb0c9bSToomas Soome // Feature removal compile options & limited resource targets
824b22b933Srs 
835ffb0c9bSToomas Soome // The following compile options are responsible for removing certain features from mDNSCore to reduce the
845ffb0c9bSToomas Soome // memory footprint for use in embedded systems with limited resources.
854b22b933Srs 
865ffb0c9bSToomas Soome // UNICAST_DISABLED - disables unicast DNS functionality, including Wide Area Bonjour
875ffb0c9bSToomas Soome // ANONYMOUS_DISABLED - disables anonymous functionality
885ffb0c9bSToomas Soome // DNSSEC_DISABLED - disables DNSSEC functionality
895ffb0c9bSToomas Soome // SPC_DISABLED - disables Bonjour Sleep Proxy client
905ffb0c9bSToomas Soome // IDLESLEEPCONTROL_DISABLED - disables sleep control for Bonjour Sleep Proxy clients
914b22b933Srs 
925ffb0c9bSToomas Soome // In order to disable the above features pass the option to your compiler, e.g. -D UNICAST_DISABLED
934b22b933Srs 
94cda73f64SToomas Soome // Additionally, the LIMITED_RESOURCES_TARGET compile option will reduce the maximum DNS message sizes.
954b22b933Srs 
965ffb0c9bSToomas Soome #ifdef LIMITED_RESOURCES_TARGET
975ffb0c9bSToomas Soome // Don't support jumbo frames
98cda73f64SToomas Soome // 40 (IPv6 header) + 8 (UDP header) + 12 (DNS message header) + 1440 (DNS message body) = 1500 total
99c65ebfc7SToomas Soome #define AbsoluteMaxDNSMessageData   1440
1005ffb0c9bSToomas Soome // StandardAuthRDSize is 264 (256+8), which is large enough to hold a maximum-sized SRV record (6 + 256 bytes)
101c65ebfc7SToomas Soome #define MaximumRDSize               264
1024b22b933Srs #endif
1034b22b933Srs 
104*3b436d06SToomas Soome #if !defined(MDNSRESPONDER_BTMM_SUPPORT)
105*3b436d06SToomas Soome #define MDNSRESPONDER_BTMM_SUPPORT 0
106*3b436d06SToomas Soome #endif
107*3b436d06SToomas Soome 
1084b22b933Srs // ***************************************************************************
1094b22b933Srs // Function scope indicators
1104b22b933Srs 
1114b22b933Srs // If you see "mDNSlocal" before a function name in a C file, it means the function is not callable outside this file
1124b22b933Srs #ifndef mDNSlocal
1134b22b933Srs #define mDNSlocal static
1144b22b933Srs #endif
1154b22b933Srs // If you see "mDNSexport" before a symbol in a C file, it means the symbol is exported for use by clients
1164b22b933Srs // For every "mDNSexport" in a C file, there needs to be a corresponding "extern" declaration in some header file
1174b22b933Srs // (When a C file #includes a header file, the "extern" declarations tell the compiler:
1184b22b933Srs // "This symbol exists -- but not necessarily in this C file.")
1194b22b933Srs #ifndef mDNSexport
1204b22b933Srs #define mDNSexport
1214b22b933Srs #endif
1224b22b933Srs 
1234b22b933Srs // Explanation: These local/export markers are a little habit of mine for signaling the programmers' intentions.
1244b22b933Srs // When "mDNSlocal" is just a synonym for "static", and "mDNSexport" is a complete no-op, you could be
1254b22b933Srs // forgiven for asking what purpose they serve. The idea is that if you see "mDNSexport" in front of a
1264b22b933Srs // function definition it means the programmer intended it to be exported and callable from other files
1274b22b933Srs // in the project. If you see "mDNSlocal" in front of a function definition it means the programmer
1284b22b933Srs // intended it to be private to that file. If you see neither in front of a function definition it
1294b22b933Srs // means the programmer forgot (so you should work out which it is supposed to be, and fix it).
1304b22b933Srs // Using "mDNSlocal" instead of "static" makes it easier to do a textual searches for one or the other.
1314b22b933Srs // For example you can do a search for "static" to find if any functions declare any local variables as "static"
1324b22b933Srs // (generally a bad idea unless it's also "const", because static storage usually risks being non-thread-safe)
1334b22b933Srs // without the results being cluttered with hundreds of matches for functions declared static.
1344b22b933Srs // - Stuart Cheshire
1354b22b933Srs 
1364b22b933Srs // ***************************************************************************
1374b22b933Srs // Structure packing macro
1384b22b933Srs 
1394b22b933Srs // If we're not using GNUC, it's not fatal.
1404b22b933Srs // Most compilers naturally pack the on-the-wire structures correctly anyway, so a plain "struct" is usually fine.
1414b22b933Srs // In the event that structures are not packed correctly, mDNS_Init() will detect this and report an error, so the
1424b22b933Srs // developer will know what's wrong, and can investigate what needs to be done on that compiler to provide proper packing.
1434b22b933Srs #ifndef packedstruct
1444b22b933Srs  #if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))
1454b22b933Srs   #define packedstruct struct __attribute__((__packed__))
1464b22b933Srs   #define packedunion  union  __attribute__((__packed__))
1474b22b933Srs  #else
1484b22b933Srs   #define packedstruct struct
1494b22b933Srs   #define packedunion  union
1504b22b933Srs  #endif
1514b22b933Srs #endif
1524b22b933Srs 
1534b22b933Srs // ***************************************************************************
1544b22b933Srs #if 0
1554b22b933Srs #pragma mark - DNS Resource Record class and type constants
1564b22b933Srs #endif
1574b22b933Srs 
1585ffb0c9bSToomas Soome typedef enum                            // From RFC 1035
1595ffb0c9bSToomas Soome {
1605ffb0c9bSToomas Soome     kDNSClass_IN               = 1,     // Internet
1615ffb0c9bSToomas Soome     kDNSClass_CS               = 2,     // CSNET
1625ffb0c9bSToomas Soome     kDNSClass_CH               = 3,     // CHAOS
1635ffb0c9bSToomas Soome     kDNSClass_HS               = 4,     // Hesiod
1645ffb0c9bSToomas Soome     kDNSClass_NONE             = 254,   // Used in DNS UPDATE [RFC 2136]
1655ffb0c9bSToomas Soome 
1665ffb0c9bSToomas Soome     kDNSClass_Mask             = 0x7FFF, // Multicast DNS uses the bottom 15 bits to identify the record class...
1675ffb0c9bSToomas Soome     kDNSClass_UniqueRRSet      = 0x8000, // ... and the top bit indicates that all other cached records are now invalid
1685ffb0c9bSToomas Soome 
1695ffb0c9bSToomas Soome     kDNSQClass_ANY             = 255,   // Not a DNS class, but a DNS query class, meaning "all classes"
1705ffb0c9bSToomas Soome     kDNSQClass_UnicastResponse = 0x8000 // Top bit set in a question means "unicast response acceptable"
1715ffb0c9bSToomas Soome } DNS_ClassValues;
1725ffb0c9bSToomas Soome 
1735ffb0c9bSToomas Soome typedef enum                // From RFC 1035
1745ffb0c9bSToomas Soome {
1755ffb0c9bSToomas Soome     kDNSType_A = 1,         //  1 Address
1765ffb0c9bSToomas Soome     kDNSType_NS,            //  2 Name Server
1775ffb0c9bSToomas Soome     kDNSType_MD,            //  3 Mail Destination
1785ffb0c9bSToomas Soome     kDNSType_MF,            //  4 Mail Forwarder
1795ffb0c9bSToomas Soome     kDNSType_CNAME,         //  5 Canonical Name
1805ffb0c9bSToomas Soome     kDNSType_SOA,           //  6 Start of Authority
1815ffb0c9bSToomas Soome     kDNSType_MB,            //  7 Mailbox
1825ffb0c9bSToomas Soome     kDNSType_MG,            //  8 Mail Group
1835ffb0c9bSToomas Soome     kDNSType_MR,            //  9 Mail Rename
1845ffb0c9bSToomas Soome     kDNSType_NULL,          // 10 NULL RR
1855ffb0c9bSToomas Soome     kDNSType_WKS,           // 11 Well-known-service
1865ffb0c9bSToomas Soome     kDNSType_PTR,           // 12 Domain name pointer
1875ffb0c9bSToomas Soome     kDNSType_HINFO,         // 13 Host information
1885ffb0c9bSToomas Soome     kDNSType_MINFO,         // 14 Mailbox information
1895ffb0c9bSToomas Soome     kDNSType_MX,            // 15 Mail Exchanger
1905ffb0c9bSToomas Soome     kDNSType_TXT,           // 16 Arbitrary text string
1915ffb0c9bSToomas Soome     kDNSType_RP,            // 17 Responsible person
1925ffb0c9bSToomas Soome     kDNSType_AFSDB,         // 18 AFS cell database
1935ffb0c9bSToomas Soome     kDNSType_X25,           // 19 X_25 calling address
1945ffb0c9bSToomas Soome     kDNSType_ISDN,          // 20 ISDN calling address
1955ffb0c9bSToomas Soome     kDNSType_RT,            // 21 Router
1965ffb0c9bSToomas Soome     kDNSType_NSAP,          // 22 NSAP address
1975ffb0c9bSToomas Soome     kDNSType_NSAP_PTR,      // 23 Reverse NSAP lookup (deprecated)
1985ffb0c9bSToomas Soome     kDNSType_SIG,           // 24 Security signature
1995ffb0c9bSToomas Soome     kDNSType_KEY,           // 25 Security key
2005ffb0c9bSToomas Soome     kDNSType_PX,            // 26 X.400 mail mapping
2015ffb0c9bSToomas Soome     kDNSType_GPOS,          // 27 Geographical position (withdrawn)
2025ffb0c9bSToomas Soome     kDNSType_AAAA,          // 28 IPv6 Address
2035ffb0c9bSToomas Soome     kDNSType_LOC,           // 29 Location Information
2045ffb0c9bSToomas Soome     kDNSType_NXT,           // 30 Next domain (security)
2055ffb0c9bSToomas Soome     kDNSType_EID,           // 31 Endpoint identifier
2065ffb0c9bSToomas Soome     kDNSType_NIMLOC,        // 32 Nimrod Locator
2075ffb0c9bSToomas Soome     kDNSType_SRV,           // 33 Service record
2085ffb0c9bSToomas Soome     kDNSType_ATMA,          // 34 ATM Address
2095ffb0c9bSToomas Soome     kDNSType_NAPTR,         // 35 Naming Authority PoinTeR
2105ffb0c9bSToomas Soome     kDNSType_KX,            // 36 Key Exchange
2115ffb0c9bSToomas Soome     kDNSType_CERT,          // 37 Certification record
2125ffb0c9bSToomas Soome     kDNSType_A6,            // 38 IPv6 Address (deprecated)
2135ffb0c9bSToomas Soome     kDNSType_DNAME,         // 39 Non-terminal DNAME (for IPv6)
2145ffb0c9bSToomas Soome     kDNSType_SINK,          // 40 Kitchen sink (experimental)
2155ffb0c9bSToomas Soome     kDNSType_OPT,           // 41 EDNS0 option (meta-RR)
2165ffb0c9bSToomas Soome     kDNSType_APL,           // 42 Address Prefix List
2175ffb0c9bSToomas Soome     kDNSType_DS,            // 43 Delegation Signer
2185ffb0c9bSToomas Soome     kDNSType_SSHFP,         // 44 SSH Key Fingerprint
2195ffb0c9bSToomas Soome     kDNSType_IPSECKEY,      // 45 IPSECKEY
2205ffb0c9bSToomas Soome     kDNSType_RRSIG,         // 46 RRSIG
2215ffb0c9bSToomas Soome     kDNSType_NSEC,          // 47 Denial of Existence
2225ffb0c9bSToomas Soome     kDNSType_DNSKEY,        // 48 DNSKEY
2235ffb0c9bSToomas Soome     kDNSType_DHCID,         // 49 DHCP Client Identifier
2245ffb0c9bSToomas Soome     kDNSType_NSEC3,         // 50 Hashed Authenticated Denial of Existence
2255ffb0c9bSToomas Soome     kDNSType_NSEC3PARAM,    // 51 Hashed Authenticated Denial of Existence
2265ffb0c9bSToomas Soome 
2275ffb0c9bSToomas Soome     kDNSType_HIP = 55,      // 55 Host Identity Protocol
2285ffb0c9bSToomas Soome 
2295ffb0c9bSToomas Soome     kDNSType_SPF = 99,      // 99 Sender Policy Framework for E-Mail
2305ffb0c9bSToomas Soome     kDNSType_UINFO,         // 100 IANA-Reserved
2315ffb0c9bSToomas Soome     kDNSType_UID,           // 101 IANA-Reserved
2325ffb0c9bSToomas Soome     kDNSType_GID,           // 102 IANA-Reserved
2335ffb0c9bSToomas Soome     kDNSType_UNSPEC,        // 103 IANA-Reserved
2345ffb0c9bSToomas Soome 
2355ffb0c9bSToomas Soome     kDNSType_TKEY = 249,    // 249 Transaction key
2365ffb0c9bSToomas Soome     kDNSType_TSIG,          // 250 Transaction signature
2375ffb0c9bSToomas Soome     kDNSType_IXFR,          // 251 Incremental zone transfer
2385ffb0c9bSToomas Soome     kDNSType_AXFR,          // 252 Transfer zone of authority
2395ffb0c9bSToomas Soome     kDNSType_MAILB,         // 253 Transfer mailbox records
2405ffb0c9bSToomas Soome     kDNSType_MAILA,         // 254 Transfer mail agent records
2415ffb0c9bSToomas Soome     kDNSQType_ANY           // Not a DNS type, but a DNS query type, meaning "all types"
2425ffb0c9bSToomas Soome } DNS_TypeValues;
2434b22b933Srs 
2444b22b933Srs // ***************************************************************************
2454b22b933Srs #if 0
2465ffb0c9bSToomas Soome #pragma mark -
2474b22b933Srs #pragma mark - Simple types
2484b22b933Srs #endif
2494b22b933Srs 
2504b22b933Srs // mDNS defines its own names for these common types to simplify portability across
2514b22b933Srs // multiple platforms that may each have their own (different) names for these types.
2525ffb0c9bSToomas Soome typedef unsigned char mDNSBool;
2535ffb0c9bSToomas Soome typedef   signed char mDNSs8;
2545ffb0c9bSToomas Soome typedef unsigned char mDNSu8;
2554b22b933Srs typedef   signed short mDNSs16;
2564b22b933Srs typedef unsigned short mDNSu16;
2574b22b933Srs 
2585ffb0c9bSToomas Soome // Source: http://www.unix.org/version2/whatsnew/lp64_wp.html
2595ffb0c9bSToomas Soome // http://software.intel.com/sites/products/documentation/hpc/mkl/lin/MKL_UG_structure/Support_for_ILP64_Programming.htm
2605ffb0c9bSToomas Soome // It can be safely assumed that int is 32bits on the platform
2614b22b933Srs #if defined(_ILP64) || defined(__ILP64__)
2624b22b933Srs typedef   signed int32 mDNSs32;
2634b22b933Srs typedef unsigned int32 mDNSu32;
2644b22b933Srs #else
2655ffb0c9bSToomas Soome typedef   signed int mDNSs32;
2665ffb0c9bSToomas Soome typedef unsigned int mDNSu32;
2674b22b933Srs #endif
2684b22b933Srs 
2694b22b933Srs // To enforce useful type checking, we make mDNSInterfaceID be a pointer to a dummy struct
2704b22b933Srs // This way, mDNSInterfaceIDs can be assigned, and compared with each other, but not with other types
2714b22b933Srs // Declaring the type to be the typical generic "void *" would lack this type checking
2724b22b933Srs typedef struct mDNSInterfaceID_dummystruct { void *dummy; } *mDNSInterfaceID;
2734b22b933Srs 
2744b22b933Srs // These types are for opaque two- and four-byte identifiers.
2754b22b933Srs // The "NotAnInteger" fields of the unions allow the value to be conveniently passed around in a
2764b22b933Srs // register for the sake of efficiency, and compared for equality or inequality, but don't forget --
2774b22b933Srs // just because it is in a register doesn't mean it is an integer. Operations like greater than,
2784b22b933Srs // less than, add, multiply, increment, decrement, etc., are undefined for opaque identifiers,
2794b22b933Srs // and if you make the mistake of trying to do those using the NotAnInteger field, then you'll
2804b22b933Srs // find you get code that doesn't work consistently on big-endian and little-endian machines.
2815ffb0c9bSToomas Soome #if defined(_WIN32)
2825ffb0c9bSToomas Soome  #pragma pack(push,2)
283*3b436d06SToomas Soome #elif !defined(__GNUC__)
284*3b436d06SToomas Soome  #pragma pack(1)
2855ffb0c9bSToomas Soome #endif
2865ffb0c9bSToomas Soome typedef       union { mDNSu8 b[ 2]; mDNSu16 NotAnInteger; } mDNSOpaque16;
2875ffb0c9bSToomas Soome typedef       union { mDNSu8 b[ 4]; mDNSu32 NotAnInteger; } mDNSOpaque32;
2884b22b933Srs typedef packedunion { mDNSu8 b[ 6]; mDNSu16 w[3]; mDNSu32 l[1]; } mDNSOpaque48;
2895ffb0c9bSToomas Soome typedef       union { mDNSu8 b[ 8]; mDNSu16 w[4]; mDNSu32 l[2]; } mDNSOpaque64;
2905ffb0c9bSToomas Soome typedef       union { mDNSu8 b[16]; mDNSu16 w[8]; mDNSu32 l[4]; } mDNSOpaque128;
2915ffb0c9bSToomas Soome #if defined(_WIN32)
2925ffb0c9bSToomas Soome  #pragma pack(pop)
293*3b436d06SToomas Soome #elif !defined(__GNUC__)
294*3b436d06SToomas Soome  #pragma pack()
2955ffb0c9bSToomas Soome #endif
2965ffb0c9bSToomas Soome 
2975ffb0c9bSToomas Soome typedef mDNSOpaque16 mDNSIPPort;        // An IP port is a two-byte opaque identifier (not an integer)
2985ffb0c9bSToomas Soome typedef mDNSOpaque32 mDNSv4Addr;        // An IP address is a four-byte opaque identifier (not an integer)
2995ffb0c9bSToomas Soome typedef mDNSOpaque128 mDNSv6Addr;       // An IPv6 address is a 16-byte opaque identifier (not an integer)
3005ffb0c9bSToomas Soome typedef mDNSOpaque48 mDNSEthAddr;       // An Ethernet address is a six-byte opaque identifier (not an integer)
3014b22b933Srs 
3025ffb0c9bSToomas Soome // Bit operations for opaque 64 bit quantity. Uses the 32 bit quantity(l[2]) to set and clear bits
3035ffb0c9bSToomas Soome #define mDNSNBBY 8
3045ffb0c9bSToomas Soome #define bit_set_opaque64(op64, index) (op64.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] |= (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
3055ffb0c9bSToomas Soome #define bit_clr_opaque64(op64, index) (op64.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] &= ~(1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
3065ffb0c9bSToomas Soome #define bit_get_opaque64(op64, index) (op64.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] & (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
3074b22b933Srs 
308c65ebfc7SToomas Soome // Bit operations for opaque 128 bit quantity. Uses the 32 bit quantity(l[4]) to set and clear bits
309c65ebfc7SToomas Soome #define bit_set_opaque128(op128, index) (op128.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] |= (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
310c65ebfc7SToomas Soome #define bit_clr_opaque128(op128, index) (op128.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] &= ~(1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
311c65ebfc7SToomas Soome #define bit_get_opaque128(op128, index) (op128.l[((index))/(sizeof(mDNSu32) * mDNSNBBY)] & (1 << ((index) % (sizeof(mDNSu32) * mDNSNBBY))))
312c65ebfc7SToomas Soome 
313c65ebfc7SToomas Soome typedef enum
3145ffb0c9bSToomas Soome {
3155ffb0c9bSToomas Soome     mDNSAddrType_None    = 0,
3165ffb0c9bSToomas Soome     mDNSAddrType_IPv4    = 4,
3175ffb0c9bSToomas Soome     mDNSAddrType_IPv6    = 6,
3185ffb0c9bSToomas Soome     mDNSAddrType_Unknown = ~0   // Special marker value used in known answer list recording
319c65ebfc7SToomas Soome } mDNSAddr_Type;
3205ffb0c9bSToomas Soome 
321c65ebfc7SToomas Soome typedef enum
3225ffb0c9bSToomas Soome {
3235ffb0c9bSToomas Soome     mDNSTransport_None = 0,
3245ffb0c9bSToomas Soome     mDNSTransport_UDP  = 1,
3255ffb0c9bSToomas Soome     mDNSTransport_TCP  = 2
326c65ebfc7SToomas Soome } mDNSTransport_Type;
3274b22b933Srs 
3284b22b933Srs typedef struct
3295ffb0c9bSToomas Soome {
3305ffb0c9bSToomas Soome     mDNSs32 type;
3315ffb0c9bSToomas Soome     union { mDNSv6Addr v6; mDNSv4Addr v4; } ip;
3325ffb0c9bSToomas Soome } mDNSAddr;
3334b22b933Srs 
3344b22b933Srs enum { mDNSfalse = 0, mDNStrue = 1 };
3354b22b933Srs 
3364b22b933Srs #define mDNSNULL 0L
3374b22b933Srs 
3384b22b933Srs enum
3395ffb0c9bSToomas Soome {
3405ffb0c9bSToomas Soome     mStatus_Waiting           = 1,
3415ffb0c9bSToomas Soome     mStatus_NoError           = 0,
3425ffb0c9bSToomas Soome 
3435ffb0c9bSToomas Soome     // mDNS return values are in the range FFFE FF00 (-65792) to FFFE FFFF (-65537)
3445ffb0c9bSToomas Soome     // The top end of the range (FFFE FFFF) is used for error codes;
3455ffb0c9bSToomas Soome     // the bottom end of the range (FFFE FF00) is used for non-error values;
3465ffb0c9bSToomas Soome 
3475ffb0c9bSToomas Soome     // Error codes:
3485ffb0c9bSToomas Soome     mStatus_UnknownErr                = -65537,     // First value: 0xFFFE FFFF
3495ffb0c9bSToomas Soome     mStatus_NoSuchNameErr             = -65538,
3505ffb0c9bSToomas Soome     mStatus_NoMemoryErr               = -65539,
3515ffb0c9bSToomas Soome     mStatus_BadParamErr               = -65540,
3525ffb0c9bSToomas Soome     mStatus_BadReferenceErr           = -65541,
3535ffb0c9bSToomas Soome     mStatus_BadStateErr               = -65542,
3545ffb0c9bSToomas Soome     mStatus_BadFlagsErr               = -65543,
3555ffb0c9bSToomas Soome     mStatus_UnsupportedErr            = -65544,
3565ffb0c9bSToomas Soome     mStatus_NotInitializedErr         = -65545,
3575ffb0c9bSToomas Soome     mStatus_NoCache                   = -65546,
3585ffb0c9bSToomas Soome     mStatus_AlreadyRegistered         = -65547,
3595ffb0c9bSToomas Soome     mStatus_NameConflict              = -65548,
3605ffb0c9bSToomas Soome     mStatus_Invalid                   = -65549,
3615ffb0c9bSToomas Soome     mStatus_Firewall                  = -65550,
3625ffb0c9bSToomas Soome     mStatus_Incompatible              = -65551,
3635ffb0c9bSToomas Soome     mStatus_BadInterfaceErr           = -65552,
3645ffb0c9bSToomas Soome     mStatus_Refused                   = -65553,
3655ffb0c9bSToomas Soome     mStatus_NoSuchRecord              = -65554,
3665ffb0c9bSToomas Soome     mStatus_NoAuth                    = -65555,
3675ffb0c9bSToomas Soome     mStatus_NoSuchKey                 = -65556,
3685ffb0c9bSToomas Soome     mStatus_NATTraversal              = -65557,
3695ffb0c9bSToomas Soome     mStatus_DoubleNAT                 = -65558,
3705ffb0c9bSToomas Soome     mStatus_BadTime                   = -65559,
3715ffb0c9bSToomas Soome     mStatus_BadSig                    = -65560,     // while we define this per RFC 2845, BIND 9 returns Refused for bad/missing signatures
3725ffb0c9bSToomas Soome     mStatus_BadKey                    = -65561,
3735ffb0c9bSToomas Soome     mStatus_TransientErr              = -65562,     // transient failures, e.g. sending packets shortly after a network transition or wake from sleep
3745ffb0c9bSToomas Soome     mStatus_ServiceNotRunning         = -65563,     // Background daemon not running
3755ffb0c9bSToomas Soome     mStatus_NATPortMappingUnsupported = -65564,     // NAT doesn't support PCP, NAT-PMP or UPnP
3765ffb0c9bSToomas Soome     mStatus_NATPortMappingDisabled    = -65565,     // NAT supports PCP, NAT-PMP or UPnP, but it's disabled by the administrator
3775ffb0c9bSToomas Soome     mStatus_NoRouter                  = -65566,
3785ffb0c9bSToomas Soome     mStatus_PollingMode               = -65567,
3795ffb0c9bSToomas Soome     mStatus_Timeout                   = -65568,
380c65ebfc7SToomas Soome     mStatus_HostUnreachErr            = -65569,
381c65ebfc7SToomas Soome     // -65570 to -65786 currently unused; available for allocation
3825ffb0c9bSToomas Soome 
3835ffb0c9bSToomas Soome     // tcp connection status
3845ffb0c9bSToomas Soome     mStatus_ConnPending       = -65787,
3855ffb0c9bSToomas Soome     mStatus_ConnFailed        = -65788,
3865ffb0c9bSToomas Soome     mStatus_ConnEstablished   = -65789,
3875ffb0c9bSToomas Soome 
3885ffb0c9bSToomas Soome     // Non-error values:
3895ffb0c9bSToomas Soome     mStatus_GrowCache         = -65790,
3905ffb0c9bSToomas Soome     mStatus_ConfigChanged     = -65791,
3915ffb0c9bSToomas Soome     mStatus_MemFree           = -65792      // Last value: 0xFFFE FF00
3925ffb0c9bSToomas Soome                                 // mStatus_MemFree is the last legal mDNS error code, at the end of the range allocated for mDNS
3935ffb0c9bSToomas Soome };
3944b22b933Srs 
3954b22b933Srs typedef mDNSs32 mStatus;
3965ffb0c9bSToomas Soome #define MaxIp 5 // Needs to be consistent with MaxInputIf in dns_services.h
3975ffb0c9bSToomas Soome 
3985ffb0c9bSToomas Soome typedef enum { q_stop = 0, q_start } q_state;
3995ffb0c9bSToomas Soome typedef enum { reg_stop = 0, reg_start } reg_state;
4004b22b933Srs 
4014b22b933Srs // RFC 1034/1035 specify that a domain label consists of a length byte plus up to 63 characters
4024b22b933Srs #define MAX_DOMAIN_LABEL 63
4035ffb0c9bSToomas Soome typedef struct { mDNSu8 c[ 64]; } domainlabel;      // One label: length byte and up to 63 characters
4044b22b933Srs 
4055ffb0c9bSToomas Soome // RFC 1034/1035/2181 specify that a domain name (length bytes and data bytes) may be up to 255 bytes long,
4065ffb0c9bSToomas Soome // plus the terminating zero at the end makes 256 bytes total in the on-the-wire format.
4075ffb0c9bSToomas Soome #define MAX_DOMAIN_NAME 256
4085ffb0c9bSToomas Soome typedef struct { mDNSu8 c[256]; } domainname;       // Up to 256 bytes of length-prefixed domainlabels
4094b22b933Srs 
4105ffb0c9bSToomas Soome typedef struct { mDNSu8 c[256]; } UTF8str255;       // Null-terminated C string
4114b22b933Srs 
4125ffb0c9bSToomas Soome // The longest legal textual form of a DNS name is 1009 bytes, including the C-string terminating NULL at the end.
4134b22b933Srs // Explanation:
4144b22b933Srs // When a native domainname object is converted to printable textual form using ConvertDomainNameToCString(),
4154b22b933Srs // non-printing characters are represented in the conventional DNS way, as '\ddd', where ddd is a three-digit decimal number.
4165ffb0c9bSToomas Soome // The longest legal domain name is 256 bytes, in the form of four labels as shown below:
4175ffb0c9bSToomas Soome // Length byte, 63 data bytes, length byte, 63 data bytes, length byte, 63 data bytes, length byte, 62 data bytes, zero byte.
4184b22b933Srs // Each label is encoded textually as characters followed by a trailing dot.
4194b22b933Srs // If every character has to be represented as a four-byte escape sequence, then this makes the maximum textual form four labels
4204b22b933Srs // plus the C-string terminating NULL as shown below:
4215ffb0c9bSToomas Soome // 63*4+1 + 63*4+1 + 63*4+1 + 62*4+1 + 1 = 1009.
4224b22b933Srs // Note that MAX_ESCAPED_DOMAIN_LABEL is not normally used: If you're only decoding a single label, escaping is usually not required.
4234b22b933Srs // It is for domain names, where dots are used as label separators, that proper escaping is vital.
4244b22b933Srs #define MAX_ESCAPED_DOMAIN_LABEL 254
4255ffb0c9bSToomas Soome #define MAX_ESCAPED_DOMAIN_NAME 1009
4265ffb0c9bSToomas Soome 
4275ffb0c9bSToomas Soome // MAX_REVERSE_MAPPING_NAME
4285ffb0c9bSToomas Soome // For IPv4: "123.123.123.123.in-addr.arpa."  30 bytes including terminating NUL
4295ffb0c9bSToomas Soome // 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
4305ffb0c9bSToomas Soome 
4315ffb0c9bSToomas Soome #define MAX_REVERSE_MAPPING_NAME_V4 30
4325ffb0c9bSToomas Soome #define MAX_REVERSE_MAPPING_NAME_V6 74
4335ffb0c9bSToomas Soome #define MAX_REVERSE_MAPPING_NAME    74
4344b22b933Srs 
4354b22b933Srs // Most records have a TTL of 75 minutes, so that their 80% cache-renewal query occurs once per hour.
4364b22b933Srs // For records containing a hostname (in the name on the left, or in the rdata on the right),
4374b22b933Srs // like A, AAAA, reverse-mapping PTR, and SRV, we use a two-minute TTL by default, because we don't want
4384b22b933Srs // them to hang around for too long in the cache if the host in question crashes or otherwise goes away.
4395ffb0c9bSToomas Soome 
4404b22b933Srs #define kStandardTTL (3600UL * 100 / 80)
4414b22b933Srs #define kHostNameTTL 120UL
4425ffb0c9bSToomas Soome 
4435ffb0c9bSToomas Soome // Some applications want to register their SRV records with a lower ttl so that in case the server
4445ffb0c9bSToomas Soome // using a dynamic port number restarts, the clients will not have stale information for more than
4455ffb0c9bSToomas Soome // 10 seconds
4465ffb0c9bSToomas Soome 
4475ffb0c9bSToomas Soome #define kHostNameSmallTTL 10UL
4485ffb0c9bSToomas Soome 
4495ffb0c9bSToomas Soome 
4505ffb0c9bSToomas Soome // Multicast DNS uses announcements (gratuitous responses) to update peer caches.
4515ffb0c9bSToomas Soome // This means it is feasible to use relatively larger TTL values than we might otherwise
4525ffb0c9bSToomas Soome // use, because we have a cache coherency protocol to keep the peer caches up to date.
4535ffb0c9bSToomas Soome // With Unicast DNS, once an authoritative server gives a record with a certain TTL value to a client
4545ffb0c9bSToomas Soome // or caching server, that client or caching server is entitled to hold onto the record until its TTL
4555ffb0c9bSToomas Soome // expires, and has no obligation to contact the authoritative server again until that time arrives.
4565ffb0c9bSToomas Soome // This means that whereas Multicast DNS can use announcements to pre-emptively update stale data
4575ffb0c9bSToomas Soome // before it would otherwise have expired, standard Unicast DNS (not using LLQs) has no equivalent
4585ffb0c9bSToomas Soome // mechanism, and TTL expiry is the *only* mechanism by which stale data gets deleted. Because of this,
4595ffb0c9bSToomas Soome // we currently limit the TTL to ten seconds in such cases where no dynamic cache updating is possible.
4605ffb0c9bSToomas Soome #define kStaticCacheTTL 10
4614b22b933Srs 
4624b22b933Srs #define DefaultTTLforRRType(X) (((X) == kDNSType_A || (X) == kDNSType_AAAA || (X) == kDNSType_SRV) ? kHostNameTTL : kStandardTTL)
4635ffb0c9bSToomas Soome #define mDNS_KeepaliveRecord(rr) ((rr)->rrtype == kDNSType_NULL && SameDomainLabel(SecondLabel((rr)->name)->c, (mDNSu8 *)"\x0A_keepalive"))
4645ffb0c9bSToomas Soome 
4655ffb0c9bSToomas Soome // Number of times keepalives are sent if no ACK is received before waking up the system
4665ffb0c9bSToomas Soome // this is analogous to net.inet.tcp.keepcnt
4675ffb0c9bSToomas Soome #define kKeepaliveRetryCount    10
4685ffb0c9bSToomas Soome // The frequency at which keepalives are retried if no ACK is received
4695ffb0c9bSToomas Soome #define kKeepaliveRetryInterval 30
4705ffb0c9bSToomas Soome 
4715ffb0c9bSToomas Soome typedef struct AuthRecord_struct AuthRecord;
4725ffb0c9bSToomas Soome typedef struct ServiceRecordSet_struct ServiceRecordSet;
4735ffb0c9bSToomas Soome typedef struct CacheRecord_struct CacheRecord;
4745ffb0c9bSToomas Soome typedef struct CacheGroup_struct CacheGroup;
4755ffb0c9bSToomas Soome typedef struct AuthGroup_struct AuthGroup;
4765ffb0c9bSToomas Soome typedef struct DNSQuestion_struct DNSQuestion;
4775ffb0c9bSToomas Soome typedef struct ZoneData_struct ZoneData;
4785ffb0c9bSToomas Soome typedef struct mDNS_struct mDNS;
4795ffb0c9bSToomas Soome typedef struct mDNS_PlatformSupport_struct mDNS_PlatformSupport;
4805ffb0c9bSToomas Soome typedef struct NATTraversalInfo_struct NATTraversalInfo;
4815ffb0c9bSToomas Soome typedef struct ResourceRecord_struct ResourceRecord;
4825ffb0c9bSToomas Soome 
4835ffb0c9bSToomas Soome // Structure to abstract away the differences between TCP/SSL sockets, and one for UDP sockets
4845ffb0c9bSToomas Soome // The actual definition of these structures appear in the appropriate platform support code
4855ffb0c9bSToomas Soome typedef struct TCPSocket_struct TCPSocket;
4865ffb0c9bSToomas Soome typedef struct UDPSocket_struct UDPSocket;
4874b22b933Srs 
4884b22b933Srs // ***************************************************************************
4894b22b933Srs #if 0
4905ffb0c9bSToomas Soome #pragma mark -
4914b22b933Srs #pragma mark - DNS Message structures
4924b22b933Srs #endif
4934b22b933Srs 
4944b22b933Srs #define mDNS_numZones   numQuestions
4954b22b933Srs #define mDNS_numPrereqs numAnswers
4964b22b933Srs #define mDNS_numUpdates numAuthorities
4974b22b933Srs 
498c65ebfc7SToomas Soome typedef struct
4995ffb0c9bSToomas Soome {
5005ffb0c9bSToomas Soome     mDNSOpaque16 id;
5015ffb0c9bSToomas Soome     mDNSOpaque16 flags;
5025ffb0c9bSToomas Soome     mDNSu16 numQuestions;
5035ffb0c9bSToomas Soome     mDNSu16 numAnswers;
5045ffb0c9bSToomas Soome     mDNSu16 numAuthorities;
5055ffb0c9bSToomas Soome     mDNSu16 numAdditionals;
5065ffb0c9bSToomas Soome } DNSMessageHeader;
5074b22b933Srs 
5084b22b933Srs // We can send and receive packets up to 9000 bytes (Ethernet Jumbo Frame size, if that ever becomes widely used)
5094b22b933Srs // However, in the normal case we try to limit packets to 1500 bytes so that we don't get IP fragmentation on standard Ethernet
5104b22b933Srs // 40 (IPv6 header) + 8 (UDP header) + 12 (DNS message header) + 1440 (DNS message body) = 1500 total
5115ffb0c9bSToomas Soome #ifndef AbsoluteMaxDNSMessageData
5124b22b933Srs #define AbsoluteMaxDNSMessageData 8940
5135ffb0c9bSToomas Soome #endif
5144b22b933Srs #define NormalMaxDNSMessageData 1440
515c65ebfc7SToomas Soome typedef struct
5165ffb0c9bSToomas Soome {
5175ffb0c9bSToomas Soome     DNSMessageHeader h;                     // Note: Size 12 bytes
5185ffb0c9bSToomas Soome     mDNSu8 data[AbsoluteMaxDNSMessageData]; // 40 (IPv6) + 8 (UDP) + 12 (DNS header) + 8940 (data) = 9000
5195ffb0c9bSToomas Soome } DNSMessage;
5205ffb0c9bSToomas Soome 
5215ffb0c9bSToomas Soome typedef struct tcpInfo_t
5225ffb0c9bSToomas Soome {
5235ffb0c9bSToomas Soome     mDNS             *m;
5245ffb0c9bSToomas Soome     TCPSocket        *sock;
5255ffb0c9bSToomas Soome     DNSMessage request;
5265ffb0c9bSToomas Soome     int requestLen;
5275ffb0c9bSToomas Soome     DNSQuestion      *question;   // For queries
5285ffb0c9bSToomas Soome     AuthRecord       *rr;         // For record updates
5295ffb0c9bSToomas Soome     mDNSAddr Addr;
5305ffb0c9bSToomas Soome     mDNSIPPort Port;
5315ffb0c9bSToomas Soome     mDNSIPPort SrcPort;
5325ffb0c9bSToomas Soome     DNSMessage       *reply;
5335ffb0c9bSToomas Soome     mDNSu16 replylen;
5345ffb0c9bSToomas Soome     unsigned long nread;
5355ffb0c9bSToomas Soome     int numReplies;
5365ffb0c9bSToomas Soome } tcpInfo_t;
5375ffb0c9bSToomas Soome 
5385ffb0c9bSToomas Soome // ***************************************************************************
5395ffb0c9bSToomas Soome #if 0
5405ffb0c9bSToomas Soome #pragma mark -
5415ffb0c9bSToomas Soome #pragma mark - Other Packet Format Structures
5425ffb0c9bSToomas Soome #endif
5435ffb0c9bSToomas Soome 
5445ffb0c9bSToomas Soome typedef packedstruct
5455ffb0c9bSToomas Soome {
5465ffb0c9bSToomas Soome     mDNSEthAddr dst;
5475ffb0c9bSToomas Soome     mDNSEthAddr src;
5485ffb0c9bSToomas Soome     mDNSOpaque16 ethertype;
5495ffb0c9bSToomas Soome } EthernetHeader;           // 14 bytes
5505ffb0c9bSToomas Soome 
5515ffb0c9bSToomas Soome typedef packedstruct
5525ffb0c9bSToomas Soome {
5535ffb0c9bSToomas Soome     mDNSOpaque16 hrd;
5545ffb0c9bSToomas Soome     mDNSOpaque16 pro;
5555ffb0c9bSToomas Soome     mDNSu8 hln;
5565ffb0c9bSToomas Soome     mDNSu8 pln;
5575ffb0c9bSToomas Soome     mDNSOpaque16 op;
5585ffb0c9bSToomas Soome     mDNSEthAddr sha;
5595ffb0c9bSToomas Soome     mDNSv4Addr spa;
5605ffb0c9bSToomas Soome     mDNSEthAddr tha;
5615ffb0c9bSToomas Soome     mDNSv4Addr tpa;
5625ffb0c9bSToomas Soome } ARP_EthIP;                // 28 bytes
5635ffb0c9bSToomas Soome 
5645ffb0c9bSToomas Soome typedef packedstruct
5655ffb0c9bSToomas Soome {
5665ffb0c9bSToomas Soome     mDNSu8 vlen;
5675ffb0c9bSToomas Soome     mDNSu8 tos;
568cda73f64SToomas Soome     mDNSOpaque16 totlen;
5695ffb0c9bSToomas Soome     mDNSOpaque16 id;
5705ffb0c9bSToomas Soome     mDNSOpaque16 flagsfrags;
5715ffb0c9bSToomas Soome     mDNSu8 ttl;
5725ffb0c9bSToomas Soome     mDNSu8 protocol;        // Payload type: 0x06 = TCP, 0x11 = UDP
5735ffb0c9bSToomas Soome     mDNSu16 checksum;
5745ffb0c9bSToomas Soome     mDNSv4Addr src;
5755ffb0c9bSToomas Soome     mDNSv4Addr dst;
5765ffb0c9bSToomas Soome } IPv4Header;               // 20 bytes
5775ffb0c9bSToomas Soome 
5785ffb0c9bSToomas Soome typedef packedstruct
5795ffb0c9bSToomas Soome {
5805ffb0c9bSToomas Soome     mDNSu32 vcf;            // Version, Traffic Class, Flow Label
5815ffb0c9bSToomas Soome     mDNSu16 len;            // Payload Length
5825ffb0c9bSToomas Soome     mDNSu8 pro;             // Type of next header: 0x06 = TCP, 0x11 = UDP, 0x3A = ICMPv6
5835ffb0c9bSToomas Soome     mDNSu8 ttl;             // Hop Limit
5845ffb0c9bSToomas Soome     mDNSv6Addr src;
5855ffb0c9bSToomas Soome     mDNSv6Addr dst;
5865ffb0c9bSToomas Soome } IPv6Header;               // 40 bytes
5875ffb0c9bSToomas Soome 
5885ffb0c9bSToomas Soome typedef packedstruct
5895ffb0c9bSToomas Soome {
5905ffb0c9bSToomas Soome     mDNSv6Addr src;
5915ffb0c9bSToomas Soome     mDNSv6Addr dst;
5925ffb0c9bSToomas Soome     mDNSOpaque32 len;
5935ffb0c9bSToomas Soome     mDNSOpaque32 pro;
5945ffb0c9bSToomas Soome } IPv6PseudoHeader;         // 40 bytes
5955ffb0c9bSToomas Soome 
5965ffb0c9bSToomas Soome typedef union
5975ffb0c9bSToomas Soome {
5985ffb0c9bSToomas Soome     mDNSu8 bytes[20];
5995ffb0c9bSToomas Soome     ARP_EthIP arp;
6005ffb0c9bSToomas Soome     IPv4Header v4;
6015ffb0c9bSToomas Soome     IPv6Header v6;
6025ffb0c9bSToomas Soome } NetworkLayerPacket;
6035ffb0c9bSToomas Soome 
6045ffb0c9bSToomas Soome typedef packedstruct
6055ffb0c9bSToomas Soome {
6065ffb0c9bSToomas Soome     mDNSIPPort src;
6075ffb0c9bSToomas Soome     mDNSIPPort dst;
6085ffb0c9bSToomas Soome     mDNSu32 seq;
6095ffb0c9bSToomas Soome     mDNSu32 ack;
6105ffb0c9bSToomas Soome     mDNSu8 offset;
6115ffb0c9bSToomas Soome     mDNSu8 flags;
6125ffb0c9bSToomas Soome     mDNSu16 window;
6135ffb0c9bSToomas Soome     mDNSu16 checksum;
6145ffb0c9bSToomas Soome     mDNSu16 urgent;
6155ffb0c9bSToomas Soome } TCPHeader;                // 20 bytes; IP protocol type 0x06
6165ffb0c9bSToomas Soome 
6175ffb0c9bSToomas Soome typedef struct
6185ffb0c9bSToomas Soome {
6195ffb0c9bSToomas Soome     mDNSInterfaceID IntfId;
6205ffb0c9bSToomas Soome     mDNSu32 seq;
6215ffb0c9bSToomas Soome     mDNSu32 ack;
6225ffb0c9bSToomas Soome     mDNSu16 window;
6235ffb0c9bSToomas Soome } mDNSTCPInfo;
6245ffb0c9bSToomas Soome 
6255ffb0c9bSToomas Soome typedef packedstruct
6265ffb0c9bSToomas Soome {
6275ffb0c9bSToomas Soome     mDNSIPPort src;
6285ffb0c9bSToomas Soome     mDNSIPPort dst;
6295ffb0c9bSToomas Soome     mDNSu16 len;            // Length including UDP header (i.e. minimum value is 8 bytes)
6305ffb0c9bSToomas Soome     mDNSu16 checksum;
6315ffb0c9bSToomas Soome } UDPHeader;                // 8 bytes; IP protocol type 0x11
6325ffb0c9bSToomas Soome 
633c65ebfc7SToomas Soome typedef struct
6345ffb0c9bSToomas Soome {
6355ffb0c9bSToomas Soome     mDNSu8 type;            // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement
6365ffb0c9bSToomas Soome     mDNSu8 code;
6375ffb0c9bSToomas Soome     mDNSu16 checksum;
6385ffb0c9bSToomas Soome     mDNSu32 flags_res;      // R/S/O flags and reserved bits
6395ffb0c9bSToomas Soome     mDNSv6Addr target;
6405ffb0c9bSToomas Soome     // Typically 8 bytes of options are also present
6415ffb0c9bSToomas Soome } IPv6NDP;                  // 24 bytes or more; IP protocol type 0x3A
6425ffb0c9bSToomas Soome 
6435ffb0c9bSToomas Soome typedef struct
6445ffb0c9bSToomas Soome {
6455ffb0c9bSToomas Soome     mDNSAddr    ipaddr;
6465ffb0c9bSToomas Soome     char        ethaddr[18];
6475ffb0c9bSToomas Soome } IPAddressMACMapping;
6485ffb0c9bSToomas Soome 
6495ffb0c9bSToomas Soome #define NDP_Sol 0x87
6505ffb0c9bSToomas Soome #define NDP_Adv 0x88
6515ffb0c9bSToomas Soome 
6525ffb0c9bSToomas Soome #define NDP_Router    0x80
6535ffb0c9bSToomas Soome #define NDP_Solicited 0x40
6545ffb0c9bSToomas Soome #define NDP_Override  0x20
6555ffb0c9bSToomas Soome 
6565ffb0c9bSToomas Soome #define NDP_SrcLL 1
6575ffb0c9bSToomas Soome #define NDP_TgtLL 2
6585ffb0c9bSToomas Soome 
6595ffb0c9bSToomas Soome typedef union
6605ffb0c9bSToomas Soome {
6615ffb0c9bSToomas Soome     mDNSu8 bytes[20];
6625ffb0c9bSToomas Soome     TCPHeader tcp;
6635ffb0c9bSToomas Soome     UDPHeader udp;
6645ffb0c9bSToomas Soome     IPv6NDP ndp;
6655ffb0c9bSToomas Soome } TransportLayerPacket;
6665ffb0c9bSToomas Soome 
6675ffb0c9bSToomas Soome typedef packedstruct
6685ffb0c9bSToomas Soome {
6695ffb0c9bSToomas Soome     mDNSOpaque64 InitiatorCookie;
6705ffb0c9bSToomas Soome     mDNSOpaque64 ResponderCookie;
6715ffb0c9bSToomas Soome     mDNSu8 NextPayload;
6725ffb0c9bSToomas Soome     mDNSu8 Version;
6735ffb0c9bSToomas Soome     mDNSu8 ExchangeType;
6745ffb0c9bSToomas Soome     mDNSu8 Flags;
6755ffb0c9bSToomas Soome     mDNSOpaque32 MessageID;
6765ffb0c9bSToomas Soome     mDNSu32 Length;
6775ffb0c9bSToomas Soome } IKEHeader;                // 28 bytes
6784b22b933Srs 
6794b22b933Srs // ***************************************************************************
6804b22b933Srs #if 0
6815ffb0c9bSToomas Soome #pragma mark -
6824b22b933Srs #pragma mark - Resource Record structures
6834b22b933Srs #endif
6844b22b933Srs 
6854b22b933Srs // Authoritative Resource Records:
6864b22b933Srs // There are four basic types: Shared, Advisory, Unique, Known Unique
6874b22b933Srs 
6884b22b933Srs // * Shared Resource Records do not have to be unique
6894b22b933Srs // -- Shared Resource Records are used for DNS-SD service PTRs
6904b22b933Srs // -- It is okay for several hosts to have RRs with the same name but different RDATA
6914b22b933Srs // -- We use a random delay on responses to reduce collisions when all the hosts respond to the same query
6924b22b933Srs // -- These RRs typically have moderately high TTLs (e.g. one hour)
6934b22b933Srs // -- These records are announced on startup and topology changes for the benefit of passive listeners
6944b22b933Srs // -- These records send a goodbye packet when deregistering
6954b22b933Srs //
6964b22b933Srs // * Advisory Resource Records are like Shared Resource Records, except they don't send a goodbye packet
6974b22b933Srs //
6984b22b933Srs // * Unique Resource Records should be unique among hosts within any given mDNS scope
6994b22b933Srs // -- The majority of Resource Records are of this type
7004b22b933Srs // -- If two entities on the network have RRs with the same name but different RDATA, this is a conflict
7014b22b933Srs // -- Responses may be sent immediately, because only one host should be responding to any particular query
7024b22b933Srs // -- These RRs typically have low TTLs (e.g. a few minutes)
7034b22b933Srs // -- On startup and after topology changes, a host issues queries to verify uniqueness
7044b22b933Srs 
7054b22b933Srs // * Known Unique Resource Records are treated like Unique Resource Records, except that mDNS does
7064b22b933Srs // not have to verify their uniqueness because this is already known by other means (e.g. the RR name
7074b22b933Srs // is derived from the host's IP or Ethernet address, which is already known to be a unique identifier).
7084b22b933Srs 
7094b22b933Srs // Summary of properties of different record types:
7104b22b933Srs // Probe?    Does this record type send probes before announcing?
7114b22b933Srs // Conflict? Does this record type react if we observe an apparent conflict?
7124b22b933Srs // Goodbye?  Does this record type send a goodbye packet on departure?
7134b22b933Srs //
7144b22b933Srs //               Probe? Conflict? Goodbye? Notes
7154b22b933Srs // Unregistered                            Should not appear in any list (sanity check value)
7164b22b933Srs // Shared         No      No       Yes     e.g. Service PTR record
7174b22b933Srs // Deregistering  No      No       Yes     Shared record about to announce its departure and leave the list
7184b22b933Srs // Advisory       No      No       No
7194b22b933Srs // Unique         Yes     Yes      No      Record intended to be unique -- will probe to verify
7204b22b933Srs // Verified       Yes     Yes      No      Record has completed probing, and is verified unique
7214b22b933Srs // KnownUnique    No      Yes      No      Record is assumed by other means to be unique
7224b22b933Srs 
7234b22b933Srs // Valid lifecycle of a record:
7244b22b933Srs // Unregistered ->                   Shared      -> Deregistering -(goodbye)-> Unregistered
7254b22b933Srs // Unregistered ->                   Advisory                               -> Unregistered
7264b22b933Srs // Unregistered -> Unique -(probe)-> Verified                               -> Unregistered
7274b22b933Srs // Unregistered ->                   KnownUnique                            -> Unregistered
7284b22b933Srs 
7294b22b933Srs // Each Authoritative kDNSRecordType has only one bit set. This makes it easy to quickly see if a record
7304b22b933Srs // is one of a particular set of types simply by performing the appropriate bitwise masking operation.
7314b22b933Srs 
7325ffb0c9bSToomas Soome // Cache Resource Records (received from the network):
7335ffb0c9bSToomas Soome // There are four basic types: Answer, Unique Answer, Additional, Unique Additional
7345ffb0c9bSToomas Soome // Bit 7 (the top bit) of kDNSRecordType is always set for Cache Resource Records; always clear for Authoritative Resource Records
7355ffb0c9bSToomas Soome // Bit 6 (value 0x40) is set for answer records; clear for authority/additional records
7365ffb0c9bSToomas Soome // Bit 5 (value 0x20) is set for records received with the kDNSClass_UniqueRRSet
7375ffb0c9bSToomas Soome 
738c65ebfc7SToomas Soome typedef enum
7395ffb0c9bSToomas Soome {
7405ffb0c9bSToomas Soome     kDNSRecordTypeUnregistered     = 0x00,  // Not currently in any list
7415ffb0c9bSToomas Soome     kDNSRecordTypeDeregistering    = 0x01,  // Shared record about to announce its departure and leave the list
7425ffb0c9bSToomas Soome 
7435ffb0c9bSToomas Soome     kDNSRecordTypeUnique           = 0x02,  // Will become a kDNSRecordTypeVerified when probing is complete
7445ffb0c9bSToomas Soome 
7455ffb0c9bSToomas Soome     kDNSRecordTypeAdvisory         = 0x04,  // Like Shared, but no goodbye packet
7465ffb0c9bSToomas Soome     kDNSRecordTypeShared           = 0x08,  // Shared means record name does not have to be unique -- use random delay on responses
7475ffb0c9bSToomas Soome 
7485ffb0c9bSToomas Soome     kDNSRecordTypeVerified         = 0x10,  // Unique means mDNS should check that name is unique (and then send immediate responses)
7495ffb0c9bSToomas Soome     kDNSRecordTypeKnownUnique      = 0x20,  // Known Unique means mDNS can assume name is unique without checking
7505ffb0c9bSToomas Soome                                             // For Dynamic Update records, Known Unique means the record must already exist on the server.
7515ffb0c9bSToomas Soome     kDNSRecordTypeUniqueMask       = (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique),
7525ffb0c9bSToomas Soome     kDNSRecordTypeActiveSharedMask = (kDNSRecordTypeAdvisory         | kDNSRecordTypeShared),
7535ffb0c9bSToomas Soome     kDNSRecordTypeActiveUniqueMask = (kDNSRecordTypeVerified         | kDNSRecordTypeKnownUnique),
7545ffb0c9bSToomas Soome     kDNSRecordTypeActiveMask       = (kDNSRecordTypeActiveSharedMask | kDNSRecordTypeActiveUniqueMask),
7555ffb0c9bSToomas Soome 
7565ffb0c9bSToomas Soome     kDNSRecordTypePacketAdd        = 0x80,  // Received in the Additional  Section of a DNS Response
7575ffb0c9bSToomas Soome     kDNSRecordTypePacketAddUnique  = 0x90,  // Received in the Additional  Section of a DNS Response with kDNSClass_UniqueRRSet set
7585ffb0c9bSToomas Soome     kDNSRecordTypePacketAuth       = 0xA0,  // Received in the Authorities Section of a DNS Response
7595ffb0c9bSToomas Soome     kDNSRecordTypePacketAuthUnique = 0xB0,  // Received in the Authorities Section of a DNS Response with kDNSClass_UniqueRRSet set
7605ffb0c9bSToomas Soome     kDNSRecordTypePacketAns        = 0xC0,  // Received in the Answer      Section of a DNS Response
7615ffb0c9bSToomas Soome     kDNSRecordTypePacketAnsUnique  = 0xD0,  // Received in the Answer      Section of a DNS Response with kDNSClass_UniqueRRSet set
7625ffb0c9bSToomas Soome 
7635ffb0c9bSToomas Soome     kDNSRecordTypePacketNegative   = 0xF0,  // Pseudo-RR generated to cache non-existence results like NXDomain
7645ffb0c9bSToomas Soome 
7655ffb0c9bSToomas Soome     kDNSRecordTypePacketUniqueMask = 0x10   // True for PacketAddUnique, PacketAnsUnique, PacketAuthUnique, kDNSRecordTypePacketNegative
766c65ebfc7SToomas Soome } kDNSRecordTypes;
7675ffb0c9bSToomas Soome 
7685ffb0c9bSToomas Soome typedef packedstruct { mDNSu16 priority; mDNSu16 weight; mDNSIPPort port; domainname target;   } rdataSRV;
7695ffb0c9bSToomas Soome typedef packedstruct { mDNSu16 preference;                                domainname exchange; } rdataMX;
7705ffb0c9bSToomas Soome typedef packedstruct { domainname mbox; domainname txt;                                        } rdataRP;
7715ffb0c9bSToomas Soome typedef packedstruct { mDNSu16 preference; domainname map822; domainname mapx400;              } rdataPX;
7725ffb0c9bSToomas Soome 
7735ffb0c9bSToomas Soome typedef packedstruct
7745ffb0c9bSToomas Soome {
7755ffb0c9bSToomas Soome     domainname mname;
7765ffb0c9bSToomas Soome     domainname rname;
7775ffb0c9bSToomas Soome     mDNSs32 serial;     // Modular counter; increases when zone changes
7785ffb0c9bSToomas Soome     mDNSu32 refresh;    // Time in seconds that a slave waits after successful replication of the database before it attempts replication again
7795ffb0c9bSToomas Soome     mDNSu32 retry;      // Time in seconds that a slave waits after an unsuccessful replication attempt before it attempts replication again
7805ffb0c9bSToomas Soome     mDNSu32 expire;     // Time in seconds that a slave holds on to old data while replication attempts remain unsuccessful
7815ffb0c9bSToomas Soome     mDNSu32 min;        // Nominally the minimum record TTL for this zone, in seconds; also used for negative caching.
7825ffb0c9bSToomas Soome } rdataSOA;
7835ffb0c9bSToomas Soome 
7845ffb0c9bSToomas Soome // http://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
7855ffb0c9bSToomas Soome // Algorithm used for RRSIG, DS and DNS KEY
7865ffb0c9bSToomas Soome #define CRYPTO_RSA_SHA1             0x05
7875ffb0c9bSToomas Soome #define CRYPTO_DSA_NSEC3_SHA1       0x06
7885ffb0c9bSToomas Soome #define CRYPTO_RSA_NSEC3_SHA1       0x07
7895ffb0c9bSToomas Soome #define CRYPTO_RSA_SHA256           0x08
7905ffb0c9bSToomas Soome #define CRYPTO_RSA_SHA512           0x0A
7915ffb0c9bSToomas Soome 
7925ffb0c9bSToomas Soome #define CRYPTO_ALG_MAX              0x0B
7935ffb0c9bSToomas Soome 
7945ffb0c9bSToomas Soome // alg - same as in RRSIG, DNS KEY or DS.
7955ffb0c9bSToomas Soome // RFC 4034 defines SHA1
7965ffb0c9bSToomas Soome // RFC 4509 defines SHA256
7975ffb0c9bSToomas Soome // Note: NSEC3 also uses 1 for SHA1 and hence we will reuse for now till a new
7985ffb0c9bSToomas Soome // value is assigned.
7995ffb0c9bSToomas Soome //
8005ffb0c9bSToomas Soome #define SHA1_DIGEST_TYPE        1
8015ffb0c9bSToomas Soome #define SHA256_DIGEST_TYPE      2
8025ffb0c9bSToomas Soome #define DIGEST_TYPE_MAX         3
8035ffb0c9bSToomas Soome 
8045ffb0c9bSToomas Soome // We need support for base64 and base32 encoding for displaying KEY, NSEC3
8055ffb0c9bSToomas Soome // To make this platform agnostic, we define two types which the platform
8065ffb0c9bSToomas Soome // needs to support
8075ffb0c9bSToomas Soome #define ENC_BASE32              1
8085ffb0c9bSToomas Soome #define ENC_BASE64              2
8095ffb0c9bSToomas Soome #define ENC_ALG_MAX             3
8105ffb0c9bSToomas Soome 
8115ffb0c9bSToomas Soome #define DS_FIXED_SIZE           4
8125ffb0c9bSToomas Soome typedef packedstruct
8135ffb0c9bSToomas Soome {
8145ffb0c9bSToomas Soome     mDNSu16 keyTag;
8155ffb0c9bSToomas Soome     mDNSu8 alg;
8165ffb0c9bSToomas Soome     mDNSu8 digestType;
8175ffb0c9bSToomas Soome     mDNSu8  *digest;
8185ffb0c9bSToomas Soome } rdataDS;
8195ffb0c9bSToomas Soome 
8205ffb0c9bSToomas Soome typedef struct TrustAnchor
8215ffb0c9bSToomas Soome {
8225ffb0c9bSToomas Soome     struct TrustAnchor *next;
8235ffb0c9bSToomas Soome     int digestLen;
8245ffb0c9bSToomas Soome     mDNSu32 validFrom;
825c65ebfc7SToomas Soome     mDNSu32 validUntil;
8265ffb0c9bSToomas Soome     domainname zone;
8275ffb0c9bSToomas Soome     rdataDS rds;
8285ffb0c9bSToomas Soome } TrustAnchor;
8295ffb0c9bSToomas Soome 
8305ffb0c9bSToomas Soome //size of rdataRRSIG excluding signerName and signature (which are variable fields)
8315ffb0c9bSToomas Soome #define RRSIG_FIXED_SIZE      18
832c65ebfc7SToomas Soome typedef struct
8335ffb0c9bSToomas Soome {
8345ffb0c9bSToomas Soome     mDNSu16 typeCovered;
8355ffb0c9bSToomas Soome     mDNSu8 alg;
8365ffb0c9bSToomas Soome     mDNSu8 labels;
8375ffb0c9bSToomas Soome     mDNSu32 origTTL;
8385ffb0c9bSToomas Soome     mDNSu32 sigExpireTime;
8395ffb0c9bSToomas Soome     mDNSu32 sigInceptTime;
8405ffb0c9bSToomas Soome     mDNSu16 keyTag;
841c65ebfc7SToomas Soome     mDNSu8  signerName[1]; // signerName is a dynamically-sized array
8425ffb0c9bSToomas Soome     // mDNSu8 *signature
8435ffb0c9bSToomas Soome } rdataRRSig;
8445ffb0c9bSToomas Soome 
8455ffb0c9bSToomas Soome // RFC 4034: For DNS Key RR
8465ffb0c9bSToomas Soome // flags - the valid value for DNSSEC is 256 (Zone signing key - ZSK) and 257 (Secure Entry Point) which also
8475ffb0c9bSToomas Soome // includes the ZSK bit
8485ffb0c9bSToomas Soome //
8495ffb0c9bSToomas Soome #define DNSKEY_ZONE_SIGN_KEY        0x100
8505ffb0c9bSToomas Soome #define DNSKEY_SECURE_ENTRY_POINT   0x101
8515ffb0c9bSToomas Soome 
8525ffb0c9bSToomas Soome // proto - the only valid value for protocol is 3 (See RFC 4034)
8535ffb0c9bSToomas Soome #define DNSKEY_VALID_PROTO_VALUE    0x003
8545ffb0c9bSToomas Soome 
8555ffb0c9bSToomas Soome // alg - The only mandatory algorithm that we support is RSA/SHA-1
8565ffb0c9bSToomas Soome // DNSSEC_RSA_SHA1_ALG
8575ffb0c9bSToomas Soome 
8585ffb0c9bSToomas Soome #define DNSKEY_FIXED_SIZE          4
8595ffb0c9bSToomas Soome typedef packedstruct
8605ffb0c9bSToomas Soome {
8615ffb0c9bSToomas Soome     mDNSu16 flags;
8625ffb0c9bSToomas Soome     mDNSu8 proto;
8635ffb0c9bSToomas Soome     mDNSu8 alg;
8645ffb0c9bSToomas Soome     mDNSu8  *data;
8655ffb0c9bSToomas Soome } rdataDNSKey;
8665ffb0c9bSToomas Soome 
8675ffb0c9bSToomas Soome #define NSEC3_FIXED_SIZE          5
8685ffb0c9bSToomas Soome #define NSEC3_FLAGS_OPTOUT        1
8695ffb0c9bSToomas Soome #define NSEC3_MAX_ITERATIONS      2500
8705ffb0c9bSToomas Soome typedef packedstruct
8715ffb0c9bSToomas Soome {
8725ffb0c9bSToomas Soome     mDNSu8 alg;
8735ffb0c9bSToomas Soome     mDNSu8 flags;
8745ffb0c9bSToomas Soome     mDNSu16 iterations;
8755ffb0c9bSToomas Soome     mDNSu8 saltLength;
8765ffb0c9bSToomas Soome     mDNSu8 *salt;
8775ffb0c9bSToomas Soome     // hashLength, nxt, bitmap
8785ffb0c9bSToomas Soome } rdataNSEC3;
8795ffb0c9bSToomas Soome 
8805ffb0c9bSToomas Soome // In the multicast usage of NSEC3, we know the actual size of RData
8815ffb0c9bSToomas Soome // 4 bytes : HashAlg, Flags,Iterations
8825ffb0c9bSToomas Soome // 5 bytes : Salt Length 1 byte, Salt 4 bytes
8835ffb0c9bSToomas Soome // 21 bytes : HashLength 1 byte, Hash 20 bytes
8845ffb0c9bSToomas Soome // 34 bytes : Window number, Bitmap length, Type bit map to include the first 256 types
8855ffb0c9bSToomas Soome #define MCAST_NSEC3_RDLENGTH (4 + 5 + 21 + 34)
8865ffb0c9bSToomas Soome #define SHA1_HASH_LENGTH 20
8875ffb0c9bSToomas Soome 
8885ffb0c9bSToomas Soome // Base32 encoding takes 5 bytes of the input and encodes as 8 bytes of output.
8895ffb0c9bSToomas Soome // For example, SHA-1 hash of 20 bytes will be encoded as 20/5 * 8 = 32 base32
8905ffb0c9bSToomas Soome // bytes. For a max domain name size of 255 bytes of base32 encoding : (255/8)*5
8915ffb0c9bSToomas Soome // is the max hash length possible.
892c65ebfc7SToomas Soome #define NSEC3_MAX_HASH_LEN  155
8935ffb0c9bSToomas Soome // In NSEC3, the names are hashed and stored in the first label and hence cannot exceed label
8945ffb0c9bSToomas Soome // size.
895c65ebfc7SToomas Soome #define NSEC3_MAX_B32_LEN   MAX_DOMAIN_LABEL
8965ffb0c9bSToomas Soome 
8975ffb0c9bSToomas Soome // We define it here instead of dnssec.h so that these values can be used
8985ffb0c9bSToomas Soome // in files without bringing in all of dnssec.h unnecessarily.
8995ffb0c9bSToomas Soome typedef enum
9005ffb0c9bSToomas Soome {
9015ffb0c9bSToomas Soome     DNSSEC_Secure = 1,      // Securely validated and has a chain up to the trust anchor
9025ffb0c9bSToomas Soome     DNSSEC_Insecure,        // Cannot build a chain up to the trust anchor
9035ffb0c9bSToomas Soome     DNSSEC_Indeterminate,   // Not used currently
9045ffb0c9bSToomas Soome     DNSSEC_Bogus,           // failed to validate signatures
9055ffb0c9bSToomas Soome     DNSSEC_NoResponse       // No DNSSEC records to start with
9065ffb0c9bSToomas Soome } DNSSECStatus;
9075ffb0c9bSToomas Soome 
9085ffb0c9bSToomas Soome #define DNSSECRecordType(rrtype) (((rrtype) == kDNSType_RRSIG) || ((rrtype) == kDNSType_NSEC) || ((rrtype) == kDNSType_DNSKEY) || ((rrtype) == kDNSType_DS) || \
9095ffb0c9bSToomas Soome                                   ((rrtype) == kDNSType_NSEC3))
9105ffb0c9bSToomas Soome 
9115ffb0c9bSToomas Soome typedef enum
9125ffb0c9bSToomas Soome {
913c65ebfc7SToomas Soome     platform_OSX = 1,   // OSX Platform
914c65ebfc7SToomas Soome     platform_iOS,       // iOS Platform
915c65ebfc7SToomas Soome     platform_Atv,       // Atv Platform
9165ffb0c9bSToomas Soome     platform_NonApple   // Non-Apple (Windows, POSIX) Platform
9175ffb0c9bSToomas Soome } Platform_t;
9185ffb0c9bSToomas Soome 
9195ffb0c9bSToomas Soome // EDNS Option Code registrations are recorded in the "DNS EDNS0 Options" section of
9205ffb0c9bSToomas Soome // <http://www.iana.org/assignments/dns-parameters>
9215ffb0c9bSToomas Soome 
9225ffb0c9bSToomas Soome #define kDNSOpt_LLQ   1
9235ffb0c9bSToomas Soome #define kDNSOpt_Lease 2
9245ffb0c9bSToomas Soome #define kDNSOpt_NSID  3
9255ffb0c9bSToomas Soome #define kDNSOpt_Owner 4
926c65ebfc7SToomas Soome #define kDNSOpt_Trace 65001  // 65001-65534 Reserved for Local/Experimental Use
9275ffb0c9bSToomas Soome 
9285ffb0c9bSToomas Soome typedef struct
9295ffb0c9bSToomas Soome {
9305ffb0c9bSToomas Soome     mDNSu16 vers;
9315ffb0c9bSToomas Soome     mDNSu16 llqOp;
9325ffb0c9bSToomas Soome     mDNSu16 err;        // Or UDP reply port, in setup request
9335ffb0c9bSToomas Soome     // Note: In the in-memory form, there's typically a two-byte space here, so that the following 64-bit id is word-aligned
9345ffb0c9bSToomas Soome     mDNSOpaque64 id;
9355ffb0c9bSToomas Soome     mDNSu32 llqlease;
9365ffb0c9bSToomas Soome } LLQOptData;
9375ffb0c9bSToomas Soome 
9385ffb0c9bSToomas Soome typedef struct
9395ffb0c9bSToomas Soome {
9405ffb0c9bSToomas Soome     mDNSu8 vers;            // Version number of this Owner OPT record
9415ffb0c9bSToomas Soome     mDNSs8 seq;             // Sleep/wake epoch
9425ffb0c9bSToomas Soome     mDNSEthAddr HMAC;       // Host's primary identifier (e.g. MAC of on-board Ethernet)
9435ffb0c9bSToomas Soome     mDNSEthAddr IMAC;       // Interface's MAC address (if different to primary MAC)
9445ffb0c9bSToomas Soome     mDNSOpaque48 password;  // Optional password
9455ffb0c9bSToomas Soome } OwnerOptData;
9465ffb0c9bSToomas Soome 
9475ffb0c9bSToomas Soome typedef struct
9485ffb0c9bSToomas Soome {
9495ffb0c9bSToomas Soome     mDNSu8    platf;      // Running platform (see enum Platform_t)
9505ffb0c9bSToomas Soome     mDNSu32   mDNSv;      // mDNSResponder Version (DNS_SD_H defined in dns_sd.h)
9515ffb0c9bSToomas Soome } TracerOptData;
9525ffb0c9bSToomas Soome 
9535ffb0c9bSToomas Soome // Note: rdataOPT format may be repeated an arbitrary number of times in a single resource record
954c65ebfc7SToomas Soome typedef struct
9555ffb0c9bSToomas Soome {
9565ffb0c9bSToomas Soome     mDNSu16 opt;
9575ffb0c9bSToomas Soome     mDNSu16 optlen;
9585ffb0c9bSToomas Soome     union { LLQOptData llq; mDNSu32 updatelease; OwnerOptData owner; TracerOptData tracer; } u;
9595ffb0c9bSToomas Soome } rdataOPT;
9605ffb0c9bSToomas Soome 
9615ffb0c9bSToomas Soome // Space needed to put OPT records into a packet:
9625ffb0c9bSToomas Soome // Header         11  bytes (name 1, type 2, class 2, TTL 4, length 2)
9635ffb0c9bSToomas Soome // LLQ   rdata    18  bytes (opt 2, len 2, vers 2, op 2, err 2, id 8, lease 4)
9645ffb0c9bSToomas Soome // Lease rdata     8  bytes (opt 2, len 2, lease 4)
9655ffb0c9bSToomas Soome // Owner rdata 12-24  bytes (opt 2, len 2, owner 8-20)
9665ffb0c9bSToomas Soome // Trace rdata     9  bytes (opt 2, len 2, platf 1, mDNSv 4)
9675ffb0c9bSToomas Soome 
9685ffb0c9bSToomas Soome 
9695ffb0c9bSToomas Soome #define DNSOpt_Header_Space                 11
9705ffb0c9bSToomas Soome #define DNSOpt_LLQData_Space               (4 + 2 + 2 + 2 + 8 + 4)
9715ffb0c9bSToomas Soome #define DNSOpt_LeaseData_Space             (4 + 4)
9725ffb0c9bSToomas Soome #define DNSOpt_OwnerData_ID_Space          (4 + 2 + 6)
9735ffb0c9bSToomas Soome #define DNSOpt_OwnerData_ID_Wake_Space     (4 + 2 + 6 + 6)
9745ffb0c9bSToomas Soome #define DNSOpt_OwnerData_ID_Wake_PW4_Space (4 + 2 + 6 + 6 + 4)
9755ffb0c9bSToomas Soome #define DNSOpt_OwnerData_ID_Wake_PW6_Space (4 + 2 + 6 + 6 + 6)
9765ffb0c9bSToomas Soome #define DNSOpt_TraceData_Space             (4 + 1 + 4)
9775ffb0c9bSToomas Soome 
9785ffb0c9bSToomas Soome #define ValidOwnerLength(X) (   (X) == DNSOpt_OwnerData_ID_Space          - 4 || \
9795ffb0c9bSToomas Soome                                 (X) == DNSOpt_OwnerData_ID_Wake_Space     - 4 || \
9805ffb0c9bSToomas Soome                                 (X) == DNSOpt_OwnerData_ID_Wake_PW4_Space - 4 || \
9815ffb0c9bSToomas Soome                                 (X) == DNSOpt_OwnerData_ID_Wake_PW6_Space - 4    )
9825ffb0c9bSToomas Soome 
9835ffb0c9bSToomas Soome #define DNSOpt_Owner_Space(A,B) (mDNSSameEthAddress((A),(B)) ? DNSOpt_OwnerData_ID_Space : DNSOpt_OwnerData_ID_Wake_Space)
9845ffb0c9bSToomas Soome 
9855ffb0c9bSToomas Soome #define DNSOpt_Data_Space(O) (                                  \
9865ffb0c9bSToomas Soome         (O)->opt == kDNSOpt_LLQ   ? DNSOpt_LLQData_Space   :        \
9875ffb0c9bSToomas Soome         (O)->opt == kDNSOpt_Lease ? DNSOpt_LeaseData_Space :        \
9885ffb0c9bSToomas Soome         (O)->opt == kDNSOpt_Trace ? DNSOpt_TraceData_Space :        \
9895ffb0c9bSToomas Soome         (O)->opt == kDNSOpt_Owner ? DNSOpt_Owner_Space(&(O)->u.owner.HMAC, &(O)->u.owner.IMAC) : 0x10000)
9905ffb0c9bSToomas Soome 
9915ffb0c9bSToomas Soome // NSEC record is defined in RFC 4034.
9925ffb0c9bSToomas Soome // 16 bit RRTYPE space is split into 256 windows and each window has 256 bits (32 bytes).
9935ffb0c9bSToomas Soome // If we create a structure for NSEC, it's size would be:
9945ffb0c9bSToomas Soome //
9955ffb0c9bSToomas Soome //   256 bytes domainname 'nextname'
9965ffb0c9bSToomas Soome // + 256 * 34 = 8704 bytes of bitmap data
9975ffb0c9bSToomas Soome // = 8960 bytes total
9985ffb0c9bSToomas Soome //
9995ffb0c9bSToomas Soome // This would be a waste, as types about 256 are not very common. But it would be odd, if we receive
10005ffb0c9bSToomas Soome // a type above 256 (.US zone had TYPE65534 when this code was written) and not able to handle it.
10015ffb0c9bSToomas Soome // Hence, we handle any size by not fixing a strucure in place. The following is just a placeholder
10025ffb0c9bSToomas Soome // and never used anywhere.
10035ffb0c9bSToomas Soome //
10045ffb0c9bSToomas Soome #define NSEC_MCAST_WINDOW_SIZE 32
10055ffb0c9bSToomas Soome typedef struct
10065ffb0c9bSToomas Soome {
10075ffb0c9bSToomas Soome     domainname *next; //placeholders are uncommented because C89 in Windows requires that a struct has at least a member.
10085ffb0c9bSToomas Soome     char bitmap[32];
10095ffb0c9bSToomas Soome } rdataNSEC;
10105ffb0c9bSToomas Soome 
10115ffb0c9bSToomas Soome // StandardAuthRDSize is 264 (256+8), which is large enough to hold a maximum-sized SRV record (6 + 256 bytes)
10125ffb0c9bSToomas Soome // MaximumRDSize is 8K the absolute maximum we support (at least for now)
10135ffb0c9bSToomas Soome #define StandardAuthRDSize 264
10145ffb0c9bSToomas Soome #ifndef MaximumRDSize
10155ffb0c9bSToomas Soome #define MaximumRDSize 8192
10165ffb0c9bSToomas Soome #endif
10175ffb0c9bSToomas Soome 
10185ffb0c9bSToomas Soome // InlineCacheRDSize is 68
10195ffb0c9bSToomas Soome // Records received from the network with rdata this size or less have their rdata stored right in the CacheRecord object
10205ffb0c9bSToomas Soome // Records received from the network with rdata larger than this have additional storage allocated for the rdata
10215ffb0c9bSToomas Soome // A quick unscientific sample from a busy network at Apple with lots of machines revealed this:
10225ffb0c9bSToomas Soome // 1461 records in cache
10235ffb0c9bSToomas Soome // 292 were one-byte TXT records
10245ffb0c9bSToomas Soome // 136 were four-byte A records
10255ffb0c9bSToomas Soome // 184 were sixteen-byte AAAA records
10265ffb0c9bSToomas Soome // 780 were various PTR, TXT and SRV records from 12-64 bytes
10275ffb0c9bSToomas Soome // Only 69 records had rdata bigger than 64 bytes
10285ffb0c9bSToomas Soome // Note that since CacheRecord object and a CacheGroup object are allocated out of the same pool, it's sensible to
10295ffb0c9bSToomas Soome // have them both be the same size. Making one smaller without making the other smaller won't actually save any memory.
10305ffb0c9bSToomas Soome #define InlineCacheRDSize 68
10315ffb0c9bSToomas Soome 
10325ffb0c9bSToomas Soome // The RDataBody union defines the common rdata types that fit into our 264-byte limit
10335ffb0c9bSToomas Soome typedef union
10345ffb0c9bSToomas Soome {
10355ffb0c9bSToomas Soome     mDNSu8 data[StandardAuthRDSize];
10365ffb0c9bSToomas Soome     mDNSv4Addr ipv4;        // For 'A' record
10375ffb0c9bSToomas Soome     domainname name;        // For PTR, NS, CNAME, DNAME
10385ffb0c9bSToomas Soome     UTF8str255 txt;
10395ffb0c9bSToomas Soome     rdataMX mx;
10405ffb0c9bSToomas Soome     mDNSv6Addr ipv6;        // For 'AAAA' record
10415ffb0c9bSToomas Soome     rdataSRV srv;
10425ffb0c9bSToomas Soome     rdataOPT opt[2];        // For EDNS0 OPT record; RDataBody may contain multiple variable-length rdataOPT objects packed together
10435ffb0c9bSToomas Soome } RDataBody;
10445ffb0c9bSToomas Soome 
10455ffb0c9bSToomas Soome // The RDataBody2 union is the same as above, except it includes fields for the larger types like soa, rp, px
10465ffb0c9bSToomas Soome typedef union
10475ffb0c9bSToomas Soome {
10485ffb0c9bSToomas Soome     mDNSu8 data[StandardAuthRDSize];
10495ffb0c9bSToomas Soome     mDNSv4Addr ipv4;        // For 'A' record
10505ffb0c9bSToomas Soome     domainname name;        // For PTR, NS, CNAME, DNAME
10515ffb0c9bSToomas Soome     rdataSOA soa;           // This is large; not included in the normal RDataBody definition
10525ffb0c9bSToomas Soome     UTF8str255 txt;
10535ffb0c9bSToomas Soome     rdataMX mx;
10545ffb0c9bSToomas Soome     rdataRP rp;             // This is large; not included in the normal RDataBody definition
10555ffb0c9bSToomas Soome     rdataPX px;             // This is large; not included in the normal RDataBody definition
10565ffb0c9bSToomas Soome     mDNSv6Addr ipv6;        // For 'AAAA' record
10575ffb0c9bSToomas Soome     rdataSRV srv;
10585ffb0c9bSToomas Soome     rdataOPT opt[2];        // For EDNS0 OPT record; RDataBody may contain multiple variable-length rdataOPT objects packed together
10595ffb0c9bSToomas Soome     rdataDS ds;
10605ffb0c9bSToomas Soome     rdataDNSKey key;
10615ffb0c9bSToomas Soome     rdataRRSig rrsig;
10625ffb0c9bSToomas Soome } RDataBody2;
10635ffb0c9bSToomas Soome 
10645ffb0c9bSToomas Soome typedef struct
10655ffb0c9bSToomas Soome {
10665ffb0c9bSToomas Soome     mDNSu16 MaxRDLength;    // Amount of storage allocated for rdata (usually sizeof(RDataBody))
10675ffb0c9bSToomas Soome     mDNSu16 padding;        // So that RDataBody is aligned on 32-bit boundary
10685ffb0c9bSToomas Soome     RDataBody u;
10695ffb0c9bSToomas Soome } RData;
10705ffb0c9bSToomas Soome 
10715ffb0c9bSToomas Soome // sizeofRDataHeader should be 4 bytes
10725ffb0c9bSToomas Soome #define sizeofRDataHeader (sizeof(RData) - sizeof(RDataBody))
10735ffb0c9bSToomas Soome 
10745ffb0c9bSToomas Soome // RData_small is a smaller version of the RData object, used for inline data storage embedded in a CacheRecord_struct
10755ffb0c9bSToomas Soome typedef struct
10765ffb0c9bSToomas Soome {
10775ffb0c9bSToomas Soome     mDNSu16 MaxRDLength;    // Storage allocated for data (may be greater than InlineCacheRDSize if additional storage follows this object)
10785ffb0c9bSToomas Soome     mDNSu16 padding;        // So that data is aligned on 32-bit boundary
10795ffb0c9bSToomas Soome     mDNSu8 data[InlineCacheRDSize];
10805ffb0c9bSToomas Soome } RData_small;
10815ffb0c9bSToomas Soome 
10825ffb0c9bSToomas Soome // Note: Within an mDNSRecordCallback mDNS all API calls are legal except mDNS_Init(), mDNS_Exit(), mDNS_Execute()
10835ffb0c9bSToomas Soome typedef void mDNSRecordCallback (mDNS *const m, AuthRecord *const rr, mStatus result);
10845ffb0c9bSToomas Soome 
10855ffb0c9bSToomas Soome // Note:
10865ffb0c9bSToomas Soome // Restrictions: An mDNSRecordUpdateCallback may not make any mDNS API calls.
10875ffb0c9bSToomas Soome // The intent of this callback is to allow the client to free memory, if necessary.
10885ffb0c9bSToomas Soome // The internal data structures of the mDNS code may not be in a state where mDNS API calls may be made safely.
10895ffb0c9bSToomas Soome typedef void mDNSRecordUpdateCallback (mDNS *const m, AuthRecord *const rr, RData *OldRData, mDNSu16 OldRDLen);
10905ffb0c9bSToomas Soome 
10915ffb0c9bSToomas Soome // ***************************************************************************
10925ffb0c9bSToomas Soome #if 0
10935ffb0c9bSToomas Soome #pragma mark -
10945ffb0c9bSToomas Soome #pragma mark - NAT Traversal structures and constants
10955ffb0c9bSToomas Soome #endif
10965ffb0c9bSToomas Soome 
10975ffb0c9bSToomas Soome #define NATMAP_MAX_RETRY_INTERVAL    ((mDNSPlatformOneSecond * 60) * 15)    // Max retry interval is 15 minutes
10985ffb0c9bSToomas Soome #define NATMAP_MIN_RETRY_INTERVAL     (mDNSPlatformOneSecond * 2)           // Min retry interval is 2 seconds
10995ffb0c9bSToomas Soome #define NATMAP_INIT_RETRY             (mDNSPlatformOneSecond / 4)           // start at 250ms w/ exponential decay
11005ffb0c9bSToomas Soome #define NATMAP_DEFAULT_LEASE          (60 * 60 * 2)                         // 2 hour lease life in seconds
11015ffb0c9bSToomas Soome #define NATMAP_VERS 0
11025ffb0c9bSToomas Soome 
11035ffb0c9bSToomas Soome typedef enum
11045ffb0c9bSToomas Soome {
11055ffb0c9bSToomas Soome     NATOp_AddrRequest    = 0,
11065ffb0c9bSToomas Soome     NATOp_MapUDP         = 1,
11075ffb0c9bSToomas Soome     NATOp_MapTCP         = 2,
11085ffb0c9bSToomas Soome 
11095ffb0c9bSToomas Soome     NATOp_AddrResponse   = 0x80 | 0,
11105ffb0c9bSToomas Soome     NATOp_MapUDPResponse = 0x80 | 1,
11115ffb0c9bSToomas Soome     NATOp_MapTCPResponse = 0x80 | 2,
11125ffb0c9bSToomas Soome } NATOp_t;
11135ffb0c9bSToomas Soome 
11145ffb0c9bSToomas Soome enum
11155ffb0c9bSToomas Soome {
11165ffb0c9bSToomas Soome     NATErr_None    = 0,
11175ffb0c9bSToomas Soome     NATErr_Vers    = 1,
11185ffb0c9bSToomas Soome     NATErr_Refused = 2,
11195ffb0c9bSToomas Soome     NATErr_NetFail = 3,
11205ffb0c9bSToomas Soome     NATErr_Res     = 4,
11215ffb0c9bSToomas Soome     NATErr_Opcode  = 5
11225ffb0c9bSToomas Soome };
11235ffb0c9bSToomas Soome 
11245ffb0c9bSToomas Soome typedef mDNSu16 NATErr_t;
11255ffb0c9bSToomas Soome 
11265ffb0c9bSToomas Soome typedef packedstruct
11275ffb0c9bSToomas Soome {
11285ffb0c9bSToomas Soome     mDNSu8 vers;
11295ffb0c9bSToomas Soome     mDNSu8 opcode;
11305ffb0c9bSToomas Soome } NATAddrRequest;
11315ffb0c9bSToomas Soome 
11325ffb0c9bSToomas Soome typedef packedstruct
11335ffb0c9bSToomas Soome {
11345ffb0c9bSToomas Soome     mDNSu8 vers;
11355ffb0c9bSToomas Soome     mDNSu8 opcode;
11365ffb0c9bSToomas Soome     mDNSu16 err;
11375ffb0c9bSToomas Soome     mDNSu32 upseconds;          // Time since last NAT engine reboot, in seconds
11385ffb0c9bSToomas Soome     mDNSv4Addr ExtAddr;
11395ffb0c9bSToomas Soome } NATAddrReply;
11405ffb0c9bSToomas Soome 
11415ffb0c9bSToomas Soome typedef packedstruct
11425ffb0c9bSToomas Soome {
11435ffb0c9bSToomas Soome     mDNSu8 vers;
11445ffb0c9bSToomas Soome     mDNSu8 opcode;
11455ffb0c9bSToomas Soome     mDNSOpaque16 unused;
11465ffb0c9bSToomas Soome     mDNSIPPort intport;
11475ffb0c9bSToomas Soome     mDNSIPPort extport;
11485ffb0c9bSToomas Soome     mDNSu32 NATReq_lease;
11495ffb0c9bSToomas Soome } NATPortMapRequest;
11504b22b933Srs 
11515ffb0c9bSToomas Soome typedef packedstruct
11525ffb0c9bSToomas Soome {
11535ffb0c9bSToomas Soome     mDNSu8 vers;
11545ffb0c9bSToomas Soome     mDNSu8 opcode;
11555ffb0c9bSToomas Soome     mDNSu16 err;
11565ffb0c9bSToomas Soome     mDNSu32 upseconds;          // Time since last NAT engine reboot, in seconds
11575ffb0c9bSToomas Soome     mDNSIPPort intport;
11585ffb0c9bSToomas Soome     mDNSIPPort extport;
11595ffb0c9bSToomas Soome     mDNSu32 NATRep_lease;
11605ffb0c9bSToomas Soome } NATPortMapReply;
11614b22b933Srs 
11625ffb0c9bSToomas Soome // PCP Support for IPv4 mappings
11634b22b933Srs 
11645ffb0c9bSToomas Soome #define PCP_VERS 0x02
11655ffb0c9bSToomas Soome #define PCP_WAITSECS_AFTER_EPOCH_INVALID 5
11664b22b933Srs 
11675ffb0c9bSToomas Soome typedef enum
11685ffb0c9bSToomas Soome {
11695ffb0c9bSToomas Soome     PCPOp_Announce = 0,
11705ffb0c9bSToomas Soome     PCPOp_Map      = 1
11715ffb0c9bSToomas Soome } PCPOp_t;
11724b22b933Srs 
11735ffb0c9bSToomas Soome typedef enum
11745ffb0c9bSToomas Soome {
11755ffb0c9bSToomas Soome     PCPProto_All = 0,
11765ffb0c9bSToomas Soome     PCPProto_TCP = 6,
11775ffb0c9bSToomas Soome     PCPProto_UDP = 17
11785ffb0c9bSToomas Soome } PCPProto_t;
11794b22b933Srs 
11805ffb0c9bSToomas Soome typedef enum
11815ffb0c9bSToomas Soome {
11825ffb0c9bSToomas Soome     PCPResult_Success         = 0,
11835ffb0c9bSToomas Soome     PCPResult_UnsuppVersion   = 1,
11845ffb0c9bSToomas Soome     PCPResult_NotAuthorized   = 2,
11855ffb0c9bSToomas Soome     PCPResult_MalformedReq    = 3,
11865ffb0c9bSToomas Soome     PCPResult_UnsuppOpcode    = 4,
11875ffb0c9bSToomas Soome     PCPResult_UnsuppOption    = 5,
11885ffb0c9bSToomas Soome     PCPResult_MalformedOption = 6,
11895ffb0c9bSToomas Soome     PCPResult_NetworkFailure  = 7,
11905ffb0c9bSToomas Soome     PCPResult_NoResources     = 8,
11915ffb0c9bSToomas Soome     PCPResult_UnsuppProtocol  = 9,
11925ffb0c9bSToomas Soome     PCPResult_UserExQuota     = 10,
11935ffb0c9bSToomas Soome     PCPResult_CantProvideExt  = 11,
11945ffb0c9bSToomas Soome     PCPResult_AddrMismatch    = 12,
11955ffb0c9bSToomas Soome     PCPResult_ExcesRemotePeer = 13
11965ffb0c9bSToomas Soome } PCPResult_t;
11974b22b933Srs 
1198c65ebfc7SToomas Soome typedef struct
11995ffb0c9bSToomas Soome {
12005ffb0c9bSToomas Soome     mDNSu8       version;
12015ffb0c9bSToomas Soome     mDNSu8       opCode;
12025ffb0c9bSToomas Soome     mDNSOpaque16 reserved;
12035ffb0c9bSToomas Soome     mDNSu32      lifetime;
12045ffb0c9bSToomas Soome     mDNSv6Addr   clientAddr;
12055ffb0c9bSToomas Soome     mDNSu32      nonce[3];
12065ffb0c9bSToomas Soome     mDNSu8       protocol;
12075ffb0c9bSToomas Soome     mDNSu8       reservedMapOp[3];
12085ffb0c9bSToomas Soome     mDNSIPPort   intPort;
12095ffb0c9bSToomas Soome     mDNSIPPort   extPort;
12105ffb0c9bSToomas Soome     mDNSv6Addr   extAddress;
12115ffb0c9bSToomas Soome } PCPMapRequest;
12124b22b933Srs 
1213c65ebfc7SToomas Soome typedef struct
12145ffb0c9bSToomas Soome {
12155ffb0c9bSToomas Soome     mDNSu8     version;
12165ffb0c9bSToomas Soome     mDNSu8     opCode;
12175ffb0c9bSToomas Soome     mDNSu8     reserved;
12185ffb0c9bSToomas Soome     mDNSu8     result;
12195ffb0c9bSToomas Soome     mDNSu32    lifetime;
12205ffb0c9bSToomas Soome     mDNSu32    epoch;
12215ffb0c9bSToomas Soome     mDNSu32    clientAddrParts[3];
12225ffb0c9bSToomas Soome     mDNSu32    nonce[3];
12235ffb0c9bSToomas Soome     mDNSu8     protocol;
12245ffb0c9bSToomas Soome     mDNSu8     reservedMapOp[3];
12255ffb0c9bSToomas Soome     mDNSIPPort intPort;
12265ffb0c9bSToomas Soome     mDNSIPPort extPort;
12275ffb0c9bSToomas Soome     mDNSv6Addr extAddress;
12285ffb0c9bSToomas Soome } PCPMapReply;
12295ffb0c9bSToomas Soome 
12305ffb0c9bSToomas Soome // LNT Support
12314b22b933Srs 
12325ffb0c9bSToomas Soome typedef enum
12335ffb0c9bSToomas Soome {
12345ffb0c9bSToomas Soome     LNTDiscoveryOp      = 1,
12355ffb0c9bSToomas Soome     LNTExternalAddrOp   = 2,
12365ffb0c9bSToomas Soome     LNTPortMapOp        = 3,
12375ffb0c9bSToomas Soome     LNTPortMapDeleteOp  = 4
12385ffb0c9bSToomas Soome } LNTOp_t;
12395ffb0c9bSToomas Soome 
12405ffb0c9bSToomas Soome #define LNT_MAXBUFSIZE 8192
12415ffb0c9bSToomas Soome typedef struct tcpLNTInfo_struct tcpLNTInfo;
12425ffb0c9bSToomas Soome struct tcpLNTInfo_struct
12435ffb0c9bSToomas Soome {
12445ffb0c9bSToomas Soome     tcpLNTInfo       *next;
12455ffb0c9bSToomas Soome     mDNS             *m;
12465ffb0c9bSToomas Soome     NATTraversalInfo *parentNATInfo;    // pointer back to the parent NATTraversalInfo
12475ffb0c9bSToomas Soome     TCPSocket        *sock;
12485ffb0c9bSToomas Soome     LNTOp_t op;                         // operation performed using this connection
12495ffb0c9bSToomas Soome     mDNSAddr Address;                   // router address
12505ffb0c9bSToomas Soome     mDNSIPPort Port;                    // router port
12515ffb0c9bSToomas Soome     mDNSu8           *Request;          // xml request to router
12525ffb0c9bSToomas Soome     int requestLen;
12535ffb0c9bSToomas Soome     mDNSu8           *Reply;            // xml reply from router
12545ffb0c9bSToomas Soome     int replyLen;
12555ffb0c9bSToomas Soome     unsigned long nread;                // number of bytes read so far
12565ffb0c9bSToomas Soome     int retries;                        // number of times we've tried to do this port mapping
12575ffb0c9bSToomas Soome };
12585ffb0c9bSToomas Soome 
12595ffb0c9bSToomas Soome typedef void (*NATTraversalClientCallback)(mDNS *m, NATTraversalInfo *n);
12605ffb0c9bSToomas Soome 
12615ffb0c9bSToomas Soome // if m->timenow <  ExpiryTime then we have an active mapping, and we'll renew halfway to expiry
12625ffb0c9bSToomas Soome // if m->timenow >= ExpiryTime then our mapping has expired, and we're trying to create one
12634b22b933Srs 
12645ffb0c9bSToomas Soome typedef enum
12655ffb0c9bSToomas Soome {
12665ffb0c9bSToomas Soome     NATTProtocolNone    = 0,
12675ffb0c9bSToomas Soome     NATTProtocolNATPMP  = 1,
12685ffb0c9bSToomas Soome     NATTProtocolUPNPIGD = 2,
12695ffb0c9bSToomas Soome     NATTProtocolPCP     = 3,
12705ffb0c9bSToomas Soome } NATTProtocol;
12715ffb0c9bSToomas Soome 
12725ffb0c9bSToomas Soome struct NATTraversalInfo_struct
12735ffb0c9bSToomas Soome {
12745ffb0c9bSToomas Soome     // Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.
12755ffb0c9bSToomas Soome     NATTraversalInfo           *next;
12765ffb0c9bSToomas Soome 
12775ffb0c9bSToomas Soome     mDNSs32 ExpiryTime;                             // Time this mapping expires, or zero if no mapping
12785ffb0c9bSToomas Soome     mDNSs32 retryInterval;                          // Current interval, between last packet we sent and the next one
12795ffb0c9bSToomas Soome     mDNSs32 retryPortMap;                           // If Protocol is nonzero, time to send our next mapping packet
12805ffb0c9bSToomas Soome     mStatus NewResult;                              // New error code; will be copied to Result just prior to invoking callback
12815ffb0c9bSToomas Soome     NATTProtocol lastSuccessfulProtocol;            // To send correct deletion request & update non-PCP external address operations
12825ffb0c9bSToomas Soome     mDNSBool sentNATPMP;                            // Whether we just sent a NAT-PMP packet, so we won't send another if
12835ffb0c9bSToomas Soome                                                     //    we receive another NAT-PMP "Unsupported Version" packet
12844b22b933Srs 
12855ffb0c9bSToomas Soome #ifdef _LEGACY_NAT_TRAVERSAL_
12865ffb0c9bSToomas Soome     tcpLNTInfo tcpInfo;                             // Legacy NAT traversal (UPnP) TCP connection
12875ffb0c9bSToomas Soome #endif
12884b22b933Srs 
12895ffb0c9bSToomas Soome     // Result fields: When the callback is invoked these fields contain the answers the client is looking for
12905ffb0c9bSToomas Soome     // When the callback is invoked ExternalPort is *usually* set to be the same the same as RequestedPort, except:
12915ffb0c9bSToomas Soome     // (a) When we're behind a NAT gateway with port mapping disabled, ExternalPort is reported as zero to
12925ffb0c9bSToomas Soome     //     indicate that we don't currently have a working mapping (but RequestedPort retains the external port
12935ffb0c9bSToomas Soome     //     we'd like to get, the next time we meet an accomodating NAT gateway willing to give us one).
12945ffb0c9bSToomas Soome     // (b) When we have a routable non-RFC1918 address, we don't *need* a port mapping, so ExternalPort
12955ffb0c9bSToomas Soome     //     is reported as the same as our InternalPort, since that is effectively our externally-visible port too.
12965ffb0c9bSToomas Soome     //     Again, RequestedPort retains the external port we'd like to get the next time we find ourself behind a NAT gateway.
12975ffb0c9bSToomas Soome     // To improve stability of port mappings, RequestedPort is updated any time we get a successful
12985ffb0c9bSToomas Soome     // mapping response from the PCP, NAT-PMP or UPnP gateway. For example, if we ask for port 80, and
12995ffb0c9bSToomas Soome     // get assigned port 81, then thereafter we'll contine asking for port 81.
13005ffb0c9bSToomas Soome     mDNSInterfaceID InterfaceID;
13015ffb0c9bSToomas Soome     mDNSv4Addr ExternalAddress;                     // Initially set to onesIPv4Addr, until first callback
13025ffb0c9bSToomas Soome     mDNSv4Addr NewAddress;                          // May be updated with actual value assigned by gateway
13035ffb0c9bSToomas Soome     mDNSIPPort ExternalPort;
13045ffb0c9bSToomas Soome     mDNSu32 Lifetime;
13055ffb0c9bSToomas Soome     mStatus Result;
13065ffb0c9bSToomas Soome 
13075ffb0c9bSToomas Soome     // Client API fields: The client must set up these fields *before* making any NAT traversal API calls
13085ffb0c9bSToomas Soome     mDNSu8 Protocol;                                // NATOp_MapUDP or NATOp_MapTCP, or zero if just requesting the external IP address
13095ffb0c9bSToomas Soome     mDNSIPPort IntPort;                             // Client's internal port number (doesn't change)
13105ffb0c9bSToomas Soome     mDNSIPPort RequestedPort;                       // Requested external port; may be updated with actual value assigned by gateway
13115ffb0c9bSToomas Soome     mDNSu32 NATLease;                               // Requested lifetime in seconds (doesn't change)
13125ffb0c9bSToomas Soome     NATTraversalClientCallback clientCallback;
13135ffb0c9bSToomas Soome     void                       *clientContext;
13145ffb0c9bSToomas Soome };
13154b22b933Srs 
13165ffb0c9bSToomas Soome // ***************************************************************************
13175ffb0c9bSToomas Soome #if 0
13185ffb0c9bSToomas Soome #pragma mark -
13195ffb0c9bSToomas Soome #pragma mark - DNSServer & McastResolver structures and constants
13205ffb0c9bSToomas Soome #endif
13214b22b933Srs 
13225ffb0c9bSToomas Soome enum
13235ffb0c9bSToomas Soome {
1324cda73f64SToomas Soome     DNSServer_FlagDelete      = 0x1,
1325cda73f64SToomas Soome     DNSServer_FlagNew         = 0x2,
1326cda73f64SToomas Soome #if APPLE_OSX_mDNSResponder
1327cda73f64SToomas Soome     DNSServer_FlagUnreachable = 0x4,
1328cda73f64SToomas Soome #endif
13295ffb0c9bSToomas Soome };
13304b22b933Srs 
13315ffb0c9bSToomas Soome enum
13325ffb0c9bSToomas Soome {
13335ffb0c9bSToomas Soome     McastResolver_FlagDelete = 1,
13345ffb0c9bSToomas Soome     McastResolver_FlagNew    = 2
13355ffb0c9bSToomas Soome };
13365ffb0c9bSToomas Soome 
13375ffb0c9bSToomas Soome typedef struct McastResolver
13385ffb0c9bSToomas Soome {
13395ffb0c9bSToomas Soome     struct McastResolver *next;
13405ffb0c9bSToomas Soome     mDNSInterfaceID interface;
13415ffb0c9bSToomas Soome     mDNSu32 flags;              // Set when we're planning to delete this from the list
13425ffb0c9bSToomas Soome     domainname domain;
13435ffb0c9bSToomas Soome     mDNSu32 timeout;            // timeout value for questions
13445ffb0c9bSToomas Soome } McastResolver;
13455ffb0c9bSToomas Soome 
1346*3b436d06SToomas Soome enum {
1347*3b436d06SToomas Soome     Mortality_Mortal      = 0,          // This cache record can expire and get purged
1348*3b436d06SToomas Soome     Mortality_Immortal    = 1,          // Allow this record to remain in the cache indefinitely
1349*3b436d06SToomas Soome     Mortality_Ghost       = 2           // An immortal record that has expired and can linger in the cache
1350*3b436d06SToomas Soome };
1351*3b436d06SToomas Soome typedef mDNSu8 MortalityState;
1352*3b436d06SToomas Soome 
13535ffb0c9bSToomas Soome // scoped values for DNSServer matching
13545ffb0c9bSToomas Soome enum
13555ffb0c9bSToomas Soome {
13565ffb0c9bSToomas Soome     kScopeNone         = 0,        // DNS server used by unscoped questions
13575ffb0c9bSToomas Soome     kScopeInterfaceID  = 1,        // Scoped DNS server used only by scoped questions
1358c65ebfc7SToomas Soome     kScopeServiceID    = 2,         // Service specific DNS server used only by questions
13595ffb0c9bSToomas Soome                                    // have a matching serviceID
1360c65ebfc7SToomas Soome     kScopesMaxCount    = 3         // Max count for scopes enum
13615ffb0c9bSToomas Soome };
13625ffb0c9bSToomas Soome 
13635ffb0c9bSToomas Soome // Note: DNSSECAware is set if we are able to get a valid response to
13645ffb0c9bSToomas Soome // a DNSSEC question. In some cases it is possible that the proxy
13655ffb0c9bSToomas Soome // strips the EDNS0 option and we just get a plain response with no
13665ffb0c9bSToomas Soome // signatures. But we still mark DNSSECAware in that case. As DNSSECAware
13675ffb0c9bSToomas Soome // is only used to determine whether DNSSEC_VALIDATION_SECURE_OPTIONAL
13685ffb0c9bSToomas Soome // should be turned off or not, it is sufficient that we are getting
13695ffb0c9bSToomas Soome // responses back.
13705ffb0c9bSToomas Soome typedef struct DNSServer
13715ffb0c9bSToomas Soome {
13725ffb0c9bSToomas Soome     struct DNSServer *next;
13735ffb0c9bSToomas Soome     mDNSInterfaceID interface;  // DNS requests should be sent on this interface
13745ffb0c9bSToomas Soome     mDNSs32 serviceID;
13755ffb0c9bSToomas Soome     mDNSAddr addr;
13765ffb0c9bSToomas Soome     mDNSIPPort port;
13775ffb0c9bSToomas Soome     mDNSu32 flags;              // Set when we're planning to delete this from the list
13785ffb0c9bSToomas Soome     domainname domain;          // name->server matching for "split dns"
13795ffb0c9bSToomas Soome     mDNSs32 penaltyTime;        // amount of time this server is penalized
13805ffb0c9bSToomas Soome     mDNSu32 scoped;             // See the scoped enum above
13815ffb0c9bSToomas Soome     mDNSu32 timeout;            // timeout value for questions
13825ffb0c9bSToomas Soome     mDNSu16 resGroupID;         // ID of the resolver group that contains this DNSServer
1383c65ebfc7SToomas Soome     mDNSu8 retransDO;           // Total Retransmissions for queries sent with DO option
1384c65ebfc7SToomas Soome     mDNSBool cellIntf;          // Resolver from Cellular Interface?
13855ffb0c9bSToomas Soome     mDNSBool req_A;             // If set, send v4 query (DNSConfig allows A queries)
13865ffb0c9bSToomas Soome     mDNSBool req_AAAA;          // If set, send v6 query (DNSConfig allows AAAA queries)
13875ffb0c9bSToomas Soome     mDNSBool req_DO;            // If set, okay to send DNSSEC queries (EDNS DO bit is supported)
1388c65ebfc7SToomas Soome     mDNSBool DNSSECAware;       // Set if we are able to receive a response to a request sent with DO option.
1389c65ebfc7SToomas Soome     mDNSBool isExpensive;       // True if the interface to this server is expensive.
1390*3b436d06SToomas Soome     mDNSBool isCLAT46;          // True if the interface to this server is CLAT46.
13915ffb0c9bSToomas Soome } DNSServer;
13924b22b933Srs 
13934b22b933Srs typedef struct
13945ffb0c9bSToomas Soome {
13955ffb0c9bSToomas Soome     mDNSu8 *AnonData;
13965ffb0c9bSToomas Soome     int AnonDataLen;
13975ffb0c9bSToomas Soome     mDNSu32 salt;
13985ffb0c9bSToomas Soome     ResourceRecord *nsec3RR;
13995ffb0c9bSToomas Soome     mDNSInterfaceID SendNow;     // The interface ID that this record should be sent on
14005ffb0c9bSToomas Soome } AnonymousInfo;
14015ffb0c9bSToomas Soome 
14025ffb0c9bSToomas Soome struct ResourceRecord_struct
14035ffb0c9bSToomas Soome {
1404c65ebfc7SToomas Soome     mDNSu8 RecordType;                  // See kDNSRecordTypes enum.
1405*3b436d06SToomas Soome     MortalityState mortality;           // Mortality of this resource record (See MortalityState enum)
1406c65ebfc7SToomas Soome     mDNSu16 rrtype;                     // See DNS_TypeValues enum.
1407c65ebfc7SToomas Soome     mDNSu16 rrclass;                    // See DNS_ClassValues enum.
14085ffb0c9bSToomas Soome     mDNSu32 rroriginalttl;              // In seconds
14095ffb0c9bSToomas Soome     mDNSu16 rdlength;                   // Size of the raw rdata, in bytes, in the on-the-wire format
14105ffb0c9bSToomas Soome                                         // (In-memory storage may be larger, for structures containing 'holes', like SOA)
14115ffb0c9bSToomas Soome     mDNSu16 rdestimate;                 // Upper bound on on-the-wire size of rdata after name compression
14125ffb0c9bSToomas Soome     mDNSu32 namehash;                   // Name-based (i.e. case-insensitive) hash of name
14135ffb0c9bSToomas Soome     mDNSu32 rdatahash;                  // For rdata containing domain name (e.g. PTR, SRV, CNAME etc.), case-insensitive name hash
14145ffb0c9bSToomas Soome                                         // else, for all other rdata, 32-bit hash of the raw rdata
14155ffb0c9bSToomas Soome                                         // Note: This requirement is important. Various routines like AddAdditionalsToResponseList(),
14165ffb0c9bSToomas Soome                                         // ReconfirmAntecedents(), etc., use rdatahash as a pre-flight check to see
14175ffb0c9bSToomas Soome                                         // whether it's worth doing a full SameDomainName() call. If the rdatahash
14185ffb0c9bSToomas Soome                                         // is not a correct case-insensitive name hash, they'll get false negatives.
14195ffb0c9bSToomas Soome     // Grouping pointers together at the end of the structure improves the memory layout efficiency
14205ffb0c9bSToomas Soome     mDNSInterfaceID InterfaceID;        // Set if this RR is specific to one interface
14215ffb0c9bSToomas Soome                                         // For records received off the wire, InterfaceID is *always* set to the receiving interface
14225ffb0c9bSToomas Soome                                         // For our authoritative records, InterfaceID is usually zero, except for those few records
14235ffb0c9bSToomas Soome                                         // that are interface-specific (e.g. address records, especially linklocal addresses)
14245ffb0c9bSToomas Soome     const domainname *name;
14255ffb0c9bSToomas Soome     RData           *rdata;             // Pointer to storage for this rdata
1426cda73f64SToomas Soome     DNSServer       *rDNSServer;        // Unicast DNS server authoritative for this entry; null for multicast
14275ffb0c9bSToomas Soome     AnonymousInfo   *AnonInfo;          // Anonymous Information
14285ffb0c9bSToomas Soome };
14295ffb0c9bSToomas Soome 
14305ffb0c9bSToomas Soome 
14315ffb0c9bSToomas Soome // Unless otherwise noted, states may apply to either independent record registrations or service registrations
14324b22b933Srs typedef enum
14335ffb0c9bSToomas Soome {
14345ffb0c9bSToomas Soome     regState_Zero              = 0,
14355ffb0c9bSToomas Soome     regState_Pending           = 1,     // update sent, reply not received
14365ffb0c9bSToomas Soome     regState_Registered        = 2,     // update sent, reply received
14375ffb0c9bSToomas Soome     regState_DeregPending      = 3,     // dereg sent, reply not received
14385ffb0c9bSToomas Soome     regState_Unregistered      = 4,     // not in any list
14395ffb0c9bSToomas Soome     regState_Refresh           = 5,     // outstanding refresh (or target change) message
14405ffb0c9bSToomas Soome     regState_NATMap            = 6,     // establishing NAT port mapping
14415ffb0c9bSToomas Soome     regState_UpdatePending     = 7,     // update in flight as result of mDNS_Update call
14425ffb0c9bSToomas Soome     regState_NoTarget          = 8,     // SRV Record registration pending registration of hostname
14435ffb0c9bSToomas Soome     regState_NATError          = 9     // unable to complete NAT traversal
14445ffb0c9bSToomas Soome } regState_t;
14454b22b933Srs 
14465ffb0c9bSToomas Soome enum
14475ffb0c9bSToomas Soome {
14485ffb0c9bSToomas Soome     Target_Manual = 0,
14495ffb0c9bSToomas Soome     Target_AutoHost = 1,
14505ffb0c9bSToomas Soome     Target_AutoHostAndNATMAP = 2
14515ffb0c9bSToomas Soome };
14525ffb0c9bSToomas Soome 
14535ffb0c9bSToomas Soome typedef enum
14545ffb0c9bSToomas Soome {
14555ffb0c9bSToomas Soome     mergeState_Zero = 0,
14565ffb0c9bSToomas Soome     mergeState_DontMerge = 1  // Set on fatal error conditions to disable merging
14575ffb0c9bSToomas Soome } mergeState_t;
14585ffb0c9bSToomas Soome 
14595ffb0c9bSToomas Soome #define AUTH_GROUP_NAME_SIZE    128
14605ffb0c9bSToomas Soome struct AuthGroup_struct             // Header object for a list of AuthRecords with the same name
14615ffb0c9bSToomas Soome {
14625ffb0c9bSToomas Soome     AuthGroup      *next;               // Next AuthGroup object in this hash table bucket
14635ffb0c9bSToomas Soome     mDNSu32 namehash;                   // Name-based (i.e. case insensitive) hash of name
14645ffb0c9bSToomas Soome     AuthRecord     *members;            // List of CacheRecords with this same name
14655ffb0c9bSToomas Soome     AuthRecord    **rrauth_tail;        // Tail end of that list
14665ffb0c9bSToomas Soome     domainname     *name;               // Common name for all AuthRecords in this list
14675ffb0c9bSToomas Soome     AuthRecord     *NewLocalOnlyRecords;
14685ffb0c9bSToomas Soome     mDNSu8 namestorage[AUTH_GROUP_NAME_SIZE];
14695ffb0c9bSToomas Soome };
14705ffb0c9bSToomas Soome 
14715ffb0c9bSToomas Soome #ifndef AUTH_HASH_SLOTS
14725ffb0c9bSToomas Soome #define AUTH_HASH_SLOTS 499
14735ffb0c9bSToomas Soome #endif
14745ffb0c9bSToomas Soome #define FORALL_AUTHRECORDS(SLOT,AG,AR)                              \
14755ffb0c9bSToomas Soome     for ((SLOT) = 0; (SLOT) < AUTH_HASH_SLOTS; (SLOT)++)                                                                     \
14765ffb0c9bSToomas Soome         for ((AG)=m->rrauth.rrauth_hash[(SLOT)]; (AG); (AG)=(AG)->next)                                                                         \
14775ffb0c9bSToomas Soome             for ((AR) = (AG)->members; (AR); (AR)=(AR)->next)
14785ffb0c9bSToomas Soome 
14795ffb0c9bSToomas Soome typedef union AuthEntity_union AuthEntity;
14805ffb0c9bSToomas Soome union AuthEntity_union { AuthEntity *next; AuthGroup ag; };
14815ffb0c9bSToomas Soome typedef struct {
14825ffb0c9bSToomas Soome     mDNSu32 rrauth_size;                // Total number of available auth entries
14835ffb0c9bSToomas Soome     mDNSu32 rrauth_totalused;           // Number of auth entries currently occupied
14845ffb0c9bSToomas Soome     mDNSu32 rrauth_report;
14855ffb0c9bSToomas Soome     mDNSu8 rrauth_lock;                 // For debugging: Set at times when these lists may not be modified
14865ffb0c9bSToomas Soome     AuthEntity *rrauth_free;
14875ffb0c9bSToomas Soome     AuthGroup *rrauth_hash[AUTH_HASH_SLOTS];
14885ffb0c9bSToomas Soome }AuthHash;
14895ffb0c9bSToomas Soome 
14905ffb0c9bSToomas Soome // AuthRecordAny includes mDNSInterface_Any and interface specific auth records.
14915ffb0c9bSToomas Soome typedef enum
14925ffb0c9bSToomas Soome {
14935ffb0c9bSToomas Soome     AuthRecordAny,              // registered for *Any, NOT including P2P interfaces
14945ffb0c9bSToomas Soome     AuthRecordAnyIncludeP2P,    // registered for *Any, including P2P interfaces
14955ffb0c9bSToomas Soome     AuthRecordAnyIncludeAWDL,   // registered for *Any, including AWDL interface
14965ffb0c9bSToomas Soome     AuthRecordAnyIncludeAWDLandP2P, // registered for *Any, including AWDL and P2P interfaces
14975ffb0c9bSToomas Soome     AuthRecordLocalOnly,
14985ffb0c9bSToomas Soome     AuthRecordP2P               // discovered over D2D/P2P framework
14995ffb0c9bSToomas Soome } AuthRecType;
15005ffb0c9bSToomas Soome 
15015ffb0c9bSToomas Soome typedef enum
15025ffb0c9bSToomas Soome {
15035ffb0c9bSToomas Soome     AuthFlagsWakeOnly = 0x1     // WakeOnly service
15045ffb0c9bSToomas Soome } AuthRecordFlags;
15054b22b933Srs 
15064b22b933Srs struct AuthRecord_struct
15075ffb0c9bSToomas Soome {
15085ffb0c9bSToomas Soome     // For examples of how to set up this structure for use in mDNS_Register(),
15095ffb0c9bSToomas Soome     // see mDNS_AdvertiseInterface() or mDNS_RegisterService().
15105ffb0c9bSToomas Soome     // Basically, resrec and persistent metadata need to be set up before calling mDNS_Register().
15115ffb0c9bSToomas Soome     // mDNS_SetupResourceRecord() is avaliable as a helper routine to set up most fields to sensible default values for you
15125ffb0c9bSToomas Soome 
15135ffb0c9bSToomas Soome     AuthRecord     *next;               // Next in list; first element of structure for efficiency reasons
15145ffb0c9bSToomas Soome     // Field Group 1: Common ResourceRecord fields
1515cda73f64SToomas Soome     ResourceRecord resrec;              // 36 bytes when compiling for 32-bit; 48 when compiling for 64-bit (now 44/64)
15165ffb0c9bSToomas Soome 
15175ffb0c9bSToomas Soome     // Field Group 2: Persistent metadata for Authoritative Records
15185ffb0c9bSToomas Soome     AuthRecord     *Additional1;        // Recommended additional record to include in response (e.g. SRV for PTR record)
15195ffb0c9bSToomas Soome     AuthRecord     *Additional2;        // Another additional (e.g. TXT for PTR record)
15205ffb0c9bSToomas Soome     AuthRecord     *DependentOn;        // This record depends on another for its uniqueness checking
15215ffb0c9bSToomas Soome     AuthRecord     *RRSet;              // This unique record is part of an RRSet
15225ffb0c9bSToomas Soome     mDNSRecordCallback *RecordCallback; // Callback function to call for state changes, and to free memory asynchronously on deregistration
15235ffb0c9bSToomas Soome     void           *RecordContext;      // Context parameter for the callback function
15245ffb0c9bSToomas Soome     mDNSu8 AutoTarget;                  // Set if the target of this record (PTR, CNAME, SRV, etc.) is our host name
15255ffb0c9bSToomas Soome     mDNSu8 AllowRemoteQuery;            // Set if we allow hosts not on the local link to query this record
15265ffb0c9bSToomas Soome     mDNSu8 ForceMCast;                  // Set by client to advertise solely via multicast, even for apparently unicast names
15275ffb0c9bSToomas Soome     mDNSu8 AuthFlags;
15285ffb0c9bSToomas Soome 
15295ffb0c9bSToomas Soome     OwnerOptData WakeUp;                // WakeUp.HMAC.l[0] nonzero indicates that this is a Sleep Proxy record
15305ffb0c9bSToomas Soome     mDNSAddr AddressProxy;              // For reverse-mapping Sleep Proxy PTR records, address in question
15315ffb0c9bSToomas Soome     mDNSs32 TimeRcvd;                   // In platform time units
15325ffb0c9bSToomas Soome     mDNSs32 TimeExpire;                 // In platform time units
15335ffb0c9bSToomas Soome     AuthRecType ARType;                 // LocalOnly, P2P or Normal ?
15345ffb0c9bSToomas Soome     mDNSs32 KATimeExpire;               // In platform time units: time to send keepalive packet for the proxy record
15355ffb0c9bSToomas Soome 
15365ffb0c9bSToomas Soome     // Field Group 3: Transient state for Authoritative Records
15375ffb0c9bSToomas Soome     mDNSu8 Acknowledged;                // Set if we've given the success callback to the client
15385ffb0c9bSToomas Soome     mDNSu8 ProbeRestartCount;           // Number of times we have restarted probing
15395ffb0c9bSToomas Soome     mDNSu8 ProbeCount;                  // Number of probes remaining before this record is valid (kDNSRecordTypeUnique)
15405ffb0c9bSToomas Soome     mDNSu8 AnnounceCount;               // Number of announcements remaining (kDNSRecordTypeShared)
15415ffb0c9bSToomas Soome     mDNSu8 RequireGoodbye;              // Set if this RR has been announced on the wire and will require a goodbye packet
15425ffb0c9bSToomas Soome     mDNSu8 AnsweredLocalQ;              // Set if this AuthRecord has been delivered to any local question (LocalOnly or mDNSInterface_Any)
15435ffb0c9bSToomas Soome     mDNSu8 IncludeInProbe;              // Set if this RR is being put into a probe right now
15445ffb0c9bSToomas Soome     mDNSu8 ImmedUnicast;                // Set if we may send our response directly via unicast to the requester
15455ffb0c9bSToomas Soome     mDNSInterfaceID SendNSECNow;        // Set if we need to generate associated NSEC data for this rrname
15465ffb0c9bSToomas Soome     mDNSInterfaceID ImmedAnswer;        // Someone on this interface issued a query we need to answer (all-ones for all interfaces)
15474b22b933Srs #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
15485ffb0c9bSToomas Soome     mDNSs32 ImmedAnswerMarkTime;
15494b22b933Srs #endif
15505ffb0c9bSToomas Soome     mDNSInterfaceID ImmedAdditional;    // Hint that we might want to also send this record, just to be helpful
15515ffb0c9bSToomas Soome     mDNSInterfaceID SendRNow;           // The interface this query is being sent on right now
15525ffb0c9bSToomas Soome     mDNSv4Addr v4Requester;             // Recent v4 query for this record, or all-ones if more than one recent query
15535ffb0c9bSToomas Soome     mDNSv6Addr v6Requester;             // Recent v6 query for this record, or all-ones if more than one recent query
15545ffb0c9bSToomas Soome     AuthRecord     *NextResponse;       // Link to the next element in the chain of responses to generate
15555ffb0c9bSToomas Soome     const mDNSu8   *NR_AnswerTo;        // Set if this record was selected by virtue of being a direct answer to a question
15565ffb0c9bSToomas Soome     AuthRecord     *NR_AdditionalTo;    // Set if this record was selected by virtue of being additional to another
15575ffb0c9bSToomas Soome     mDNSs32 ThisAPInterval;             // In platform time units: Current interval for announce/probe
1558</