#pragma ident "%Z%%M% %I% %E% SMI"

#ifndef __mDNSClientAPI_h

#define __mDNSClientAPI_h

#if defined(EFI32) || defined(EFI64)

#include "Tiano.h"

#define va_list VA_LIST

#define va_start(a, b) VA_START(a, b)

#define va_end(a) VA_END(a)

#define va_arg(a, b) VA_ARG(a, b)

#else

#include <stdarg.h> // stdarg.h is required for for va_list support for the mDNS_vsnprintf declaration

#endif

#include "mDNSDebug.h"

#ifdef __cplusplus

extern "C" {

#endif

#ifndef mDNSlocal

#define mDNSlocal static

#endif

#ifndef mDNSexport

#define mDNSexport

#endif

#ifndef packedstruct

#if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))

#define packedstruct struct __attribute__((__packed__))

#define packedunion union __attribute__((__packed__))

#else

#define packedstruct struct

#define packedunion union

#endif

#endif

#if 0

#pragma mark - DNS Resource Record class and type constants

#endif

typedef enum // From RFC 1035

{

kDNSClass_IN = 1, // Internet

kDNSClass_CS = 2, // CSNET

kDNSClass_CH = 3, // CHAOS

kDNSClass_HS = 4, // Hesiod

kDNSClass_NONE = 254, // Used in DNS UPDATE [RFC 2136]

kDNSClass_Mask = 0x7FFF,// Multicast DNS uses the bottom 15 bits to identify the record class...

kDNSClass_UniqueRRSet = 0x8000,// ... and the top bit indicates that all other cached records are now invalid

kDNSQClass_ANY = 255, // Not a DNS class, but a DNS query class, meaning "all classes"

kDNSQClass_UnicastResponse = 0x8000 // Top bit set in a question means "unicast response acceptable"

} DNS_ClassValues;

typedef enum // From RFC 1035

{

kDNSType_A = 1, // 1 Address

kDNSType_NS, // 2 Name Server

kDNSType_MD, // 3 Mail Destination

kDNSType_MF, // 4 Mail Forwarder

kDNSType_CNAME, // 5 Canonical Name

kDNSType_SOA, // 6 Start of Authority

kDNSType_MB, // 7 Mailbox

kDNSType_MG, // 8 Mail Group

kDNSType_MR, // 9 Mail Rename

kDNSType_NULL, // 10 NULL RR

kDNSType_WKS, // 11 Well-known-service

kDNSType_PTR, // 12 Domain name pointer

kDNSType_HINFO, // 13 Host information

kDNSType_MINFO, // 14 Mailbox information

kDNSType_MX, // 15 Mail Exchanger

kDNSType_TXT, // 16 Arbitrary text string

kDNSType_AAAA = 28, // 28 IPv6 address

kDNSType_SRV = 33, // 33 Service record

kDNSType_OPT = 41, // EDNS0 OPT record

kDNSType_TSIG = 250, // 250 Transaction Signature

kDNSQType_ANY = 255 // Not a DNS type, but a DNS query type, meaning "all types"

} DNS_TypeValues;

#if 0

#pragma mark - Simple types

#endif

typedef int mDNSBool;

typedef signed char mDNSs8;

typedef unsigned char mDNSu8;

typedef signed short mDNSs16;

typedef unsigned short mDNSu16;

#if defined(_ILP64) || defined(__ILP64__)

typedef signed int32 mDNSs32;

typedef unsigned int32 mDNSu32;

#elif defined(_LP64) || defined(__LP64__)

typedef signed int mDNSs32;

typedef unsigned int mDNSu32;

#else

typedef signed long mDNSs32;

typedef unsigned long mDNSu32;

#endif

typedef struct mDNSInterfaceID_dummystruct { void *dummy; } *mDNSInterfaceID;

typedef packedunion { mDNSu8 b[ 2]; mDNSu16 NotAnInteger; } mDNSOpaque16;

typedef packedunion { mDNSu8 b[ 4]; mDNSu32 NotAnInteger; } mDNSOpaque32;

typedef packedunion { mDNSu8 b[ 6]; mDNSu16 w[3]; mDNSu32 l[1]; } mDNSOpaque48;

typedef packedunion { mDNSu8 b[16]; mDNSu16 w[8]; mDNSu32 l[4]; } mDNSOpaque128;

typedef mDNSOpaque16 mDNSIPPort; // An IP port is a two-byte opaque identifier (not an integer)

typedef mDNSOpaque32 mDNSv4Addr; // An IP address is a four-byte opaque identifier (not an integer)

typedef mDNSOpaque128 mDNSv6Addr; // An IPv6 address is a 16-byte opaque identifier (not an integer)

typedef mDNSOpaque48 mDNSEthAddr; // An Ethernet address is a six-byte opaque identifier (not an integer)

{

mDNSAddrType_None = 0,

mDNSAddrType_IPv4 = 4,

mDNSAddrType_IPv6 = 6,

mDNSAddrType_Unknown = ~0 // Special marker value used in known answer list recording

};

typedef struct

{

mDNSs32 type;

union { mDNSv6Addr v6; mDNSv4Addr v4; } ip;

} mDNSAddr;

enum { mDNSfalse = 0, mDNStrue = 1 };

#define mDNSNULL 0L

{

mStatus_Waiting = 1,

mStatus_NoError = 0,

// mDNS return values are in the range FFFE FF00 (-65792) to FFFE FFFF (-65537)

// The top end of the range (FFFE FFFF) is used for error codes;

// the bottom end of the range (FFFE FF00) is used for non-error values;

// Error codes:

mStatus_UnknownErr = -65537, // First value: 0xFFFE FFFF

mStatus_NoSuchNameErr = -65538,

mStatus_NoMemoryErr = -65539,

mStatus_BadParamErr = -65540,

mStatus_BadReferenceErr = -65541,

mStatus_BadStateErr = -65542,

mStatus_BadFlagsErr = -65543,

mStatus_UnsupportedErr = -65544,

mStatus_NotInitializedErr = -65545,

mStatus_NoCache = -65546,

mStatus_AlreadyRegistered = -65547,

mStatus_NameConflict = -65548,

mStatus_Invalid = -65549,

mStatus_Firewall = -65550,

mStatus_Incompatible = -65551,

mStatus_BadInterfaceErr = -65552,

mStatus_Refused = -65553,

mStatus_NoSuchRecord = -65554,

mStatus_NoAuth = -65555,

mStatus_NoSuchKey = -65556,

mStatus_NATTraversal = -65557,

mStatus_DoubleNAT = -65558,

mStatus_BadTime = -65559,

mStatus_BadSig = -65560, // while we define this per RFC 2845, BIND 9 returns Refused for bad/missing signatures

mStatus_BadKey = -65561,

mStatus_TransientErr = -65562, // transient failures, e.g. sending packets shortly after a network transition or wake from sleep

// -65563 to -65786 currently unused; available for allocation

// tcp connection status

mStatus_ConnPending = -65787,

mStatus_ConnFailed = -65788,

mStatus_ConnEstablished = -65789,

// Non-error values:

mStatus_GrowCache = -65790,

mStatus_ConfigChanged = -65791,

mStatus_MemFree = -65792 // Last value: 0xFFFE FF00

// mStatus_MemFree is the last legal mDNS error code, at the end of the range allocated for mDNS

};

typedef mDNSs32 mStatus;

#define MAX_DOMAIN_LABEL 63

typedef struct { mDNSu8 c[ 64]; } domainlabel; // One label: length byte and up to 63 characters

#define MAX_DOMAIN_NAME 255

typedef struct { mDNSu8 c[256]; } domainname; // Up to 255 bytes of length-prefixed domainlabels

typedef struct { mDNSu8 c[256]; } UTF8str255; // Null-terminated C string

#define MAX_ESCAPED_DOMAIN_LABEL 254

#define MAX_ESCAPED_DOMAIN_NAME 1005

#define kStandardTTL (3600UL * 100 / 80)

#define kHostNameTTL 120UL

#define kWideAreaTTL 3

#define DefaultTTLforRRType(X) (((X) == kDNSType_A || (X) == kDNSType_AAAA || (X) == kDNSType_SRV) ? kHostNameTTL : kStandardTTL)

#if 0

#pragma mark - DNS Message structures

#endif

#define mDNS_numZones numQuestions

#define mDNS_numPrereqs numAnswers

#define mDNS_numUpdates numAuthorities

typedef packedstruct

{

mDNSOpaque16 id;

mDNSOpaque16 flags;

mDNSu16 numQuestions;

mDNSu16 numAnswers;

mDNSu16 numAuthorities;

mDNSu16 numAdditionals;

} DNSMessageHeader;

#define AbsoluteMaxDNSMessageData 8940

#define NormalMaxDNSMessageData 1440

typedef packedstruct

{

DNSMessageHeader h; // Note: Size 12 bytes

mDNSu8 data[AbsoluteMaxDNSMessageData]; // 40 (IPv6) + 8 (UDP) + 12 (DNS header) + 8940 (data) = 9000

} DNSMessage;

#if 0

#pragma mark - Resource Record structures

#endif

{

kDNSRecordTypeUnregistered = 0x00, // Not currently in any list

kDNSRecordTypeDeregistering = 0x01, // Shared record about to announce its departure and leave the list

kDNSRecordTypeUnique = 0x02, // Will become a kDNSRecordTypeVerified when probing is complete

kDNSRecordTypeAdvisory = 0x04, // Like Shared, but no goodbye packet

kDNSRecordTypeShared = 0x08, // Shared means record name does not have to be unique -- use random delay on responses

kDNSRecordTypeVerified = 0x10, // Unique means mDNS should check that name is unique (and then send immediate responses)

kDNSRecordTypeKnownUnique = 0x20, // Known Unique means mDNS can assume name is unique without checking

// For Dynamic Update records, Known Unique means the record must already exist on the server.

kDNSRecordTypeUniqueMask = (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique),

kDNSRecordTypeActiveMask = (kDNSRecordTypeAdvisory | kDNSRecordTypeShared | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique),

kDNSRecordTypePacketAdd = 0x80, // Received in the Additional Section of a DNS Response

kDNSRecordTypePacketAddUnique = 0x90, // Received in the Additional Section of a DNS Response with kDNSClass_UniqueRRSet set

kDNSRecordTypePacketAuth = 0xA0, // Received in the Authorities Section of a DNS Response

kDNSRecordTypePacketAuthUnique = 0xB0, // Received in the Authorities Section of a DNS Response with kDNSClass_UniqueRRSet set

kDNSRecordTypePacketAns = 0xC0, // Received in the Answer Section of a DNS Response

kDNSRecordTypePacketAnsUnique = 0xD0, // Received in the Answer Section of a DNS Response with kDNSClass_UniqueRRSet set

kDNSRecordTypePacketAnsMask = 0x40, // True for PacketAns and PacketAnsUnique

kDNSRecordTypePacketUniqueMask = 0x10 // True for PacketAddUnique, PacketAnsUnique, PacketAuthUnique

};

typedef packedstruct { mDNSu16 priority; mDNSu16 weight; mDNSIPPort port; domainname target; } rdataSRV;

typedef packedstruct { mDNSu16 preference; domainname exchange; } rdataMX;

typedef packedstruct

{

domainname mname;

domainname rname;

mDNSs32 serial; // Modular counter; increases when zone changes

mDNSu32 refresh; // Time in seconds that a slave waits after successful replication of the database before it attempts replication again

mDNSu32 retry; // Time in seconds that a slave waits after an unsuccessful replication attempt before it attempts replication again

mDNSu32 expire; // Time in seconds that a slave holds on to old data while replication attempts remain unsuccessful

mDNSu32 min; // Nominally the minimum record TTL for this zone, in seconds; also used for negative caching.

} rdataSOA;

typedef packedstruct

{

mDNSu16 vers;

mDNSu16 llqOp;

mDNSu16 err;

mDNSu8 id[8];

mDNSu32 lease;

} LLQOptData;

#define LLQ_OPTLEN ((3 * sizeof(mDNSu16)) + 8 + sizeof(mDNSu32))

typedef packedstruct

{

mDNSu16 opt;

mDNSu16 optlen;

union { LLQOptData llq; mDNSu32 lease; } OptData;

} rdataOpt;

#define StandardAuthRDSize 264

#define MaximumRDSize 8192

#define InlineCacheRDSize 68

#define InlineCacheGroupNameSize 144

typedef union

{

mDNSu8 data[StandardAuthRDSize];

mDNSv4Addr ipv4; // For 'A' record

mDNSv6Addr ipv6; // For 'AAAA' record

domainname name; // For PTR, NS, and CNAME records

UTF8str255 txt; // For TXT record

rdataSRV srv; // For SRV record

rdataMX mx; // For MX record

rdataSOA soa; // For SOA record

rdataOpt opt; // For eDNS0 opt record

} RDataBody;

typedef struct

{

mDNSu16 MaxRDLength; // Amount of storage allocated for rdata (usually sizeof(RDataBody))

RDataBody u;

} RData;

#define sizeofRDataHeader (sizeof(RData) - sizeof(RDataBody))

typedef struct AuthRecord_struct AuthRecord;

typedef struct CacheRecord_struct CacheRecord;

typedef struct CacheGroup_struct CacheGroup;

typedef struct DNSQuestion_struct DNSQuestion;

typedef struct mDNS_struct mDNS;

typedef struct mDNS_PlatformSupport_struct mDNS_PlatformSupport;

typedef struct NATTraversalInfo_struct NATTraversalInfo;

typedef void mDNSRecordCallback(mDNS *const m, AuthRecord *const rr, mStatus result);

typedef void mDNSRecordUpdateCallback(mDNS *const m, AuthRecord *const rr, RData *OldRData);

typedef struct

{

mDNSu8 RecordType; // See enum above

mDNSInterfaceID InterfaceID; // Set if this RR is specific to one interface

// For records received off the wire, InterfaceID is *always* set to the receiving interface

// For our authoritative records, InterfaceID is usually zero, except for those few records

// that are interface-specific (e.g. address records, especially linklocal addresses)

domainname *name;

mDNSu16 rrtype;

mDNSu16 rrclass;

mDNSu32 rroriginalttl; // In seconds

mDNSu16 rdlength; // Size of the raw rdata, in bytes

mDNSu16 rdestimate; // Upper bound on size of rdata after name compression

mDNSu32 namehash; // Name-based (i.e. case-insensitive) hash of name

mDNSu32 rdatahash; // For rdata containing domain name (e.g. PTR, SRV, CNAME etc.), case-insensitive name hash

// else, for all other rdata, 32-bit hash of the raw rdata

// Note: This requirement is important. Various routines like AddAdditionalsToResponseList(),

// ReconfirmAntecedents(), etc., use rdatahash as a pre-flight check to see

// whether it's worth doing a full SameDomainName() call. If the rdatahash

// is not a correct case-insensitive name hash, they'll get false negatives.

RData *rdata; // Pointer to storage for this rdata

} ResourceRecord;

typedef enum

{

regState_FetchingZoneData = 1, // getting info - update not sent

regState_Pending = 2, // update sent, reply not received

regState_Registered = 3, // update sent, reply received

regState_DeregPending = 4, // dereg sent, reply not received

regState_DeregDeferred = 5, // dereg requested while in Pending state - send dereg AFTER registration is confirmed

regState_Cancelled = 6, // update not sent, reg. cancelled by client

regState_Unregistered = 8, // not in any list

regState_Refresh = 9, // outstanding refresh (or target change) message

regState_NATMap = 10, // establishing NAT port mapping or learning public address

regState_UpdatePending = 11, // update in flight as result of mDNS_Update call

regState_NoTarget = 12, // service registration pending registration of hostname (ServiceRegistrations only)

regState_ExtraQueued = 13, // extra record to be registered upon completion of service registration (RecordRegistrations only)

regState_NATError = 14 // unable to complete NAT traversal

} regState_t;

typedef struct

{

// registration/lease state

regState_t state;

mDNSBool lease; // dynamic update contains (should contain) lease option

mDNSs32 expire; // expiration of lease (-1 for static)

mDNSBool TestForSelfConflict; // on name conflict, check if we're just seeing our own orphaned records

// identifier to match update request and response

mDNSOpaque16 id;

// server info

domainname zone; // the zone that is updated

mDNSAddr ns; // primary name server for the record's zone !!!KRS not technically correct to cache longer than TTL

mDNSIPPort port; // port on which server accepts dynamic updates

// NAT traversal context

NATTraversalInfo *NATinfo; // may be NULL

// state for deferred operations

mDNSBool ClientCallbackDeferred; // invoke client callback on completion of pending operation(s)

mStatus DeferredStatus; // status to deliver when above flag is set

mDNSBool SRVUpdateDeferred; // do we need to change target or port once current operation completes?

mDNSBool SRVChanged; // temporarily deregistered service because its SRV target or port changed

// uDNS_UpdateRecord support fields

RData *OrigRData; mDNSu16 OrigRDLen; // previously registered, being deleted

RData *InFlightRData; mDNSu16 InFlightRDLen; // currently being registered

RData *QueuedRData; mDNSu16 QueuedRDLen; // if the client call Update while an update is in flight, we must finish the

// pending operation (re-transmitting if necessary) THEN register the queued update

mDNSRecordUpdateCallback *UpdateRDCallback; // client callback to free old rdata

} uDNS_RegInfo;

struct AuthRecord_struct

{

// For examples of how to set up this structure for use in mDNS_Register(),

// see mDNS_AdvertiseInterface() or mDNS_RegisterService().

// Basically, resrec and persistent metadata need to be set up before calling mDNS_Register().

// mDNS_SetupResourceRecord() is avaliable as a helper routine to set up most fields to sensible default values for you

AuthRecord *next; // Next in list; first element of structure for efficiency reasons

// Field Group 1: Common ResourceRecord fields

ResourceRecord resrec;

uDNS_RegInfo uDNS_info;

// Field Group 2: Persistent metadata for Authoritative Records

AuthRecord *Additional1; // Recommended additional record to include in response

AuthRecord *Additional2; // Another additional

AuthRecord *DependentOn; // This record depends on another for its uniqueness checking

AuthRecord *RRSet; // This unique record is part of an RRSet

mDNSRecordCallback *RecordCallback; // Callback function to call for state changes, and to free memory asynchronously on deregistration

void *RecordContext; // Context parameter for the callback function

mDNSu8 HostTarget; // Set if the target of this record (PTR, CNAME, SRV, etc.) is our host name

mDNSu8 AllowRemoteQuery; // Set if we allow hosts not on the local link to query this record

mDNSu8 ForceMCast; // Set by client to advertise solely via multicast, even for apparently unicast names

// Field Group 3: Transient state for Authoritative Records

mDNSu8 Acknowledged; // Set if we've given the success callback to the client

mDNSu8 ProbeCount; // Number of probes remaining before this record is valid (kDNSRecordTypeUnique)

mDNSu8 AnnounceCount; // Number of announcements remaining (kDNSRecordTypeShared)

mDNSu8 RequireGoodbye; // Set if this RR has been announced on the wire and will require a goodbye packet

mDNSu8 LocalAnswer; // Set if this RR has been delivered to LocalOnly questions

mDNSu8 IncludeInProbe; // Set if this RR is being put into a probe right now

mDNSInterfaceID ImmedAnswer; // Someone on this interface issued a query we need to answer (all-ones for all interfaces)

mDNSu8 ImmedUnicast; // Set if we may send our response directly via unicast to the requester

#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES

mDNSs32 ImmedAnswerMarkTime;

#endif

mDNSInterfaceID ImmedAdditional; // Hint that we might want to also send this record, just to be helpful

mDNSInterfaceID SendRNow; // The interface this query is being sent on right now

mDNSv4Addr v4Requester; // Recent v4 query for this record, or all-ones if more than one recent query

mDNSv6Addr v6Requester; // Recent v6 query for this record, or all-ones if more than one recent query

AuthRecord *NextResponse; // Link to the next element in the chain of responses to generate

const mDNSu8 *NR_AnswerTo; // Set if this record was selected by virtue of being a direct answer to a question

AuthRecord *NR_AdditionalTo; // Set if this record was selected by virtue of being additional to another

mDNSs32 ThisAPInterval; // In platform time units: Current interval for announce/probe

mDNSs32 AnnounceUntil; // In platform time units: Creation time + TTL

mDNSs32 LastAPTime; // In platform time units: Last time we sent announcement/probe

mDNSs32 LastMCTime; // Last time we multicast this record (used to guard against packet-storm attacks)

mDNSInterfaceID LastMCInterface; // Interface this record was multicast on at the time LastMCTime was recorded

RData *NewRData; // Set if we are updating this record with new rdata

mDNSu16 newrdlength; // ... and the length of the new RData

mDNSRecordUpdateCallback *UpdateCallback;

mDNSu32 UpdateCredits; // Token-bucket rate limiting of excessive updates

mDNSs32 NextUpdateCredit; // Time next token is added to bucket

mDNSs32 UpdateBlocked; // Set if update delaying is in effect

domainname namestorage;

RData rdatastorage; // Normally the storage is right here, except for oversized records

// rdatastorage MUST be the last thing in the structure -- when using oversized AuthRecords, extra bytes

// are appended after the end of the AuthRecord, logically augmenting the size of the rdatastorage

// DO NOT ADD ANY MORE FIELDS HERE

};

typedef struct ARListElem

{

struct ARListElem *next;

AuthRecord ar; // Note: Must be last struct in field to accomodate oversized AuthRecords

} ARListElem;

struct CacheGroup_struct // Header object for a list of CacheRecords with the same name

{

CacheGroup *next; // Next CacheGroup object in this hash table bucket

mDNSu32 namehash; // Name-based (i.e. case insensitive) hash of name

CacheRecord *members; // List of CacheRecords with this same name

CacheRecord **rrcache_tail; // Tail end of that list

domainname *name; // Common name for all CacheRecords in this list

mDNSu8 namestorage[InlineCacheGroupNameSize];

};

struct CacheRecord_struct

{

CacheRecord *next; // Next in list; first element of structure for efficiency reasons

ResourceRecord resrec;

// Transient state for Cache Records

CacheRecord *NextInKAList; // Link to the next element in the chain of known answers to send

mDNSs32 TimeRcvd; // In platform time units

mDNSs32 DelayDelivery; // Set if we want to defer delivery of this answer to local clients

mDNSs32 NextRequiredQuery; // In platform time units

mDNSs32 LastUsed; // In platform time units

DNSQuestion *CRActiveQuestion; // Points to an active question referencing this answer

mDNSu32 UnansweredQueries; // Number of times we've issued a query for this record without getting an answer

mDNSs32 LastUnansweredTime; // In platform time units; last time we incremented UnansweredQueries

mDNSu32 MPUnansweredQ; // Multi-packet query handling: Number of times we've seen a query for this record

mDNSs32 MPLastUnansweredQT; // Multi-packet query handling: Last time we incremented MPUnansweredQ

mDNSu32 MPUnansweredKA; // Multi-packet query handling: Number of times we've seen this record in a KA list

mDNSBool MPExpectingKA; // Multi-packet query handling: Set when we increment MPUnansweredQ; allows one KA

CacheRecord *NextInCFList; // Set if this is in the list of records we just received with the cache flush bit set

struct { mDNSu16 MaxRDLength; mDNSu8 data[InlineCacheRDSize]; } rdatastorage; // Storage for small records is right here

};

typedef union CacheEntity_union CacheEntity;

union CacheEntity_union { CacheEntity *next; CacheGroup cg; CacheRecord cr; };

typedef struct

{

CacheRecord r;

mDNSu8 _extradata[MaximumRDSize-InlineCacheRDSize]; // Glue on the necessary number of extra bytes

domainname namestorage; // Needs to go *after* the extra rdata bytes

} LargeCacheRecord;

typedef struct uDNS_HostnameInfo

{

struct uDNS_HostnameInfo *next;

domainname fqdn;

AuthRecord *arv4; // registered IPv4 address record

AuthRecord *arv6; // registered IPv6 address record

mDNSRecordCallback *StatusCallback; // callback to deliver success or error code to client layer

const void *StatusContext; // Client Context

} uDNS_HostnameInfo;

{

DNSServer_Untested = 0,

DNSServer_Failed = 1,

DNSServer_Passed = 2

};

typedef struct DNSServer

{

struct DNSServer *next;

mDNSAddr addr;

mDNSBool del; // Set when we're planning to delete this from the list

mDNSu32 teststate; // Have we sent bug-detection query to this server?

domainname domain; // name->server matching for "split dns"

} DNSServer;

typedef struct NetworkInterfaceInfo_struct NetworkInterfaceInfo;

struct NetworkInterfaceInfo_struct

{

// Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.

NetworkInterfaceInfo *next;

mDNSBool InterfaceActive; // Set if interface is sending & receiving packets (see comment above)

mDNSBool IPv4Available; // If InterfaceActive, set if v4 available on this InterfaceID

mDNSBool IPv6Available; // If InterfaceActive, set if v6 available on this InterfaceID

// Standard AuthRecords that every Responder host should have (one per active IP address)

AuthRecord RR_A; // 'A' or 'AAAA' (address) record for our ".local" name

AuthRecord RR_PTR; // PTR (reverse lookup) record

AuthRecord RR_HINFO;

// Client API fields: The client must set up these fields *before* calling mDNS_RegisterInterface()

mDNSInterfaceID InterfaceID; // Identifies physical interface; MUST NOT be 0, -1, or -2

mDNSAddr ip; // The IPv4 or IPv6 address to advertise

mDNSAddr mask;

char ifname[64]; // Windows uses a GUID string for the interface name, which doesn't fit in 16 bytes

mDNSBool Advertise; // False if you are only searching on this interface

mDNSBool McastTxRx; // Send/Receive multicast on this { InterfaceID, address family } ?

};

typedef struct ExtraResourceRecord_struct ExtraResourceRecord;

struct ExtraResourceRecord_struct

{

ExtraResourceRecord *next;

mDNSu32 ClientID; // Opaque ID field to be used by client to map an AddRecord call to a set of Extra records

AuthRecord r;

// Note: Add any additional fields *before* the AuthRecord in this structure, not at the end.

// In some cases clients can allocate larger chunks of memory and set r->rdata->MaxRDLength to indicate

// that this extra memory is available, which would result in any fields after the AuthRecord getting smashed

};

typedef struct ServiceRecordSet_struct ServiceRecordSet;

typedef void mDNSServiceCallback(mDNS *const m, ServiceRecordSet *const sr, mStatus result);

struct ServiceRecordSet_struct

{

// Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.

// No fields need to be set up by the client prior to calling mDNS_RegisterService();

// all required data is passed as parameters to that function.

ServiceRecordSet *next;

uDNS_RegInfo uDNS_info;

mDNSServiceCallback *ServiceCallback;

void *ServiceContext;

ExtraResourceRecord *Extras; // Optional list of extra AuthRecords attached to this service registration

mDNSu32 NumSubTypes;

AuthRecord *SubTypes;

mDNSBool Conflict; // Set if this record set was forcibly deregistered because of a conflict

domainname Host; // Set if this service record does not use the standard target host name

AuthRecord RR_ADV; // e.g. _services._dns-sd._udp.local. PTR _printer._tcp.local.

AuthRecord RR_PTR; // e.g. _printer._tcp.local. PTR Name._printer._tcp.local.

AuthRecord RR_SRV; // e.g. Name._printer._tcp.local. SRV 0 0 port target

AuthRecord RR_TXT; // e.g. Name._printer._tcp.local. TXT PrintQueueName

// Don't add any fields after AuthRecord RR_TXT.

// This is where the implicit extra space goes if we allocate a ServiceRecordSet containing an oversized RR_TXT record

};

#if 0

#pragma mark - Question structures

#endif

#define DupSuppressInfoSize 8

typedef struct

{

mDNSs32 Time;

mDNSInterfaceID InterfaceID;

mDNSs32 Type; // v4 or v6?

} DupSuppressInfo;

typedef enum

{

// Setup states

LLQ_UnInit = 0,

LLQ_GetZoneInfo = 1,

LLQ_InitialRequest = 2,

LLQ_SecondaryRequest = 3,

LLQ_Refresh = 4,

LLQ_Retry = 5,

LLQ_Established = 6,

LLQ_Suspended = 7,

LLQ_SuspendDeferred = 8, // suspend once we get zone info

LLQ_SuspendedPoll = 9, // suspended from polling state

LLQ_NatMapWait = 10,

// Established/error states

LLQ_Static = 16,

LLQ_Poll = 17,

LLQ_Error = 18,

LLQ_Cancelled = 19

} LLQ_State;

typedef struct

{

LLQ_State state;

mDNSAddr servAddr;

mDNSIPPort servPort;

DNSQuestion *question;

mDNSu32 origLease; // seconds (relative)

mDNSs32 retry; // ticks (absolute)

mDNSs32 expire; // ticks (absolute)

mDNSs16 ntries;

mDNSu8 id[8];

mDNSBool deriveRemovesOnResume;

mDNSBool NATMap; // does this LLQ use the global LLQ NAT mapping?

} LLQ_Info;

#define kDNSOpt_LLQ 1

#define kDNSOpt_Lease 2

#define kLLQ_Vers 1

#define kLLQ_DefLease 7200 // 2 hours

#define kLLQ_MAX_TRIES 3 // retry an operation 3 times max

#define kLLQ_INIT_RESEND 2 // resend an un-ack'd packet after 2 seconds, then double for each additional

#define kLLQ_DEF_RETRY 1800 // retry a failed operation after 30 minutes

#define kLLQOp_Setup 1

#define kLLQOp_Refresh 2

#define kLLQOp_Event 3

#define LLQ_OPT_RDLEN ((2 * sizeof(mDNSu16)) + LLQ_OPTLEN)

#define LEASE_OPT_RDLEN (2 * sizeof(mDNSu16)) + sizeof(mDNSs32)

{

LLQErr_NoError = 0,

LLQErr_ServFull = 1,

LLQErr_Static = 2,

LLQErr_FormErr = 3,

LLQErr_NoSuchLLQ = 4,

LLQErr_BadVers = 5,

LLQErr_UnknownErr = 6

};

typedef void (*InternalResponseHndlr)(mDNS *const m, DNSMessage *msg, const mDNSu8 *end, DNSQuestion *question, void *internalContext);

typedef struct

{

mDNSOpaque16 id;

mDNSBool internal;

InternalResponseHndlr responseCallback; // NULL if internal field is false

LLQ_Info *llq; // NULL for 1-shot queries

mDNSBool Answered; // have we received an answer (including NXDOMAIN) for this question?

CacheRecord *knownAnswers;

mDNSs32 RestartTime; // Mark when we restart a suspended query

void *context;

} uDNS_QuestionInfo;

typedef void mDNSQuestionCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord);

struct DNSQuestion_struct

{

// Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.

DNSQuestion *next;

mDNSu32 qnamehash;

mDNSs32 DelayAnswering; // Set if we want to defer answering this question until the cache settles

mDNSs32 LastQTime; // Last scheduled transmission of this Q on *all* applicable interfaces

mDNSs32 ThisQInterval; // LastQTime + ThisQInterval is the next scheduled transmission of this Q

// ThisQInterval > 0 for an active question;

// ThisQInterval = 0 for a suspended question that's still in the list

// ThisQInterval = -1 for a cancelled question that's been removed from the list

mDNSs32 LastAnswerPktNum; // The sequence number of the last response packet containing an answer to this Q

mDNSu32 RecentAnswerPkts; // Number of answers since the last time we sent this query

mDNSu32 CurrentAnswers; // Number of records currently in the cache that answer this question

mDNSu32 LargeAnswers; // Number of answers with rdata > 1024 bytes

mDNSu32 UniqueAnswers; // Number of answers received with kDNSClass_UniqueRRSet bit set

mDNSInterfaceID FlappingInterface;// Set when an interface goes away, to flag if removes are delivered for this Q

DNSQuestion *DuplicateOf;

DNSQuestion *NextInDQList;

DupSuppressInfo DupSuppress[DupSuppressInfoSize];

mDNSInterfaceID SendQNow; // The interface this query is being sent on right now

mDNSBool SendOnAll; // Set if we're sending this question on all active interfaces

mDNSu32 RequestUnicast; // Non-zero if we want to send query with kDNSQClass_UnicastResponse bit set

mDNSs32 LastQTxTime; // Last time this Q was sent on one (but not necessarily all) interfaces

uDNS_QuestionInfo uDNS_info;

// Client API fields: The client must set up these fields *before* calling mDNS_StartQuery()

mDNSInterfaceID InterfaceID; // Non-zero if you want to issue queries only on a single specific IP interface

mDNSAddr Target; // Non-zero if you want to direct queries to a specific unicast target address

mDNSIPPort TargetPort; // Must be set if Target is set

mDNSOpaque16 TargetQID; // Must be set if Target is set

domainname qname;

mDNSu16 qtype;

mDNSu16 qclass;

mDNSBool LongLived; // Set by client for calls to mDNS_StartQuery to indicate LLQs to unicast layer.

mDNSBool ExpectUnique; // Set by client if it's expecting unique RR(s) for this question, not shared RRs

mDNSBool ForceMCast; // Set by client to force mDNS query, even for apparently uDNS names

mDNSBool ReturnCNAME; // Set by client to request callbacks for intermediate CNAME records

mDNSQuestionCallback *QuestionCallback;

void *QuestionContext;

};

typedef struct

{

// Client API fields: The client must set up name and InterfaceID *before* calling mDNS_StartResolveService()

// When the callback is invoked, ip, port, TXTlen and TXTinfo will have been filled in with the results learned from the network.

domainname name;

mDNSInterfaceID InterfaceID; // ID of the interface the response was received on

mDNSAddr ip; // Remote (destination) IP address where this service can be accessed

mDNSIPPort port; // Port where this service can be accessed

mDNSu16 TXTlen;

mDNSu8 TXTinfo[2048]; // Additional demultiplexing information (e.g. LPR queue name)

} ServiceInfo;

typedef struct ServiceInfoQuery_struct ServiceInfoQuery;

typedef void mDNSServiceInfoQueryCallback(mDNS *const m, ServiceInfoQuery *query);

struct ServiceInfoQuery_struct

{

// Internal state fields. These are used internally by mDNSCore; the client layer needn't be concerned with them.

// No fields need to be set up by the client prior to calling mDNS_StartResolveService();

// all required data is passed as parameters to that function.

// The ServiceInfoQuery structure memory is working storage for mDNSCore to discover the requested information

// and place it in the ServiceInfo structure. After the client has called mDNS_StopResolveService(), it may

// dispose of the ServiceInfoQuery structure while retaining the results in the ServiceInfo structure.

DNSQuestion qSRV;

DNSQuestion qTXT;

DNSQuestion qAv4;

DNSQuestion qAv6;

mDNSu8 GotSRV;

mDNSu8 GotTXT;

mDNSu8 GotADD;

mDNSu32 Answers;

ServiceInfo *info;

mDNSServiceInfoQueryCallback *ServiceInfoQueryCallback;

void *ServiceInfoQueryContext;

};

#if 0

#pragma mark - NAT Traversal structures and constants

#endif

#define NATMAP_INIT_RETRY (mDNSPlatformOneSecond / 4) // start at 250ms w/ exponential decay

#define NATMAP_MAX_RETRY mDNSPlatformOneSecond // back off to once per second

#define NATMAP_MAX_TRIES 3 // for max 3 tries

#define NATMAP_DEFAULT_LEASE (60 * 60) // lease life in seconds

#define NATMAP_VERS 0

#define NATMAP_RESPONSE_MASK 0x80

typedef enum

{

NATOp_AddrRequest = 0,

NATOp_MapUDP = 1,

NATOp_MapTCP = 2

} NATOp_t;

{

NATErr_None = 0,

NATErr_Vers = 1,

NATErr_Refused = 2,

NATErr_NetFail = 3,

NATErr_Res = 4,

NATErr_Opcode = 5

};

typedef mDNSu16 NATErr_t;

typedef enum

{

NATState_Init = 0,

NATState_Request = 1,

NATState_Established = 2,

NATState_Legacy = 3,

NATState_Error = 4,

NATState_Refresh = 5,

NATState_Deleted = 6

} NATState_t;

// have an outstanding NAT request. This is conveyed by the "reg" pointer being set to NULL

typedef packedstruct

{

mDNSu8 vers;

mDNSu8 opcode;

} NATAddrRequest;

typedef packedstruct

{

mDNSu8 vers;

mDNSu8 opcode;

mDNSOpaque16 err;

mDNSOpaque32 uptime;

mDNSv4Addr PubAddr;

} NATAddrReply;

typedef packedstruct

{

mDNSu8 vers;

mDNSu8 opcode;

mDNSOpaque16 unused;

mDNSIPPort priv;

mDNSIPPort pub;

mDNSOpaque32 lease;

} NATPortMapRequest;

typedef packedstruct

{

mDNSu8 vers;

mDNSu8 opcode;

mDNSOpaque16 err;

mDNSOpaque32 uptime;

mDNSIPPort priv;

mDNSIPPort pub;

mDNSOpaque32 lease;

} NATPortMapReply;

typedef mDNSBool (*NATResponseHndlr)(NATTraversalInfo *n, mDNS *m, mDNSu8 *pkt, mDNSu16 len);

struct NATTraversalInfo_struct

{

NATOp_t op;

NATResponseHndlr ReceiveResponse;

union { AuthRecord *RecordRegistration; ServiceRecordSet *ServiceRegistration; } reg;

mDNSAddr Router;

mDNSIPPort PublicPort;

union { NATAddrRequest AddrReq; NATPortMapRequest PortReq; } request;

mDNSs32 retry; // absolute time when we retry

mDNSs32 RetryInterval; // delta between time sent and retry

int ntries;

NATState_t state;

NATTraversalInfo *next;

};

#if 0

#pragma mark - Main mDNS object, used to hold all the mDNS state

#endif

typedef void mDNSCallback(mDNS *const m, mStatus result);

#define CACHE_HASH_SLOTS 499

{

mDNS_KnownBug_PhantomInterfaces = 1

};

typedef struct

{

mDNSs32 nextevent;

DNSQuestion *ActiveQueries; //!!!KRS this should be a hashtable (hash on messageID)

DNSQuestion *CurrentQuery; // pointer to ActiveQueries list being examined in a loop. Functions that remove

// elements from the ActiveQueries list must update this pointer (if non-NULL) as necessary.

//!!!KRS do the same for registration lists

ServiceRecordSet *ServiceRegistrations;

AuthRecord *RecordRegistrations;

NATTraversalInfo *NATTraversals;

mDNSu16 NextMessageID;

DNSServer *Servers; // list of DNS servers

mDNSAddr Router;

mDNSAddr AdvertisedV4; // IPv4 address pointed to by hostname

mDNSAddr MappedV4; // Cache of public address if PrimaryIP is behind a NAT

mDNSAddr AdvertisedV6; // IPv6 address pointed to by hostname

NATTraversalInfo *LLQNatInfo; // Nat port mapping to receive LLQ events

domainname ServiceRegDomain; // (going away w/ multi-user support)

struct uDNS_AuthInfo *AuthInfoList; // list of domains requiring authentication for updates.

uDNS_HostnameInfo *Hostnames; // List of registered hostnames + hostname metadata

DNSQuestion ReverseMap; // Reverse-map query to find static hostname for service target

mDNSBool ReverseMapActive; // Is above query active?

domainname StaticHostname; // Current answer to reverse-map query (above)

mDNSBool DelaySRVUpdate; // Delay SRV target/port update to avoid "flap"

mDNSs32 NextSRVUpdate; // Time to perform delayed update

} uDNS_GlobalInfo;

struct mDNS_struct

{

// Internal state fields. These hold the main internal state of mDNSCore;

// the client layer needn't be concerned with them.

// No fields need to be set up by the client prior to calling mDNS_Init();

// all required data is passed as parameters to that function.

mDNS_PlatformSupport *p; // Pointer to platform-specific data of indeterminite size

mDNSu32 KnownBugs;

mDNSBool CanReceiveUnicastOn5353;

mDNSBool AdvertiseLocalAddresses;

mStatus mDNSPlatformStatus;

mDNSIPPort UnicastPort4;

mDNSIPPort UnicastPort6;

mDNSCallback *MainCallback;

void *MainContext;

// For debugging: To catch and report locking failures

mDNSu32 mDNS_busy; // Incremented between mDNS_Lock/mDNS_Unlock section

mDNSu32 mDNS_reentrancy; // Incremented when calling a client callback

mDNSu8 mDNS_shutdown; // Set when we're shutting down, allows us to skip some unnecessary steps

mDNSu8 lock_rrcache; // For debugging: Set at times when these lists may not be modified

mDNSu8 lock_Questions;

mDNSu8 lock_Records;

#define MaxMsg 120

char MsgBuffer[MaxMsg]; // Temp storage used while building error log messages

// Task Scheduling variables

mDNSs32 timenow_adjust; // Correction applied if we ever discover time went backwards

mDNSs32 timenow; // The time that this particular activation of the mDNS code started

mDNSs32 timenow_last; // The time the last time we ran

mDNSs32 NextScheduledEvent; // Derived from values below

mDNSs32 SuppressSending; // Don't send *any* packets during this time

mDNSs32 NextCacheCheck; // Next time to refresh cache record before it expires

mDNSs32 NextScheduledQuery; // Next time to send query in its exponential backoff sequence

mDNSs32 NextScheduledProbe; // Next time to probe for new authoritative record

mDNSs32 NextScheduledResponse; // Next time to send authoritative record(s) in responses

mDNSs32 ExpectUnicastResponse; // Set when we send a query with the kDNSQClass_UnicastResponse bit set

mDNSs32 RandomQueryDelay; // For de-synchronization of query packets on the wire

mDNSu32 RandomReconfirmDelay; // For de-synchronization of reconfirmation queries on the wire

mDNSs32 PktNum; // Unique sequence number assigned to each received packet

mDNSBool SendDeregistrations; // Set if we need to send deregistrations (immediately)

mDNSBool SendImmediateAnswers; // Set if we need to send answers (immediately -- or as soon as SuppressSending clears)

mDNSBool SleepState; // Set if we're sleeping (send no more packets)

// These fields only required for mDNS Searcher...

DNSQuestion *Questions; // List of all registered questions, active and inactive

DNSQuestion *NewQuestions; // Fresh questions not yet answered from cache

DNSQuestion *CurrentQuestion; // Next question about to be examined in AnswerLocalQuestions()

DNSQuestion *LocalOnlyQuestions; // Questions with InterfaceID set to mDNSInterface_LocalOnly

DNSQuestion *NewLocalOnlyQuestions; // Fresh local-only questions not yet answered

mDNSu32 rrcache_size; // Total number of available cache entries

mDNSu32 rrcache_totalused; // Number of cache entries currently occupied

mDNSu32 rrcache_active; // Number of cache entries currently occupied by records that answer active questions

mDNSu32 rrcache_report;

CacheEntity *rrcache_free;

CacheGroup *rrcache_hash[CACHE_HASH_SLOTS];

// Fields below only required for mDNS Responder...

domainlabel nicelabel; // Rich text label encoded using canonically precomposed UTF-8

domainlabel hostlabel; // Conforms to RFC 1034 "letter-digit-hyphen" ARPANET host name rules

domainname MulticastHostname; // Fully Qualified "dot-local" Host Name, e.g. "Foo.local."

UTF8str255 HIHardware;

UTF8str255 HISoftware;

AuthRecord *ResourceRecords;

AuthRecord *DuplicateRecords; // Records currently 'on hold' because they are duplicates of existing records

AuthRecord *NewLocalRecords; // Fresh local-only records not yet delivered to local-only questions

AuthRecord *CurrentRecord; // Next AuthRecord about to be examined

NetworkInterfaceInfo *HostInterfaces;

mDNSs32 ProbeFailTime;

mDNSu32 NumFailedProbes;

mDNSs32 SuppressProbes;

// unicast-specific data

uDNS_GlobalInfo uDNS_info;

mDNSs32 SuppressStdPort53Queries; // Wait before allowing the next standard unicast query to the user's configured DNS server

// Fixed storage, to avoid creating large objects on the stack

DNSMessage imsg; // Incoming message received from wire

DNSMessage omsg; // Outgoing message we're building

LargeCacheRecord rec; // Resource Record extracted from received message

};

#define FORALL_CACHERECORDS(SLOT,CG,CR) \

for ((SLOT) = 0; (SLOT) < CACHE_HASH_SLOTS; (SLOT)++) \

for((CG)=m->rrcache_hash[(SLOT)]; (CG); (CG)=(CG)->next) \

for ((CR) = (CG)->members; (CR); (CR)=(CR)->next)

#if 0

#pragma mark - Useful Static Constants

#endif

extern const mDNSIPPort zeroIPPort;

extern const mDNSv4Addr zerov4Addr;

extern const mDNSv6Addr zerov6Addr;

extern const mDNSEthAddr zeroEthAddr;

extern const mDNSv4Addr onesIPv4Addr;

extern const mDNSv6Addr onesIPv6Addr;

extern const mDNSAddr zeroAddr;

extern const mDNSInterfaceID mDNSInterface_Any; // Zero

extern const mDNSInterfaceID mDNSInterface_LocalOnly; // Special value

extern const mDNSIPPort UnicastDNSPort;

extern const mDNSIPPort NATPMPPort;

extern const mDNSIPPort DNSEXTPort;

extern const mDNSIPPort MulticastDNSPort;

extern const mDNSIPPort LoopbackIPCPort;

extern const mDNSv4Addr AllDNSAdminGroup;

#define AllDNSLinkGroupv4 (AllDNSLinkGroup_v4.ip.v4)

#define AllDNSLinkGroupv6 (AllDNSLinkGroup_v6.ip.v6)

extern const mDNSAddr AllDNSLinkGroup_v4;

extern const mDNSAddr AllDNSLinkGroup_v6;

extern const mDNSOpaque16 zeroID;

extern const mDNSOpaque16 QueryFlags;

extern const mDNSOpaque16 uQueryFlags;

extern const mDNSOpaque16 ResponseFlags;

extern const mDNSOpaque16 UpdateReqFlags;

extern const mDNSOpaque16 UpdateRespFlags;

#define localdomain (*(const domainname *)"\x5" "local")

#define LocalReverseMapDomain (*(const domainname *)"\x3" "254" "\x3" "169" "\x7" "in-addr" "\x4" "arpa")

#if 0

#pragma mark - Inline functions

#endif

#if (defined(_MSC_VER))

#define mDNSinline static __inline

#elif ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 9)))

#define mDNSinline static inline

#endif

#if !defined(mDNSinline)

extern mDNSs32 NonZeroTime(mDNSs32 t);

extern mDNSu16 mDNSVal16(mDNSOpaque16 x);

extern mDNSu32 mDNSVal32(mDNSOpaque32 x);

extern mDNSOpaque16 mDNSOpaque16fromIntVal(mDNSu16 v);

extern mDNSOpaque32 mDNSOpaque32fromIntVal(mDNSu32 v);

#endif

#if (!defined(mDNSinline) && mDNS_InstantiateInlines)

#define mDNSinline

#endif

#ifdef mDNSinline

mDNSinline mDNSs32 NonZeroTime(mDNSs32 t) { if (t) return(t); else return(1); }

mDNSinline mDNSu16 mDNSVal16(mDNSOpaque16 x) { return((mDNSu16)((mDNSu16)x.b[0] << 8 | (mDNSu16)x.b[1])); }

mDNSinline mDNSu32 mDNSVal32(mDNSOpaque32 x) { return((mDNSu32)((mDNSu32)x.b[0] << 24 | (mDNSu32)x.b[1] << 16 | (mDNSu32)x.b[2] << 8 | (mDNSu32)x.b[3])); }

mDNSinline mDNSOpaque16 mDNSOpaque16fromIntVal(mDNSu16 v)

{

mDNSOpaque16 x;

x.b[0] = (mDNSu8)(v >> 8);

x.b[1] = (mDNSu8)(v & 0xFF);

return(x);

}

mDNSinline mDNSOpaque32 mDNSOpaque32fromIntVal(mDNSu32 v)

{

mDNSOpaque32 x;

x.b[0] = (mDNSu8) (v >> 24) ;

x.b[1] = (mDNSu8)((v >> 16) & 0xFF);

x.b[2] = (mDNSu8)((v >> 8 ) & 0xFF);

x.b[3] = (mDNSu8)((v ) & 0xFF);

return x;

}

#endif

#if 0

#pragma mark - Main Client Functions

#endif

extern mStatus mDNS_Init (mDNS *const m, mDNS_PlatformSupport *const p,

CacheEntity *rrcachestorage, mDNSu32 rrcachesize,

mDNSBool AdvertiseLocalAddresses,

mDNSCallback *Callback, void *Context);

#define mDNS_Init_NoCache mDNSNULL

#define mDNS_Init_ZeroCacheSize 0

#define mDNS_Init_AdvertiseLocalAddresses mDNStrue

#define mDNS_Init_DontAdvertiseLocalAddresses mDNSfalse

#define mDNS_Init_NoInitCallback mDNSNULL

#define mDNS_Init_NoInitCallbackContext mDNSNULL

extern void mDNS_GrowCache (mDNS *const m, CacheEntity *storage, mDNSu32 numrecords);

extern void mDNS_Close (mDNS *const m);

extern mDNSs32 mDNS_Execute (mDNS *const m);

extern mStatus mDNS_Register (mDNS *const m, AuthRecord *const rr);

extern mStatus mDNS_Update (mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,

const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback);

extern mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr);

extern mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question);

extern mStatus mDNS_StopQuery (mDNS *const m, DNSQuestion *const question);

extern mStatus mDNS_Reconfirm (mDNS *const m, CacheRecord *const cacherr);

extern mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr);

extern mDNSs32 mDNS_TimeNow(const mDNS *const m);

#if 0

#pragma mark - Platform support functions that are accessible to the client layer too

#endif

extern mDNSs32 mDNSPlatformOneSecond;

#if 0

#pragma mark - General utility and helper functions

#endif

extern void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,

mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, mDNSRecordCallback Callback, void *Context);

extern mStatus mDNS_RegisterService (mDNS *const m, ServiceRecordSet *sr,

const domainlabel *const name, const domainname *const type, const domainname *const domain,

const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen,

AuthRecord *SubTypes, mDNSu32 NumSubTypes,

const mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context);

extern mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl);

extern mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, mDNSRecordCallback MemFreeCallback, void *Context);

extern mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname);

extern mStatus mDNS_DeregisterService(mDNS *const m, ServiceRecordSet *sr);

extern mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr,

const domainlabel *const name, const domainname *const type, const domainname *const domain,

const domainname *const host,

const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context);

#define mDNS_DeregisterNoSuchService mDNS_Deregister

extern mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,

const domainname *const srv, const domainname *const domain,

const mDNSInterfaceID InterfaceID, mDNSBool ForceMCast, mDNSQuestionCallback *Callback, void *Context);

#define mDNS_StopBrowse mDNS_StopQuery

extern mStatus mDNS_StartResolveService(mDNS *const m, ServiceInfoQuery *query, ServiceInfo *info, mDNSServiceInfoQueryCallback *Callback, void *Context);

extern void mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *query);

typedef enum

{

mDNS_DomainTypeBrowse = 0,

mDNS_DomainTypeBrowseDefault = 1,

mDNS_DomainTypeBrowseLegacy = 2,

mDNS_DomainTypeRegistration = 3,

mDNS_DomainTypeRegistrationDefault = 4,

mDNS_DomainTypeMax = 4

} mDNS_DomainType;

extern const char *const mDNS_DomainTypeNames[];

extern mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom,

const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context);

#define mDNS_StopGetDomains mDNS_StopQuery

extern mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr, mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname);

#define mDNS_StopAdvertiseDomains mDNS_Deregister

#if 0

#pragma mark - DNS name utility functions

#endif

#define AssignDomainName(DST, SRC) mDNSPlatformMemCopy((SRC)->c, (DST)->c, DomainNameLength((SRC)))

extern mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b);

extern mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2);

extern mDNSBool IsLocalDomain(const domainname *d); // returns true for domains that by default should be looked up using link-local multicast

extern mDNSu16 DomainNameLength(const domainname *const name);

extern mDNSu8 *AppendLiteralLabelString(domainname *const name, const char *cstr);

extern mDNSu8 *AppendDNSNameString (domainname *const name, const char *cstr);

extern mDNSu8 *AppendDomainLabel (domainname *const name, const domainlabel *const label);

extern mDNSu8 *AppendDomainName (domainname *const name, const domainname *const append);

extern mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr);

extern mDNSu8 *MakeDomainNameFromDNSNameString (domainname *const name, const char *cstr);

extern char *ConvertDomainLabelToCString_withescape(const domainlabel *const name, char *cstr, char esc);

#define ConvertDomainLabelToCString_unescaped(D,C) ConvertDomainLabelToCString_withescape((D), (C), 0)

#define ConvertDomainLabelToCString(D,C) ConvertDomainLabelToCString_withescape((D), (C), '\\')

extern char *ConvertDomainNameToCString_withescape(const domainname *const name, char *cstr, char esc);

#define ConvertDomainNameToCString_unescaped(D,C) ConvertDomainNameToCString_withescape((D), (C), 0)

#define ConvertDomainNameToCString(D,C) ConvertDomainNameToCString_withescape((D), (C), '\\')

extern void ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel);

extern mDNSu8 *ConstructServiceName(domainname *const fqdn, const domainlabel *name, const domainname *type, const domainname *const domain);

extern mDNSBool DeconstructServiceName(const domainname *const fqdn, domainlabel *const name, domainname *const type, domainname *const domain);

#if 0

#pragma mark - Other utility functions and macros

#endif

extern mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg);

extern mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...) IS_A_PRINTF_STYLE_FUNCTION(3,4);

extern mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id);

extern char *DNSTypeName(mDNSu16 rrtype);

extern char *GetRRDisplayString_rdb(const ResourceRecord *rr, RDataBody *rd, char *buffer);

#define RRDisplayString(m, rr) GetRRDisplayString_rdb(rr, &(rr)->rdata->u, (m)->MsgBuffer)

#define ARDisplayString(m, rr) GetRRDisplayString_rdb(&(rr)->resrec, &(rr)->resrec.rdata->u, (m)->MsgBuffer)

#define CRDisplayString(m, rr) GetRRDisplayString_rdb(&(rr)->resrec, &(rr)->resrec.rdata->u, (m)->MsgBuffer)

extern mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2);

extern void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText);

extern mDNSBool IsPrivateV4Addr(mDNSAddr *addr); // returns true for RFC1918 private addresses

#define mDNSSameIPv4Address(A,B) ((A).NotAnInteger == (B).NotAnInteger)

#define mDNSSameIPv6Address(A,B) ((A).l[0] == (B).l[0] && (A).l[1] == (B).l[1] && (A).l[2] == (B).l[2] && (A).l[3] == (B).l[3])

#define mDNSSameEthAddress(A,B) ((A)->w[0] == (B)->w[0] && (A)->w[1] == (B)->w[1] && (A)->w[2] == (B)->w[2])

#define mDNSIPv4AddressIsZero(A) mDNSSameIPv4Address((A), zerov4Addr)

#define mDNSIPv6AddressIsZero(A) mDNSSameIPv6Address((A), zerov6Addr)

#define mDNSIPv4AddressIsOnes(A) mDNSSameIPv4Address((A), onesIPv4Addr)

#define mDNSIPv6AddressIsOnes(A) mDNSSameIPv6Address((A), onesIPv6Addr)

#define mDNSAddressIsAllDNSLinkGroup(X) ( \

((X)->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address((X)->ip.v4, AllDNSLinkGroupv4)) || \

((X)->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address((X)->ip.v6, AllDNSLinkGroupv6)) )

#define mDNSAddressIsZero(X) ( \

((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsZero((X)->ip.v4)) || \

((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsZero((X)->ip.v6)) )

#define mDNSAddressIsValidNonZero(X) ( \

((X)->type == mDNSAddrType_IPv4 && !mDNSIPv4AddressIsZero((X)->ip.v4)) || \

((X)->type == mDNSAddrType_IPv6 && !mDNSIPv6AddressIsZero((X)->ip.v6)) )

#define mDNSAddressIsOnes(X) ( \

((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsOnes((X)->ip.v4)) || \

((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsOnes((X)->ip.v6)) )

#define mDNSAddressIsValid(X) ( \

((X)->type == mDNSAddrType_IPv4) ? !(mDNSIPv4AddressIsZero((X)->ip.v4) || mDNSIPv4AddressIsOnes((X)->ip.v4)) : \

((X)->type == mDNSAddrType_IPv6) ? !(mDNSIPv6AddressIsZero((X)->ip.v6) || mDNSIPv6AddressIsOnes((X)->ip.v6)) : mDNSfalse)

#if 0

#pragma mark - Authentication Support

#endif

#define HMAC_LEN 64

#define HMAC_IPAD 0x36

#define HMAC_OPAD 0x5c

#define MD5_LEN 16

typedef struct

{

mDNSu8 ipad[HMAC_LEN];

mDNSu8 opad[HMAC_LEN];

} HMAC_Key;

typedef struct uDNS_AuthInfo

{

domainname zone;

domainname keyname;

HMAC_Key key;

struct uDNS_AuthInfo *next;

} uDNS_AuthInfo;

extern mStatus mDNS_SetSecretForZone(mDNS *m, const domainname *zone, const domainname *key, const char *sharedSecret);

extern void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *StatusContext);

extern void mDNS_RemoveDynDNSHostName(mDNS *m, const domainname *fqdn);

extern void mDNS_SetPrimaryInterfaceInfo(mDNS *m, const mDNSAddr *v4addr, const mDNSAddr *v6addr, const mDNSAddr *router);

extern void mDNS_UpdateLLQs(mDNS *m);

extern void mDNS_AddDNSServer(mDNS *const m, const mDNSAddr *dnsAddr, const domainname *domain);

extern void mDNS_DeleteDNSServers(mDNS *const m);

extern mDNSs32 DNSDigest_Base64ToBin(const char *src, mDNSu8 *target, mDNSu32 targsize);

extern void DNSDigest_ConstructHMACKey(uDNS_AuthInfo *info, const mDNSu8 *key, mDNSu32 len);

extern mDNSu8 *DNSDigest_SignMessage(DNSMessage *msg, mDNSu8 **end, mDNSu16 *numAdditionals, uDNS_AuthInfo *info);

#if 0

#pragma mark - PlatformSupport interface

#endif

extern mStatus mDNSPlatformInit (mDNS *const m);

extern void mDNSPlatformClose (mDNS *const m);

extern mStatus mDNSPlatformSendUDP(const mDNS *const m, const void *const msg, const mDNSu8 *const end,

mDNSInterfaceID InterfaceID, const mDNSAddr *dst, mDNSIPPort dstport);

extern void mDNSPlatformLock (const mDNS *const m);

extern void mDNSPlatformUnlock (const mDNS *const m);

extern void mDNSPlatformStrCopy (const void *src, void *dst);

extern mDNSu32 mDNSPlatformStrLen (const void *src);

extern void mDNSPlatformMemCopy (const void *src, void *dst, mDNSu32 len);

extern mDNSBool mDNSPlatformMemSame (const void *src, const void *dst, mDNSu32 len);

extern void mDNSPlatformMemZero ( void *dst, mDNSu32 len);

extern void * mDNSPlatformMemAllocate (mDNSu32 len);

extern void mDNSPlatformMemFree (void *mem);

extern mDNSu32 mDNSPlatformRandomSeed (void);

extern mStatus mDNSPlatformTimeInit (void);

extern mDNSs32 mDNSPlatformRawTime (void);

extern mDNSs32 mDNSPlatformUTC (void);

#define mDNS_TimeNow_NoLock(m) (mDNSPlatformRawTime() + m->timenow_adjust)

extern mDNSInterfaceID mDNSPlatformInterfaceIDfromInterfaceIndex(mDNS *const m, mDNSu32 index);

extern mDNSu32 mDNSPlatformInterfaceIndexfromInterfaceID(mDNS *const m, mDNSInterfaceID id);

typedef void (*TCPConnectionCallback)(int sd, void *context, mDNSBool ConnectionEstablished);

extern mStatus mDNSPlatformTCPConnect(const mDNSAddr *dst, mDNSOpaque16 dstport, mDNSInterfaceID InterfaceID,

TCPConnectionCallback callback, void *context, int *descriptor);

extern void mDNSPlatformTCPCloseConnection(int sd);

extern int mDNSPlatformReadTCP(int sd, void *buf, int buflen);

extern int mDNSPlatformWriteTCP(int sd, const char *msg, int len);

typedef struct DNameListElem

{

domainname name;

struct DNameListElem *next;

} DNameListElem;

extern DNameListElem *mDNSPlatformGetSearchDomainList(void);

extern DNameListElem *mDNSPlatformGetRegDomainList(void);

extern DNameListElem *mDNS_CopyDNameList(const DNameListElem *orig);

extern void mDNS_FreeDNameList(DNameListElem *list);

#ifdef _LEGACY_NAT_TRAVERSAL_

#define DYN_PORT_MIN 49152 // ephemeral port range

#define DYN_PORT_MAX 65535

#define LEGACY_NATMAP_MAX_TRIES 4 // if our desired mapping is taken, how many times we try mapping to a random port

extern mStatus LNT_GetPublicIP(mDNSOpaque32 *ip);

extern mStatus LNT_MapPort(mDNSIPPort priv, mDNSIPPort pub, mDNSBool tcp);

extern mStatus LNT_UnmapPort(mDNSIPPort PubPort, mDNSBool tcp);

#endif // _LEGACY_NAT_TRAVERSAL_

extern void mDNS_SetFQDN(mDNS *const m);

extern mStatus mDNS_RegisterInterface (mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping);

extern void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping);

extern void mDNSCoreInitComplete(mDNS *const m, mStatus result);

extern void mDNSCoreReceive(mDNS *const m, void *const msg, const mDNSu8 *const end,