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

#include "DNSCommon.h" // Defines general DNS untility routines

#include "uDNS.h" // Defines entry points into unicast-specific routines

#if(defined(_MSC_VER))

// Disable "conditional expression is constant" warning for debug macros.

// Otherwise, this generates warnings for the perfectly natural construct "while(1)"

// If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know

#pragma warning(disable:4127)

// Disable "assignment within conditional expression".

// Other compilers understand the convention that if you place the assignment expression within an extra pair

// of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary.

// The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal

// to the compiler that the assignment is intentional, we have to just turn this warning off completely.

#pragma warning(disable:4706)

#endif

#if COMPILER_LIKES_PRAGMA_MARK

#pragma mark -

#pragma mark - Program Constants

#endif

mDNSexport const mDNSIPPort zeroIPPort = { { 0 } };

mDNSexport const mDNSv4Addr zerov4Addr = { { 0 } };

mDNSexport const mDNSv6Addr zerov6Addr = { { 0 } };

mDNSexport const mDNSEthAddr zeroEthAddr = { { 0 } };

mDNSexport const mDNSv4Addr onesIPv4Addr = { { 255, 255, 255, 255 } };

mDNSexport const mDNSv6Addr onesIPv6Addr = { { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } };

mDNSexport const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };

mDNSexport const mDNSInterfaceID mDNSInterface_Any = 0;

mDNSexport const mDNSInterfaceID mDNSInterface_LocalOnly = (mDNSInterfaceID)1;

mDNSlocal const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID)~0;

#define UnicastDNSPortAsNumber 53

#define NATPMPPortAsNumber 5351

#define DNSEXTPortAsNumber 5352 // Port used for end-to-end DNS operations like LLQ, Updates with Leases, etc.

#define MulticastDNSPortAsNumber 5353

#define LoopbackIPCPortAsNumber 5354

mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };

mDNSexport const mDNSIPPort NATPMPPort = { { NATPMPPortAsNumber >> 8, NATPMPPortAsNumber & 0xFF } };

mDNSexport const mDNSIPPort DNSEXTPort = { { DNSEXTPortAsNumber >> 8, DNSEXTPortAsNumber & 0xFF } };

mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };

mDNSexport const mDNSIPPort LoopbackIPCPort = { { LoopbackIPCPortAsNumber >> 8, LoopbackIPCPortAsNumber & 0xFF } };

mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };

mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } };

mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } } } };

mDNSexport const mDNSOpaque16 zeroID = { { 0, 0 } };

mDNSexport const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery, 0 } };

mDNSexport const mDNSOpaque16 uQueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery | kDNSFlag0_RD, 0 } };

mDNSexport const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } };

mDNSexport const mDNSOpaque16 UpdateReqFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_Update, 0 } };

mDNSexport const mDNSOpaque16 UpdateRespFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_Update, 0 } };

#define SmallRecordLimit 1024

#define kMaxUpdateCredits 10

#define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6)

mDNSexport const char *const mDNS_DomainTypeNames[] =

{

"b._dns-sd._udp.", // Browse

"db._dns-sd._udp.", // Default Browse

"lb._dns-sd._udp.", // Legacy Browse

"r._dns-sd._udp.", // Registration

"dr._dns-sd._udp." // Default Registration

};

#ifdef UNICAST_DISABLED

#define uDNS_IsActiveQuery(q, u) mDNSfalse

#endif

#if COMPILER_LIKES_PRAGMA_MARK

#pragma mark -

#pragma mark - Specialized mDNS version of vsnprintf

#endif

static const struct mDNSprintf_format

{

unsigned leftJustify : 1;

unsigned forceSign : 1;

unsigned zeroPad : 1;

unsigned havePrecision : 1;

unsigned hSize : 1;

unsigned lSize : 1;

char altForm;

char sign; // +, - or space

unsigned int fieldWidth;

unsigned int precision;

} mDNSprintf_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

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

{

mDNSu32 nwritten = 0;

int c;

if (buflen == 0) return(0);

buflen--; // Pre-reserve one space in the buffer for the terminating null

if (buflen == 0) goto exit;

for (c = *fmt; c != 0; c = *++fmt)

{

if (c != '%')

{

*sbuffer++ = (char)c;

if (++nwritten >= buflen) goto exit;

}

else

{

unsigned int i=0, j;

// The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for

// generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc.

// The size needs to be enough for a 256-byte domain name plus some error text.

#define mDNS_VACB_Size 300

char mDNS_VACB[mDNS_VACB_Size];

#define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size])

#define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s))

char *s = mDNS_VACB_Lim, *digits;

struct mDNSprintf_format F = mDNSprintf_format_default;

while (1) // decode flags

{

c = *++fmt;

if (c == '-') F.leftJustify = 1;

else if (c == '+') F.forceSign = 1;

else if (c == ' ') F.sign = ' ';

else if (c == '#') F.altForm++;

else if (c == '0') F.zeroPad = 1;

else break;

}

if (c == '*') // decode field width

{

int f = va_arg(arg, int);

if (f < 0) { f = -f; F.leftJustify = 1; }

F.fieldWidth = (unsigned int)f;

c = *++fmt;

}

else

{

for (; c >= '0' && c <= '9'; c = *++fmt)

F.fieldWidth = (10 * F.fieldWidth) + (c - '0');

}

if (c == '.') // decode precision

{

if ((c = *++fmt) == '*')

{ F.precision = va_arg(arg, unsigned int); c = *++fmt; }

else for (; c >= '0' && c <= '9'; c = *++fmt)

F.precision = (10 * F.precision) + (c - '0');

F.havePrecision = 1;

}

if (F.leftJustify) F.zeroPad = 0;

conv:

switch (c) // perform appropriate conversion

{

unsigned long n;

case 'h' : F.hSize = 1; c = *++fmt; goto conv;

case 'l' : // fall through

case 'L' : F.lSize = 1; c = *++fmt; goto conv;

case 'd' :

case 'i' : if (F.lSize) n = (unsigned long)va_arg(arg, long);

else n = (unsigned long)va_arg(arg, int);

if (F.hSize) n = (short) n;

if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; }

else if (F.forceSign) F.sign = '+';

goto decimal;

case 'u' : if (F.lSize) n = va_arg(arg, unsigned long);

else n = va_arg(arg, unsigned int);

if (F.hSize) n = (unsigned short) n;

F.sign = 0;

goto decimal;

decimal: if (!F.havePrecision)

{

if (F.zeroPad)

{

F.precision = F.fieldWidth;

if (F.sign) --F.precision;

}

if (F.precision < 1) F.precision = 1;

}

if (F.precision > mDNS_VACB_Size - 1)

F.precision = mDNS_VACB_Size - 1;

for (i = 0; n; n /= 10, i++) *--s = (char)(n % 10 + '0');

for (; i < F.precision; i++) *--s = '0';

if (F.sign) { *--s = F.sign; i++; }

break;

case 'o' : if (F.lSize) n = va_arg(arg, unsigned long);

else n = va_arg(arg, unsigned int);

if (F.hSize) n = (unsigned short) n;

if (!F.havePrecision)

{

if (F.zeroPad) F.precision = F.fieldWidth;

if (F.precision < 1) F.precision = 1;

}

if (F.precision > mDNS_VACB_Size - 1)

F.precision = mDNS_VACB_Size - 1;

for (i = 0; n; n /= 8, i++) *--s = (char)(n % 8 + '0');

if (F.altForm && i && *s != '0') { *--s = '0'; i++; }

for (; i < F.precision; i++) *--s = '0';

break;

case 'a' : {

unsigned char *a = va_arg(arg, unsigned char *);

if (!a) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }

else

{

s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end

if (F.altForm)

{

mDNSAddr *ip = (mDNSAddr*)a;

switch (ip->type)

{

case mDNSAddrType_IPv4: F.precision = 4; a = (unsigned char *)&ip->ip.v4; break;

case mDNSAddrType_IPv6: F.precision = 16; a = (unsigned char *)&ip->ip.v6; break;

default: F.precision = 0; break;

}

}

switch (F.precision)

{

case 4: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d",

a[0], a[1], a[2], a[3]); break;

case 6: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X",

a[0], a[1], a[2], a[3], a[4], a[5]); break;

case 16: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB),

"%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",

a[0x0], a[0x1], a[0x2], a[0x3], a[0x4], a[0x5], a[0x6], a[0x7],

a[0x8], a[0x9], a[0xA], a[0xB], a[0xC], a[0xD], a[0xE], a[0xF]); break;

default: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify"

" address size (i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>"); break;

}

}

}

break;

case 'p' : F.havePrecision = F.lSize = 1;

F.precision = 8;

case 'X' : digits = "0123456789ABCDEF";

goto hexadecimal;

case 'x' : digits = "0123456789abcdef";

hexadecimal:if (F.lSize) n = va_arg(arg, unsigned long);

else n = va_arg(arg, unsigned int);

if (F.hSize) n = (unsigned short) n;

if (!F.havePrecision)

{

if (F.zeroPad)

{

F.precision = F.fieldWidth;

if (F.altForm) F.precision -= 2;

}

if (F.precision < 1) F.precision = 1;

}

if (F.precision > mDNS_VACB_Size - 1)

F.precision = mDNS_VACB_Size - 1;

for (i = 0; n; n /= 16, i++) *--s = digits[n % 16];

for (; i < F.precision; i++) *--s = '0';

if (F.altForm) { *--s = (char)c; *--s = '0'; i += 2; }

break;

case 'c' : *--s = (char)va_arg(arg, int); i = 1; break;

case 's' : s = va_arg(arg, char *);

if (!s) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }

else switch (F.altForm)

{

case 0: i=0;

if (!F.havePrecision) // C string

while(s[i]) i++;

else

{

while ((i < F.precision) && s[i]) i++;

// Make sure we don't truncate in the middle of a UTF-8 character

// If last character we got was any kind of UTF-8 multi-byte character,

// then see if we have to back up.

// This is not as easy as the similar checks below, because

// here we can't assume it's safe to examine the *next* byte, so we

// have to confine ourselves to working only backwards in the string.

j = i; // Record where we got to

// Now, back up until we find first non-continuation-char

while (i>0 && (s[i-1] & 0xC0) == 0x80) i--;

// Now s[i-1] is the first non-continuation-char

// and (j-i) is the number of continuation-chars we found

if (i>0 && (s[i-1] & 0xC0) == 0xC0) // If we found a start-char

{

i--; // Tentatively eliminate this start-char as well

// Now (j-i) is the number of characters we're considering eliminating.

// To be legal UTF-8, the start-char must contain (j-i) one-bits,

// followed by a zero bit. If we shift it right by (7-(j-i)) bits

// (with sign extension) then the result has to be 0xFE.

// If this is right, then we reinstate the tentatively eliminated bytes.

if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j;

}

}

break;

case 1: i = (unsigned char) *s++; break; // Pascal string

case 2: { // DNS label-sequence name

unsigned char *a = (unsigned char *)s;

s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end

if (*a == 0) *s++ = '.'; // Special case for root DNS name

while (*a)

{

if (*a > 63)

{ s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a); break; }

if (s + *a >= &mDNS_VACB[254])

{ s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>"); break; }

s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%#s.", a);

a += 1 + *a;

}

i = (mDNSu32)(s - mDNS_VACB);

s = mDNS_VACB; // Reset s back to the start of the buffer

break;

}

}

// Make sure we don't truncate in the middle of a UTF-8 character (see similar comment below)

if (F.havePrecision && i > F.precision)

{ i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--; }

break;

case 'n' : s = va_arg(arg, char *);

if (F.hSize) * (short *) s = (short)nwritten;

else if (F.lSize) * (long *) s = (long)nwritten;

else * (int *) s = (int)nwritten;

continue;

default: s = mDNS_VACB;

i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c);

case '%' : *sbuffer++ = (char)c;

if (++nwritten >= buflen) goto exit;

break;

}

if (i < F.fieldWidth && !F.leftJustify) // Pad on the left

do {

*sbuffer++ = ' ';

if (++nwritten >= buflen) goto exit;

} while (i < --F.fieldWidth);

// Make sure we don't truncate in the middle of a UTF-8 character.

// Note: s[i] is the first eliminated character; i.e. the next character *after* the last character of the

// allowed output. If s[i] is a UTF-8 continuation character, then we've cut a unicode character in half,

// so back up 'i' until s[i] is no longer a UTF-8 continuation character. (if the input was proprly

// formed, s[i] will now be the UTF-8 start character of the multi-byte character we just eliminated).

if (i > buflen - nwritten)

{ i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--; }

for (j=0; j<i; j++) *sbuffer++ = *s++; // Write the converted result

nwritten += i;

if (nwritten >= buflen) goto exit;

for (; i < F.fieldWidth; i++) // Pad on the right

{

*sbuffer++ = ' ';

if (++nwritten >= buflen) goto exit;

}

}

}

exit:

*sbuffer++ = 0;

return(nwritten);

}

mDNSexport mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...)

{

mDNSu32 length;

va_list ptr;

va_start(ptr,fmt);

length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr);

va_end(ptr);

return(length);

}

#if COMPILER_LIKES_PRAGMA_MARK

#pragma mark -

#pragma mark - General Utility Functions

#endif

#define InitialQuestionInterval (mDNSPlatformOneSecond/2)

#define ActiveQuestion(Q) ((Q)->ThisQInterval > 0 && !(Q)->DuplicateOf)

#define TimeToSendThisQuestion(Q,time) (ActiveQuestion(Q) && (time) - ((Q)->LastQTime + (Q)->ThisQInterval) >= 0)

mDNSlocal void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q)

{

if (ActiveQuestion(q))

if (m->NextScheduledQuery - (q->LastQTime + q->ThisQInterval) > 0)

m->NextScheduledQuery = (q->LastQTime + q->ThisQInterval);

}

mDNSlocal CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 slot, const mDNSu32 namehash, const domainname *const name)

{

CacheGroup *cg;

for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)

if (cg->namehash == namehash && SameDomainName(cg->name, name))

break;

return(cg);

}

mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr)

{

return(CacheGroupForName(m, slot, rr->namehash, rr->name));

}

mDNSlocal mDNSBool AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr)

{

NetworkInterfaceInfo *intf;

if (addr->type == mDNSAddrType_IPv4)

{

if (addr->ip.v4.b[0] == 169 && addr->ip.v4.b[1] == 254) return(mDNStrue);

for (intf = m->HostInterfaces; intf; intf = intf->next)

if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)

if (((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) & intf->mask.ip.v4.NotAnInteger) == 0)

return(mDNStrue);

}

if (addr->type == mDNSAddrType_IPv6)

{

if (addr->ip.v6.b[0] == 0xFE && addr->ip.v6.b[1] == 0x80) return(mDNStrue);

for (intf = m->HostInterfaces; intf; intf = intf->next)

if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)

if ((((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) & intf->mask.ip.v6.l[0]) == 0) &&

(((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) & intf->mask.ip.v6.l[1]) == 0) &&

(((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) & intf->mask.ip.v6.l[2]) == 0) &&

(((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) & intf->mask.ip.v6.l[3]) == 0))

return(mDNStrue);

}

return(mDNSfalse);

}

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

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

{

mDNSPlatformMemZero(&rr->uDNS_info, sizeof(uDNS_RegInfo));

// Don't try to store a TTL bigger than we can represent in platform time units

if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond)

ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond;

else if (ttl == 0) // And Zero TTL is illegal

ttl = DefaultTTLforRRType(rrtype);

// Field Group 1: The actual information pertaining to this resource record

rr->resrec.RecordType = RecordType;

rr->resrec.InterfaceID = InterfaceID;

rr->resrec.name = &rr->namestorage;

rr->resrec.rrtype = rrtype;

rr->resrec.rrclass = kDNSClass_IN;

rr->resrec.rroriginalttl = ttl;

if (RDataStorage)

rr->resrec.rdata = RDataStorage;

else

{

rr->resrec.rdata = &rr->rdatastorage;

rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);

}

// Field Group 2: Persistent metadata for Authoritative Records

rr->Additional1 = mDNSNULL;

rr->Additional2 = mDNSNULL;

rr->DependentOn = mDNSNULL;

rr->RRSet = mDNSNULL;

rr->RecordCallback = Callback;

rr->RecordContext = Context;

rr->HostTarget = mDNSfalse;

rr->AllowRemoteQuery = mDNSfalse;

rr->ForceMCast = mDNSfalse;

// Field Group 3: Transient state for Authoritative Records (set in mDNS_Register_internal)

rr->namestorage.c[0] = 0; // MUST be set by client before calling mDNS_Register()

}

mDNSlocal void AnswerLocalOnlyQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, AuthRecord *rr, mDNSBool AddRecord)

{

// Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it

if (AddRecord) rr->LocalAnswer = mDNStrue;

m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback

if (q->QuestionCallback)

q->QuestionCallback(m, q, &rr->resrec, AddRecord);

m->mDNS_reentrancy--; // Decrement to block mDNS API calls again

}

mDNSlocal void AnswerLocalQuestions(mDNS *const m, AuthRecord *rr, mDNSBool AddRecord)

{

if (m->CurrentQuestion) LogMsg("AnswerLocalQuestions ERROR m->CurrentQuestion already set");

m->CurrentQuestion = m->LocalOnlyQuestions;

while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions)

{

DNSQuestion *q = m->CurrentQuestion;

m->CurrentQuestion = q->next;

if (ResourceRecordAnswersQuestion(&rr->resrec, q))

AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord); // MUST NOT dereference q again

}

// If this AuthRecord is marked LocalOnly, then we want to deliver it to all local 'mDNSInterface_Any' questions

if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)

{

m->CurrentQuestion = m->Questions;

while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)

{

DNSQuestion *q = m->CurrentQuestion;

m->CurrentQuestion = q->next;

if (ResourceRecordAnswersQuestion(&rr->resrec, q))

AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord); // MUST NOT dereference q again

}

}

m->CurrentQuestion = mDNSNULL;

}

#if COMPILER_LIKES_PRAGMA_MARK

#pragma mark -

#pragma mark - Resource Record Utility Functions

#endif

#define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA)

#define ResourceRecordIsValidAnswer(RR) ( ((RR)-> resrec.RecordType & kDNSRecordTypeActiveMask) && \

((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \

((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \

((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) )

#define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \

(ResourceRecordIsValidAnswer(RR) && \

((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID)))

#define DefaultProbeCountForTypeUnique ((mDNSu8)3)

#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)

#define InitialAnnounceCount ((mDNSu8)10)

#define DefaultProbeIntervalForTypeUnique (mDNSPlatformOneSecond/4)

#define DefaultAnnounceIntervalForTypeShared (mDNSPlatformOneSecond/2)

#define DefaultAnnounceIntervalForTypeUnique (mDNSPlatformOneSecond/2)

#define DefaultAPIntervalForRecordType(X) ((X) & (kDNSRecordTypeAdvisory | kDNSRecordTypeShared ) ? DefaultAnnounceIntervalForTypeShared : \

(X) & (kDNSRecordTypeUnique ) ? DefaultProbeIntervalForTypeUnique : \

(X) & (kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique) ? DefaultAnnounceIntervalForTypeUnique : 0)

#define TimeToAnnounceThisRecord(RR,time) ((RR)->AnnounceCount && (time) - ((RR)->LastAPTime + (RR)->ThisAPInterval) >= 0)

#define TimeToSendThisRecord(RR,time) ((TimeToAnnounceThisRecord(RR,time) || (RR)->ImmedAnswer) && ResourceRecordIsValidAnswer(RR))

#define TicksTTL(RR) ((mDNSs32)(RR)->resrec.rroriginalttl * mDNSPlatformOneSecond)

#define RRExpireTime(RR) ((RR)->TimeRcvd + TicksTTL(RR))

#define MaxUnansweredQueries 4

mDNSlocal mDNSBool SameResourceRecordSignature(const ResourceRecord *const r1, const ResourceRecord *const r2)

{

if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse); }

if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse); }

if (r1->InterfaceID &&

r2->InterfaceID &&

r1->InterfaceID != r2->InterfaceID) return(mDNSfalse);

return(mDNSBool)(

r1->rrtype == r2->rrtype &&

r1->rrclass == r2->rrclass &&

r1->namehash == r2->namehash &&

SameDomainName(r1->name, r2->name));

}

mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr)

{

if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse); }

if (!authrr) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL"); return(mDNSfalse); }

if (pktrr->resrec.InterfaceID &&

authrr->resrec.InterfaceID &&

pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse);

if (!(authrr->resrec.RecordType & kDNSRecordTypeUniqueMask) && pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse);

return(mDNSBool)(

pktrr->resrec.rrclass == authrr->resrec.rrclass &&

pktrr->resrec.namehash == authrr->resrec.namehash &&

SameDomainName(pktrr->resrec.name, authrr->resrec.name));

}

mDNSlocal mDNSBool IdenticalResourceRecord(const ResourceRecord *const r1, const ResourceRecord *const r2)

{

if (!r1) { LogMsg("IdenticalResourceRecord ERROR: r1 is NULL"); return(mDNSfalse); }

if (!r2) { LogMsg("IdenticalResourceRecord ERROR: r2 is NULL"); return(mDNSfalse); }

if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass || r1->namehash != r2->namehash || !SameDomainName(r1->name, r2->name))

return(mDNSfalse);

return(SameRData(r1, r2));

}

mDNSlocal mDNSBool ShouldSuppressKnownAnswer(const CacheRecord *const ka, const AuthRecord *const rr)

{

// If RR signature is different, or data is different, then don't suppress our answer

if (!IdenticalResourceRecord(&ka->resrec, &rr->resrec)) return(mDNSfalse);

// If the requester's indicated TTL is less than half the real TTL,

// we need to give our answer before the requester's copy expires.

// If the requester's indicated TTL is at least half the real TTL,

// then we can suppress our answer this time.

// If the requester's indicated TTL is greater than the TTL we believe,

// then that's okay, and we don't need to do anything about it.

// (If two responders on the network are offering the same information,

// that's okay, and if they are offering the information with different TTLs,

// the one offering the lower TTL should defer to the one offering the higher TTL.)

return(mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2);

}

mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr)

{

if (rr->resrec.RecordType == kDNSRecordTypeUnique)

{

//LogMsg("ProbeCount %d Next %ld %s",

// rr->ProbeCount, (rr->LastAPTime + rr->ThisAPInterval) - m->timenow, ARDisplayString(m, rr));

if (m->NextScheduledProbe - (rr->LastAPTime + rr->ThisAPInterval) >= 0)

m->NextScheduledProbe = (rr->LastAPTime + rr->ThisAPInterval);

}

else if (rr->AnnounceCount && ResourceRecordIsValidAnswer(rr))

{

if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0)

m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval);

}

}

mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr)

{

// To allow us to aggregate probes when a group of services are registered together,

// the first probe is delayed 1/4 second. This means the common-case behaviour is:

// 1/4 second wait; probe

// 1/4 second wait; probe

// 1/4 second wait; probe

// 1/4 second wait; announce (i.e. service is normally announced exactly one second after being registered)

// If we have no probe suppression time set, or it is in the past, set it now

if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0)

{

m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique);

// If we already have a probe scheduled to go out sooner, then use that time to get better aggregation

if (m->SuppressProbes - m->NextScheduledProbe >= 0)

m->SuppressProbes = m->NextScheduledProbe;

// If we already have a query scheduled to go out sooner, then use that time to get better aggregation

if (m->SuppressProbes - m->NextScheduledQuery >= 0)

m->SuppressProbes = m->NextScheduledQuery;

}

// We announce to flush stale data from other caches. It is a reasonable assumption that any

// old stale copies will probably have the same TTL we're using, so announcing longer than

// this serves no purpose -- any stale copies of that record will have expired by then anyway.

rr->AnnounceUntil = m->timenow + TicksTTL(rr);

rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval;

// Set LastMCTime to now, to inhibit multicast responses

// (no need to send additional multicast responses when we're announcing anyway)

rr->LastMCTime = m->timenow;

rr->LastMCInterface = mDNSInterfaceMark;

// If this is a record type that's not going to probe, then delay its first announcement so that

// it will go out synchronized with the first announcement for the other records that *are* probing.

// This is a minor performance tweak that helps keep groups of related records synchronized together.

// The addition of "rr->ThisAPInterval / 2" is to make sure that, in the event that any of the probes are

// delayed by a few milliseconds, this announcement does not inadvertently go out *before* the probing is complete.

// When the probing is complete and those records begin to announce, these records will also be picked up and accelerated,

// because they will meet the criterion of being at least half-way to their scheduled announcement time.

if (rr->resrec.RecordType != kDNSRecordTypeUnique)

rr->LastAPTime += DefaultProbeIntervalForTypeUnique * DefaultProbeCountForTypeUnique + rr->ThisAPInterval / 2;

SetNextAnnounceProbeTime(m, rr);

}

#define HashSlot(X) (DomainNameHashValue(X) % CACHE_HASH_SLOTS)

mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr)

{

domainname *target = GetRRDomainNameTarget(&rr->resrec);

if (!target) debugf("SetTargetToHostName: Don't know how to set the target of rrtype %d", rr->resrec.rrtype);

if (target && SameDomainName(target, &m->MulticastHostname))

debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name->c, target->c);

if (target && !SameDomainName(target, &m->MulticastHostname))

{

AssignDomainName(target, &m->MulticastHostname);

SetNewRData(&rr->resrec, mDNSNULL, 0);

// If we're in the middle of probing this record, we need to start again,

// because changing its rdata may change the outcome of the tie-breaker.

// (If the record type is kDNSRecordTypeUnique (unconfirmed unique) then DefaultProbeCountForRecordType is non-zero.)

rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);

// If we've announced this record, we really should send a goodbye packet for the old rdata before

// changing to the new rdata. However, in practice, we only do SetTargetToHostName for unique records,

// so when we announce them we'll set the kDNSClass_UniqueRRSet and clear any stale data that way.

if (rr->RequireGoodbye && rr->resrec.RecordType == kDNSRecordTypeShared)

debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

rr->AnnounceCount = InitialAnnounceCount;

rr->RequireGoodbye = mDNSfalse;

rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);

InitializeLastAPTime(m,rr);

}

}

mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr)

{

if (!rr->Acknowledged && rr->RecordCallback)

{

// CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function

// is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.

rr->Acknowledged = mDNStrue;

m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback

rr->RecordCallback(m, rr, mStatus_NoError);

m->mDNS_reentrancy--; // Decrement to block mDNS API calls again

}

}

#define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || \

((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified))

#define RecordIsLocalDuplicate(A,B) \

((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(&(A)->resrec, &(B)->resrec))

mDNSlocal mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr)

{

domainname *target = GetRRDomainNameTarget(&rr->resrec);

AuthRecord *r;

AuthRecord **p = &m->ResourceRecords;

AuthRecord **d = &m->DuplicateRecords;

mDNSPlatformMemZero(&rr->uDNS_info, sizeof(uDNS_RegInfo));

if ((mDNSs32)rr->resrec.rroriginalttl <= 0)

{ LogMsg("mDNS_Register_internal: TTL must be 1 - 0x7FFFFFFF %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); }

#ifndef UNICAST_DISABLED

if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly || rr->ForceMCast || IsLocalDomain(rr->resrec.name))

rr->uDNS_info.id = zeroID;

else return uDNS_RegisterRecord(m, rr);

#endif

while (*p && *p != rr) p=&(*p)->next;

while (*d && *d != rr) d=&(*d)->next;

if (*d || *p)

{

LogMsg("Error! Tried to register a AuthRecord %p %##s (%s) that's already in the list",

rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

return(mStatus_AlreadyRegistered);

}

if (rr->DependentOn)

{

if (rr->resrec.RecordType == kDNSRecordTypeUnique)

rr->resrec.RecordType = kDNSRecordTypeVerified;

else

{

LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

return(mStatus_Invalid);

}

if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified)))

{

LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType);

return(mStatus_Invalid);

}

}

// If this resource record is referencing a specific interface, make sure it exists

if (rr->resrec.InterfaceID && rr->resrec.InterfaceID != mDNSInterface_LocalOnly)

{

NetworkInterfaceInfo *intf;

for (intf = m->HostInterfaces; intf; intf = intf->next)

if (intf->InterfaceID == rr->resrec.InterfaceID) break;

if (!intf)

{

debugf("mDNS_Register_internal: Bogus InterfaceID %p in resource record", rr->resrec.InterfaceID);

return(mStatus_BadReferenceErr);

}

}

rr->next = mDNSNULL;

// Field Group 1: Persistent metadata for Authoritative Records

// Make sure target is not uninitialized data, or we may crash writing debugging log messages

if (rr->HostTarget && target) target->c[0] = 0;

// Field Group 2: Transient state for Authoritative Records

rr->Acknowledged = mDNSfalse;

rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);

rr->AnnounceCount = InitialAnnounceCount;

rr->RequireGoodbye = mDNSfalse;

rr->LocalAnswer = mDNSfalse;

rr->IncludeInProbe = mDNSfalse;

rr->ImmedAnswer = mDNSNULL;

rr->ImmedUnicast = mDNSfalse;

rr->ImmedAdditional = mDNSNULL;

rr->SendRNow = mDNSNULL;

rr->v4Requester = zerov4Addr;

rr->v6Requester = zerov6Addr;

rr->NextResponse = mDNSNULL;

rr->NR_AnswerTo = mDNSNULL;

rr->NR_AdditionalTo = mDNSNULL;

rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);

if (!rr->HostTarget) InitializeLastAPTime(m, rr);

rr->NewRData = mDNSNULL;

rr->newrdlength = 0;

rr->UpdateCallback = mDNSNULL;

rr->UpdateCredits = kMaxUpdateCredits;

rr->NextUpdateCredit = 0;

rr->UpdateBlocked = 0;

if (rr->HostTarget)

SetTargetToHostName(m, rr); // Also sets rdlength and rdestimate for us, and calls InitializeLastAPTime();

else

{

rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse);

rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue);

}

if (!ValidateDomainName(rr->resrec.name))

{ LogMsg("Attempt to register record with invalid name: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }

// BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,

// since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".

// Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.

if (rr->resrec.rrtype == kDNSType_TXT && rr->resrec.rdlength == 0) { rr->resrec.rdlength = 1; rr->resrec.rdata->u.txt.c[0] = 0; }

// Don't do this until *after* we've set rr->resrec.rdlength

if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata))

{ LogMsg("Attempt to register record with invalid rdata: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }

rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);

rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr->resrec.rdlength, &rr->resrec.rdata->u);

if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)

{

// If this is supposed to be unique, make sure we don't have any name conflicts

if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)

{

const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr;

for (r = m->ResourceRecords; r; r=r->next)

{

const AuthRecord *s2 = r->RRSet ? r->RRSet : r;

if (s1 != s2 && SameResourceRecordSignature(&r->resrec, &rr->resrec) && !SameRData(&r->resrec, &rr->resrec))

break;

}

if (r) // If we found a conflict, set RecordType = kDNSRecordTypeDeregistering so we'll deliver the callback

{

debugf("Name conflict %p %##s (%s)", rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

rr->resrec.RecordType = kDNSRecordTypeDeregistering;

rr->resrec.rroriginalttl = 0;

rr->ImmedAnswer = mDNSInterfaceMark;

m->NextScheduledResponse = m->timenow;

}

}

}

// Now that we've finished building our new record, make sure it's not identical to one we already have

for (r = m->ResourceRecords; r; r=r->next) if (RecordIsLocalDuplicate(r, rr)) break;

if (r)

{

debugf("Adding to duplicate list %p %s", rr, ARDisplayString(m,rr));

*d = rr;

// If the previous copy of this record is already verified unique,

// then indicate that we should move this record promptly to kDNSRecordTypeUnique state.

// Setting ProbeCount to zero will cause SendQueries() to advance this record to

// kDNSRecordTypeVerified state and call the client callback at the next appropriate time.

if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)

rr->ProbeCount = 0;

}

else

{

debugf("Adding to active record list %p %s", rr, ARDisplayString(m,rr));

if (!m->NewLocalRecords) m->NewLocalRecords = rr;

*p = rr;

}

// For records that are not going to probe, acknowledge them right away

if (rr->resrec.RecordType != kDNSRecordTypeUnique && rr->resrec.RecordType != kDNSRecordTypeDeregistering)

AcknowledgeRecord(m, rr);

return(mStatus_NoError);

}

mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr)

{

m->ProbeFailTime = m->timenow;

m->NumFailedProbes++;

// If we've had fifteen or more probe failures, rate-limit to one every five seconds.

// If a bunch of hosts have all been configured with the same name, then they'll all

// conflict and run through the same series of names: name-2, name-3, name-4, etc.,

// up to name-10. After that they'll start adding random increments in the range 1-100,

// so they're more likely to branch out in the available namespace and settle on a set of

// unique names quickly. If after five more tries the host is still conflicting, then we

// may have a serious problem, so we start rate-limiting so we don't melt down the network.

if (m->NumFailedProbes >= 15)

{

m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5);

LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect",

m->NumFailedProbes, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

}

}

mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr)

{

RData *OldRData = rr->resrec.rdata;

SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata

rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...

if (rr->UpdateCallback)

rr->UpdateCallback(m, rr, OldRData); // ... and let the client know

}

typedef enum { mDNS_Dereg_normal, mDNS_Dereg_conflict, mDNS_Dereg_repeat } mDNS_Dereg_type;

mDNSlocal mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt)

{

AuthRecord *r2;

mDNSu8 RecordType = rr->resrec.RecordType;

AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records

#ifndef UNICAST_DISABLED

if (!(rr->resrec.InterfaceID == mDNSInterface_LocalOnly || rr->ForceMCast || IsLocalDomain(rr->resrec.name)))

return uDNS_DeregisterRecord(m, rr);

#endif

while (*p && *p != rr) p=&(*p)->next;

if (*p)

{

// We found our record on the main list. See if there are any duplicates that need special handling.

if (drt == mDNS_Dereg_conflict) // If this was a conflict, see that all duplicates get the same treatment

{

// Scan for duplicates of rr, and mark them for deregistration at the end of this routine, after we've finished

// deregistering rr. We need to do this scan *before* we give the client the chance to free and reuse the rr memory.

for (r2 = m->DuplicateRecords; r2; r2=r2->next) if (RecordIsLocalDuplicate(r2, rr)) r2->ProbeCount = 0xFF;

}

else

{

// Before we delete the record (and potentially send a goodbye packet)

// first see if we have a record on the duplicate list ready to take over from it.

AuthRecord **d = &m->DuplicateRecords;

while (*d && !RecordIsLocalDuplicate(*d, rr)) d=&(*d)->next;

if (*d)

{

AuthRecord *dup = *d;

debugf("Duplicate record %p taking over from %p %##s (%s)",

dup, rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

*d = dup->next; // Cut replacement record from DuplicateRecords list

dup->next = rr->next; // And then...

rr->next = dup; // ... splice it in right after the record we're about to delete

dup->resrec.RecordType = rr->resrec.RecordType;

dup->ProbeCount = rr->ProbeCount;

dup->AnnounceCount = rr->AnnounceCount;

dup->RequireGoodbye = rr->RequireGoodbye;

dup->ImmedAnswer = rr->ImmedAnswer;

dup->ImmedUnicast = rr->ImmedUnicast;

dup->ImmedAdditional = rr->ImmedAdditional;

dup->v4Requester = rr->v4Requester;

dup->v6Requester = rr->v6Requester;

dup->ThisAPInterval = rr->ThisAPInterval;

dup->AnnounceUntil = rr->AnnounceUntil;

dup->LastAPTime = rr->LastAPTime;

dup->LastMCTime = rr->LastMCTime;

dup->LastMCInterface = rr->LastMCInterface;

rr->RequireGoodbye = mDNSfalse;

}

}

}

else

{

// We didn't find our record on the main list; try the DuplicateRecords list instead.

p = &m->DuplicateRecords;

while (*p && *p != rr) p=&(*p)->next;

// If we found our record on the duplicate list, then make sure we don't send a goodbye for it

if (*p) rr->RequireGoodbye = mDNSfalse;

if (*p) debugf("DNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)",

rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

}

if (!*p)

{

// No need to log an error message if we already know this is a potentially repeated deregistration

if (drt != mDNS_Dereg_repeat)

LogMsg("mDNS_Deregister_internal: Record %p %##s (%s) not found in list",

rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

return(mStatus_BadReferenceErr);

}

// If this is a shared record and we've announced it at least once,

// we need to retract that announcement before we delete the record

if (RecordType == kDNSRecordTypeShared && rr->RequireGoodbye)

{

verbosedebugf("mDNS_Deregister_internal: Sending deregister for %##s (%s)",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

rr->resrec.RecordType = kDNSRecordTypeDeregistering;

rr->resrec.rroriginalttl = 0;

rr->ImmedAnswer = mDNSInterfaceMark;

if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)

m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);

}

else

{

*p = rr->next; // Cut this record from the list

// If someone is about to look at this, bump the pointer forward

if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;

if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next;

rr->next = mDNSNULL;

if (RecordType == kDNSRecordTypeUnregistered)

debugf("mDNS_Deregister_internal: Record %##s (%s) already marked kDNSRecordTypeUnregistered",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

else if (RecordType == kDNSRecordTypeDeregistering)

debugf("mDNS_Deregister_internal: Record %##s (%s) already marked kDNSRecordTypeDeregistering",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

else

{

verbosedebugf("mDNS_Deregister_internal: Deleting record for %##s (%s)",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

rr->resrec.RecordType = kDNSRecordTypeUnregistered;

}

if ((drt == mDNS_Dereg_conflict || drt == mDNS_Dereg_repeat) && RecordType == kDNSRecordTypeShared)

debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)",

rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

// If we have an update queued up which never executed, give the client a chance to free that memory

if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client

if (rr->LocalAnswer) AnswerLocalQuestions(m, rr, mDNSfalse);

// CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function

// is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.

// In this case the likely client action to the mStatus_MemFree message is to free the memory,

// so any attempt to touch rr after this is likely to lead to a crash.

m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback

if (drt != mDNS_Dereg_conflict)

{

if (rr->RecordCallback) rr->RecordCallback(m, rr, mStatus_MemFree); // MUST NOT touch rr after this

}

else

{

RecordProbeFailure(m, rr);

if (rr->RecordCallback) rr->RecordCallback(m, rr, mStatus_NameConflict); // MUST NOT touch rr after this

// Now that we've finished deregistering rr, check our DuplicateRecords list for any that we marked previously.

// Note that with all the client callbacks going on, by the time we get here all the

// records we marked may have been explicitly deregistered by the client anyway.

r2 = m->DuplicateRecords;

while (r2)

{

if (r2->ProbeCount != 0xFF) r2 = r2->next;

else { mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict); r2 = m->DuplicateRecords; }

}

}

m->mDNS_reentrancy--; // Decrement to block mDNS API calls again

}

return(mStatus_NoError);

}

#if COMPILER_LIKES_PRAGMA_MARK

#pragma mark -

#pragma mark -

#pragma mark - Packet Sending Functions

#endif

mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)

{

if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)

{

**nrpp = rr;

// NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo)

// If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does

// The referenced record will definitely be acceptable (by recursive application of this rule)

if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo;

rr->NR_AdditionalTo = add;

*nrpp = &rr->NextResponse;

}

debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));

}

mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID)

{

AuthRecord *rr, *rr2;

for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put

{

// (Note: This is an "if", not a "while". If we add a record, we'll find it again

// later in the "for" loop, and we will follow further "additional" links then.)

if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))

AddRecordToResponseList(nrpp, rr->Additional1, rr);

if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))

AddRecordToResponseList(nrpp, rr->Additional2, rr);

// For SRV records, automatically add the Address record(s) for the target host

if (rr->resrec.rrtype == kDNSType_SRV)

for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records

if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ...

ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ...

rr->resrec.rdatahash == rr2->resrec.namehash && // ... whose name is the name of the SRV target

SameDomainName(&rr->resrec.rdata->u.srv.target, rr2->resrec.name))

AddRecordToResponseList(nrpp, rr2, rr);

}

}

mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID)

{

AuthRecord *rr;

AuthRecord *ResponseRecords = mDNSNULL;

AuthRecord **nrp = &ResponseRecords;