#define TEST_LOCALONLY_FOR_EVERYTHING 0
#include "DNSCommon.h" // Defines general DNS untility routines
#include "uDNS.h" // Defines entry points into unicast-specific routines
#if(defined(_MSC_VER))
#pragma warning(disable:4127)
#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 zeroIPAddr = { { 0 } };
mDNSexport const mDNSv6Addr zerov6Addr = { { 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;
mDNSexport const mDNSInterfaceID mDNSInterface_ForceMCast = (mDNSInterfaceID)-2;
mDNSlocal const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID)~0;
#define UnicastDNSPortAsNumber 53
#define MulticastDNSPortAsNumber 5353
mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };
mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };
mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
mDNSexport const mDNSv4Addr AllDNSLinkGroup = { { 224, 0, 0, 251 } };
mDNSexport const mDNSv6Addr AllDNSLinkGroupv6 = { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } };
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 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } };
mDNSexport const mDNSOpaque16 UpdateReqFlags= { { kDNSFlag0_OP_Update | kDNSFlag0_QR_Query, 0 } };
mDNSexport const mDNSOpaque16 UpdateRespFlags={ { kDNSFlag0_OP_Update | kDNSFlag0_QR_Response, 0 } };
#define zeroDomainNamePtr ((domainname*)"")
#define SmallRecordLimit 1024
#define kDefaultTTLforUnique 240
#define kDefaultTTLforShared (2*3600)
#define kMaxUpdateCredits 10
#define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 50)
static const char *const mDNS_DomainTypeNames[] =
{
"_browse._dns-sd._udp.",
"_default._browse._dns-sd._udp.",
"_register._dns-sd._udp.",
"_default._register._dns-sd._udp."
};
#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; 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--; 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;
#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) {
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 == '*') {
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 == '.') {
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) {
unsigned long n;
case 'h' : F.hSize = 1; c = *++fmt; goto conv;
case 'l' : 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; 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) while(s[i]) i++;
else
{
while ((i < F.precision) && s[i]) i++;
j = i; while (i>0 && (s[i-1] & 0xC0) == 0x80) i--;
if (i>0 && (s[i-1] & 0xC0) == 0xC0) {
i--; if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j;
}
}
break;
case 1: i = (unsigned char) *s++; break; case 2: { unsigned char *a = (unsigned char *)s;
s = mDNS_VACB; if (*a == 0) *s++ = '.'; 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; break;
}
}
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) do {
*sbuffer++ = ' ';
if (++nwritten >= buflen) goto exit;
} while (i < --F.fieldWidth);
if (i > buflen - nwritten)
{ i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--; }
for (j=0; j<i; j++) *sbuffer++ = *s++; nwritten += i;
if (nwritten >= buflen) goto exit;
for (; i < F.fieldWidth; i++) {
*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);
}
#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 RRUniqueOrKnownUnique(RR) ((RR)->RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeKnownUnique))
#define DefaultProbeCountForTypeUnique ((mDNSu8)3)
#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)
#define InitialAnnounceCount ((mDNSu8)10)
#define ReannounceCount ((mDNSu8)9)
#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 != kDNSRecordTypeUnique && 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 (!IdenticalResourceRecord(&ka->resrec,&rr->resrec)) return(mDNSfalse);
return(mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2);
}
mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr)
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
{
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)
{
if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0)
{
m->SuppressProbes = (m->timenow + DefaultProbeIntervalForTypeUnique) | 1;
if (m->SuppressProbes - m->NextScheduledProbe >= 0)
m->SuppressProbes = m->NextScheduledProbe;
if (m->SuppressProbes - m->NextScheduledQuery >= 0)
m->SuppressProbes = m->NextScheduledQuery;
}
rr->AnnounceUntil = m->timenow + TicksTTL(rr);
rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval;
rr->LastMCTime = m->timenow;
rr->LastMCInterface = mDNSInterfaceMark;
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->hostname))
debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name.c, target->c);
if (target && !SameDomainName(target, &m->hostname))
{
AssignDomainName(*target, m->hostname);
SetNewRData(&rr->resrec, mDNSNULL, 0);
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->AnnounceCount < InitialAnnounceCount && 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));
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m,rr);
}
}
mDNSlocal void CompleteProbing(mDNS *const m, AuthRecord *const rr)
{
verbosedebugf("Probing for %##s (%s) complete", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
if (!rr->Acknowledged && rr->RecordCallback)
{
rr->Acknowledged = mDNStrue;
m->mDNS_reentrancy++; rr->RecordCallback(m, rr, mStatus_NoError);
m->mDNS_reentrancy--; }
}
#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;
AuthRecord **l = &m->LocalOnlyRecords;
#if TEST_LOCALONLY_FOR_EVERYTHING
rr->resrec.InterfaceID = mDNSInterface_LocalOnly;
#endif
if (rr->resrec.InterfaceID || IsLocalDomain(&rr->resrec.name))
rr->uDNS_info.id = zeroID;
else return uDNS_RegisterRecord(m, rr);
while (*p && *p != rr) p=&(*p)->next;
while (*d && *d != rr) d=&(*d)->next;
while (*l && *l != rr) l=&(*l)->next;
if (*d || *p || *l)
{
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 (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;
if (rr->HostTarget && target) target->c[0] = 0;
rr->Acknowledged = mDNSfalse;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
rr->AnnounceCount = InitialAnnounceCount;
rr->IncludeInProbe = mDNSfalse;
rr->ImmedAnswer = mDNSNULL;
rr->ImmedAdditional = mDNSNULL;
rr->SendRNow = mDNSNULL;
rr->v4Requester = zeroIPAddr;
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); 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", GetRRDisplayString(m, rr)); return(mStatus_Invalid); }
if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata))
{ LogMsg("Attempt to register record with invalid rdata: %s", GetRRDisplayString(m, rr)); return(mStatus_Invalid); }
rr->resrec.namehash = DomainNameHashValue(&rr->resrec.name);
rr->resrec.rdatahash = RDataHashValue(rr->resrec.rdlength, &rr->resrec.rdata->u);
rr->resrec.rdnamehash = target ? DomainNameHashValue(target) : 0;
if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
{
debugf("Adding %p %##s (%s) to LocalOnly list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*l = rr;
if (!m->NewLocalOnlyRecords) m->NewLocalOnlyRecords = rr;
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr;
for (r = m->LocalOnlyRecords; 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) {
debugf("Name conflict %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
m->DiscardLocalOnlyRecords = mDNStrue;
}
else {
rr->ProbeCount = 0;
if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
}
}
}
else
{
for (r = m->ResourceRecords; r; r=r->next) if (RecordIsLocalDuplicate(r, rr)) break;
if (r)
{
debugf("Adding %p %##s (%s) to duplicate list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*d = rr;
if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)
rr->ProbeCount = 0;
}
else
{
debugf("Adding %p %##s (%s) to active record list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*p = rr;
}
}
return(mStatus_NoError);
}
mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr)
{
m->ProbeFailTime = m->timenow;
m->NumFailedProbes++;
if (m->NumFailedProbes >= 10)
{
m->SuppressProbes = (m->timenow + mDNSPlatformOneSecond * 5) | 1;
LogMsg("Excessive name conflicts (%d) 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); rr->NewRData = mDNSNULL; if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, OldRData); }
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)
{
mDNSu8 RecordType = rr->resrec.RecordType;
AuthRecord **p = &m->ResourceRecords;
if (!rr->resrec.InterfaceID && !IsLocalDomain(&rr->resrec.name) && rr->uDNS_info.id.NotAnInteger)
return uDNS_DeregisterRecord(m, rr);
if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly) p = &m->LocalOnlyRecords;
while (*p && *p != rr) p=&(*p)->next;
if (*p)
{
if (drt == mDNS_Dereg_conflict) {
AuthRecord *r2 = m->DuplicateRecords;
while (r2)
{
if (RecordIsLocalDuplicate(r2, rr)) { mDNS_Deregister_internal(m, r2, drt); r2 = m->DuplicateRecords; }
else r2=r2->next;
}
}
else
{
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; dup->next = rr->next; rr->next = dup; dup->resrec.RecordType = rr->resrec.RecordType;
dup->ProbeCount = rr->ProbeCount;
dup->AnnounceCount = rr->AnnounceCount;
dup->ImmedAnswer = rr->ImmedAnswer;
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;
if (RecordType == kDNSRecordTypeShared) rr->AnnounceCount = InitialAnnounceCount;
}
}
}
else
{
p = &m->DuplicateRecords;
while (*p && *p != rr) p=&(*p)->next;
if (*p && RecordType == kDNSRecordTypeShared) rr->AnnounceCount = InitialAnnounceCount;
if (*p) debugf("DNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
if (!*p)
{
if (drt != mDNS_Dereg_repeat)
debugf("mDNS_Deregister_internal: Record %p %##s (%s) not found in list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_BadReferenceErr);
}
if (RecordType == kDNSRecordTypeShared && rr->AnnounceCount < InitialAnnounceCount)
{
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 (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
m->DiscardLocalOnlyRecords = mDNStrue;
else
{
if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)
m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);
}
}
else
{
*p = rr->next; if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
if (m->NewLocalOnlyRecords == rr) m->NewLocalOnlyRecords = 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 (rr->NewRData) CompleteRDataUpdate(m, rr);
m->mDNS_reentrancy++; if (RecordType == kDNSRecordTypeShared)
{
if (rr->RecordCallback)
rr->RecordCallback(m, rr, mStatus_MemFree);
}
else if (drt == mDNS_Dereg_conflict)
{
RecordProbeFailure(m, rr);
if (rr->RecordCallback)
rr->RecordCallback(m, rr, mStatus_NameConflict);
}
m->mDNS_reentrancy--; }
return(mStatus_NoError);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - Packet Sending Functions
#endif
mDNSlocal void CompleteDeregistration(mDNS *const m, AuthRecord *rr)
{
rr->resrec.RecordType = kDNSRecordTypeShared;
rr->AnnounceCount = InitialAnnounceCount;
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
}
mDNSlocal void DiscardDeregistrations(mDNS *const m)
{
if (m->CurrentRecord) LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
CompleteDeregistration(m, rr);
}
}
mDNSlocal void GrantUpdateCredit(AuthRecord *rr)
{
if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0;
else rr->NextUpdateCredit = (rr->NextUpdateCredit + kUpdateCreditRefreshInterval) | 1;
}
mDNSlocal mDNSBool HaveSentEntireRRSet(const mDNS *const m, const AuthRecord *const rr, mDNSInterfaceID InterfaceID)
{
const AuthRecord *a;
for (a = m->ResourceRecords; a; a=a->next)
if (a->SendRNow == InterfaceID && a != rr && SameResourceRecordSignature(&a->resrec, &rr->resrec)) break;
return (a == mDNSNULL); }
mDNSlocal void SendResponses(mDNS *const m)
{
int pktcount = 0;
AuthRecord *rr, *r2;
mDNSs32 maxExistingAnnounceInterval = 0;
const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
m->NextScheduledResponse = m->timenow + 0x78000000;
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr);
if (TimeToAnnounceThisRecord(rr, m->timenow) && ResourceRecordIsValidAnswer(rr))
{
rr->ImmedAnswer = mDNSInterfaceMark; if (maxExistingAnnounceInterval < rr->ThisAPInterval)
maxExistingAnnounceInterval = rr->ThisAPInterval;
if (rr->UpdateBlocked) rr->UpdateBlocked = 0;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if ((rr->resrec.InterfaceID && rr->ImmedAnswer) ||
(rr->ThisAPInterval <= maxExistingAnnounceInterval &&
TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2) &&
ResourceRecordIsValidAnswer(rr)))
rr->ImmedAnswer = mDNSInterfaceMark;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->ImmedAnswer && rr->resrec.rrtype == kDNSType_SRV)
for (r2=m->ResourceRecords; r2; r2=r2->next) if (RRTypeIsAddressType(r2->resrec.rrtype) && ResourceRecordIsValidAnswer(r2) && rr->LastMCTime - r2->LastMCTime >= 0 && rr->resrec.rdnamehash == r2->resrec.namehash && SameDomainName(&rr->resrec.rdata->u.srv.target, &r2->resrec.name) &&
(rr->ImmedAnswer == mDNSInterfaceMark || rr->ImmedAnswer == r2->resrec.InterfaceID))
r2->ImmedAdditional = r2->resrec.InterfaceID;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
if (rr->ImmedAnswer) {
for (r2 = m->ResourceRecords; r2; r2=r2->next)
if (ResourceRecordIsValidAnswer(r2))
if (r2->ImmedAnswer != mDNSInterfaceMark && r2->ImmedAnswer != rr->ImmedAnswer && SameResourceRecordSignature(&r2->resrec, &rr->resrec))
r2->ImmedAnswer = rr->ImmedAnswer;
}
else if (rr->ImmedAdditional) {
for (r2 = m->ResourceRecords; r2; r2=r2->next)
if (ResourceRecordIsValidAnswer(r2))
if (r2->ImmedAdditional != rr->ImmedAdditional && SameResourceRecordSignature(&r2->resrec, &rr->resrec))
r2->ImmedAdditional = rr->ImmedAdditional;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->ImmedAnswer == mDNSInterfaceMark) {
rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID;
rr->ImmedAdditional = mDNSNULL; rr->LastMCTime = m->timenow;
rr->LastMCInterface = rr->ImmedAnswer;
if (TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2))
{
rr->AnnounceCount--;
rr->ThisAPInterval *= 2;
rr->LastAPTime = m->timenow;
if (rr->LastAPTime + rr->ThisAPInterval - rr->AnnounceUntil >= 0) rr->AnnounceCount = 0;
debugf("Announcing %##s (%s) %d", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount);
}
}
else if (rr->ImmedAnswer) {
rr->SendRNow = rr->ImmedAnswer; rr->ImmedAdditional = mDNSNULL; rr->LastMCTime = m->timenow;
rr->LastMCInterface = rr->ImmedAnswer;
}
SetNextAnnounceProbeTime(m, rr);
}
while (intf)
{
int numDereg = 0;
int numAnnounce = 0;
int numAnswer = 0;
DNSMessage response;
mDNSu8 *responseptr = response.data;
mDNSu8 *newptr;
InitializeDNSMessage(&response.h, zeroID, ResponseFlags);
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow == intf->InterfaceID)
{
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
{
newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, 0);
if (!newptr && response.h.numAnswers) break;
numDereg++;
responseptr = newptr;
}
else if (rr->NewRData) {
RData *OldRData = rr->resrec.rdata;
mDNSu16 oldrdlength = rr->resrec.rdlength;
if (ResourceRecordIsValidAnswer(rr) && rr->AnnounceCount < InitialAnnounceCount-1)
{
newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, 0);
if (!newptr && response.h.numAnswers) break;
numDereg++;
responseptr = newptr;
}
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength);
if ((rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && HaveSentEntireRRSet(m, rr, intf->InterfaceID))
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecord(&response, responseptr, &response.h.numAnswers, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (newptr) responseptr = newptr;
SetNewRData(&rr->resrec, OldRData, oldrdlength);
}
else
{
if ((rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && HaveSentEntireRRSet(m, rr, intf->InterfaceID))
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, m->SleepState ? 0 : rr->resrec.rroriginalttl);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (!newptr && response.h.numAnswers) break;
if (rr->LastAPTime == m->timenow) numAnnounce++; else numAnswer++;
responseptr = newptr;
}
if (rr->ImmedAnswer == mDNSInterfaceMark && rr->resrec.InterfaceID == mDNSInterface_Any)
rr->SendRNow = GetNextActiveInterfaceID(intf);
else
rr->SendRNow = mDNSNULL;
}
newptr = responseptr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->ImmedAdditional == intf->InterfaceID)
{
rr->ImmedAdditional = mDNSNULL;
if (newptr && ResourceRecordIsValidAnswer(rr))
{
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
const AuthRecord *a;
for (a = m->ResourceRecords; a; a=a->next)
if (a->ImmedAdditional == intf->InterfaceID && SameResourceRecordSignature(&a->resrec, &rr->resrec)) break;
if (a == mDNSNULL) rr->resrec.rrclass |= kDNSClass_UniqueRRSet; }
newptr = PutResourceRecord(&response, newptr, &response.h.numAdditionals, &rr->resrec);
if (newptr)
{
responseptr = newptr;
rr->LastMCTime = m->timenow;
rr->LastMCInterface = intf->InterfaceID;
}
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; }
}
if (response.h.numAnswers > 0) {
debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p",
numDereg, numDereg == 1 ? "" : "s",
numAnnounce, numAnnounce == 1 ? "" : "s",
numAnswer, numAnswer == 1 ? "" : "s",
response.h.numAdditionals, response.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID);
if (intf->IPv4Available) mDNSSendDNSMessage(m, &response, responseptr, intf->InterfaceID, &AllDNSLinkGroup_v4, MulticastDNSPort);
if (intf->IPv6Available) mDNSSendDNSMessage(m, &response, responseptr, intf->InterfaceID, &AllDNSLinkGroup_v6, MulticastDNSPort);
if (!m->SuppressSending) m->SuppressSending = (m->timenow + mDNSPlatformOneSecond/10) | 1; if (++pktcount >= 1000)
{ LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount); break; }
}
else {
const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
#if MDNS_DEBUGMSGS && 0
const char *const msg = next ? "SendResponses: Nothing more on %p; moving to %p" : "SendResponses: Nothing more on %p";
debugf(msg, intf, next);
#endif
intf = next;
}
}
if (m->CurrentRecord) LogMsg("SendResponses: ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->SendRNow)
{ LogMsg("SendResponses: No active interface to send: %s", GetRRDisplayString(m, rr)); rr->SendRNow = mDNSNULL; }
if (rr->NewRData) CompleteRDataUpdate(m,rr);
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
CompleteDeregistration(m, rr);
else
{
rr->ImmedAnswer = mDNSNULL;
rr->v4Requester = zeroIPAddr;
rr->v6Requester = zerov6Addr;
}
}
verbosedebugf("SendResponses: Next in %d ticks", m->NextScheduledResponse - m->timenow);
}
#define CacheCheckGracePeriod(RR) ( \
((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \
((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \
((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : (mDNSPlatformOneSecond/10))
mDNSlocal void SetNextCacheCheckTime(mDNS *const m, CacheRecord *const rr)
{
rr->NextRequiredQuery = RRExpireTime(rr);
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
{
rr->NextRequiredQuery -= TicksTTL(rr)/20 * (MaxUnansweredQueries - rr->UnansweredQueries);
rr->NextRequiredQuery += mDNSRandom((mDNSu32)TicksTTL(rr)/50);
verbosedebugf("SetNextCacheCheckTime: %##s (%s) NextRequiredQuery in %ld sec",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond);
}
if (m->NextCacheCheck - (rr->NextRequiredQuery + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (rr->NextRequiredQuery + CacheCheckGracePeriod(rr));
}
#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 45)
#define kDefaultReconfirmTimeForCableDisconnect ((mDNSu32)mDNSPlatformOneSecond * 5)
#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
mDNSlocal mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval)
{
if (!rr->resrec.InterfaceID && !IsLocalDomain(&rr->resrec.name))
{
LogMsg("mDNS_Reconfirm_internal: Not implemented for unicast DNS");
return mStatus_UnsupportedErr;
}
if (interval < kMinimumReconfirmTime)
interval = kMinimumReconfirmTime;
if (interval > 0x10000000) interval = 0x10000000;
if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3))
{
interval += mDNSRandom(interval/3);
rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3;
rr->resrec.rroriginalttl = interval * 4 / mDNSPlatformOneSecond;
SetNextCacheCheckTime(m, rr);
}
debugf("mDNS_Reconfirm_internal:%5ld ticks to go for %s", RRExpireTime(rr) - m->timenow, GetRRDisplayString(m, rr));
return(mStatus_NoError);
}
#define MaxQuestionInterval (3600 * mDNSPlatformOneSecond)
mDNSlocal mDNSBool BuildQuestion(mDNS *const m, DNSMessage *query, mDNSu8 **queryptr, DNSQuestion *q,
CacheRecord ***kalistptrptr, mDNSu32 *answerforecast)
{
mDNSBool ucast = (q->LargeAnswers || q->ThisQInterval <= InitialQuestionInterval*2) && m->CanReceiveUnicast;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
const mDNSu8 *const limit = query->data + NormalMaxDNSMessageData;
mDNSu8 *newptr = putQuestion(query, *queryptr, limit, &q->qname, q->qtype, (mDNSu16)(q->qclass | ucbit));
if (!newptr)
{
debugf("BuildQuestion: No more space in this packet for question %##s", q->qname.c);
return(mDNSfalse);
}
else if (newptr + *answerforecast >= limit)
{
verbosedebugf("BuildQuestion: Retracting question %##s new forecast total %d", q->qname.c, newptr + *answerforecast - query->data);
query->h.numQuestions--;
return(mDNSfalse);
}
else
{
mDNSu32 forecast = *answerforecast;
CacheRecord *rr;
CacheRecord **ka = *kalistptrptr;
for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) if (rr->resrec.InterfaceID == q->SendQNow && rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && rr->resrec.rdlength <= SmallRecordLimit && ResourceRecordAnswersQuestion(&rr->resrec, q) && rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0) {
*ka = rr; ka = &rr->NextInKAList;
forecast += 12 + rr->resrec.rdestimate;
if (query->h.numQuestions > 1 && newptr + forecast >= limit)
{
debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d",
q->qname.c, DNSTypeName(q->qtype), newptr + forecast - query->data);
query->h.numQuestions--;
ka = *kalistptrptr; while (*ka) { CacheRecord *rr = *ka; *ka = mDNSNULL; ka = &rr->NextInKAList; }
return(mDNSfalse); }
}
if (q->UniqueAnswers || newptr + forecast >= limit)
if (q->ThisQInterval == InitialQuestionInterval * 8 || q->ThisQInterval == InitialQuestionInterval * 32)
{
query->h.numQuestions--;
ka = *kalistptrptr; while (*ka) { CacheRecord *rr = *ka; *ka = mDNSNULL; ka = &rr->NextInKAList; }
return(mDNStrue); }
*queryptr = newptr; *answerforecast = forecast; *kalistptrptr = ka; if (ucast) m->ExpectUnicastResponse = m->timenow;
for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) if (rr->resrec.InterfaceID == q->SendQNow && rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && ResourceRecordAnswersQuestion(&rr->resrec, q)) {
rr->UnansweredQueries++; rr->LastUnansweredTime = m->timenow;
SetNextCacheCheckTime(m, rr);
}
return(mDNStrue);
}
}
mDNSlocal void ReconfirmAntecedents(mDNS *const m, DNSQuestion *q)
{
mDNSu32 slot;
CacheRecord *rr;
domainname *target;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if ((target = GetRRDomainNameTarget(&rr->resrec)) && rr->resrec.rdnamehash == q->qnamehash && SameDomainName(target, &q->qname))
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
}
mDNSlocal void ExpireDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time)
{
int i;
for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL;
}
mDNSlocal void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time, mDNSInterfaceID InterfaceID)
{
int i;
for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL;
}
mDNSlocal mDNSBool SuppressOnThisInterface(const DupSuppressInfo ds[DupSuppressInfoSize], const NetworkInterfaceInfo * const intf)
{
int i;
mDNSBool v4 = !intf->IPv4Available; mDNSBool v6 = !intf->IPv6Available; for (i=0; i<DupSuppressInfoSize; i++)
if (ds[i].InterfaceID == intf->InterfaceID)
{
if (ds[i].Type == mDNSAddrType_IPv4) v4 = mDNStrue;
else if (ds[i].Type == mDNSAddrType_IPv6) v6 = mDNStrue;
if (v4 && v6) return(mDNStrue);
}
return(mDNSfalse);
}
mDNSlocal int RecordDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 Time, mDNSInterfaceID InterfaceID, mDNSs32 Type)
{
int i, j;
for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Type == Type) break;
if (i >= DupSuppressInfoSize)
{
i = 0;
for (j=1; j<DupSuppressInfoSize && ds[i].InterfaceID; j++)
if (!ds[j].InterfaceID || ds[j].Time - ds[i].Time < 0)
i = j;
}
ds[i].Time = Time;
ds[i].InterfaceID = InterfaceID;
ds[i].Type = Type;
return(i);
}
mDNSlocal mDNSBool AccelerateThisQuery(mDNS *const m, DNSQuestion *q)
{
if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/10))
return(mDNStrue);
if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/2))
{
mDNSu32 forecast = (mDNSu32)DomainNameLength(&q->qname) + 4;
CacheRecord *rr;
for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) if (rr->resrec.rdlength <= SmallRecordLimit && ResourceRecordAnswersQuestion(&rr->resrec, q) && rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0) {
forecast += 12 + rr->resrec.rdestimate;
if (forecast >= 512) return(mDNSfalse); }
return(mDNStrue);
}
return(mDNSfalse);
}
mDNSlocal void SendQueries(mDNS *const m)
{
int pktcount = 0;
DNSQuestion *q;
mDNSs32 maxExistingQuestionInterval = 0;
const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
CacheRecord *KnownAnswerList = mDNSNULL;
if (m->timenow - m->NextScheduledQuery >= 0)
{
mDNSu32 slot;
CacheRecord *rr;
m->NextScheduledQuery = m->timenow + 0x78000000;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
if (m->timenow + TicksTTL(rr)/50 - rr->NextRequiredQuery >= 0)
{
q = rr->CRActiveQuestion;
ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(rr)/20, rr->resrec.InterfaceID);
if (q->Target.type) q->SendQNow = mDNSInterfaceMark; else if (q->SendQNow == mDNSNULL) q->SendQNow = rr->resrec.InterfaceID;
else if (q->SendQNow != rr->resrec.InterfaceID) q->SendQNow = mDNSInterfaceMark;
}
for (q = m->Questions; q; q=q->next)
if (q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow)))
{
DNSMessage query;
mDNSu8 *qptr = query.data;
const mDNSu8 *const limit = query.data + sizeof(query.data);
InitializeDNSMessage(&query.h, q->TargetQID, QueryFlags);
qptr = putQuestion(&query, qptr, limit, &q->qname, q->qtype, q->qclass);
mDNSSendDNSMessage(m, &query, qptr, mDNSInterface_Any, &q->Target, q->TargetPort);
q->ThisQInterval *= 2;
q->LastQTime = m->timenow;
q->LastQTxTime = m->timenow;
q->RecentAnswers = 0;
q->SendQNow = mDNSNULL;
m->ExpectUnicastResponse = m->timenow;
}
for (q = m->Questions; q; q=q->next)
if (!q->Target.type && TimeToSendThisQuestion(q, m->timenow))
{
q->SendQNow = mDNSInterfaceMark; if (maxExistingQuestionInterval < q->ThisQInterval)
maxExistingQuestionInterval = q->ThisQInterval;
}
for (q = m->Questions; q; q=q->next)
{
if (q->SendQNow ||
(!q->Target.type && ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q)))
{
if (m->timenow - (q->LastQTime + q->ThisQInterval/2) >= 0)
{
q->SendQNow = mDNSInterfaceMark; q->ThisQInterval *= 2;
if (q->ThisQInterval > MaxQuestionInterval)
q->ThisQInterval = MaxQuestionInterval;
else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * 8)
{
debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents", q->qname.c, DNSTypeName(q->qtype));
ReconfirmAntecedents(m, q); }
}
q->SendOnAll = (q->SendQNow == mDNSInterfaceMark);
if (q->SendOnAll)
{
q->SendQNow = !intf ? mDNSNULL : (q->InterfaceID) ? q->InterfaceID : intf->InterfaceID;
q->LastQTime = m->timenow;
}
ExpireDupSuppressInfo(q->DupSuppress, m->timenow - q->ThisQInterval/2);
q->LastQTxTime = m->timenow;
q->RecentAnswers = 0;
}
SetNextQueryTime(m,q);
}
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
m->NextScheduledProbe = m->timenow + 0x78000000;
if (m->CurrentRecord) LogMsg("SendQueries: ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeUnique) {
if (m->timenow - (rr->LastAPTime + rr->ThisAPInterval) < 0)
{
SetNextAnnounceProbeTime(m, rr);
}
else if (rr->ProbeCount)
{
rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID;
rr->LastAPTime = m->timenow;
rr->ProbeCount--;
SetNextAnnounceProbeTime(m, rr);
}
else
{
AuthRecord *r2;
rr->resrec.RecordType = kDNSRecordTypeVerified;
rr->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique;
rr->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique;
SetNextAnnounceProbeTime(m, rr);
for (r2 = m->DuplicateRecords; r2; r2=r2->next)
if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, rr))
r2->ProbeCount = 0;
CompleteProbing(m, rr);
}
}
}
m->CurrentRecord = m->DuplicateRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeUnique && rr->ProbeCount == 0)
CompleteProbing(m, rr);
}
}
while (intf)
{
AuthRecord *rr;
DNSMessage query;
mDNSu8 *queryptr = query.data;
InitializeDNSMessage(&query.h, zeroID, QueryFlags);
if (KnownAnswerList) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet");
if (!KnownAnswerList)
{
CacheRecord **kalistptr = &KnownAnswerList;
mDNSu32 answerforecast = 0;
for (q = m->Questions; q; q=q->next)
if (q->SendQNow == intf->InterfaceID)
{
debugf("SendQueries: %s question for %##s (%s) at %lu forecast total %lu",
SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting ",
q->qname.c, DNSTypeName(q->qtype), queryptr - query.data, queryptr + answerforecast - query.data);
if (SuppressOnThisInterface(q->DupSuppress, intf) ||
BuildQuestion(m, &query, &queryptr, q, &kalistptr, &answerforecast))
q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf);
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow == intf->InterfaceID)
{
mDNSBool ucast = (rr->ProbeCount >= DefaultProbeCountForTypeUnique-1) && m->CanReceiveUnicast;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
const mDNSu8 *const limit = query.data + ((query.h.numQuestions) ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData);
mDNSu8 *newptr = putQuestion(&query, queryptr, limit, &rr->resrec.name, kDNSQType_ANY, (mDNSu16)(rr->resrec.rrclass | ucbit));
mDNSu32 forecast = answerforecast + 12 + rr->resrec.rdestimate;
if (newptr && newptr + forecast < limit)
{
queryptr = newptr;
answerforecast = forecast;
rr->SendRNow = (rr->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf);
rr->IncludeInProbe = mDNStrue;
verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->ProbeCount);
}
else
{
verbosedebugf("SendQueries: Retracting Question %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
query.h.numQuestions--;
}
}
}
while (KnownAnswerList)
{
CacheRecord *rr = KnownAnswerList;
mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
mDNSu8 *newptr = PutResourceRecordTTL(&query, queryptr, &query.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl - SecsSinceRcvd);
if (newptr)
{
verbosedebugf("SendQueries: Put %##s (%s) at %lu - %lu", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), queryptr - query.data, newptr - query.data);
queryptr = newptr;
KnownAnswerList = rr->NextInKAList;
rr->NextInKAList = mDNSNULL;
}
else
{
if (query.h.numQuestions > 1)
LogMsg("SendQueries: Put %d answers; No more space for known answers", query.h.numAnswers);
query.h.flags.b[0] |= kDNSFlag0_TC;
break;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->IncludeInProbe)
{
mDNSu8 *newptr = PutResourceRecord(&query, queryptr, &query.h.numAuthorities, &rr->resrec);
rr->IncludeInProbe = mDNSfalse;
if (newptr) queryptr = newptr;
else LogMsg("SendQueries: How did we fail to have space for the Update record %##s (%s)?",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
if (queryptr > query.data)
{
if ((query.h.flags.b[0] & kDNSFlag0_TC) && query.h.numQuestions > 1)
LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet\n", query.h.numQuestions);
debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p",
query.h.numQuestions, query.h.numQuestions == 1 ? "" : "s",
query.h.numAnswers, query.h.numAnswers == 1 ? "" : "s",
query.h.numAuthorities, query.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID);
if (intf->IPv4Available) mDNSSendDNSMessage(m, &query, queryptr, intf->InterfaceID, &AllDNSLinkGroup_v4, MulticastDNSPort);
if (intf->IPv6Available) mDNSSendDNSMessage(m, &query, queryptr, intf->InterfaceID, &AllDNSLinkGroup_v6, MulticastDNSPort);
if (!m->SuppressSending) m->SuppressSending = (m->timenow + mDNSPlatformOneSecond/10) | 1; if (++pktcount >= 1000)
{ LogMsg("SendQueries exceeded loop limit %d: giving up", pktcount); break; }
}
else {
const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
#if MDNS_DEBUGMSGS && 0
const char *const msg = next ? "SendQueries: Nothing more on %p; moving to %p" : "SendQueries: Nothing more on %p";
debugf(msg, intf, next);
#endif
intf = next;
}
}
{
AuthRecord *rr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow)
{ LogMsg("SendQueries: No active interface to send: %s", GetRRDisplayString(m, rr)); rr->SendRNow = mDNSNULL; }
}
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - RR List Management & Task Management
#endif
mDNSlocal void AnswerQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, CacheRecord *rr, mDNSBool AddRecord)
{
verbosedebugf("AnswerQuestionWithResourceRecord:%4lu %s TTL%6lu %##s (%s)",
q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
rr->LastUsed = m->timenow;
rr->UseCount++;
if (ActiveQuestion(q) && rr->CRActiveQuestion != q)
{
if (!rr->CRActiveQuestion) m->rrcache_active++; rr->CRActiveQuestion = q; SetNextCacheCheckTime(m, rr);
}
m->mDNS_reentrancy++; if (q->QuestionCallback)
q->QuestionCallback(m, q, &rr->resrec, AddRecord);
m->mDNS_reentrancy--; }
mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr)
{
if (m->CurrentQuestion) LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set");
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
if (ActiveQuestion(q) && ++q->RecentAnswers >= 10 &&
q->ThisQInterval > InitialQuestionInterval*16 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond)
{
LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst; restarting exponential backoff sequence",
q->qname.c, DNSTypeName(q->qtype));
q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4);
q->ThisQInterval = InitialQuestionInterval;
SetNextQueryTime(m,q);
}
verbosedebugf("CacheRecordAdd %p %##s (%s) %lu", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
q->CurrentAnswers++;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
AnswerQuestionWithResourceRecord(m, q, rr, mDNStrue);
}
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr)
{
if (m->CurrentQuestion) LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set");
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
verbosedebugf("CacheRecordRmv %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
if (q->CurrentAnswers == 0)
LogMsg("CacheRecordRmv ERROR: How can CurrentAnswers already be zero for %p %##s (%s)?", q, q->qname.c, DNSTypeName(q->qtype));
else
{
q->CurrentAnswers--;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--;
}
if (q->CurrentAnswers == 0)
{
debugf("CacheRecordRmv: Zero current answers for %##s (%s); will reconfirm antecedents", q->qname.c, DNSTypeName(q->qtype));
ReconfirmAntecedents(m, q);
}
AnswerQuestionWithResourceRecord(m, q, rr, mDNSfalse);
}
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void ReleaseCacheRR(mDNS *const m, CacheRecord *r)
{
if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->rdatastorage)
mDNSPlatformMemFree(r->resrec.rdata);
r->resrec.rdata = mDNSNULL;
r->next = m->rrcache_free;
m->rrcache_free = r;
m->rrcache_totalused--;
}
mDNSlocal void CheckCacheExpiration(mDNS *const m, mDNSu32 slot)
{
CacheRecord **rp = &(m->rrcache_hash[slot]);
if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; }
m->lock_rrcache = 1;
while (*rp)
{
CacheRecord *const rr = *rp;
mDNSs32 event = RRExpireTime(rr);
if (m->timenow - event >= 0) {
*rp = rr->next; verbosedebugf("CheckCacheExpiration: Deleting %s", GetRRDisplayString(m, rr));
if (rr->CRActiveQuestion) {
CacheRecordRmv(m, rr);
m->rrcache_active--;
}
m->rrcache_used[slot]--;
ReleaseCacheRR(m, rr);
}
else {
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
{
if (m->timenow - rr->NextRequiredQuery < 0) event = rr->NextRequiredQuery; else {
m->NextScheduledQuery = m->timenow;
event = m->timenow + 0x3FFFFFFF;
}
}
if (m->NextCacheCheck - (event + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (event + CacheCheckGracePeriod(rr));
rp = &rr->next;
}
}
if (m->rrcache_tail[slot] != rp) debugf("CheckCacheExpiration: Updating m->rrcache_tail[%d] from %p to %p", slot, m->rrcache_tail[slot], rp);
m->rrcache_tail[slot] = rp;
m->lock_rrcache = 0;
}
mDNSlocal void AnswerNewQuestion(mDNS *const m)
{
mDNSBool ShouldQueryImmediately = mDNStrue;
CacheRecord *rr;
DNSQuestion *q = m->NewQuestions; mDNSu32 slot = HashSlot(&q->qname);
verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
CheckCacheExpiration(m, slot);
m->NewQuestions = q->next;
if (m->lock_rrcache) LogMsg("AnswerNewQuestion ERROR! Cache already locked!");
m->lock_rrcache = 1;
if (m->CurrentQuestion) LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set");
m->CurrentQuestion = q; for (rr=m->rrcache_hash[slot]; rr; rr=rr->next)
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
if (rr->resrec.rroriginalttl <= SecsSinceRcvd)
{
LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %##s (%s)",
rr->resrec.rroriginalttl, SecsSinceRcvd, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
continue; }
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ShouldQueryImmediately = mDNSfalse;
q->CurrentAnswers++;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
AnswerQuestionWithResourceRecord(m, q, rr, mDNStrue);
if (m->CurrentQuestion != q) break; }
else if (RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype))
if (rr->resrec.namehash == q->qnamehash && SameDomainName(&rr->resrec.name, &q->qname))
ShouldQueryImmediately = mDNSfalse;
if (ShouldQueryImmediately && m->CurrentQuestion == q)
{
q->ThisQInterval = InitialQuestionInterval;
q->LastQTime = m->timenow - q->ThisQInterval;
m->NextScheduledQuery = m->timenow;
}
m->CurrentQuestion = mDNSNULL;
m->lock_rrcache = 0;
}
mDNSlocal void AnswerLocalOnlyQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, AuthRecord *rr, mDNSBool AddRecord)
{
if (AddRecord) rr->AnnounceCount = InitialAnnounceCount - 1;
m->mDNS_reentrancy++; if (q->QuestionCallback)
q->QuestionCallback(m, q, &rr->resrec, AddRecord);
m->mDNS_reentrancy--; }
mDNSlocal void AnswerNewLocalOnlyQuestion(mDNS *const m)
{
DNSQuestion *q = m->NewLocalOnlyQuestions; m->NewLocalOnlyQuestions = q->next;
debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
if (m->CurrentQuestion) LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set");
m->CurrentQuestion = q;
m->CurrentRecord = m->LocalOnlyRecords;
while (m->CurrentRecord && m->CurrentRecord != m->NewLocalOnlyRecords)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, mDNStrue);
if (m->CurrentQuestion != q) break; }
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void AnswerLocalOnlyQuestions(mDNS *const m, AuthRecord *rr, mDNSBool AddRecord)
{
if (m->CurrentQuestion) LogMsg("AnswerLocalOnlyQuestions 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))
{
debugf("AnswerLocalOnlyQuestions %p %##s (%s) %lu", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord);
}
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void DiscardLocalOnlyRecords(mDNS *const m)
{
AuthRecord *rr = m->LocalOnlyRecords;
while (rr)
{
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
{ AnswerLocalOnlyQuestions(m, rr, mDNSfalse); CompleteDeregistration(m, rr); return; }
if (rr->ProbeCount) { mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); return; }
rr=rr->next;
}
m->DiscardLocalOnlyRecords = mDNSfalse;
}
mDNSlocal void AnswerForNewLocalOnlyRecords(mDNS *const m)
{
AuthRecord *rr = m->NewLocalOnlyRecords;
m->NewLocalOnlyRecords = m->NewLocalOnlyRecords->next;
AnswerLocalOnlyQuestions(m, rr, mDNStrue);
}
mDNSlocal CacheRecord *GetFreeCacheRR(mDNS *const m, mDNSu16 RDLength)
{
CacheRecord *r = mDNSNULL;
if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); }
m->lock_rrcache = 1;
if (!m->rrcache_free && m->MainCallback)
{
if (m->rrcache_totalused != m->rrcache_size)
LogMsg("GetFreeCacheRR: count mismatch: m->rrcache_totalused %lu != m->rrcache_size %lu",
m->rrcache_totalused, m->rrcache_size);
if (m->rrcache_size >= 512 && m->rrcache_size / 32 > m->rrcache_active)
debugf("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
m->rrcache_size, m->rrcache_active);
else
{
m->mDNS_reentrancy++; m->MainCallback(m, mStatus_GrowCache);
m->mDNS_reentrancy--; }
}
if (!m->rrcache_free)
{
#if MDNS_DEBUGMSGS
mDNSu32 oldtotalused = m->rrcache_totalused;
#endif
mDNSu32 slot;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
CacheRecord **rp = &(m->rrcache_hash[slot]);
while (*rp)
{
if ((*rp)->CRActiveQuestion)
rp=&(*rp)->next;
else
{
CacheRecord *rr = *rp;
*rp = (*rp)->next; m->rrcache_used[slot]--; ReleaseCacheRR(m, rr);
}
}
if (m->rrcache_tail[slot] != rp) debugf("GetFreeCacheRR: Updating m->rrcache_tail[%d] from %p to %p", slot, m->rrcache_tail[slot], rp);
m->rrcache_tail[slot] = rp;
}
#if MDNS_DEBUGMSGS
debugf("Clear unused records; m->rrcache_totalused was %lu; now %lu", oldtotalused, m->rrcache_totalused);
#endif
}
if (m->rrcache_free) {
r = m->rrcache_free;
m->rrcache_free = r->next;
}
if (r)
{
if (++m->rrcache_totalused >= m->rrcache_report)
{
debugf("RR Cache now using %ld records", m->rrcache_totalused);
if (m->rrcache_report < 100) m->rrcache_report += 10;
else m->rrcache_report += 100;
}
mDNSPlatformMemZero(r, sizeof(*r));
r->resrec.rdata = (RData*)&r->rdatastorage;
if (RDLength > InlineCacheRDSize) {
r->resrec.rdata = (RData*)mDNSPlatformMemAllocate(sizeofRDataHeader + RDLength);
if (r->resrec.rdata) r->resrec.rdata->MaxRDLength = r->resrec.rdlength = RDLength;
else { ReleaseCacheRR(m, r); r = mDNSNULL; }
}
}
m->lock_rrcache = 0;
return(r);
}
mDNSlocal void PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr)
{
rr->TimeRcvd = m->timenow - mDNSPlatformOneSecond * 60;
rr->UnansweredQueries = MaxUnansweredQueries;
rr->resrec.rroriginalttl = 0;
SetNextCacheCheckTime(m, rr);
}
mDNSlocal void mDNS_Lock(mDNS *const m)
{
mDNSPlatformLock(m);
if (m->mDNS_busy != m->mDNS_reentrancy)
LogMsg("mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
if (m->mDNS_busy == 0)
{
if (m->timenow)
LogMsg("mDNS_Lock: m->timenow already set (%ld/%ld)", m->timenow, mDNSPlatformTimeNow() + m->timenow_adjust);
m->timenow = mDNSPlatformTimeNow() + m->timenow_adjust;
if (m->timenow == 0) m->timenow = 1;
}
else if (m->timenow == 0)
{
LogMsg("mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy);
m->timenow = mDNSPlatformTimeNow() + m->timenow_adjust;
if (m->timenow == 0) m->timenow = 1;
}
if (m->timenow_last - m->timenow > 0)
{
m->timenow_adjust += m->timenow_last - m->timenow;
LogMsg("mDNSPlatformTimeNow went backwards by %ld ticks; setting correction factor to %ld", m->timenow_last - m->timenow, m->timenow_adjust);
m->timenow = m->timenow_last;
}
m->timenow_last = m->timenow;
m->mDNS_busy++;
}
mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
{
mDNSs32 e = m->timenow + 0x78000000;
if (m->mDNSPlatformStatus != mStatus_NoError || m->SleepState) return(e);
if (m->NewQuestions) return(m->timenow);
if (m->NewLocalOnlyQuestions) return(m->timenow);
if (m->NewLocalOnlyRecords) return(m->timenow);
if (m->DiscardLocalOnlyRecords) return(m->timenow);
if (m->SuppressSending) return(m->SuppressSending);
if (e - m->uDNS_info.nextevent > 0) e = m->uDNS_info.nextevent;
if (e - m->NextCacheCheck > 0) e = m->NextCacheCheck;
if (e - m->NextScheduledQuery > 0) e = m->NextScheduledQuery;
if (e - m->NextScheduledProbe > 0) e = m->NextScheduledProbe;
if (e - m->NextScheduledResponse > 0) e = m->NextScheduledResponse;
return(e);
}
mDNSlocal void mDNS_Unlock(mDNS *const m)
{
m->mDNS_busy--;
if (m->mDNS_busy != m->mDNS_reentrancy)
LogMsg("mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
if (m->mDNS_busy == 0)
{
m->NextScheduledEvent = GetNextScheduledEvent(m);
if (m->timenow == 0) LogMsg("mDNS_Unlock: ERROR! m->timenow aready zero");
m->timenow = 0;
}
mDNSPlatformUnlock(m);
}
mDNSexport mDNSs32 mDNS_Execute(mDNS *const m)
{
mDNS_Lock(m);
if (m->timenow - m->NextScheduledEvent >= 0)
{
int i;
verbosedebugf("mDNS_Execute");
if (m->CurrentQuestion) LogMsg("mDNS_Execute: ERROR! m->CurrentQuestion already set");
if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0;
if (m->NumFailedProbes && m->timenow - m->ProbeFailTime >= mDNSPlatformOneSecond * 10) m->NumFailedProbes = 0;
if (m->rrcache_size && m->timenow - m->NextCacheCheck >= 0)
{
mDNSu32 slot;
m->NextCacheCheck = m->timenow + 0x3FFFFFFF;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) CheckCacheExpiration(m, slot);
}
for (i=0; m->NewQuestions && i<1000; i++) AnswerNewQuestion(m);
if (i >= 1000) debugf("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
for (i=0; m->DiscardLocalOnlyRecords && i<1000; i++) DiscardLocalOnlyRecords(m);
if (i >= 1000) debugf("mDNS_Execute: DiscardLocalOnlyRecords exceeded loop limit");
for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m);
if (i >= 1000) debugf("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
for (i=0; m->NewLocalOnlyRecords && i<1000; i++) AnswerForNewLocalOnlyRecords(m);
if (i >= 1000) debugf("mDNS_Execute: AnswerLocalOnlyQuestions exceeded loop limit");
if (m->mDNSPlatformStatus != mStatus_NoError || m->SleepState) DiscardDeregistrations(m);
else if (m->SuppressSending == 0 || m->timenow - m->SuppressSending >= 0)
{
m->SuppressSending = 0;
if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m);
if (m->timenow - m->NextScheduledQuery >= 0)
{
LogMsg("mDNS_Execute: SendQueries didn't send all its queries; will try again in one second");
m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond;
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
LogMsg("mDNS_Execute: SendQueries didn't send all its probes; will try again in one second");
m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond;
}
if (m->timenow - m->NextScheduledResponse >= 0) SendResponses(m);
if (m->timenow - m->NextScheduledResponse >= 0)
{
LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second");
m->NextScheduledResponse = m->timenow + mDNSPlatformOneSecond;
}
}
m->RandomQueryDelay = 0; }
uDNS_Execute(m);
mDNS_Unlock(m); return(m->NextScheduledEvent);
}
mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleepstate)
{
AuthRecord *rr;
mDNS_Lock(m);
m->SleepState = sleepstate;
LogMsg("%s at %ld", sleepstate ? "Sleeping" : "Waking", m->timenow);
if (sleepstate)
{
uDNS_SuspendLLQs(m);
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->AnnounceCount < InitialAnnounceCount)
rr->ImmedAnswer = mDNSInterfaceMark;
SendResponses(m);
}
else
{
DNSQuestion *q;
mDNSu32 slot;
CacheRecord *cr;
uDNS_RestartLLQs(m);
for (q = m->Questions; q; q=q->next) if (ActiveQuestion(q))
{
q->ThisQInterval = InitialQuestionInterval; q->LastQTime = m->timenow - q->ThisQInterval;
q->RecentAnswers = 0;
ExpireDupSuppressInfo(q->DupSuppress, m->timenow);
m->NextScheduledQuery = m->timenow;
}
m->NextCacheCheck = m->timenow;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (cr = m->rrcache_hash[slot]; cr; cr=cr->next)
mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForCableDisconnect);
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
}
mDNS_Unlock(m);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Packet Reception Functions
#endif
mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)
{
if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)
{
**nrpp = rr;
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));
}
#define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo)
mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end,
const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, DNSMessage *const response, AuthRecord *ResponseRecords)
{
mDNSu8 *responseptr = response->data;
const mDNSu8 *const limit = response->data + sizeof(response->data);
const mDNSu8 *ptr = query->data;
AuthRecord *rr;
mDNSu32 maxttl = 0x70000000;
int i;
InitializeDNSMessage(&response->h, query->h.id, ResponseFlags);
if (LegacyQuery)
{
maxttl = 10;
for (i=0; i<query->h.numQuestions; i++) {
DNSQuestion q;
ptr = getQuestion(query, ptr, end, InterfaceID, &q); if (!ptr) return(mDNSNULL);
for (rr=ResponseRecords; rr; rr=rr->NextResponse) {
if (rr->NR_AnswerTo == ptr) { responseptr = putQuestion(response, responseptr, limit, &q.qname, q.qtype, q.qclass);
if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL); }
break; }
}
}
if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL); }
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (rr->NR_AnswerTo)
{
mDNSu8 *p = PutResourceRecordCappedTTL(response, responseptr, &response->h.numAnswers, &rr->resrec, maxttl);
if (p) responseptr = p;
else { debugf("GenerateUnicastResponse: Ran out of space for answers!"); response->h.flags.b[0] |= kDNSFlag0_TC; }
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (rr->NR_AdditionalTo && !rr->NR_AnswerTo)
{
mDNSu8 *p = PutResourceRecordCappedTTL(response, responseptr, &response->h.numAdditionals, &rr->resrec, maxttl);
if (p) responseptr = p;
else debugf("GenerateUnicastResponse: No more space for additionals");
}
return(responseptr);
}
mDNSlocal int CompareRData(AuthRecord *our, CacheRecord *pkt)
{
mDNSu8 ourdata[256], *ourptr = ourdata, *ourend;
mDNSu8 pktdata[256], *pktptr = pktdata, *pktend;
if (!our) { LogMsg("CompareRData ERROR: our is NULL"); return(+1); }
if (!pkt) { LogMsg("CompareRData ERROR: pkt is NULL"); return(+1); }
ourend = putRData(mDNSNULL, ourdata, ourdata + sizeof(ourdata), &our->resrec);
pktend = putRData(mDNSNULL, pktdata, pktdata + sizeof(pktdata), &pkt->resrec);
while (ourptr < ourend && pktptr < pktend && *ourptr == *pktptr) { ourptr++; pktptr++; }
if (ourptr >= ourend && pktptr >= pktend) return(0);
if (ourptr >= ourend) return(-1); if (pktptr >= pktend) return(+1); if (*pktptr > *ourptr) return(-1); if (*pktptr < *ourptr) return(+1);
debugf("CompareRData: How did we get here?");
return(-1);
}
mDNSlocal mDNSBool MatchDependentOn(const mDNS *const m, const CacheRecord *const pktrr, const AuthRecord *const master)
{
const AuthRecord *r1;
for (r1 = m->ResourceRecords; r1; r1=r1->next)
{
if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec))
{
const AuthRecord *r2 = r1;
while (r2->DependentOn) r2 = r2->DependentOn;
if (r2 == master) return(mDNStrue);
}
}
for (r1 = m->DuplicateRecords; r1; r1=r1->next)
{
if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec))
{
const AuthRecord *r2 = r1;
while (r2->DependentOn) r2 = r2->DependentOn;
if (r2 == master) return(mDNStrue);
}
}
return(mDNSfalse);
}
mDNSlocal const AuthRecord *FindRRSet(const mDNS *const m, const CacheRecord *const pktrr)
{
const AuthRecord *rr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (IdenticalResourceRecord(&rr->resrec, &pktrr->resrec))
{
while (rr->RRSet && rr != rr->RRSet) rr = rr->RRSet;
return(rr);
}
}
return(mDNSNULL);
}
mDNSlocal mDNSBool PacketRRConflict(const mDNS *const m, const AuthRecord *const our, const CacheRecord *const pktrr)
{
const AuthRecord *ourset = our->RRSet ? our->RRSet : our;
if (!(our->resrec.RecordType & kDNSRecordTypeUniqueMask)) return(mDNSfalse);
if (our->DependentOn || MatchDependentOn(m, pktrr, our)) return(mDNSfalse);
if (FindRRSet(m, pktrr) == ourset) return(mDNSfalse);
return(mDNStrue);
}
mDNSlocal void ResolveSimultaneousProbe(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
DNSQuestion *q, AuthRecord *our)
{
int i;
const mDNSu8 *ptr = LocateAuthorities(query, end);
mDNSBool FoundUpdate = mDNSfalse;
for (i = 0; i < query->h.numAuthorities; i++)
{
LargeCacheRecord pkt;
ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, 0, &pkt);
if (!ptr) break;
if (ResourceRecordAnswersQuestion(&pkt.r.resrec, q))
{
FoundUpdate = mDNStrue;
if (PacketRRConflict(m, our, &pkt.r))
{
int result = (int)our->resrec.rrclass - (int)pkt.r.resrec.rrclass;
if (!result) result = (int)our->resrec.rrtype - (int)pkt.r.resrec.rrtype;
if (!result) result = CompareRData(our, &pkt.r);
switch (result)
{
case 1: debugf("ResolveSimultaneousProbe: %##s (%s): We won", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
break;
case 0: break;
case -1: debugf("ResolveSimultaneousProbe: %##s (%s): We lost", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
mDNS_Deregister_internal(m, our, mDNS_Dereg_conflict);
return;
}
}
}
}
if (!FoundUpdate)
debugf("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
}
mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, ResourceRecord *pktrr)
{
CacheRecord *rr;
for (rr = m->rrcache_hash[HashSlot(&pktrr->name)]; rr; rr=rr->next)
if (pktrr->InterfaceID == rr->resrec.InterfaceID && IdenticalResourceRecord(pktrr, &rr->resrec)) break;
return(rr);
}
mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast,
DNSMessage *const response)
{
AuthRecord *ResponseRecords = mDNSNULL;
AuthRecord **nrp = &ResponseRecords;
CacheRecord *ExpectedAnswers = mDNSNULL; CacheRecord **eap = &ExpectedAnswers;
DNSQuestion *DupQuestions = mDNSNULL; DNSQuestion **dqp = &DupQuestions;
mDNSs32 delayresponse = 0;
mDNSBool HaveUnicastAnswer = mDNSfalse;
const mDNSu8 *ptr = query->data;
mDNSu8 *responseptr = mDNSNULL;
AuthRecord *rr, *rr2;
int i;
if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond;
for (i=0; i<query->h.numQuestions; i++) {
mDNSBool QuestionNeedsMulticastResponse;
int NumAnswersForThisQuestion = 0;
DNSQuestion pktq, *q;
ptr = getQuestion(query, ptr, end, InterfaceID, &pktq); if (!ptr) goto exit;
QuestionNeedsMulticastResponse = QueryWasMulticast && !LegacyQuery && !(pktq.qclass & kDNSQClass_UnicastResponse);
pktq.qclass &= ~kDNSQClass_UnicastResponse;
if (m->CurrentRecord) LogMsg("ProcessQuery ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq))
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
ResolveSimultaneousProbe(m, query, end, &pktq, rr);
else if (ResourceRecordIsValidAnswer(rr))
{
NumAnswersForThisQuestion++;
if (QuestionNeedsMulticastResponse)
{
if (m->timenow - (rr->LastMCTime + mDNSPlatformOneSecond) >= 0 ||
(rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID))
rr->NR_AnswerTo = (mDNSu8*)~0;
}
else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = ptr;
}
}
}
if (QuestionNeedsMulticastResponse)
{
CacheRecord *rr;
if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond;
for (rr = m->rrcache_hash[HashSlot(&pktq.qname)]; rr; rr=rr->next)
if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq) && rr->resrec.rdlength <= SmallRecordLimit)
if (!rr->NextInKAList && eap != &rr->NextInKAList)
{
*eap = rr;
eap = &rr->NextInKAList;
if (rr->MPUnansweredQ == 0 || m->timenow - rr->MPLastUnansweredQT >= mDNSPlatformOneSecond)
{
rr->MPUnansweredQ++;
rr->MPLastUnansweredQT = m->timenow;
rr->MPExpectingKA = mDNStrue;
}
}
if (!(query->h.flags.b[0] & kDNSFlag0_TC))
for (q = m->Questions; q; q=q->next)
if (!q->Target.type && ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4)
if (!q->InterfaceID || q->InterfaceID == InterfaceID)
if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList)
if (q->qtype == pktq.qtype && q->qclass == pktq.qclass && q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname))
{ *dqp = q; dqp = &q->NextInDQList; }
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->NR_AnswerTo) AddRecordToResponseList(&nrp, rr, mDNSNULL);
for (rr=ResponseRecords; rr; rr=rr->NextResponse) {
if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))
AddRecordToResponseList(&nrp, rr->Additional1, rr);
if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))
AddRecordToResponseList(&nrp, rr->Additional2, rr);
if (rr->resrec.rrtype == kDNSType_SRV)
for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) if (RRTypeIsAddressType(rr2->resrec.rrtype) && ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && rr->resrec.rdnamehash == rr2->resrec.namehash && SameDomainName(&rr->resrec.rdata->u.srv.target, &rr2->resrec.name))
AddRecordToResponseList(&nrp, rr2, rr);
}
for (i=0; i<query->h.numAnswers; i++) {
LargeCacheRecord pkt;
AuthRecord *rr;
CacheRecord *ourcacherr;
ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &pkt);
if (!ptr) goto exit;
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&pkt.r, rr))
{ rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
for (rr=m->ResourceRecords; rr; rr=rr->next)
{
if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&pkt.r, rr))
{
if (srcaddr->type == mDNSAddrType_IPv4)
{
if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zeroIPAddr;
}
else if (srcaddr->type == mDNSAddrType_IPv6)
{
if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr;
}
if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester))
{
rr->ImmedAnswer = mDNSNULL;
#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
LogMsg("Suppressed after%4d: %s", m->timenow - rr->ImmedAnswerMarkTime, GetRRDisplayString(m, rr));
#endif
}
}
}
ourcacherr = FindIdenticalRecordInCache(m, &pkt.r.resrec);
if (ourcacherr && ourcacherr->MPExpectingKA && m->timenow - ourcacherr->MPLastUnansweredQT < mDNSPlatformOneSecond)
{
ourcacherr->MPUnansweredKA++;
ourcacherr->MPExpectingKA = mDNSfalse;
}
eap = &ExpectedAnswers;
while (*eap)
{
CacheRecord *rr = *eap;
if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&pkt.r.resrec, &rr->resrec))
{ *eap = rr->NextInKAList; rr->NextInKAList = mDNSNULL; }
else eap = &rr->NextInKAList;
}
if (!ourcacherr)
{
dqp = &DupQuestions;
while (*dqp)
{
DNSQuestion *q = *dqp;
if (ResourceRecordAnswersQuestion(&pkt.r.resrec, q))
{ *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; }
else dqp = &q->NextInDQList;
}
}
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (rr->NR_AdditionalTo && !MustSendRecord(rr->NR_AdditionalTo))
{ rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
{
if (rr->NR_AnswerTo)
{
mDNSBool SendMulticastResponse = mDNSfalse;
if (m->timenow - (rr->LastMCTime + TicksTTL(rr)/4) >= 0) SendMulticastResponse = mDNStrue;
if (rr->NR_AnswerTo == (mDNSu8*)~0) SendMulticastResponse = mDNStrue;
else if (rr->NR_AnswerTo) HaveUnicastAnswer = mDNStrue;
if (SendMulticastResponse)
{
#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
rr->ImmedAnswerMarkTime = m->timenow;
#endif
m->NextScheduledResponse = m->timenow;
if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID)
{
rr->ImmedAnswer = mDNSInterfaceMark;
debugf("ProcessQuery: %##s (%s) : Will send on all interfaces", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
else
{
rr->ImmedAnswer = InterfaceID; if (srcaddr->type == mDNSAddrType_IPv4)
{
if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4;
else if (!mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = onesIPv4Addr;
}
else if (srcaddr->type == mDNSAddrType_IPv6)
{
if (mDNSIPv6AddressIsZero(rr->v6Requester)) rr->v6Requester = srcaddr->ip.v6;
else if (!mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = onesIPv6Addr;
}
}
}
if (rr->resrec.RecordType == kDNSRecordTypeShared)
{
if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; else delayresponse = mDNSPlatformOneSecond; }
}
else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == (mDNSu8*)~0)
{
rr->ImmedAdditional = InterfaceID;
}
}
if (delayresponse && (!m->SuppressSending || (m->SuppressSending - m->timenow) < (delayresponse + 49) / 50))
{
#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
mDNSs32 oldss = m->SuppressSending;
if (oldss && delayresponse)
LogMsg("Current SuppressSending delay%5ld; require%5ld", m->SuppressSending - m->timenow, (delayresponse + 49) / 50);
#endif
m->SuppressSending = m->timenow + (delayresponse + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*5) + 49) / 50;
if (m->SuppressSending == 0) m->SuppressSending = 1;
#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
if (oldss && delayresponse)
LogMsg("Set SuppressSending to %5ld", m->SuppressSending - m->timenow);
#endif
}
if (HaveUnicastAnswer)
responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords);
exit:
while (ResponseRecords)
{
rr = ResponseRecords;
ResponseRecords = rr->NextResponse;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
}
while (ExpectedAnswers)
{
CacheRecord *rr;
rr = ExpectedAnswers;
ExpectedAnswers = rr->NextInKAList;
rr->NextInKAList = mDNSNULL;
if (!(query->h.flags.b[0] & kDNSFlag0_TC))
if (rr->UnansweredQueries == 0 || m->timenow - rr->LastUnansweredTime >= mDNSPlatformOneSecond)
{
rr->UnansweredQueries++;
rr->LastUnansweredTime = m->timenow;
if (rr->UnansweredQueries > 1)
debugf("ProcessQuery: (!TC) UAQ %lu MPQ %lu MPKA %lu %s",
rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
SetNextCacheCheckTime(m, rr);
}
if (rr->UnansweredQueries >= MaxUnansweredQueries)
{
if (RRExpireTime(rr) - m->timenow > 4 * mDNSPlatformOneSecond)
debugf("ProcessQuery: (Max) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
}
else if (rr->MPUnansweredQ * 4 > rr->MPUnansweredKA * 5 + 8)
{
mDNSu32 remain = (mDNSu32)(RRExpireTime(rr) - m->timenow) / 4;
if (remain > 240 * (mDNSu32)mDNSPlatformOneSecond)
remain = 240 * (mDNSu32)mDNSPlatformOneSecond;
if (RRExpireTime(rr) - m->timenow > 4 * mDNSPlatformOneSecond)
debugf("ProcessQuery: (MPQ) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
if (remain <= 60 * (mDNSu32)mDNSPlatformOneSecond)
rr->UnansweredQueries++; rr->MPUnansweredQ = 0; rr->MPUnansweredKA = 0;
rr->MPExpectingKA = mDNSfalse;
if (remain < kDefaultReconfirmTimeForNoAnswer)
remain = kDefaultReconfirmTimeForNoAnswer;
mDNS_Reconfirm_internal(m, rr, remain);
}
}
while (DupQuestions)
{
int i;
DNSQuestion *q = DupQuestions;
DupQuestions = q->NextInDQList;
q->NextInDQList = mDNSNULL;
i = RecordDupSuppressInfo(q->DupSuppress, m->timenow, InterfaceID, srcaddr->type);
debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s %d", q->qname.c, DNSTypeName(q->qtype), InterfaceID,
srcaddr->type == mDNSAddrType_IPv4 ? "v4" : "v6", i);
}
return(responseptr);
}
mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end,
const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
const mDNSInterfaceID InterfaceID)
{
DNSMessage response;
mDNSu8 *responseend = mDNSNULL;
if (!InterfaceID)
{
LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%.8X with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,",
msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,",
msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,",
msg->h.numAdditionals, msg->h.numAdditionals == 1 ? "" : "s");
return;
}
verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%.8X with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,",
msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,",
msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,",
msg->h.numAdditionals, msg->h.numAdditionals == 1 ? "" : "s");
responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID,
(srcport.NotAnInteger != MulticastDNSPort.NotAnInteger), mDNSAddrIsDNSMulticast(dstaddr), &response);
if (responseend) {
debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
response.h.numQuestions, response.h.numQuestions == 1 ? "" : "s",
response.h.numAnswers, response.h.numAnswers == 1 ? "" : "s",
response.h.numAdditionals, response.h.numAdditionals == 1 ? "" : "s",
srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type);
mDNSSendDNSMessage(m, &response, responseend, InterfaceID, srcaddr, srcport);
}
}
mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m,
const DNSMessage *const response, const mDNSu8 *end,
const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
const mDNSInterfaceID InterfaceID, mDNSu8 ttl)
{
static mDNSu32 NumPktsAccepted = 0, NumPktsIgnored = 0;
int i;
const mDNSu8 *ptr = LocateAnswers(response, end); CacheRecord *CacheFlushRecords = mDNSNULL;
CacheRecord **cfp = &CacheFlushRecords;
int totalrecords = response->h.numAnswers + response->h.numAuthorities + response->h.numAdditionals;
(void)srcaddr;
verbosedebugf("Received Response from %#-15a addressed to %#-15a on %p TTL %d with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
srcaddr, dstaddr, InterfaceID, ttl,
response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,",
response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s");
if (ttl < 254 || (!mDNSAddrIsDNSMulticast(dstaddr) && (mDNSu32)(m->timenow - m->ExpectUnicastResponse) > (mDNSu32)(mDNSPlatformOneSecond*2)))
{
mDNSBool ignoredlots = (++NumPktsIgnored > NumPktsAccepted + 10);
if (ignoredlots || NumPktsIgnored <= 10)
LogMsg("Ignored apparent spoof mDNS Response with TTL %d from %#-15a:%-5d to %#-15a:%-5d on %p with %2d Q %2d Ans %2d Auth %2d Add",
ttl, srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
response->h.numQuestions, response->h.numAnswers, response->h.numAuthorities, response->h.numAdditionals);
if (ignoredlots)
LogMsg("WARNING: Have ignored %lu packets out of %lu; this may indicate an error in the platform support layer.",
NumPktsIgnored, NumPktsIgnored + NumPktsAccepted);
return;
}
NumPktsAccepted++;
for (i = 0; i < totalrecords && ptr && ptr < end; i++)
{
LargeCacheRecord pkt;
const mDNSu8 RecordType = (mDNSu8)((i < response->h.numAnswers) ? kDNSRecordTypePacketAns : kDNSRecordTypePacketAdd);
ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &pkt);
if (!ptr) break;
if (m->CurrentRecord) LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (PacketRRMatchesSignature(&pkt.r, rr)) {
if (SameRData(&pkt.r.resrec, &rr->resrec))
{
if (pkt.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState)
{
if (rr->ImmedAnswer == InterfaceID) rr->ImmedAnswer = mDNSNULL;
}
else
{
if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; }
else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
}
}
else
{
if (pkt.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &pkt.r))
{
debugf("mDNSCoreReceiveResponse: Our Record: %08X %08X %s", rr-> resrec.rdatahash, rr-> resrec.rdnamehash, GetRRDisplayString(m, rr));
debugf("mDNSCoreReceiveResponse: Pkt Record: %08X %08X %s", pkt.r.resrec.rdatahash, pkt.r.resrec.rdnamehash, GetRRDisplayString(m, &pkt.r));
while (rr->DependentOn) rr = rr->DependentOn;
if (rr->ProbeCount <= DefaultProbeCountForTypeUnique)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified)
{
debugf("mDNSCoreReceiveResponse: Reseting to Probing: %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForTypeUnique + 1;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(kDNSRecordTypeUnique);
InitializeLastAPTime(m, rr);
RecordProbeFailure(m, rr); }
else if (rr->resrec.RecordType == kDNSRecordTypeUnique)
{
debugf("mDNSCoreReceiveResponse: Will rename %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
}
else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique)
{
debugf("mDNSCoreReceiveResponse: Unexpected conflict on %##s (%s) -- discarding our record",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
}
else
debugf("mDNSCoreReceiveResponse: Unexpected record type %X %##s (%s)",
rr->resrec.RecordType, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
}
else if ((pkt.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && m->timenow - rr->LastMCTime > mDNSPlatformOneSecond/2)
{ rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
}
}
}
if (m->rrcache_size) {
mDNSu32 slot = HashSlot(&pkt.r.resrec.name);
CacheRecord *rr;
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
{
if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&pkt.r.resrec, &rr->resrec))
{
if (pkt.r.resrec.rdlength > InlineCacheRDSize)
verbosedebugf("Found record size %5d interface %p already in cache: %s",
pkt.r.resrec.rdlength, InterfaceID, GetRRDisplayString(m, &pkt.r));
rr->TimeRcvd = m->timenow;
if (pkt.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask)
{
if (rr->NextInCFList == mDNSNULL && cfp != &rr->NextInCFList)
{ *cfp = rr; cfp = &rr->NextInCFList; }
if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (ResourceRecordAnswersQuestion(&rr->resrec, q)) q->UniqueAnswers++;
rr->resrec.RecordType = pkt.r.resrec.RecordType;
}
}
if (pkt.r.resrec.rroriginalttl > 0)
{
rr->resrec.rroriginalttl = pkt.r.resrec.rroriginalttl;
rr->UnansweredQueries = 0;
rr->MPUnansweredQ = 0;
rr->MPUnansweredKA = 0;
rr->MPExpectingKA = mDNSfalse;
}
else
{
rr->resrec.rroriginalttl = 1;
rr->UnansweredQueries = MaxUnansweredQueries;
}
SetNextCacheCheckTime(m, rr);
break;
}
}
if (!rr && pkt.r.resrec.rroriginalttl > 0)
{
rr = GetFreeCacheRR(m, pkt.r.resrec.rdlength);
if (!rr) debugf("No cache space to add record for %#s", pkt.r.resrec.name.c);
else
{
RData *saveptr = rr->resrec.rdata; *rr = pkt.r;
rr->resrec.rdata = saveptr; if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)
{ *cfp = rr; cfp = &rr->NextInCFList; }
if (pkt.r.resrec.rdlength > InlineCacheRDSize)
mDNSPlatformMemCopy(pkt.r.resrec.rdata, rr->resrec.rdata, sizeofRDataHeader + pkt.r.resrec.rdlength);
rr->next = mDNSNULL; *(m->rrcache_tail[slot]) = rr; m->rrcache_tail[slot] = &(rr->next); m->rrcache_used[slot]++;
CacheRecordAdd(m, rr);
SetNextCacheCheckTime(m, rr);
}
}
}
}
while (CacheFlushRecords)
{
CacheRecord *r1 = CacheFlushRecords, *r2;
CacheFlushRecords = CacheFlushRecords->NextInCFList;
r1->NextInCFList = mDNSNULL;
for (r2 = m->rrcache_hash[HashSlot(&r1->resrec.name)]; r2; r2=r2->next)
if (SameResourceRecordSignature(&r1->resrec, &r2->resrec) && m->timenow - r2->TimeRcvd > mDNSPlatformOneSecond)
{
verbosedebugf("Cache flush %p X %p %##s (%s)", r1, r2, r2->resrec.name.c, DNSTypeName(r2->resrec.rrtype));
r2->resrec.rroriginalttl = 1;
r2->TimeRcvd = m->timenow;
r2->UnansweredQueries = MaxUnansweredQueries;
SetNextCacheCheckTime(m, r2);
}
}
}
mDNSexport void mDNSCoreReceive(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *const dstaddr, const mDNSIPPort dstport,
const mDNSInterfaceID InterfaceID, mDNSu8 ttl)
{
const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery;
const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
const mDNSu8 UpdateR = kDNSFlag0_OP_Update | kDNSFlag0_QR_Response;
const mDNSu8 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
mDNSu8 *ptr = (mDNSu8 *)&msg->h.numQuestions;
msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]);
if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; }
if (!mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; }
if (dstaddr->type == mDNSAddrType_IPv4 && dstaddr->ip.v4.NotAnInteger != AllDNSLinkGroup.NotAnInteger &&
(QR_OP == StdR || QR_OP == UpdateR ) && msg->h.id.NotAnInteger)
{
uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID, ttl);
return;
}
mDNS_Lock(m);
if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID);
else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID, ttl);
else LogMsg("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d on %p (ignored)",
msg->h.flags.b[0], msg->h.flags.b[1], srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID);
mDNS_Unlock(m);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - Searcher Functions
#endif
#define SameQTarget(A,B) (mDNSSameAddress(&(A)->Target, &(B)->Target) && (A)->TargetPort.NotAnInteger == (B)->TargetPort.NotAnInteger)
mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q && q != question; q=q->next) if (q->InterfaceID == question->InterfaceID && SameQTarget(q, question) && q->qtype == question->qtype && q->qclass == question->qclass && q->qnamehash == question->qnamehash &&
SameDomainName(&q->qname, &question->qname)) return(q);
return(mDNSNULL);
}
mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, const DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (q->DuplicateOf == question) {
q->ThisQInterval = question->ThisQInterval;
q->LastQTime = question->LastQTime;
q->RecentAnswers = 0;
q->DuplicateOf = FindDuplicateQuestion(m, q);
q->LastQTxTime = question->LastQTxTime;
SetNextQueryTime(m,q);
}
}
#define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \
((Q)->TargetPort.NotAnInteger == UnicastDNSPort.NotAnInteger || (Q)->TargetPort.NotAnInteger == MulticastDNSPort.NotAnInteger))
mDNSlocal mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question)
{
#if TEST_LOCALONLY_FOR_EVERYTHING
question->InterfaceID = mDNSInterface_LocalOnly;
#endif
if (question->Target.type && !ValidQuestionTarget(question))
{
LogMsg("Warning! Target.type = %d port = %u (Client forgot to initialize before calling mDNS_StartQuery?)",
question->Target.type, mDNSVal16(question->TargetPort));
question->Target.type = mDNSAddrType_None;
}
if (question->InterfaceID || IsLocalDomain(&question->qname))
question->uDNS_info.id = zeroID;
else return uDNS_StartQuery(m, question);
if (question->InterfaceID == mDNSInterface_ForceMCast)
question->InterfaceID = mDNSInterface_Any;
if (m->rrcache_size == 0) return(mStatus_NoCache);
else
{
int i;
DNSQuestion **q = &m->Questions;
if (question->InterfaceID == mDNSInterface_LocalOnly) q = &m->LocalOnlyQuestions;
while (*q && *q != question) q=&(*q)->next;
if (*q)
{
LogMsg("Error! Tried to add a question %##s (%s) that's already in the active list",
question->qname.c, DNSTypeName(question->qtype));
return(mStatus_AlreadyRegistered);
}
if (question->InterfaceID && question->InterfaceID != mDNSInterface_LocalOnly)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == question->InterfaceID) break;
if (!intf)
{
debugf("mDNS_StartQuery_internal: Question %##s InterfaceID %p not found", question->qname.c, question->InterfaceID);
return(mStatus_BadInterfaceErr);
}
}
if (!ValidateDomainName(&question->qname))
{
LogMsg("Attempt to start query with invalid qname %##s %s", question->qname.c, DNSTypeName(question->qtype));
return(mStatus_Invalid);
}
if (!m->RandomQueryDelay) m->RandomQueryDelay = 1 + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
question->next = mDNSNULL;
question->qnamehash = DomainNameHashValue(&question->qname); question->ThisQInterval = InitialQuestionInterval * 2; question->LastQTime = m->timenow - m->RandomQueryDelay; question->RecentAnswers = 0;
question->CurrentAnswers = 0;
question->LargeAnswers = 0;
question->UniqueAnswers = 0;
question->DuplicateOf = FindDuplicateQuestion(m, question);
question->NextInDQList = mDNSNULL;
for (i=0; i<DupSuppressInfoSize; i++)
question->DupSuppress[i].InterfaceID = mDNSNULL;
question->SendQNow = mDNSNULL;
question->SendOnAll = mDNSfalse;
question->LastQTxTime = m->timenow;
if (!question->DuplicateOf)
verbosedebugf("mDNS_StartQuery_internal: Question %##s %s %p (%p) started",
question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, question);
else
verbosedebugf("mDNS_StartQuery_internal: Question %##s %s %p (%p) duplicate of (%p)",
question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, question, question->DuplicateOf);
*q = question;
if (question->InterfaceID == mDNSInterface_LocalOnly)
{
if (!m->NewLocalOnlyQuestions) m->NewLocalOnlyQuestions = question;
}
else
{
if (!m->NewQuestions) m->NewQuestions = question;
SetNextQueryTime(m,question);
}
return(mStatus_NoError);
}
}
mDNSlocal mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question)
{
CacheRecord *rr;
DNSQuestion **q = &m->Questions;
if (IsActiveUnicastQuery(question, &m->uDNS_info)) return uDNS_StopQuery(m, question);
if (question->InterfaceID == mDNSInterface_LocalOnly) q = &m->LocalOnlyQuestions;
while (*q && *q != question) q=&(*q)->next;
if (*q) *q = (*q)->next;
else
{
if (question->ThisQInterval >= 0) LogMsg("mDNS_StopQuery_internal: Question %##s (%s) not found in active list",
question->qname.c, DNSTypeName(question->qtype));
return(mStatus_BadReferenceErr);
}
UpdateQuestionDuplicates(m, question);
question->ThisQInterval = -1;
for (rr = m->rrcache_hash[HashSlot(&question->qname)]; rr; rr=rr->next)
{
if (rr->CRActiveQuestion == question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q))
break;
verbosedebugf("mDNS_StopQuery_internal: Cache RR %##s (%s) setting CRActiveQuestion to %X", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), q);
rr->CRActiveQuestion = q; if (!q) m->rrcache_active--; }
}
if (m->CurrentQuestion == question)
{
debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)",
question->qname.c, DNSTypeName(question->qtype));
m->CurrentQuestion = question->next;
}
if (m->NewQuestions == question)
{
debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)",
question->qname.c, DNSTypeName(question->qtype));
m->NewQuestions = question->next;
}
if (m->NewLocalOnlyQuestions == question) m->NewLocalOnlyQuestions = question->next;
question->next = mDNSNULL;
return(mStatus_NoError);
}
mDNSexport mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_StartQuery_internal(m, question);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_StopQuery_internal(m, question);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const rr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr)
{
mStatus status = mStatus_BadReferenceErr;
CacheRecord *cr;
mDNS_Lock(m);
cr = FindIdenticalRecordInCache(m, rr);
if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,
const domainname *const srv, const domainname *const domain,
const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
{
question->InterfaceID = InterfaceID;
question->Target = zeroAddr;
question->qtype = kDNSType_PTR;
question->qclass = kDNSClass_IN;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) return(mStatus_BadParamErr);
if (question->InterfaceID || IsLocalDomain(&question->qname))
{
question->LongLived = mDNSfalse;
question->uDNS_info.id = zeroID;
return(mDNS_StartQuery(m, question));
}
else
{
question->LongLived = mDNStrue;
return uDNS_StartQuery(m, question);
}
}
mDNSlocal void FoundServiceInfoSRV(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
mDNSBool PortChanged = (mDNSBool)(query->info->port.NotAnInteger != answer->rdata->u.srv.port.NotAnInteger);
if (!AddRecord) return;
if (answer->rrtype != kDNSType_SRV) return;
query->info->port = answer->rdata->u.srv.port;
if (!query->GotSRV)
{
query->GotSRV = mDNStrue;
query->qAv4.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv4.qname, answer->rdata->u.srv.target);
query->qAv6.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv6.qname, answer->rdata->u.srv.target);
mDNS_StartQuery_internal(m, &query->qAv4);
mDNS_StartQuery_internal(m, &query->qAv6);
}
else if ((query->qAv4.InterfaceID != query->qSRV.InterfaceID && query->qAv4.InterfaceID != answer->InterfaceID) ||
!SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target))
{
mDNS_StopQuery_internal(m, &query->qAv4);
mDNS_StopQuery_internal(m, &query->qAv6);
if (SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target) && !PortChanged)
{
query->qAv4.InterfaceID = query->qSRV.InterfaceID; query->qAv6.InterfaceID = query->qSRV.InterfaceID;
}
else
{
query->qAv4.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv4.qname, answer->rdata->u.srv.target);
query->qAv6.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv6.qname, answer->rdata->u.srv.target);
}
debugf("FoundServiceInfoSRV: Restarting address queries for %##s", query->qAv4.qname.c);
mDNS_StartQuery_internal(m, &query->qAv4);
mDNS_StartQuery_internal(m, &query->qAv6);
}
else if (query->ServiceInfoQueryCallback && query->GotADD && query->GotTXT && PortChanged)
{
if (++query->Answers >= 100)
debugf("**** WARNING **** Have given %lu answers for %##s (SRV) %##s %u",
query->Answers, query->qSRV.qname.c, answer->rdata->u.srv.target.c,
mDNSVal16(answer->rdata->u.srv.port));
query->ServiceInfoQueryCallback(m, query);
}
}
mDNSlocal void FoundServiceInfoTXT(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
if (!AddRecord) return;
if (answer->rrtype != kDNSType_TXT) return;
if (answer->rdlength > sizeof(query->info->TXTinfo)) return;
query->GotTXT = mDNStrue;
query->info->TXTlen = answer->rdlength;
query->info->TXTinfo[0] = 0; mDNSPlatformMemCopy(answer->rdata->u.txt.c, query->info->TXTinfo, answer->rdlength);
verbosedebugf("FoundServiceInfoTXT: %##s GotADD=%d", query->info->name.c, query->GotADD);
if (query->ServiceInfoQueryCallback && query->GotADD)
{
if (++query->Answers >= 100)
debugf("**** WARNING **** have given %lu answers for %##s (TXT) %#s...",
query->Answers, query->qSRV.qname.c, answer->rdata->u.txt.c);
query->ServiceInfoQueryCallback(m, query);
}
}
mDNSlocal void FoundServiceInfo(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
if (!AddRecord) return;
if (answer->rrtype == kDNSType_A)
{
query->info->ip.type = mDNSAddrType_IPv4;
query->info->ip.ip.v4 = answer->rdata->u.ip;
}
else if (answer->rrtype == kDNSType_AAAA)
{
query->info->ip.type = mDNSAddrType_IPv6;
query->info->ip.ip.v6 = answer->rdata->u.ipv6;
}
else
{
debugf("FoundServiceInfo: answer %##s type %d (%s) unexpected", answer->name.c, answer->rrtype, DNSTypeName(answer->rrtype));
return;
}
query->GotADD = mDNStrue;
query->info->InterfaceID = answer->InterfaceID;
verbosedebugf("FoundServiceInfo v%d: %##s GotTXT=%d", query->info->ip.type, query->info->name.c, query->GotTXT);
if (query->ServiceInfoQueryCallback && query->GotTXT)
{
if (++query->Answers >= 100)
{
if (answer->rrtype == kDNSType_A)
debugf("**** WARNING **** have given %lu answers for %##s (A) %.4a", query->Answers, query->qSRV.qname.c, &answer->rdata->u.ip);
else
debugf("**** WARNING **** have given %lu answers for %##s (AAAA) %.16a", query->Answers, query->qSRV.qname.c, &answer->rdata->u.ipv6);
}
query->ServiceInfoQueryCallback(m, query);
}
}
mDNSexport mStatus mDNS_StartResolveService(mDNS *const m,
ServiceInfoQuery *query, ServiceInfo *info, mDNSServiceInfoQueryCallback *Callback, void *Context)
{
mStatus status;
mDNS_Lock(m);
query->qSRV.ThisQInterval = -1; query->qSRV.InterfaceID = info->InterfaceID;
query->qSRV.Target = zeroAddr;
AssignDomainName(query->qSRV.qname, info->name);
query->qSRV.qtype = kDNSType_SRV;
query->qSRV.qclass = kDNSClass_IN;
query->qSRV.QuestionCallback = FoundServiceInfoSRV;
query->qSRV.QuestionContext = query;
query->qTXT.ThisQInterval = -1; query->qTXT.InterfaceID = info->InterfaceID;
query->qTXT.Target = zeroAddr;
AssignDomainName(query->qTXT.qname, info->name);
query->qTXT.qtype = kDNSType_TXT;
query->qTXT.qclass = kDNSClass_IN;
query->qTXT.QuestionCallback = FoundServiceInfoTXT;
query->qTXT.QuestionContext = query;
query->qAv4.ThisQInterval = -1; query->qAv4.InterfaceID = info->InterfaceID;
query->qAv4.Target = zeroAddr;
query->qAv4.qname.c[0] = 0;
query->qAv4.qtype = kDNSType_A;
query->qAv4.qclass = kDNSClass_IN;
query->qAv4.QuestionCallback = FoundServiceInfo;
query->qAv4.QuestionContext = query;
query->qAv6.ThisQInterval = -1; query->qAv6.InterfaceID = info->InterfaceID;
query->qAv6.Target = zeroAddr;
query->qAv6.qname.c[0] = 0;
query->qAv6.qtype = kDNSType_AAAA;
query->qAv6.qclass = kDNSClass_IN;
query->qAv6.QuestionCallback = FoundServiceInfo;
query->qAv6.QuestionContext = query;
query->GotSRV = mDNSfalse;
query->GotTXT = mDNSfalse;
query->GotADD = mDNSfalse;
query->Answers = 0;
query->info = info;
query->ServiceInfoQueryCallback = Callback;
query->ServiceInfoQueryContext = Context;
info->ip = zeroAddr;
info->port = zeroIPPort;
info->TXTlen = 0;
status = mDNS_StartQuery_internal(m, &query->qSRV);
if (status == mStatus_NoError) status = mDNS_StartQuery_internal(m, &query->qTXT);
if (status != mStatus_NoError) mDNS_StopResolveService(m, query);
mDNS_Unlock(m);
return(status);
}
mDNSexport void mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *query)
{
mDNS_Lock(m);
if (query->qSRV.ThisQInterval >= 0 || IsActiveUnicastQuery(&query->qSRV, &m->uDNS_info))
mDNS_StopQuery_internal(m, &query->qSRV);
if (query->qTXT.ThisQInterval >= 0 || IsActiveUnicastQuery(&query->qTXT, &m->uDNS_info))
mDNS_StopQuery_internal(m, &query->qTXT);
if (query->qAv4.ThisQInterval >= 0 || IsActiveUnicastQuery(&query->qAv4, &m->uDNS_info))
mDNS_StopQuery_internal(m, &query->qAv4);
if (query->qAv6.ThisQInterval >= 0 || IsActiveUnicastQuery(&query->qAv6, &m->uDNS_info))
mDNS_StopQuery_internal(m, &query->qAv6);
mDNS_Unlock(m);
}
mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom,
const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
{
question->InterfaceID = InterfaceID;
question->Target = zeroAddr;
question->qtype = kDNSType_PTR;
question->qclass = kDNSClass_IN;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
if (DomainType > mDNS_DomainTypeRegistrationDefault) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
if (!dom) dom = (const domainname *)"\x5local";
if (!AppendDomainName(&question->qname, dom)) return(mStatus_BadParamErr);
return(mDNS_StartQuery(m, question));
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Responder Functions
#endif
mDNSexport void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, mDNSRecordCallback Callback, void *Context)
{
if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond)
ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond;
else if (ttl == 0) ttl = kDefaultTTLforShared;
rr->Additional1 = mDNSNULL;
rr->Additional2 = mDNSNULL;
rr->DependentOn = mDNSNULL;
rr->RRSet = mDNSNULL;
rr->RecordCallback = Callback;
rr->RecordContext = Context;
rr->resrec.RecordType = RecordType;
rr->HostTarget = mDNSfalse;
rr->resrec.InterfaceID = InterfaceID;
rr->resrec.name.c[0] = 0; 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);
}
}
mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Register_internal(m, rr);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,
const mDNSu16 newrdlength,
RData *const newrdata, mDNSRecordUpdateCallback *Callback)
{
if (!rr->resrec.InterfaceID && !IsLocalDomain(&rr->resrec.name))
{
LogMsg("mDNS_Update: Not implemented for unicast DNS");
return mStatus_UnsupportedErr;
}
if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata))
{ LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(m, &rr->resrec, &newrdata->u)); return(mStatus_Invalid); }
mDNS_Lock(m);
if (newttl == 0) newttl = rr->resrec.rroriginalttl;
if (rr->NewRData)
{
RData *n = rr->NewRData;
rr->NewRData = mDNSNULL; if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, n); }
rr->NewRData = newrdata;
rr->newrdlength = newrdlength;
rr->UpdateCallback = Callback;
if (rr->resrec.rroriginalttl == newttl && rr->resrec.rdlength == newrdlength && mDNSPlatformMemSame(rr->resrec.rdata->u.data, newrdata->u.data, newrdlength))
CompleteRDataUpdate(m, rr);
else
{
domainlabel name;
domainname type, domain;
DeconstructServiceName(&rr->resrec.name, &name, &type, &domain);
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
if (SameDomainLabel(type.c, (mDNSu8*)"\x6_ichat")) rr->AnnounceCount = 1;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr);
if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--;
if (!rr->NextUpdateCredit) rr->NextUpdateCredit = (m->timenow + kUpdateCreditRefreshInterval) | 1;
if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1);
if (rr->UpdateCredits <= 5)
{
mDNSs32 delay = 1 << (5 - rr->UpdateCredits);
if (!rr->UpdateBlocked) rr->UpdateBlocked = (m->timenow + delay * mDNSPlatformOneSecond) | 1;
rr->LastAPTime = rr->UpdateBlocked;
rr->ThisAPInterval *= 4;
LogMsg("Excessive update rate for %##s; delaying announcement by %d second%s", rr->resrec.name.c, delay, delay > 1 ? "s" : "");
}
rr->resrec.rroriginalttl = newttl;
}
mDNS_Unlock(m);
return(mStatus_NoError);
}
mDNSexport mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
mDNS_Unlock(m);
return(status);
}
mDNSexport void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise) break;
return(intf);
}
mDNSlocal void AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
char buffer[256];
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
if (!primary) primary = set;
uDNS_AdvertiseInterface(m, set);
mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kDefaultTTLforUnique, kDNSRecordTypeUnique, mDNS_HostNameCallback, set);
mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kDefaultTTLforUnique, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kDefaultTTLforUnique, kDNSRecordTypeUnique, mDNSNULL, mDNSNULL);
AssignDomainName(set->RR_A.resrec.name, m->hostname);
if (set->ip.type == mDNSAddrType_IPv4)
{
set->RR_A.resrec.rrtype = kDNSType_A;
set->RR_A.resrec.rdata->u.ip = set->ip.ip.v4;
mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.",
set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]);
}
else if (set->ip.type == mDNSAddrType_IPv6)
{
int i;
set->RR_A.resrec.rrtype = kDNSType_AAAA;
set->RR_A.resrec.rdata->u.ipv6 = set->ip.ip.v6;
for (i = 0; i < 16; i++)
{
static const char hexValues[] = "0123456789ABCDEF";
buffer[i * 4 ] = hexValues[set->ip.ip.v6.b[15 - i] & 0x0F];
buffer[i * 4 + 1] = '.';
buffer[i * 4 + 2] = hexValues[set->ip.ip.v6.b[15 - i] >> 4];
buffer[i * 4 + 3] = '.';
}
mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa.");
}
MakeDomainNameFromDNSNameString(&set->RR_PTR.resrec.name, buffer);
set->RR_PTR.HostTarget = mDNStrue;
set->RR_A.RRSet = &primary->RR_A;
mDNS_Register_internal(m, &set->RR_A);
mDNS_Register_internal(m, &set->RR_PTR);
if (m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254)
{
mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data;
AssignDomainName(set->RR_HINFO.resrec.name, m->hostname);
set->RR_HINFO.DependentOn = &set->RR_A;
mDNSPlatformMemCopy(&m->HIHardware, p, 1 + (mDNSu32)m->HIHardware.c[0]);
p += 1 + (int)p[0];
mDNSPlatformMemCopy(&m->HISoftware, p, 1 + (mDNSu32)m->HISoftware.c[0]);
mDNS_Register_internal(m, &set->RR_HINFO);
}
else
{
debugf("Not creating HINFO record: platform support layer provided no information");
set->RR_HINFO.resrec.RecordType = kDNSRecordTypeUnregistered;
}
}
mDNSlocal void DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
NetworkInterfaceInfo *intf;
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
AuthRecord *A = primary ? &primary->RR_A : mDNSNULL;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->RR_A.RRSet == &set->RR_A)
intf->RR_A.RRSet = A;
if (set->RR_A. resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_A, mDNS_Dereg_normal);
if (set->RR_PTR. resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_PTR, mDNS_Dereg_normal);
if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal);
}
mDNSlocal void GenerateFQDN(mDNS *const m, const char *domain, mDNSBool local)
{
domainname newname;
mDNS_Lock(m);
newname.c[0] = 0;
if (!AppendDomainLabel(&newname, &m->hostlabel)) LogMsg("ERROR: GenerateFQDN: Cannot create hostname");
if (!AppendDNSNameString(&newname, domain)) LogMsg("ERROR: GenerateFQDN: Cannot create hostname");
if ((local && !SameDomainName(&m->hostname, &newname)) ||
(!local && !SameDomainName(&m->uDNS_info.hostname, &newname)))
{
NetworkInterfaceInfo *intf;
AuthRecord *rr;
if (local) m->hostname = newname;
else m->uDNS_info.hostname = newname;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise)
local ? DeadvertiseInterface(m, intf) : uDNS_DeadvertiseInterface(m, intf);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise)
local ? AdvertiseInterface(m, intf) : uDNS_AdvertiseInterface(m, intf);
if (local)
{
for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->HostTarget) SetTargetToHostName(m, rr);
for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->HostTarget) SetTargetToHostName(m, rr);
}
else uDNS_UpdateServiceTargets(m);
}
mDNS_Unlock(m);
}
mDNSexport void mDNS_GenerateFQDN(mDNS *const m)
{
GenerateFQDN(m, "local.", mDNStrue);
}
mDNSexport void mDNS_GenerateGlobalFQDN(mDNS *const m)
{
if (!m->uDNS_info.NameRegDomain[0]) return;
GenerateFQDN(m, m->uDNS_info.NameRegDomain, mDNSfalse);
}
mDNSexport void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
(void)rr;
#if MDNS_DEBUGMSGS
{
char *msg = "Unknown result";
if (result == mStatus_NoError) msg = "Name registered";
else if (result == mStatus_NameConflict) msg = "Name conflict";
debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), msg, result);
}
#endif
if (result == mStatus_NoError)
{
if (m->MainCallback)
{
m->mDNS_reentrancy++; m->MainCallback(m, result);
m->mDNS_reentrancy--; }
}
else if (result == mStatus_NameConflict)
{
domainlabel oldlabel = m->hostlabel;
mDNSBool local = (IsLocalDomain(&rr->resrec.name) || rr->resrec.InterfaceID);
if (m->MainCallback)
{
m->mDNS_reentrancy++; m->MainCallback(m, mStatus_NameConflict);
m->mDNS_reentrancy--; }
if (SameDomainLabel(m->hostlabel.c, oldlabel.c))
IncrementLabelSuffix(&m->hostlabel, mDNSfalse);
if (!local)
{
char regdomain[MAX_ESCAPED_DOMAIN_NAME];
ConvertDomainNameToCString_unescaped((domainname *)(rr->resrec.name.c + rr->resrec.name.c[0] + 1), regdomain);
mDNS_GenerateGlobalFQDN(m);
LogMsg("Host Name %s.%s already in use; new name %s.%s selected for this host", oldlabel.c, regdomain, m->hostlabel.c, regdomain);
}
else
{
mDNS_GenerateFQDN(m);
LogMsg("Link-Local Host Name %#s.local. already in use; new name %#s.local. selected for this host.", oldlabel.c, m->hostlabel.c);
}
}
else LogMsg("mDNS_HostNameCallback: Unknown error %d for registration of record %s", result, rr->resrec.name.c);
}
mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active)
{
NetworkInterfaceInfo *intf;
active->IPv4Available = mDNSfalse;
active->IPv6Available = mDNSfalse;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == active->InterfaceID)
{
if (intf->ip.type == mDNSAddrType_IPv4 && intf->McastTxRx) active->IPv4Available = mDNStrue;
if (intf->ip.type == mDNSAddrType_IPv6 && intf->McastTxRx) active->IPv6Available = mDNStrue;
}
}
mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
mDNSBool FirstOfType = mDNStrue;
NetworkInterfaceInfo **p = &m->HostInterfaces;
mDNS_Lock(m);
set->InterfaceActive = mDNStrue;
set->IPv4Available = (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx);
set->IPv6Available = (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx);
while (*p)
{
if (*p == set)
{
LogMsg("Error! Tried to register a NetworkInterfaceInfo that's already in the list");
mDNS_Unlock(m);
return(mStatus_AlreadyRegistered);
}
if ((*p)->InterfaceID == set->InterfaceID)
{
set->InterfaceActive = mDNSfalse;
if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse;
if (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx) (*p)->IPv4Available = mDNStrue;
if (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx) (*p)->IPv6Available = mDNStrue;
}
p=&(*p)->next;
}
set->next = mDNSNULL;
*p = set;
debugf("mDNS_RegisterInterface: InterfaceID %p %#a %s", set->InterfaceID, &set->ip,
set->InterfaceActive ?
"not represented in list; marking active and retriggering queries" :
"already represented in list; marking inactive for now");
if ((m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) || FirstOfType || set->InterfaceActive)
{
DNSQuestion *q;
AuthRecord *rr;
if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
for (q = m->Questions; q; q=q->next) if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) { q->ThisQInterval = InitialQuestionInterval; q->LastQTime = m->timenow - q->ThisQInterval;
q->RecentAnswers = 0;
if (ActiveQuestion(q)) m->NextScheduledQuery = m->timenow;
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
}
if (set->Advertise)
AdvertiseInterface(m, set);
mDNS_Unlock(m);
return(mStatus_NoError);
}
mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
NetworkInterfaceInfo **p = &m->HostInterfaces;
mDNSBool revalidate = mDNSfalse;
if (m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) revalidate = mDNStrue;
mDNS_Lock(m);
while (*p && *p != set) p=&(*p)->next;
if (!*p) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list"); mDNS_Unlock(m); return; }
*p = (*p)->next;
set->next = mDNSNULL;
if (!set->InterfaceActive)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceActive && intf->InterfaceID == set->InterfaceID)
UpdateInterfaceProtocols(m, intf);
}
else
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == set->InterfaceID)
break;
if (intf)
{
debugf("mDNS_DeregisterInterface: Another representative of InterfaceID %p exists; making it active",
set->InterfaceID);
intf->InterfaceActive = mDNStrue;
UpdateInterfaceProtocols(m, intf);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == set->InterfaceID && intf->ip.type == set->ip.type)
break;
if (!intf) revalidate = mDNStrue;
}
else
{
CacheRecord *rr;
DNSQuestion *q;
mDNSu32 slot;
debugf("mDNS_DeregisterInterface: Last representative of InterfaceID %p deregistered; marking questions etc. dormant",
set->InterfaceID);
for (q = m->Questions; q; q=q->next)
if (q->InterfaceID == set->InterfaceID)
q->ThisQInterval = 0;
revalidate = mDNSfalse; for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if (rr->resrec.InterfaceID == set->InterfaceID)
PurgeCacheResourceRecord(m, rr);
}
}
if (set->Advertise)
{
DeadvertiseInterface(m, set);
uDNS_DeadvertiseInterface(m, set);
}
if (revalidate && !m->mDNS_shutdown)
{
mDNSu32 slot;
CacheRecord *rr;
m->NextCacheCheck = m->timenow;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if (rr->resrec.InterfaceID == set->InterfaceID)
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForCableDisconnect);
}
mDNS_Unlock(m);
}
mDNSlocal void ServiceCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext;
(void)m;
#if MDNS_DEBUGMSGS
{
char *msg = "Unknown result";
if (result == mStatus_NoError) msg = "Name Registered";
else if (result == mStatus_NameConflict) msg = "Name Conflict";
else if (result == mStatus_MemFree) msg = "Memory Free";
debugf("ServiceCallback: %##s (%s) %s (%ld)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), msg, result);
}
#endif
if (result == mStatus_NameConflict)
{
sr->Conflict = mDNStrue; sr->RR_PTR.AnnounceCount = InitialAnnounceCount; mDNS_DeregisterService(m, sr); return;
}
if (result == mStatus_MemFree)
{
mDNSu32 i;
if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return;
for (i=0; i<sr->NumSubTypes; i++) if (sr->SubTypes[i].resrec.RecordType != kDNSRecordTypeUnregistered) return;
if (sr->Conflict) result = mStatus_NameConflict;
}
if (sr->ServiceCallback)
sr->ServiceCallback(m, sr, result);
}
mDNSexport 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)
{
mStatus err;
mDNSu32 i;
sr->ServiceCallback = Callback;
sr->ServiceContext = Context;
sr->Extras = mDNSNULL;
sr->NumSubTypes = NumSubTypes;
sr->SubTypes = SubTypes;
sr->Conflict = mDNSfalse;
if (host && host->c[0]) sr->Host = *host;
else sr->Host.c[0] = 0;
mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeAdvisory, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, kDefaultTTLforUnique, kDNSRecordTypeUnique, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kDefaultTTLforUnique, kDNSRecordTypeUnique, ServiceCallback, sr);
if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen)
sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen;
if (ConstructServiceName(&sr->RR_ADV.resrec.name, (domainlabel*)"\x09_services", (domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL)
return(mStatus_BadParamErr);
if (ConstructServiceName(&sr->RR_PTR.resrec.name, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
if (ConstructServiceName(&sr->RR_SRV.resrec.name, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
AssignDomainName(sr->RR_TXT.resrec.name, sr->RR_SRV.resrec.name);
AssignDomainName(sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name);
AssignDomainName(sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name);
sr->RR_PTR.Additional1 = &sr->RR_SRV;
sr->RR_PTR.Additional2 = &sr->RR_TXT;
for (i=0; i<NumSubTypes; i++)
{
domainlabel s = *(domainlabel*)&sr->SubTypes[i].resrec.name;
mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, ServiceCallback, sr);
if (ConstructServiceName(&sr->SubTypes[i].resrec.name, &s, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
AssignDomainName(sr->SubTypes[i].resrec.rdata->u.name, sr->RR_SRV.resrec.name);
sr->SubTypes[i].Additional1 = &sr->RR_SRV;
sr->SubTypes[i].Additional2 = &sr->RR_TXT;
}
sr->RR_SRV.resrec.rdata->u.srv.priority = 0;
sr->RR_SRV.resrec.rdata->u.srv.weight = 0;
sr->RR_SRV.resrec.rdata->u.srv.port = port;
if (sr->Host.c[0]) AssignDomainName(sr->RR_SRV.resrec.rdata->u.srv.target, sr->Host);
else { sr->RR_SRV.HostTarget = mDNStrue; sr->RR_SRV.resrec.rdata->u.srv.target.c[0] = '\0'; }
if (txtinfo == mDNSNULL) sr->RR_TXT.resrec.rdlength = 0;
else if (txtinfo != sr->RR_TXT.resrec.rdata->u.txt.c)
{
sr->RR_TXT.resrec.rdlength = txtlen;
if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr);
mDNSPlatformMemCopy(txtinfo, sr->RR_TXT.resrec.rdata->u.txt.c, txtlen);
}
sr->RR_TXT.DependentOn = &sr->RR_SRV;
if (!InterfaceID && !IsLocalDomain(&sr->RR_SRV.resrec.name))
return uDNS_RegisterService(m, sr);
mDNS_Lock(m);
err = mDNS_Register_internal(m, &sr->RR_SRV);
if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT);
if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV);
for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]);
if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR);
mDNS_Unlock(m);
if (err) mDNS_DeregisterService(m, sr);
return(err);
}
mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr,
ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl)
{
ExtraResourceRecord **e;
mStatus status;
if (!sr->RR_SRV.resrec.InterfaceID && !IsLocalDomain(&sr->RR_SRV.resrec.name))
{
LogMsg("mDNS_AddRecordToService: Not implemented for unicast DNS");
return mStatus_UnsupportedErr;
}
mDNS_Lock(m);
e = &sr->Extras;
while (*e) e = &(*e)->next;
if (ttl == 0) ttl = kDefaultTTLforUnique;
extra->next = mDNSNULL;
mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID, extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, ServiceCallback, sr);
AssignDomainName(extra->r.resrec.name, sr->RR_SRV.resrec.name);
extra->r.DependentOn = &sr->RR_SRV;
debugf("mDNS_AddRecordToService adding record to %##s", extra->r.resrec.name.c);
status = mDNS_Register_internal(m, &extra->r);
if (status == mStatus_NoError) *e = extra;
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra)
{
ExtraResourceRecord **e;
mStatus status;
if (!sr->RR_SRV.resrec.InterfaceID && !IsLocalDomain(&sr->RR_SRV.resrec.name))
{
LogMsg("mDNS_AddRecordToService: Not implemented for unicast DNS");
return mStatus_UnsupportedErr;
}
mDNS_Lock(m);
e = &sr->Extras;
while (*e && *e != extra) e = &(*e)->next;
if (!*e)
{
debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra->r.resrec.name.c);
status = mStatus_BadReferenceErr;
}
else
{
debugf("mDNS_RemoveRecordFromService removing record from %##s", extra->r.resrec.name.c);
*e = (*e)->next;
status = mDNS_Deregister_internal(m, &extra->r, mDNS_Dereg_normal);
}
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname)
{
domainlabel name1, name2;
domainname type, domain;
domainname *host = mDNSNULL;
ExtraResourceRecord *extras = sr->Extras;
mStatus err;
DeconstructServiceName(&sr->RR_SRV.resrec.name, &name1, &type, &domain);
if (!newname)
{
name2 = name1;
IncrementLabelSuffix(&name2, mDNStrue);
newname = &name2;
}
LogMsg("Service \"%##s\" renamed to \"%#s\"", sr->RR_SRV.resrec.name.c, newname->c);
if (sr->RR_SRV.HostTarget == mDNSfalse && sr->Host.c[0]) host = &sr->Host;
err = mDNS_RegisterService(m, sr, newname, &type, &domain,
host, sr->RR_SRV.resrec.rdata->u.srv.port, sr->RR_TXT.resrec.rdata->u.txt.c, sr->RR_TXT.resrec.rdlength,
sr->SubTypes, sr->NumSubTypes,
sr->RR_PTR.resrec.InterfaceID, sr->ServiceCallback, sr->ServiceContext);
while (!err && extras)
{
ExtraResourceRecord *e = extras;
extras = extras->next;
err = mDNS_AddRecordToService(m, sr, e, e->r.resrec.rdata, e->r.resrec.rroriginalttl);
}
return(err);
}
mDNSexport mStatus mDNS_DeregisterService(mDNS *const m, ServiceRecordSet *sr)
{
if (!sr->RR_SRV.resrec.InterfaceID && !IsLocalDomain(&sr->RR_SRV.resrec.name))
return uDNS_DeregisterService(m, sr);
if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered)
{
debugf("Service set for %##s already deregistered", sr->RR_PTR.resrec.name.c);
return(mStatus_BadReferenceErr);
}
else if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeDeregistering)
{
debugf("Service set for %##s already in the process of deregistering", sr->RR_PTR.resrec.name.c);
return(mStatus_NoError);
}
else
{
mDNSu32 i;
mStatus status;
ExtraResourceRecord *e;
mDNS_Lock(m);
e = sr->Extras;
mDNS_Deregister_internal(m, &sr->RR_SRV, mDNS_Dereg_repeat);
mDNS_Deregister_internal(m, &sr->RR_TXT, mDNS_Dereg_repeat);
mDNS_Deregister_internal(m, &sr->RR_ADV, mDNS_Dereg_normal);
while (e)
{
mDNS_Deregister_internal(m, &e->r, mDNS_Dereg_repeat);
e = e->next;
}
for (i=0; i<sr->NumSubTypes; i++)
mDNS_Deregister_internal(m, &sr->SubTypes[i], mDNS_Dereg_normal);
status = mDNS_Deregister_internal(m, &sr->RR_PTR, mDNS_Dereg_normal);
mDNS_Unlock(m);
return(status);
}
}
mDNSexport 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)
{
mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kDefaultTTLforUnique, kDNSRecordTypeUnique, Callback, Context);
if (ConstructServiceName(&rr->resrec.name, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
rr->resrec.rdata->u.srv.priority = 0;
rr->resrec.rdata->u.srv.weight = 0;
rr->resrec.rdata->u.srv.port = zeroIPPort;
if (host && host->c[0]) AssignDomainName(rr->resrec.rdata->u.srv.target, *host);
else rr->HostTarget = mDNStrue;
return(mDNS_Register(m, rr));
}
mDNSexport mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr,
mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname)
{
mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, mDNSNULL, mDNSNULL);
if (!MakeDomainNameFromDNSNameString(&rr->resrec.name, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr);
return(mDNS_Register(m, rr));
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - Startup and Shutdown
#endif
mDNSlocal void mDNS_GrowCache_internal(mDNS *const m, CacheRecord *storage, mDNSu32 numrecords)
{
if (storage && numrecords)
{
mDNSu32 i;
for (i=0; i<numrecords; i++) storage[i].next = &storage[i+1];
storage[numrecords-1].next = m->rrcache_free;
m->rrcache_free = storage;
m->rrcache_size += numrecords;
}
}
mDNSexport void mDNS_GrowCache(mDNS *const m, CacheRecord *storage, mDNSu32 numrecords)
{
mDNS_Lock(m);
mDNS_GrowCache_internal(m, storage, numrecords);
mDNS_Unlock(m);
}
mDNSexport mStatus mDNS_Init(mDNS *const m, mDNS_PlatformSupport *const p,
CacheRecord *rrcachestorage, mDNSu32 rrcachesize,
mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context)
{
mDNSu32 slot;
mDNSs32 timenow;
mStatus result = mDNSPlatformTimeInit(&timenow);
if (result != mStatus_NoError) return(result);
if (!rrcachestorage) rrcachesize = 0;
m->p = p;
m->KnownBugs = 0;
m->CanReceiveUnicast = mDNSfalse; m->AdvertiseLocalAddresses = AdvertiseLocalAddresses;
m->mDNSPlatformStatus = mStatus_Waiting;
m->MainCallback = Callback;
m->MainContext = Context;
m->mDNS_busy = 0;
m->mDNS_reentrancy = 0;
m->mDNS_shutdown = mDNSfalse;
m->lock_rrcache = 0;
m->lock_Questions = 0;
m->lock_Records = 0;
m->timenow = 0; m->timenow_last = timenow;
m->timenow_adjust = 0;
m->NextScheduledEvent = timenow;
m->SuppressSending = timenow;
m->NextCacheCheck = timenow + 0x78000000;
m->NextScheduledQuery = timenow + 0x78000000;
m->NextScheduledProbe = timenow + 0x78000000;
m->NextScheduledResponse = timenow + 0x78000000;
m->ExpectUnicastResponse = timenow + 0x78000000;
m->RandomQueryDelay = 0;
m->SendDeregistrations = mDNSfalse;
m->SendImmediateAnswers = mDNSfalse;
m->SleepState = mDNSfalse;
m->Questions = mDNSNULL;
m->NewQuestions = mDNSNULL;
m->CurrentQuestion = mDNSNULL;
m->LocalOnlyQuestions = mDNSNULL;
m->NewLocalOnlyQuestions = mDNSNULL;
m->rrcache_size = 0;
m->rrcache_totalused = 0;
m->rrcache_active = 0;
m->rrcache_report = 10;
m->rrcache_free = mDNSNULL;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
m->rrcache_hash[slot] = mDNSNULL;
m->rrcache_tail[slot] = &m->rrcache_hash[slot];
m->rrcache_used[slot] = 0;
}
mDNS_GrowCache_internal(m, rrcachestorage, rrcachesize);
m->hostlabel.c[0] = 0;
m->nicelabel.c[0] = 0;
m->hostname.c[0] = 0;
m->HIHardware.c[0] = 0;
m->HISoftware.c[0] = 0;
m->ResourceRecords = mDNSNULL;
m->DuplicateRecords = mDNSNULL;
m->LocalOnlyRecords = mDNSNULL;
m->NewLocalOnlyRecords = mDNSNULL;
m->DiscardLocalOnlyRecords = mDNSfalse;
m->CurrentRecord = mDNSNULL;
m->HostInterfaces = mDNSNULL;
m->ProbeFailTime = 0;
m->NumFailedProbes = 0;
m->SuppressProbes = 0;
uDNS_Init(m);
result = mDNSPlatformInit(m);
return(result);
}
mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result)
{
m->mDNSPlatformStatus = result;
if (m->MainCallback)
{
mDNS_Lock(m);
m->mDNS_reentrancy++; m->MainCallback(m, mStatus_NoError);
m->mDNS_reentrancy--; mDNS_Unlock(m);
}
}
mDNSexport void mDNS_Close(mDNS *const m)
{
mDNSu32 rrcache_active = 0;
mDNSu32 rrcache_totalused = 0;
mDNSu32 slot;
NetworkInterfaceInfo *intf;
mDNS_Lock(m);
m->mDNS_shutdown = mDNStrue;
rrcache_totalused = m->rrcache_totalused;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
while (m->rrcache_hash[slot])
{
CacheRecord *rr = m->rrcache_hash[slot];
m->rrcache_hash[slot] = rr->next;
if (rr->CRActiveQuestion) rrcache_active++;
m->rrcache_used[slot]--;
ReleaseCacheRR(m, rr);
}
m->rrcache_tail[slot] = &m->rrcache_hash[slot];
}
debugf("mDNS_Close: RR Cache was using %ld records, %d active", rrcache_totalused, rrcache_active);
if (rrcache_active != m->rrcache_active)
LogMsg("*** ERROR *** rrcache_active %lu != m->rrcache_active %lu", rrcache_active, m->rrcache_active);
m->Questions = mDNSNULL;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise)
DeadvertiseInterface(m, intf);
if (m->CurrentRecord) LogMsg("mDNS_Close ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType != kDNSRecordTypeDeregistering)
{
debugf("mDNS_Close: Record type %X still in ResourceRecords list %##s", rr->resrec.RecordType, rr->resrec.name.c);
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
}
}
uDNS_SuspendLLQs(m);
if (m->ResourceRecords) debugf("mDNS_Close: Sending final packets for deregistering records");
else debugf("mDNS_Close: No deregistering records remain");
if (m->mDNSPlatformStatus != mStatus_NoError)
DiscardDeregistrations(m);
else
while (m->ResourceRecords)
SendResponses(m);
mDNS_Unlock(m);
debugf("mDNS_Close: mDNSPlatformClose");
mDNSPlatformClose(m);
debugf("mDNS_Close: done");
}