#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 - Program Constants
#endif
#define NO_HINFO 1
mDNSlocal const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID)~0;
#define SmallRecordLimit 1024
#define kMaxUpdateCredits 10
#define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6)
mDNSexport const char *const mDNS_DomainTypeNames[] =
{
"b._dns-sd._udp.", "db._dns-sd._udp.", "lb._dns-sd._udp.", "r._dns-sd._udp.", "dr._dns-sd._udp." };
#ifdef UNICAST_DISABLED
#define uDNS_IsActiveQuery(q, u) mDNSfalse
#endif
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - General Utility Functions
#endif
#define ActiveQuestion(Q) ((Q)->ThisQInterval > 0 && !(Q)->DuplicateOf)
#define TimeToSendThisQuestion(Q,time) (ActiveQuestion(Q) && (time) - ((Q)->LastQTime + (Q)->ThisQInterval) >= 0)
mDNSexport void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q)
{
if (m->mDNS_busy != m->mDNS_reentrancy+1)
LogMsg("SetNextQueryTime: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
if (ActiveQuestion(q))
{
mDNSs32 sendtime = q->LastQTime + q->ThisQInterval;
if (!mDNSOpaque16IsZero(q->TargetQID) && !q->LongLived && m->SuppressStdPort53Queries && (sendtime - m->SuppressStdPort53Queries < 0))
sendtime = m->SuppressStdPort53Queries;
if (m->NextScheduledQuery - sendtime > 0)
m->NextScheduledQuery = sendtime;
}
}
mDNSexport CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 slot, const mDNSu32 namehash, const domainname *const name)
{
CacheGroup *cg;
for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
if (cg->namehash == namehash && SameDomainName(cg->name, name))
break;
return(cg);
}
mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr)
{
return(CacheGroupForName(m, slot, rr->namehash, rr->name));
}
mDNSlocal mDNSBool AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr)
{
NetworkInterfaceInfo *intf;
if (addr->type == mDNSAddrType_IPv4)
{
if (mDNSv4AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)
if (((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) & intf->mask.ip.v4.NotAnInteger) == 0)
return(mDNStrue);
}
if (addr->type == mDNSAddrType_IPv6)
{
if (mDNSv6AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)
if ((((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) & intf->mask.ip.v6.l[0]) == 0) &&
(((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) & intf->mask.ip.v6.l[1]) == 0) &&
(((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) & intf->mask.ip.v6.l[2]) == 0) &&
(((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) & intf->mask.ip.v6.l[3]) == 0))
return(mDNStrue);
}
return(mDNSfalse);
}
mDNSlocal void AnswerLocalOnlyQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, AuthRecord *rr, QC_result AddRecord)
{
if (AddRecord) rr->LocalAnswer = mDNStrue;
mDNS_DropLockBeforeCallback(); if (q->QuestionCallback && !q->NoAnswer)
q->QuestionCallback(m, q, &rr->resrec, AddRecord);
mDNS_ReclaimLockAfterCallback(); }
mDNSlocal void AnswerLocalQuestions(mDNS *const m, AuthRecord *rr, QC_result AddRecord)
{
if (m->CurrentQuestion)
LogMsg("AnswerLocalQuestions ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->LocalOnlyQuestions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord); }
if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
{
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord); }
}
m->CurrentQuestion = mDNSNULL;
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Resource Record Utility Functions
#endif
#define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA)
#define ResourceRecordIsValidAnswer(RR) ( ((RR)-> resrec.RecordType & kDNSRecordTypeActiveMask) && \
((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) )
#define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \
(ResourceRecordIsValidAnswer(RR) && \
((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID)))
#define DefaultProbeCountForTypeUnique ((mDNSu8)3)
#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)
#define InitialAnnounceCount ((mDNSu8)8)
#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 AuthRecord *const r1, const AuthRecord *const r2)
{
if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse); }
if (r1->resrec.InterfaceID &&
r2->resrec.InterfaceID &&
r1->resrec.InterfaceID != r2->resrec.InterfaceID) return(mDNSfalse);
return(mDNSBool)(
r1->resrec.rrtype == r2->resrec.rrtype &&
r1->resrec.rrclass == r2->resrec.rrclass &&
r1->resrec.namehash == r2->resrec.namehash &&
SameDomainName(r1->resrec.name, r2->resrec.name));
}
mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr)
{
if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse); }
if (!authrr) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL"); return(mDNSfalse); }
if (pktrr->resrec.InterfaceID &&
authrr->resrec.InterfaceID &&
pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse);
if (!(authrr->resrec.RecordType & kDNSRecordTypeUniqueMask) && pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse);
return(mDNSBool)(
pktrr->resrec.rrclass == authrr->resrec.rrclass &&
pktrr->resrec.namehash == authrr->resrec.namehash &&
SameDomainName(pktrr->resrec.name, authrr->resrec.name));
}
mDNSlocal mDNSBool IdenticalResourceRecord(const ResourceRecord *const r1, const ResourceRecord *const r2)
{
if (!r1) { LogMsg("IdenticalResourceRecord ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("IdenticalResourceRecord ERROR: r2 is NULL"); return(mDNSfalse); }
if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass || r1->namehash != r2->namehash || !SameDomainName(r1->name, r2->name))
return(mDNSfalse);
return(SameRData(r1, r2));
}
mDNSlocal mDNSBool IdenticalSameNameRecord(const ResourceRecord *const r1, const ResourceRecord *const r2)
{
if (!r1) { LogMsg("IdenticalSameNameRecord ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("IdenticalSameNameRecord ERROR: r2 is NULL"); return(mDNSfalse); }
if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass)
return(mDNSfalse);
#if VerifySameNameAssumptions
if (r1->namehash != r2->namehash || !SameDomainName(r1->name, r2->name))
{
LogMsg("Bogus IdenticalSameNameRecord call: %##s does not match %##s", r1->name->c, r1->name->c);
return(mDNSfalse);
}
#endif
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 = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique);
if (m->SuppressProbes - m->NextScheduledProbe >= 0)
m->SuppressProbes = m->NextScheduledProbe;
if (m->SuppressProbes - m->NextScheduledQuery >= 0)
m->SuppressProbes = m->NextScheduledQuery;
}
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);
}
mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr)
{
domainname *target = GetRRDomainNameTarget(&rr->resrec);
if (!target) debugf("SetTargetToHostName: Don't know how to set the target of rrtype %d", rr->resrec.rrtype);
if (target && SameDomainName(target, &m->MulticastHostname))
debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name->c, target->c);
if (target && !SameDomainName(target, &m->MulticastHostname))
{
AssignDomainName(target, &m->MulticastHostname);
SetNewRData(&rr->resrec, mDNSNULL, 0);
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->RequireGoodbye && rr->resrec.RecordType == kDNSRecordTypeShared)
debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating",
rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
rr->AnnounceCount = InitialAnnounceCount;
rr->RequireGoodbye = mDNSfalse;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m,rr);
}
}
mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr)
{
if (rr->RecordCallback)
{
rr->Acknowledged = mDNStrue;
mDNS_DropLockBeforeCallback(); rr->RecordCallback(m, rr, mStatus_NoError);
mDNS_ReclaimLockAfterCallback(); }
}
#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))
mDNSexport 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;
if ((mDNSs32)rr->resrec.rroriginalttl <= 0)
{ LogMsg("mDNS_Register_internal: TTL must be 1 - 0x7FFFFFFF %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); }
if (!rr->resrec.RecordType)
{ LogMsg("mDNS_Register_internal: RecordType must be non-zero %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); }
while (*p && *p != rr) p=&(*p)->next;
while (*d && *d != rr) d=&(*d)->next;
if (*d || *p)
{
LogMsg("Error! Tried to register 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->AutoTarget && target) target->c[0] = 0;
rr->Acknowledged = mDNSfalse;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
rr->AnnounceCount = InitialAnnounceCount;
rr->RequireGoodbye = mDNSfalse;
rr->LocalAnswer = mDNSfalse;
rr->IncludeInProbe = mDNSfalse;
rr->ImmedAnswer = mDNSNULL;
rr->ImmedUnicast = mDNSfalse;
rr->ImmedAdditional = mDNSNULL;
rr->SendRNow = mDNSNULL;
rr->v4Requester = zerov4Addr;
rr->v6Requester = zerov6Addr;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
if (!rr->AutoTarget) InitializeLastAPTime(m, rr);
rr->NewRData = mDNSNULL;
rr->newrdlength = 0;
rr->UpdateCallback = mDNSNULL;
rr->UpdateCredits = kMaxUpdateCredits;
rr->NextUpdateCredit = 0;
rr->UpdateBlocked = 0;
rr->state = regState_Zero;
rr->uselease = 0;
rr->expire = 0;
rr->Private = 0;
rr->id = zeroID;
rr->zone.c[0] = 0;
rr->UpdateServer = zeroAddr;
rr->UpdatePort = zeroIPPort;
rr->nta = mDNSNULL;
rr->tcp = mDNSNULL;
rr->OrigRData = 0;
rr->OrigRDLen = 0;
rr->InFlightRData = 0;
rr->InFlightRDLen = 0;
rr->QueuedRData = 0;
rr->QueuedRDLen = 0;
if (rr->AutoTarget)
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", ARDisplayString(m, rr)); return(mStatus_Invalid); }
if (rr->resrec.rrtype == kDNSType_TXT && rr->resrec.rdlength == 0) { rr->resrec.rdlength = 1; rr->resrec.rdata->u.txt.c[0] = 0; }
if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata))
{ LogMsg("Attempt to register record with invalid rdata: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }
rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr->resrec.rdlength, &rr->resrec.rdata->u);
if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
{
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr;
for (r = m->ResourceRecords; r; r=r->next)
{
const AuthRecord *s2 = r->RRSet ? r->RRSet : r;
if (s1 != s2 && SameResourceRecordSignature(r, rr) && !SameRData(&r->resrec, &rr->resrec))
break;
}
if (r) {
debugf("Name conflict %p %##s (%s)", rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
rr->resrec.RecordType = kDNSRecordTypeDeregistering;
rr->resrec.rroriginalttl = 0;
rr->ImmedAnswer = mDNSInterfaceMark;
m->NextScheduledResponse = m->timenow;
}
}
}
for (r = m->ResourceRecords; r; r=r->next) if (RecordIsLocalDuplicate(r, rr)) break;
if (r)
{
debugf("Adding to duplicate list %p %s", rr, ARDisplayString(m,rr));
*d = rr;
if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)
rr->ProbeCount = 0;
}
else
{
debugf("Adding to active record list %p %s", rr, ARDisplayString(m,rr));
if (!m->NewLocalRecords) m->NewLocalRecords = rr;
*p = rr;
}
if (rr->resrec.InterfaceID != mDNSInterface_Any || rr->ForceMCast || IsLocalDomain(rr->resrec.name))
{
if (rr->resrec.RecordType != kDNSRecordTypeUnique && rr->resrec.RecordType != kDNSRecordTypeDeregistering)
AcknowledgeRecord(m, rr);
}
#ifndef UNICAST_DISABLED
else
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
rr->ProbeCount = 0;
rr->AnnounceCount = 0;
rr->state = regState_FetchingZoneData;
rr->uselease = mDNStrue;
rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationCallback, rr);
return rr->nta ? mStatus_NoError : mStatus_NoMemoryErr;
}
#endif
return(mStatus_NoError);
}
mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr)
{
m->ProbeFailTime = m->timenow;
m->NumFailedProbes++;
if (m->NumFailedProbes >= 15)
{
m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5);
LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect",
m->NumFailedProbes, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
}
mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr)
{
RData *OldRData = rr->resrec.rdata;
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); rr->NewRData = mDNSNULL; if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, OldRData); }
mDNSexport mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt)
{
AuthRecord *r2;
mDNSu8 RecordType = rr->resrec.RecordType;
AuthRecord **p = &m->ResourceRecords;
while (*p && *p != rr) p=&(*p)->next;
if (*p)
{
if (drt == mDNS_Dereg_conflict) {
for (r2 = m->DuplicateRecords; r2; r2=r2->next) if (RecordIsLocalDuplicate(r2, rr)) r2->ProbeCount = 0xFF;
}
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->RequireGoodbye = rr->RequireGoodbye;
dup->ImmedAnswer = rr->ImmedAnswer;
dup->ImmedUnicast = rr->ImmedUnicast;
dup->ImmedAdditional = rr->ImmedAdditional;
dup->v4Requester = rr->v4Requester;
dup->v6Requester = rr->v6Requester;
dup->ThisAPInterval = rr->ThisAPInterval;
dup->LastAPTime = rr->LastAPTime;
dup->LastMCTime = rr->LastMCTime;
dup->LastMCInterface = rr->LastMCInterface;
rr->RequireGoodbye = mDNSfalse;
}
}
}
else
{
p = &m->DuplicateRecords;
while (*p && *p != rr) p=&(*p)->next;
if (*p) rr->RequireGoodbye = mDNSfalse;
if (*p) debugf("DNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)",
rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
if (!*p)
{
if (drt != mDNS_Dereg_repeat)
LogMsg("mDNS_Deregister_internal: Record %p %##s (%s) not found in list",
rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_BadReferenceErr);
}
#ifndef UNICAST_DISABLED
if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly && !rr->ForceMCast && !IsLocalDomain(rr->resrec.name))
if (rr->RequireGoodbye)
{
if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
rr->resrec.RecordType = kDNSRecordTypeDeregistering;
uDNS_DeregisterRecord(m, rr);
return(mStatus_NoError);
}
#endif UNICAST_DISABLED
if (RecordType == kDNSRecordTypeShared && (rr->RequireGoodbye || rr->LocalAnswer))
{
verbosedebugf("mDNS_Deregister_internal: Sending deregister for %s", ARDisplayString(m, rr));
rr->resrec.RecordType = kDNSRecordTypeDeregistering;
rr->resrec.rroriginalttl = 0;
rr->ImmedAnswer = mDNSInterfaceMark;
if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)
m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);
}
else
{
*p = rr->next; if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next;
rr->next = mDNSNULL;
if (RecordType == kDNSRecordTypeUnregistered)
LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered", ARDisplayString(m, rr));
else if (RecordType == kDNSRecordTypeDeregistering)
LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering", ARDisplayString(m, rr));
else
{
verbosedebugf("mDNS_Deregister_internal: Deleting record for %s", ARDisplayString(m, rr));
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);
if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; }
if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
mDNS_DropLockBeforeCallback(); if (drt != mDNS_Dereg_conflict)
{
if (rr->RecordCallback)
rr->RecordCallback(m, rr, mStatus_MemFree); }
else
{
RecordProbeFailure(m, rr);
if (rr->RecordCallback)
rr->RecordCallback(m, rr, mStatus_NameConflict); r2 = m->DuplicateRecords;
while (r2)
{
if (r2->ProbeCount != 0xFF) r2 = r2->next;
else { mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict); r2 = m->DuplicateRecords; }
}
}
mDNS_ReclaimLockAfterCallback(); }
return(mStatus_NoError);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Packet Sending Functions
#endif
mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)
{
if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)
{
**nrpp = rr;
if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo;
rr->NR_AdditionalTo = add;
*nrpp = &rr->NextResponse;
}
debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID)
{
AuthRecord *rr, *rr2;
for (rr=ResponseRecords; rr; rr=rr->NextResponse) {
if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))
AddRecordToResponseList(nrpp, rr->Additional1, rr);
if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))
AddRecordToResponseList(nrpp, 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.rdatahash == rr2->resrec.namehash && SameDomainName(&rr->resrec.rdata->u.srv.target, rr2->resrec.name))
AddRecordToResponseList(nrpp, rr2, rr);
}
else if (RRTypeIsAddressType(rr->resrec.rrtype)) {
for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) if (RRTypeIsAddressType(rr2->resrec.rrtype) && ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && rr->resrec.namehash == rr2->resrec.namehash && SameDomainName(rr->resrec.name, rr2->resrec.name))
AddRecordToResponseList(nrpp, rr2, rr);
}
else if (rr->resrec.rrtype == kDNSType_PTR) {
if (ResourceRecordIsValidInterfaceAnswer(&m->DeviceInfo, InterfaceID) &&
SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c))
AddRecordToResponseList(nrpp, &m->DeviceInfo, rr);
}
}
}
mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID)
{
AuthRecord *rr;
AuthRecord *ResponseRecords = mDNSNULL;
AuthRecord **nrp = &ResponseRecords;
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->ImmedAnswer == mDNSInterfaceMark ||
mDNSSameIPv4Address(rr->v4Requester, onesIPv4Addr) ||
mDNSSameIPv6Address(rr->v6Requester, onesIPv6Addr) )
rr->ImmedUnicast = mDNSfalse;
if (rr->ImmedUnicast && rr->ImmedAnswer == InterfaceID)
if ((dest->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->v4Requester, dest->ip.v4)) ||
(dest->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->v6Requester, dest->ip.v6)))
{
rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse;
rr->v4Requester = zerov4Addr;
rr->v6Requester = zerov6Addr;
if (rr->NextResponse == mDNSNULL && nrp != &rr->NextResponse) { rr->NR_AnswerTo = (mDNSu8*)~0; *nrp = rr; nrp = &rr->NextResponse; }
}
}
AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID);
while (ResponseRecords)
{
mDNSu8 *responseptr = m->omsg.data;
mDNSu8 *newptr;
InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags);
while (ResponseRecords && ResponseRecords->NR_AnswerTo)
{
rr = ResponseRecords;
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (!newptr && m->omsg.h.numAnswers) break; if (newptr) responseptr = newptr;
ResponseRecords = rr->NextResponse;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
rr->RequireGoodbye = mDNStrue;
}
while (ResponseRecords && !ResponseRecords->NR_AnswerTo)
{
rr = ResponseRecords;
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet;
if (newptr) responseptr = newptr;
if (newptr && m->omsg.h.numAnswers) rr->RequireGoodbye = mDNStrue;
else if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) rr->ImmedAnswer = mDNSInterfaceMark;
ResponseRecords = rr->NextResponse;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
}
if (m->omsg.h.numAnswers) mDNSSendDNSMessage(m, &m->omsg, responseptr, mDNSInterface_Any, dest, MulticastDNSPort, mDNSNULL, mDNSNULL);
}
}
mDNSexport void CompleteDeregistration(mDNS *const m, AuthRecord *rr)
{
rr->resrec.RecordType = kDNSRecordTypeShared;
rr->RequireGoodbye = mDNSfalse;
if (rr->LocalAnswer) { AnswerLocalQuestions(m, rr, mDNSfalse); rr->LocalAnswer = mDNSfalse; }
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); }
mDNSlocal void DiscardDeregistrations(mDNS *const m)
{
if (m->CurrentRecord)
LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
CompleteDeregistration(m, rr); else
m->CurrentRecord = rr->next;
}
}
mDNSlocal void GrantUpdateCredit(AuthRecord *rr)
{
if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0;
else rr->NextUpdateCredit = NonZeroTime(rr->NextUpdateCredit + kUpdateCreditRefreshInterval);
}
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)
if (rr->ImmedUnicast)
{
mDNSAddr v4 = { mDNSAddrType_IPv4, {{{0}}} };
mDNSAddr v6 = { mDNSAddrType_IPv6, {{{0}}} };
v4.ip.v4 = rr->v4Requester;
v6.ip.v6 = rr->v6Requester;
if (!mDNSIPv4AddressIsZero(rr->v4Requester)) SendDelayedUnicastResponse(m, &v4, rr->ImmedAnswer);
if (!mDNSIPv6AddressIsZero(rr->v6Requester)) SendDelayedUnicastResponse(m, &v6, rr->ImmedAnswer);
if (rr->ImmedUnicast)
{
LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s", ARDisplayString(m, rr));
rr->ImmedUnicast = mDNSfalse;
}
}
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.rdatahash == 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; if (rr->ImmedAnswer && rr->resrec.RecordType == kDNSRecordTypeShared && rr->resrec.rrtype == kDNSType_PTR)
if (ResourceRecordIsValidAnswer(&m->DeviceInfo) && SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c))
{
if (!m->DeviceInfo.ImmedAnswer) m->DeviceInfo.ImmedAnswer = rr->ImmedAnswer;
else m->DeviceInfo.ImmedAnswer = mDNSInterfaceMark;
}
}
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, rr))
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, rr))
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;
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;
mDNSu8 *responseptr = m->omsg.data;
mDNSu8 *newptr;
InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags);
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow == intf->InterfaceID)
{
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
{
newptr = PutResourceRecordTTL(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0);
if (newptr) { responseptr = newptr; numDereg++; }
else if (m->omsg.h.numAnswers) break;
}
else if (rr->NewRData && !m->SleepState) {
RData *OldRData = rr->resrec.rdata;
mDNSu16 oldrdlength = rr->resrec.rdlength;
if (ResourceRecordIsValidAnswer(rr) && rr->RequireGoodbye)
{
newptr = PutResourceRecordTTL(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0);
if (newptr) { responseptr = newptr; numDereg++; rr->RequireGoodbye = mDNSfalse; }
else if (m->omsg.h.numAnswers) break;
}
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength);
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (newptr) { responseptr = newptr; rr->RequireGoodbye = mDNStrue; }
SetNewRData(&rr->resrec, OldRData, oldrdlength);
}
else
{
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecordTTL(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, m->SleepState ? 0 : rr->resrec.rroriginalttl);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (newptr)
{
responseptr = newptr;
rr->RequireGoodbye = (mDNSu8) (!m->SleepState);
if (rr->LastAPTime == m->timenow) numAnnounce++; else numAnswer++;
}
else if (m->omsg.h.numAnswers) break;
}
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)
if (ResourceRecordIsValidAnswer(rr))
{
mDNSBool SendAdditional = (m->omsg.h.numAnswers > 0);
if (!SendAdditional && (rr->resrec.RecordType & kDNSRecordTypeUniqueMask))
{
const AuthRecord *a;
for (a = m->ResourceRecords; a; a=a->next)
if (a->LastMCTime == m->timenow &&
a->LastMCInterface == intf->InterfaceID &&
SameResourceRecordSignature(a, rr)) { SendAdditional = mDNStrue; break; }
}
if (!SendAdditional) rr->ImmedAdditional = mDNSNULL; else if (newptr) {
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecord(&m->omsg, newptr, &m->omsg.h.numAdditionals, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (newptr)
{
responseptr = newptr;
rr->ImmedAdditional = mDNSNULL;
rr->RequireGoodbye = mDNStrue;
rr->LastMCTime = m->timenow;
rr->LastMCInterface = intf->InterfaceID;
}
}
}
if (m->omsg.h.numAnswers > 0 || m->omsg.h.numAdditionals)
{
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",
m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID);
if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL);
if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL);
if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10);
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 %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->SendRNow)
{
if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly)
LogMsg("SendResponses: No active interface to send: %s", ARDisplayString(m, rr));
rr->SendRNow = mDNSNULL;
}
if (rr->ImmedAnswer)
{
if (rr->NewRData) CompleteRDataUpdate(m,rr);
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
CompleteDeregistration(m, rr); else
{
rr->ImmedAnswer = mDNSNULL;
rr->ImmedUnicast = mDNSfalse;
rr->v4Requester = zerov4Addr;
rr->v6Requester = zerov6Addr;
}
}
}
verbosedebugf("SendResponses: Next in %ld ticks", m->NextScheduledResponse - m->timenow);
}
#define CacheCheckGracePeriod(RR) ( \
((RR)->DelayDelivery ) ? (mDNSPlatformOneSecond/10) : \
((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 CacheCheckGracePeriod %d ticks",
rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype),
(rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr));
}
if (m->NextCacheCheck - (rr->NextRequiredQuery + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (rr->NextRequiredQuery + CacheCheckGracePeriod(rr));
if (rr->DelayDelivery)
if (m->NextCacheCheck - rr->DelayDelivery > 0)
m->NextCacheCheck = rr->DelayDelivery;
}
#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
#define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5)
#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5)
#define kDefaultReconfirmTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 30)
mDNSlocal mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval)
{
if (interval < kMinimumReconfirmTime)
interval = kMinimumReconfirmTime;
if (interval > 0x10000000) interval = 0x10000000;
if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3))
{
if (!m->RandomReconfirmDelay) m->RandomReconfirmDelay = 1 + mDNSRandom(0x3FFFFFFF);
interval += mDNSRandomFromFixedSeed(m->RandomReconfirmDelay, interval/3);
rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3;
rr->resrec.rroriginalttl = (interval * 4 + mDNSPlatformOneSecond - 1) / mDNSPlatformOneSecond;
SetNextCacheCheckTime(m, rr);
}
debugf("mDNS_Reconfirm_internal:%6ld ticks to go for %s %p",
RRExpireTime(rr) - m->timenow, CRDisplayString(m, rr), rr->CRActiveQuestion);
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->RequestUnicast) && m->CanReceiveUnicastOn5353;
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 (%s)", q->qname.c, DNSTypeName(q->qtype));
return(mDNSfalse);
}
else if (newptr + *answerforecast >= limit)
{
verbosedebugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d",
q->qname.c, DNSTypeName(q->qtype), newptr + *answerforecast - query->data);
query->h.numQuestions--;
return(mDNSfalse);
}
else
{
mDNSu32 forecast = *answerforecast;
const mDNSu32 slot = HashSlot(&q->qname);
const CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
CacheRecord *rr;
CacheRecord **ka = *kalistptrptr;
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) if (rr->resrec.InterfaceID == q->SendQNow && rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && rr->resrec.rdlength <= SmallRecordLimit && SameNameRecordAnswersQuestion(&rr->resrec, q) && rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow > mDNSPlatformOneSecond) {
*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); }
}
*queryptr = newptr; *answerforecast = forecast; *kalistptrptr = ka; if (ucast) q->ExpectUnicastResp = NonZeroTime(m->timenow);
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) if (rr->resrec.InterfaceID == q->SendQNow && rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && SameNameRecordAnswersQuestion(&rr->resrec, q)) {
rr->UnansweredQueries++; rr->LastUnansweredTime = m->timenow;
SetNextCacheCheckTime(m, rr);
}
return(mDNStrue);
}
}
mDNSlocal void ReconfirmAntecedents(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const int depth)
{
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *cr;
debugf("ReconfirmAntecedents (depth=%d) for %##s", depth, name->c);
FORALL_CACHERECORDS(slot, cg, cr)
{
domainname *crtarget = GetRRDomainNameTarget(&cr->resrec);
if (crtarget && cr->resrec.rdatahash == namehash && SameDomainName(crtarget, name))
{
LogOperation("ReconfirmAntecedents: Reconfirming (depth=%d) %s", depth, CRDisplayString(m, cr));
mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
if (depth < 5) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, depth+1);
}
}
}
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;
const mDNSu32 slot = HashSlot(&q->qname);
const CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
CacheRecord *rr;
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) if (rr->resrec.rdlength <= SmallRecordLimit && SameNameRecordAnswersQuestion(&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)
{
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *cr;
AuthRecord *ar;
int pktcount = 0;
DNSQuestion *q;
mDNSs32 maxExistingQuestionInterval = 0;
const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
CacheRecord *KnownAnswerList = mDNSNULL;
if (m->timenow - m->NextScheduledQuery >= 0)
{
CacheRecord *rr;
FORALL_CACHERECORDS(slot, cg, rr)
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
if (m->timenow + TicksTTL(rr)/50 - rr->NextRequiredQuery >= 0)
{
LogOperation("Sending %d%% cache expiration query for %s", 80 + 5 * rr->UnansweredQueries, CRDisplayString(m, rr));
q = rr->CRActiveQuestion;
ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(rr)/20, rr->resrec.InterfaceID);
if (q->Target.type) q->SendQNow = mDNSInterfaceMark; else if (!mDNSOpaque16IsZero(q->TargetQID)) q->LastQTime = m->timenow - q->ThisQInterval; else if (q->SendQNow == mDNSNULL) q->SendQNow = rr->resrec.InterfaceID;
else if (q->SendQNow != rr->resrec.InterfaceID) q->SendQNow = mDNSInterfaceMark;
}
if (m->SuppressStdPort53Queries && m->timenow - m->SuppressStdPort53Queries >= 0)
m->SuppressStdPort53Queries = 0;
if (m->CurrentQuestion)
LogMsg("SendQueries ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion)
{
q = m->CurrentQuestion;
if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID)) uDNS_CheckCurrentQuestion(m);
else if (mDNSOpaque16IsZero(q->TargetQID) && q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow)))
{
mDNSu8 *qptr = m->omsg.data;
const mDNSu8 *const limit = m->omsg.data + sizeof(m->omsg.data);
InitializeDNSMessage(&m->omsg.h, q->TargetQID, QueryFlags);
qptr = putQuestion(&m->omsg, qptr, limit, &q->qname, q->qtype, q->qclass);
mDNSSendDNSMessage(m, &m->omsg, qptr, mDNSInterface_Any, &q->Target, q->TargetPort, mDNSNULL, mDNSNULL);
q->ThisQInterval *= QuestionIntervalStep;
if (q->ThisQInterval > MaxQuestionInterval)
q->ThisQInterval = MaxQuestionInterval;
q->LastQTime = m->timenow;
q->LastQTxTime = m->timenow;
q->RecentAnswerPkts = 0;
q->SendQNow = mDNSNULL;
q->ExpectUnicastResp = NonZeroTime(m->timenow);
}
else if (mDNSOpaque16IsZero(q->TargetQID) && !q->Target.type && TimeToSendThisQuestion(q, m->timenow))
{
q->SendQNow = mDNSInterfaceMark; if (maxExistingQuestionInterval < q->ThisQInterval)
maxExistingQuestionInterval = q->ThisQInterval;
}
if (q == m->CurrentQuestion) m->CurrentQuestion = m->CurrentQuestion->next;
}
m->NextScheduledQuery = m->timenow + 0x78000000;
for (q = m->Questions; q; q=q->next)
{
if (mDNSOpaque16IsZero(q->TargetQID) && (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 *= QuestionIntervalStep;
if (q->ThisQInterval > MaxQuestionInterval)
q->ThisQInterval = MaxQuestionInterval;
else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * QuestionIntervalStep2)
{
debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents",
q->qname.c, DNSTypeName(q->qtype));
ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0);
}
}
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->RecentAnswerPkts = 0;
if (q->RequestUnicast) q->RequestUnicast--;
}
SetNextQueryTime(m,q);
}
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
m->NextScheduledProbe = m->timenow + 0x78000000;
if (m->CurrentRecord)
LogMsg("SendQueries ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
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);
if (rr->ProbeCount == 0)
{
AuthRecord *r2;
for (r2 = m->DuplicateRecords; r2; r2=r2->next)
if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, rr))
r2->ProbeCount = 0;
if (!rr->Acknowledged) AcknowledgeRecord(m, rr);
}
}
else
{
if (!rr->Acknowledged) AcknowledgeRecord(m, rr); rr->resrec.RecordType = kDNSRecordTypeVerified;
rr->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique;
rr->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique;
SetNextAnnounceProbeTime(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 && !rr->Acknowledged)
AcknowledgeRecord(m, rr);
}
}
while (intf)
{
AuthRecord *rr;
mDNSu8 *queryptr = m->omsg.data;
InitializeDNSMessage(&m->omsg.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 (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow == intf->InterfaceID))
{
debugf("SendQueries: %s question for %##s (%s) at %d forecast total %d",
SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting ",
q->qname.c, DNSTypeName(q->qtype), queryptr - m->omsg.data, queryptr + answerforecast - m->omsg.data);
if (SuppressOnThisInterface(q->DupSuppress, intf) ||
BuildQuestion(m, &m->omsg, &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->CanReceiveUnicastOn5353;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
const mDNSu8 *const limit = m->omsg.data + ((m->omsg.h.numQuestions) ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData);
mDNSu8 *newptr = putQuestion(&m->omsg, 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));
m->omsg.h.numQuestions--;
}
}
}
while (KnownAnswerList)
{
CacheRecord *rr = KnownAnswerList;
mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
mDNSu8 *newptr = PutResourceRecordTTL(&m->omsg, queryptr, &m->omsg.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl - SecsSinceRcvd);
if (newptr)
{
verbosedebugf("SendQueries: Put %##s (%s) at %d - %d",
rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), queryptr - m->omsg.data, newptr - m->omsg.data);
queryptr = newptr;
KnownAnswerList = rr->NextInKAList;
rr->NextInKAList = mDNSNULL;
}
else
{
if (m->omsg.h.numQuestions > 1)
LogMsg("SendQueries: Put %d answers; No more space for known answers", m->omsg.h.numAnswers);
m->omsg.h.flags.b[0] |= kDNSFlag0_TC;
break;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->IncludeInProbe)
{
mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.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 > m->omsg.data)
{
if ((m->omsg.h.flags.b[0] & kDNSFlag0_TC) && m->omsg.h.numQuestions > 1)
LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet", m->omsg.h.numQuestions);
debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p",
m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s",
m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s",
m->omsg.h.numAuthorities, m->omsg.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID);
if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL);
if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL);
if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10);
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;
}
}
for (ar = m->ResourceRecords; ar; ar=ar->next)
if (ar->SendRNow)
{
if (ar->resrec.InterfaceID != mDNSInterface_LocalOnly)
LogMsg("SendQueries: No active interface to send: %s", ARDisplayString(m, ar));
ar->SendRNow = mDNSNULL;
}
FORALL_CACHERECORDS(slot, cg, cr)
if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries && m->timenow - cr->NextRequiredQuery >= 0)
{
cr->UnansweredQueries++;
cr->CRActiveQuestion->SendQNow = mDNSNULL;
SetNextCacheCheckTime(m, cr);
}
for (q = m->Questions; q; q=q->next)
if (q->SendQNow)
{
LogMsg("SendQueries: No active interface to send: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
q->SendQNow = mDNSNULL;
}
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - RR List Management & Task Management
#endif
mDNSexport void AnswerCurrentQuestionWithResourceRecord(mDNS *const m, CacheRecord *const rr, const QC_result AddRecord)
{
DNSQuestion *const q = m->CurrentQuestion;
mDNSBool followcname = rr->resrec.RecordType != kDNSRecordTypePacketNegative && AddRecord &&
rr->resrec.rrtype == kDNSType_CNAME && q->qtype != kDNSType_CNAME;
verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s", q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, CRDisplayString(m, rr));
rr->LastUsed = m->timenow;
if (AddRecord == QC_add && !q->DuplicateOf && rr->CRActiveQuestion != q)
{
if (!rr->CRActiveQuestion) m->rrcache_active++; debugf("AnswerCurrentQuestionWithResourceRecord: Updating CRActiveQuestion to %p for cache record %s", q, CRDisplayString(m,rr));
rr->CRActiveQuestion = q; SetNextCacheCheckTime(m, rr);
}
if ((AddRecord == QC_addnocache && !q->RequestUnicast) ||
(AddRecord == QC_add && (q->ExpectUnique || (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))))
if (ActiveQuestion(q) && (mDNSOpaque16IsZero(q->TargetQID) || !q->LongLived))
{
q->LastQTime = m->timenow;
q->LastQTxTime = m->timenow;
q->RecentAnswerPkts = 0;
q->ThisQInterval = MaxQuestionInterval;
q->RequestUnicast = mDNSfalse;
}
if (rr->DelayDelivery) return;
if (rr->resrec.RecordType == kDNSRecordTypePacketNegative && (!AddRecord || !q->ReturnIntermed)) return;
if (q->QuestionCallback && !q->NoAnswer && (!followcname || q->ReturnIntermed))
{
mDNS_DropLockBeforeCallback(); q->QuestionCallback(m, q, &rr->resrec, AddRecord);
mDNS_ReclaimLockAfterCallback(); }
if (followcname && m->CurrentQuestion == q && q->CNAMEReferrals < 10)
{
const mDNSu32 c = q->CNAMEReferrals + 1;
LogOperation("AnswerCurrentQuestionWithResourceRecord: following CNAME referral for %s", CRDisplayString(m, rr));
mDNS_StopQuery_internal(m, q); AssignDomainName(&q->qname, &rr->resrec.rdata->u.name); q->qnamehash = DomainNameHashValue(&q->qname); mDNS_StartQuery_internal(m, q); q->CNAMEReferrals = c; }
}
mDNSlocal void CacheRecordDeferredAdd(mDNS *const m, CacheRecord *rr)
{
rr->DelayDelivery = 0; if (m->CurrentQuestion)
LogMsg("CacheRecordDeferredAdd ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
if (m->CurrentQuestion == q) m->CurrentQuestion = q->next;
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal mDNSs32 CheckForSoonToExpireRecords(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const mDNSu32 slot)
{
const mDNSs32 threshhold = m->timenow + mDNSPlatformOneSecond; const mDNSs32 start = m->timenow - 0x10000000;
mDNSs32 delay = start;
CacheGroup *cg = CacheGroupForName(m, slot, namehash, name);
CacheRecord *rr;
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (threshhold - RRExpireTime(rr) >= 0) if (delay - RRExpireTime(rr) < 0) delay = RRExpireTime(rr);
if (delay - start > 0) return(NonZeroTime(delay));
else return(0);
}
mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next)
{
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
if (q->LastAnswerPktNum != m->PktNum)
{
q->LastAnswerPktNum = m->PktNum;
if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q) && ++q->RecentAnswerPkts >= 10 &&
q->ThisQInterval > InitialQuestionInterval * QuestionIntervalStep3 && 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++;
if (q->CurrentAnswers > 4000)
{
static int msgcount = 0;
if (msgcount++ < 10)
LogMsg("CacheRecordAdd: %##s (%s) has %d answers; shedding records to resist DOS attack",
q->qname.c, DNSTypeName(q->qtype), q->CurrentAnswers);
rr->resrec.rroriginalttl = 0;
rr->UnansweredQueries = MaxUnansweredQueries;
}
}
}
if (!rr->DelayDelivery)
{
if (m->CurrentQuestion)
LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
if (m->CurrentQuestion == q) m->CurrentQuestion = q->next;
}
m->CurrentQuestion = mDNSNULL;
}
SetNextCacheCheckTime(m, rr);
}
mDNSlocal void NoCacheAnswer(mDNS *const m, CacheRecord *rr)
{
LogMsg("No cache space: Delivering non-cached result for %##s", m->rec.r.resrec.name->c);
if (m->CurrentQuestion)
LogMsg("NoCacheAnswer ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion)
{
DNSQuestion *q = m->CurrentQuestion;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
AnswerCurrentQuestionWithResourceRecord(m, rr, QC_addnocache); if (m->CurrentQuestion == q) m->CurrentQuestion = q->next;
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr)
{
if (m->CurrentQuestion)
LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
verbosedebugf("CacheRecordRmv %p %s", rr, CRDisplayString(m, rr));
q->FlappingInterface1 = mDNSNULL;
q->FlappingInterface2 = mDNSNULL;
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 (rr->resrec.rdata->MaxRDLength) {
if (q->CurrentAnswers == 0)
{
LogOperation("CacheRecordRmv: Last answer for %##s (%s) expired from cache; will reconfirm antecedents",
q->qname.c, DNSTypeName(q->qtype));
ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0);
}
AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv);
}
}
if (m->CurrentQuestion == q) m->CurrentQuestion = q->next;
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void ReleaseCacheEntity(mDNS *const m, CacheEntity *e)
{
#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1
unsigned int i;
for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF;
#endif
e->next = m->rrcache_free;
m->rrcache_free = e;
m->rrcache_totalused--;
}
mDNSlocal void ReleaseCacheGroup(mDNS *const m, CacheGroup **cp)
{
CacheEntity *e = (CacheEntity *)(*cp);
if ((*cp)->rrcache_tail != &(*cp)->members)
LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrcache_tail != &(*cp)->members)");
if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name);
(*cp)->name = mDNSNULL;
*cp = (*cp)->next; ReleaseCacheEntity(m, e);
}
mDNSlocal void ReleaseCacheRecord(mDNS *const m, CacheRecord *r)
{
if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->rdatastorage) mDNSPlatformMemFree(r->resrec.rdata);
r->resrec.rdata = mDNSNULL;
ReleaseCacheEntity(m, (CacheEntity *)r);
}
mDNSlocal void CheckCacheExpiration(mDNS *const m, CacheGroup *const cg)
{
CacheRecord **rp = &cg->members;
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%7d %4d %p %s",
m->timenow - rr->TimeRcvd, rr->resrec.rroriginalttl, rr->CRActiveQuestion, CRDisplayString(m, rr));
if (rr->CRActiveQuestion) {
CacheRecordRmv(m, rr);
m->rrcache_active--;
}
ReleaseCacheRecord(m, rr);
}
else {
if (rr->DelayDelivery && rr->DelayDelivery - m->timenow > 0)
event = rr->DelayDelivery;
else
{
if (rr->DelayDelivery) CacheRecordDeferredAdd(m, rr);
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
{
if (m->timenow - rr->NextRequiredQuery < 0) event = rr->NextRequiredQuery; else {
m->NextScheduledQuery = m->timenow;
event = m->timenow + 0x3FFFFFFF;
}
}
}
verbosedebugf("CheckCacheExpiration:%6d %5d %s",
(event - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m, rr));
if (m->NextCacheCheck - (event + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (event + CacheCheckGracePeriod(rr));
rp = &rr->next;
}
}
if (cg->rrcache_tail != rp) verbosedebugf("CheckCacheExpiration: Updating CacheGroup tail from %p to %p", cg->rrcache_tail, rp);
cg->rrcache_tail = rp;
m->lock_rrcache = 0;
}
mDNSlocal void AnswerNewQuestion(mDNS *const m)
{
mDNSBool ShouldQueryImmediately = mDNStrue;
CacheRecord *rr;
DNSQuestion *q = m->NewQuestions; const mDNSu32 slot = HashSlot(&q->qname);
CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
if (cg) CheckCacheExpiration(m, cg);
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: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = q;
if (q->NoAnswer == NoAnswer_Fail)
{
LogMsg("AnswerNewQuestion: NoAnswer_Fail %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
MakeNegativeCacheRecord(m, &q->qname, q->qnamehash, q->qtype, q->qclass, 60);
q->NoAnswer = NoAnswer_Normal; AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, QC_addnocache);
q->NoAnswer = NoAnswer_Fail; m->rec.r.resrec.RecordType = 0; }
if (m->CurrentQuestion == q && q->InterfaceID == mDNSInterface_Any)
{
if (m->CurrentRecord)
LogMsg("AnswerNewQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, mDNStrue);
if (m->CurrentQuestion != q) break; }
}
m->CurrentRecord = mDNSNULL;
}
if (m->CurrentQuestion == q)
{
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (SameNameRecordAnswersQuestion(&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) %d %d",
rr->resrec.rroriginalttl, SecsSinceRcvd, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), m->timenow, rr->TimeRcvd);
continue; }
if ((rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) || (q->ExpectUnique))
ShouldQueryImmediately = mDNSfalse;
q->CurrentAnswers++;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
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 (m->CurrentQuestion == q && ShouldQueryImmediately && ActiveQuestion(q))
{
q->ThisQInterval = InitialQuestionInterval;
q->LastQTime = m->timenow - q->ThisQInterval;
if (mDNSOpaque16IsZero(q->TargetQID))
{
if (!m->RandomQueryDelay)
m->RandomQueryDelay = (mDNSPlatformOneSecond + mDNSRandom(mDNSPlatformOneSecond*5) - 1) / 50 + 1;
q->LastQTime += m->RandomQueryDelay;
}
m->NextScheduledQuery = m->timenow;
}
m->CurrentQuestion = mDNSNULL;
m->lock_rrcache = 0;
}
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("AnswerNewLocalOnlyQuestion ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = q;
if (m->CurrentRecord)
LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords)
{
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;
m->CurrentRecord = mDNSNULL;
}
mDNSlocal CacheEntity *GetCacheEntity(mDNS *const m, const CacheGroup *const PreserveCG)
{
CacheEntity *e = 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 > 3000 && m->rrcache_size / 32 > m->rrcache_active)
LogOperation("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
m->rrcache_size, m->rrcache_active);
else
{
mDNS_DropLockBeforeCallback(); m->MainCallback(m, mStatus_GrowCache);
mDNS_ReclaimLockAfterCallback(); }
}
if (!m->rrcache_free)
{
#if LogAllOperations || MDNS_DEBUGMSGS
mDNSu32 oldtotalused = m->rrcache_totalused;
#endif
mDNSu32 slot;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
CacheGroup **cp = &m->rrcache_hash[slot];
while (*cp)
{
CacheRecord **rp = &(*cp)->members;
while (*rp)
{
if ((*rp)->CRActiveQuestion || (*rp)->NextInCFList)
rp=&(*rp)->next;
else
{
CacheRecord *rr = *rp;
*rp = (*rp)->next; ReleaseCacheRecord(m, rr);
}
}
if ((*cp)->rrcache_tail != rp)
verbosedebugf("GetFreeCacheRR: Updating rrcache_tail[%lu] from %p to %p", slot, (*cp)->rrcache_tail, rp);
(*cp)->rrcache_tail = rp;
if ((*cp)->members || (*cp)==PreserveCG) cp=&(*cp)->next;
else ReleaseCacheGroup(m, cp);
}
}
LogOperation("GetCacheEntity recycled %d records to reduce cache from %d to %d",
oldtotalused - m->rrcache_totalused, oldtotalused, m->rrcache_totalused);
}
if (m->rrcache_free) {
e = m->rrcache_free;
m->rrcache_free = e->next;
if (++m->rrcache_totalused >= m->rrcache_report)
{
LogOperation("RR Cache now using %ld objects", m->rrcache_totalused);
if (m->rrcache_report < 100) m->rrcache_report += 10;
else m->rrcache_report += 100;
}
mDNSPlatformMemZero(e, sizeof(*e));
}
m->lock_rrcache = 0;
return(e);
}
mDNSlocal CacheRecord *GetCacheRecord(mDNS *const m, CacheGroup *cg, mDNSu16 RDLength)
{
CacheRecord *r = (CacheRecord *)GetCacheEntity(m, cg);
if (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 { ReleaseCacheEntity(m, (CacheEntity*)r); r = mDNSNULL; }
}
}
return(r);
}
mDNSlocal CacheGroup *GetCacheGroup(mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr)
{
mDNSu16 namelen = DomainNameLength(rr->name);
CacheGroup *cg = (CacheGroup*)GetCacheEntity(m, mDNSNULL);
if (!cg) { LogMsg("GetCacheGroup: Failed to allocate memory for %##s", rr->name->c); return(mDNSNULL); }
cg->next = m->rrcache_hash[slot];
cg->namehash = rr->namehash;
cg->members = mDNSNULL;
cg->rrcache_tail = &cg->members;
cg->name = (domainname*)cg->namestorage;
if (namelen > InlineCacheGroupNameSize) cg->name = mDNSPlatformMemAllocate(namelen);
if (!cg->name)
{
LogMsg("GetCacheGroup: Failed to allocate name storage for %##s", rr->name->c);
ReleaseCacheEntity(m, (CacheEntity*)cg);
return(mDNSNULL);
}
AssignDomainName(cg->name, rr->name);
if (CacheGroupForRecord(m, slot, rr)) LogMsg("GetCacheGroup: Already have CacheGroup for %##s", rr->name->c);
m->rrcache_hash[slot] = cg;
if (CacheGroupForRecord(m, slot, rr) != cg) LogMsg("GetCacheGroup: Not finding CacheGroup for %##s", rr->name->c);
return(cg);
}
mDNSexport void mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr)
{
rr->TimeRcvd = m->timenow - mDNSPlatformOneSecond * 60;
rr->UnansweredQueries = MaxUnansweredQueries;
rr->resrec.rroriginalttl = 0;
SetNextCacheCheckTime(m, rr);
}
mDNSexport mDNSs32 mDNS_TimeNow(const mDNS *const m)
{
mDNSs32 time;
mDNSPlatformLock(m);
if (m->mDNS_busy)
{
LogMsg("mDNS_TimeNow called while holding mDNS lock. This is incorrect. Code protected by lock should just use m->timenow.");
if (!m->timenow) LogMsg("mDNS_TimeNow: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy);
}
if (m->timenow) time = m->timenow;
else time = mDNS_TimeNow_NoLock(m);
mDNSPlatformUnlock(m);
return(time);
}
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: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
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++)
{
CacheGroup **cp = &m->rrcache_hash[slot];
while (*cp)
{
CheckCacheExpiration(m, *cp);
if ((*cp)->members) cp=&(*cp)->next;
else ReleaseCacheGroup(m, cp);
}
}
}
for (i=0; m->NewQuestions && i<1000; i++)
{
if (m->NewQuestions->DelayAnswering && m->timenow - m->NewQuestions->DelayAnswering < 0) break;
AnswerNewQuestion(m);
}
if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m);
if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
for (i=0; i<1000 && m->NewLocalRecords && LocalRecordReady(m->NewLocalRecords); i++)
{
AuthRecord *rr = m->NewLocalRecords;
m->NewLocalRecords = m->NewLocalRecords->next;
AnswerLocalQuestions(m, rr, mDNStrue);
}
if (i >= 1000) LogMsg("mDNS_Execute: AnswerForNewLocalRecords 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)
{
DNSQuestion *q;
LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second",
m->timenow, m->NextScheduledQuery, m->timenow - m->NextScheduledQuery);
m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond;
for (q = m->Questions; q; q=q->next)
if (ActiveQuestion(q) && q->LastQTime + q->ThisQInterval - m->timenow <= 0)
LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second",
m->timenow, m->NextScheduledProbe, m->timenow - m->NextScheduledProbe);
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;
m->RandomReconfirmDelay = 0;
}
#ifndef UNICAST_DISABLED
uDNS_Execute(m);
#endif
mDNS_Unlock(m); return(m->NextScheduledEvent);
}
mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleepstate)
{
AuthRecord *rr;
mDNS_Lock(m);
m->SleepState = sleepstate;
LogOperation("%s at %ld", sleepstate ? "Sleeping" : "Waking", m->timenow);
if (sleepstate)
{
#ifndef UNICAST_DISABLED
uDNS_Sleep(m);
#endif
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye)
rr->ImmedAnswer = mDNSInterfaceMark;
SendResponses(m);
}
else
{
DNSQuestion *q;
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *cr;
#ifndef UNICAST_DISABLED
uDNS_Wake(m);
#endif
for (q = m->Questions; q; q=q->next) if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q))
{
q->ThisQInterval = InitialQuestionInterval; q->RequestUnicast = 2; q->LastQTime = m->timenow - q->ThisQInterval;
q->RecentAnswerPkts = 0;
ExpireDupSuppressInfo(q->DupSuppress, m->timenow);
m->NextScheduledQuery = m->timenow;
}
m->NextCacheCheck = m->timenow;
FORALL_CACHERECORDS(slot, cg, cr)
mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForWake);
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);
rr->AnnounceCount = InitialAnnounceCount;
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
#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);
LogMsg("CompareRData ERROR: Invalid state");
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++)
{
ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
if (!ptr) break;
if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q))
{
FoundUpdate = mDNStrue;
if (PacketRRConflict(m, our, &m->rec.r))
{
int result = (int)our->resrec.rrclass - (int)m->rec.r.resrec.rrclass;
if (!result) result = (int)our->resrec.rrtype - (int)m->rec.r.resrec.rrtype;
if (!result) result = CompareRData(our, &m->rec.r);
if (result > 0)
LogOperation("ResolveSimultaneousProbe: %##s (%s): We won", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
else if (result < 0)
{
LogOperation("ResolveSimultaneousProbe: %##s (%s): We lost", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
mDNS_Deregister_internal(m, our, mDNS_Dereg_conflict);
goto exit;
}
}
}
m->rec.r.resrec.RecordType = 0; }
if (!FoundUpdate)
LogOperation("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
exit:
m->rec.r.resrec.RecordType = 0; }
mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, ResourceRecord *pktrr)
{
mDNSu32 slot = HashSlot(pktrr->name);
CacheGroup *cg = CacheGroupForRecord(m, slot, pktrr);
CacheRecord *rr;
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (pktrr->InterfaceID == rr->resrec.InterfaceID && IdenticalSameNameRecord(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,
mDNSBool QueryWasLocalUnicast, DNSMessage *const response)
{
mDNSBool FromLocalSubnet = srcaddr && AddressIsLocalSubnet(m, InterfaceID, srcaddr);
AuthRecord *ResponseRecords = mDNSNULL;
AuthRecord **nrp = &ResponseRecords;
CacheRecord *ExpectedAnswers = mDNSNULL; CacheRecord **eap = &ExpectedAnswers;
DNSQuestion *DupQuestions = mDNSNULL; DNSQuestion **dqp = &DupQuestions;
mDNSs32 delayresponse = 0;
mDNSBool SendLegacyResponse = mDNSfalse;
const mDNSu8 *ptr = query->data;
mDNSu8 *responseptr = mDNSNULL;
AuthRecord *rr;
int i;
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 %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq) && (QueryWasMulticast || QueryWasLocalUnicast || rr->AllowRemoteQuery))
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
ResolveSimultaneousProbe(m, query, end, &pktq, rr);
else if (ResourceRecordIsValidAnswer(rr))
{
NumAnswersForThisQuestion++;
if (QuestionNeedsMulticastResponse || (!FromLocalSubnet && QueryWasMulticast && !LegacyQuery))
{
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 = LegacyQuery ? ptr : (mDNSu8*)~1;
}
}
}
if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond;
if (QuestionNeedsMulticastResponse)
{
const mDNSu32 slot = HashSlot(&pktq.qname);
CacheGroup *cg = CacheGroupForName(m, slot, pktq.qnamehash, &pktq.qname);
CacheRecord *rr;
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (SameNameRecordAnswersQuestion(&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);
AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID);
for (i=0; i<query->h.numAnswers; i++) {
AuthRecord *rr;
CacheRecord *ourcacherr;
ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &m->rec);
if (!ptr) goto exit;
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&m->rec.r, rr))
{ rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
for (rr=m->ResourceRecords; rr; rr=rr->next)
{
if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&m->rec.r, rr))
{
if (srcaddr->type == mDNSAddrType_IPv4)
{
if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zerov4Addr;
}
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;
rr->ImmedUnicast = mDNSfalse;
#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
LogMsg("Suppressed after%4d: %s", m->timenow - rr->ImmedAnswerMarkTime, ARDisplayString(m, rr));
#endif
}
}
}
ourcacherr = FindIdenticalRecordInCache(m, &m->rec.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(&m->rec.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(&m->rec.r.resrec, q))
{ *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; }
else dqp = &q->NextInDQList;
}
}
m->rec.r.resrec.RecordType = 0; }
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; mDNSBool SendUnicastResponse = mDNSfalse;
if (m->timenow - (rr->LastMCTime + TicksTTL(rr)/4) >= 0)
{
SendMulticastResponse = mDNStrue;
if (rr->NR_AnswerTo == (mDNSu8*)~1) rr->NR_AnswerTo = (mDNSu8*)~0;
}
if (rr->NR_AnswerTo == (mDNSu8*)~0) SendMulticastResponse = mDNStrue;
else if (rr->NR_AnswerTo == (mDNSu8*)~1) SendUnicastResponse = mDNStrue;
else if (rr->NR_AnswerTo) SendLegacyResponse = mDNStrue;
if (SendMulticastResponse || SendUnicastResponse)
{
#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
rr->ImmedAnswerMarkTime = m->timenow;
#endif
m->NextScheduledResponse = m->timenow;
if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID)
rr->ImmedAnswer = mDNSInterfaceMark;
else
{
rr->ImmedAnswer = InterfaceID; if (SendUnicastResponse) rr->ImmedUnicast = mDNStrue;
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 (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; else if (rr->resrec.RecordType == kDNSRecordTypeShared) 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 (SendLegacyResponse)
responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords);
exit:
m->rec.r.resrec.RecordType = 0;
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, CRDisplayString(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, CRDisplayString(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, CRDisplayString(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)
{
mDNSu8 *responseend = mDNSNULL;
mDNSBool QueryWasLocalUnicast = srcaddr && dstaddr &&
!mDNSAddrIsDNSMulticast(dstaddr) && AddressIsLocalSubnet(m, InterfaceID, srcaddr);
if (!InterfaceID && dstaddr && mDNSAddrIsDNSMulticast(dstaddr))
{
LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
"%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s (Multicast, but no InterfaceID)",
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%p 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,
!mDNSSameIPPort(srcport, MulticastDNSPort), mDNSAddrIsDNSMulticast(dstaddr), QueryWasLocalUnicast, &m->omsg);
if (responseend) {
debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s",
m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s",
m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s",
srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type);
mDNSSendDNSMessage(m, &m->omsg, responseend, InterfaceID, srcaddr, srcport, mDNSNULL, mDNSNULL);
}
}
mDNSlocal mDNSBool TrustedSource(const mDNS *const m, const mDNSAddr *const srcaddr)
{
DNSServer *s;
(void)m; (void)srcaddr; for (s = m->DNSServers; s; s = s->next)
if (mDNSSameAddress(srcaddr, &s->addr)) return(mDNStrue);
return(mDNSfalse);
}
mDNSlocal const DNSQuestion *ExpectingUnicastResponseForQuestion(const mDNS *const m, const mDNSOpaque16 id, const DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next)
if (mDNSSameOpaque16(q->TargetQID, id) &&
q->qtype == question->qtype &&
q->qclass == question->qclass &&
q->qnamehash == question->qnamehash &&
SameDomainName(&q->qname, &question->qname))
return(q);
return(mDNSNULL);
}
mDNSlocal mDNSBool ExpectingUnicastResponseForRecord(mDNS *const m, const mDNSAddr *const srcaddr, const mDNSBool SrcLocal, const mDNSOpaque16 id, const CacheRecord *const rr)
{
DNSQuestion *q;
(void)id;
for (q = m->Questions; q; q=q->next)
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
if (!mDNSOpaque16IsZero(q->TargetQID))
{
{
if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue);
if (mDNSSameOpaque16(q->TargetQID, id)) return(mDNStrue);
if (TrustedSource(m, srcaddr)) return(mDNStrue);
LogOperation("WARNING: Ignoring suspect uDNS response for %##s (%s) %#a from %#a: %s",
q->qname.c, DNSTypeName(q->qtype), &q->Target, srcaddr, CRDisplayString(m, rr));
return(mDNSfalse);
}
}
else
{
if (SrcLocal && q->ExpectUnicastResp && (mDNSu32)(m->timenow - q->ExpectUnicastResp) < (mDNSu32)(mDNSPlatformOneSecond*2))
return(mDNStrue);
}
}
return(mDNSfalse);
}
mDNSexport CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg)
{
CacheRecord *rr = mDNSNULL;
mDNSu16 RDLength;
switch (m->rec.r.resrec.rrtype)
{
case kDNSType_SOA: RDLength = sizeof(rdataSOA); break;
case kDNSType_RP: RDLength = sizeof(rdataRP); break;
case kDNSType_PX: RDLength = sizeof(rdataPX); break;
default: RDLength = m->rec.r.resrec.rdlength; break;
}
if (!cg) cg = GetCacheGroup(m, slot, &m->rec.r.resrec); if (cg) rr = GetCacheRecord(m, cg, RDLength); if (!rr) NoCacheAnswer(m, &m->rec.r);
else
{
RData *saveptr = rr->resrec.rdata; *rr = m->rec.r; rr->resrec.rdata = saveptr; rr->resrec.name = cg->name;
if (rr->resrec.rdata == (RData*)&rr->rdatastorage && RDLength > InlineCacheRDSize)
LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s", m->rec.r.resrec.name->c);
else if (rr->resrec.rdata != (RData*)&rr->rdatastorage && RDLength <= InlineCacheRDSize)
LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s", m->rec.r.resrec.name->c);
if (RDLength > InlineCacheRDSize)
mDNSPlatformMemCopy(rr->resrec.rdata, m->rec.r.resrec.rdata, sizeofRDataHeader + RDLength);
rr->next = mDNSNULL; *(cg->rrcache_tail) = rr; cg->rrcache_tail = &(rr->next); if (rr->resrec.RecordType == kDNSRecordTypePacketNegative)
rr->DelayDelivery = NonZeroTime(m->timenow);
else if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask && rr->resrec.rdata->MaxRDLength != 0) rr->DelayDelivery = NonZeroTime(m->timenow + mDNSPlatformOneSecond); else
rr->DelayDelivery = CheckForSoonToExpireRecords(m, rr->resrec.name, rr->resrec.namehash, slot);
CacheRecordAdd(m, rr); }
return(rr);
}
mDNSlocal void RefreshCacheRecord(mDNS *const m, CacheRecord *rr, mDNSu32 ttl)
{
rr->TimeRcvd = m->timenow;
rr->resrec.rroriginalttl = ttl;
rr->UnansweredQueries = 0;
rr->MPUnansweredQ = 0;
rr->MPUnansweredKA = 0;
rr->MPExpectingKA = mDNSfalse;
SetNextCacheCheckTime(m, rr);
}
mDNSexport void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease)
{
CacheRecord *rr;
const mDNSu32 slot = HashSlot(&q->qname);
CacheGroup *cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (rr->CRActiveQuestion == q)
{
RefreshCacheRecord(m, rr, lease);
}
}
mDNSlocal mDNSu32 GetEffectiveTTL(const uDNS_LLQType LLQType, mDNSu32 ttl) {
if (LLQType == uDNS_LLQ_Poll) ttl = LLQ_POLL_INTERVAL * 2 / mDNSPlatformOneSecond;
else if (LLQType == uDNS_LLQ_Setup) ttl = kLLQ_DefLease;
else if (LLQType == uDNS_LLQ_Events)
{
if (ttl == 0xFFFFFFFF) ttl = 0;
else ttl = kLLQ_DefLease;
}
else {
if (ttl > 0x8000000UL) ttl = 0x8000000UL;
ttl += ttl/4 + 2;
if (ttl < 15) ttl = 15;
}
return ttl;
}
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)
{
int i;
mDNSBool ResponseMCast = dstaddr && mDNSAddrIsDNSMulticast(dstaddr);
mDNSBool ResponseSrcLocal = !srcaddr || AddressIsLocalSubnet(m, InterfaceID, srcaddr);
uDNS_LLQType LLQType = uDNS_recvLLQResponse(m, response, end, srcaddr, srcport);
CacheRecord *CacheFlushRecords = (CacheRecord*)1;
CacheRecord **cfp = &CacheFlushRecords;
int totalrecords = response->h.numAnswers + response->h.numAuthorities + response->h.numAdditionals;
const mDNSu8 *ptr = response->data;
(void)srcport;
(void)dstport;
debugf("Received Response from %#-15a addressed to %#-15a on %p with "
"%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s LLQType %d",
srcaddr, dstaddr, InterfaceID,
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", LLQType);
if (ResponseMCast || LLQType == uDNS_LLQ_Events || (response->h.flags.b[0] & kDNSFlag0_TC))
ptr = LocateAnswers(response, end);
else
{
for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
{
DNSQuestion q;
ptr = getQuestion(response, ptr, end, InterfaceID, &q);
if (ptr && ExpectingUnicastResponseForQuestion(m, response->h.id, &q))
{
CacheRecord *rr;
const mDNSu32 slot = HashSlot(&q.qname);
CacheGroup *cg = CacheGroupForName(m, slot, q.qnamehash, &q.qname);
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (SameNameRecordAnswersQuestion(&rr->resrec, &q))
{
rr->TimeRcvd = m->timenow - rr->resrec.rroriginalttl * mDNSPlatformOneSecond;
rr->UnansweredQueries = MaxUnansweredQueries;
}
}
}
}
for (i = 0; i < totalrecords && ptr && ptr < end; i++)
{
mDNSBool AcceptableResponse = ResponseMCast || !dstaddr || LLQType;
const mDNSu8 RecordType = (mDNSu8)((i < response->h.numAnswers) ? kDNSRecordTypePacketAns : kDNSRecordTypePacketAdd);
ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &m->rec);
if (!ptr) goto exit; if (m->rec.r.resrec.rrtype == kDNSType_OPT || m->rec.r.resrec.rrtype == kDNSType_TSIG)
{ m->rec.r.resrec.RecordType = 0; continue; }
if (!mDNSOpaque16IsZero(response->h.id))
m->rec.r.resrec.rroriginalttl = GetEffectiveTTL(LLQType, m->rec.r.resrec.rroriginalttl);
if (!AcceptableResponse) AcceptableResponse = ExpectingUnicastResponseForRecord(m, srcaddr, ResponseSrcLocal, response->h.id, &m->rec.r);
if (mDNSOpaque16IsZero(response->h.id))
{
if (m->CurrentRecord)
LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (!AcceptableResponse && !(ResponseSrcLocal && rr->resrec.RecordType == kDNSRecordTypeUnique)) continue;
if (PacketRRMatchesSignature(&m->rec.r, rr)) {
if (m->rec.r.resrec.rrtype == rr->resrec.rrtype && SameRData(&m->rec.r.resrec, &rr->resrec))
{
if (m->rec.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState)
{
if (rr->ImmedAnswer == InterfaceID) { rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse; }
}
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 (m->rec.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &m->rec.r))
{
debugf("mDNSCoreReceiveResponse: Our Record: %08lX %s", rr-> resrec.rdatahash, ARDisplayString(m, rr));
debugf("mDNSCoreReceiveResponse: Pkt Record: %08lX %s", m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.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 (m->rec.r.resrec.rrtype == rr->resrec.rrtype)
if ((m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && m->timenow - rr->LastMCTime > mDNSPlatformOneSecond/2)
{ rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
}
}
}
if (m->rrcache_size && AcceptableResponse)
{
const mDNSu32 slot = HashSlot(m->rec.r.resrec.name);
CacheGroup *cg = CacheGroupForRecord(m, slot, &m->rec.r.resrec);
CacheRecord *rr;
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
{
if (rr->resrec.InterfaceID == InterfaceID && IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec))
{
if (m->rec.r.resrec.rdlength > InlineCacheRDSize)
verbosedebugf("Found record size %5d interface %p already in cache: %s",
m->rec.r.resrec.rdlength, InterfaceID, CRDisplayString(m, &m->rec.r));
rr->TimeRcvd = m->timenow;
if (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask)
{
if (rr->NextInCFList == mDNSNULL && cfp != &rr->NextInCFList && LLQType != uDNS_LLQ_Events)
{ *cfp = rr; cfp = &rr->NextInCFList; *cfp = (CacheRecord*)1; }
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 = m->rec.r.resrec.RecordType;
}
}
if (!mDNSPlatformMemSame(m->rec.r.resrec.rdata->u.data, rr->resrec.rdata->u.data, m->rec.r.resrec.rdlength))
{
rr->resrec.rroriginalttl = 0;
rr->UnansweredQueries = MaxUnansweredQueries;
SetNextCacheCheckTime(m, rr);
}
else if (m->rec.r.resrec.rroriginalttl > 0)
{
RefreshCacheRecord(m, rr, m->rec.r.resrec.rroriginalttl);
break;
}
else
{
rr->resrec.rroriginalttl = 1;
rr->UnansweredQueries = MaxUnansweredQueries;
SetNextCacheCheckTime(m, rr);
break;
}
}
}
if (!rr && m->rec.r.resrec.rroriginalttl > 0)
{
rr = CreateNewCacheEntry(m, slot, cg);
if (rr && (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) && LLQType != uDNS_LLQ_Events)
{ *cfp = rr; cfp = &rr->NextInCFList; *cfp = (CacheRecord*)1; }
}
}
m->rec.r.resrec.RecordType = 0; }
exit:
m->rec.r.resrec.RecordType = 0;
while (CacheFlushRecords != (CacheRecord*)1)
{
CacheRecord *r1 = CacheFlushRecords, *r2;
const mDNSu32 slot = HashSlot(r1->resrec.name);
const CacheGroup *cg = CacheGroupForRecord(m, slot, &r1->resrec);
CacheFlushRecords = CacheFlushRecords->NextInCFList;
r1->NextInCFList = mDNSNULL;
for (r2 = cg ? cg->members : mDNSNULL; r2; r2=r2->next)
if (r1->resrec.InterfaceID == r2->resrec.InterfaceID &&
r1->resrec.rrtype == r2->resrec.rrtype &&
r1->resrec.rrclass == r2->resrec.rrclass)
if (RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond)
{
if (m->timenow - r2->TimeRcvd < mDNSPlatformOneSecond)
{
if (r2->resrec.rroriginalttl != r1->resrec.rroriginalttl && r1->resrec.rroriginalttl > 1)
{
if (r2->resrec.rroriginalttl != 240 && r1->resrec.rroriginalttl != 60 && r2->resrec.rrtype != kDNSType_TXT &&
mDNSOpaque16IsZero(response->h.id))
LogMsg("Correcting TTL from %4d to %4d for %s",
r2->resrec.rroriginalttl, r1->resrec.rroriginalttl, CRDisplayString(m, r2));
r2->resrec.rroriginalttl = r1->resrec.rroriginalttl;
}
}
else {
verbosedebugf("Cache flush %p X %p %s", r1, r2, CRDisplayString(m, r2));
r2->resrec.rroriginalttl = 1;
r2->UnansweredQueries = MaxUnansweredQueries;
}
r2->TimeRcvd = m->timenow;
SetNextCacheCheckTime(m, r2);
}
if (r1->DelayDelivery) {
r1->DelayDelivery = CheckForSoonToExpireRecords(m, r1->resrec.name, r1->resrec.namehash, slot);
if (!r1->DelayDelivery) CacheRecordDeferredAdd(m, r1);
}
}
ptr = response->data;
for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
{
DNSQuestion q;
ptr = getQuestion(response, ptr, end, InterfaceID, &q);
if (ptr && ExpectingUnicastResponseForQuestion(m, response->h.id, &q))
{
CacheRecord *rr;
mDNSu32 slot = HashSlot(&q.qname);
CacheGroup *cg = CacheGroupForName(m, slot, q.qnamehash, &q.qname);
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (SameNameRecordAnswersQuestion(&rr->resrec, &q))
{
if (rr->resrec.rroriginalttl) break;
if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) break;
}
if (!rr || rr->resrec.RecordType == kDNSRecordTypePacketNegative)
{
mDNSu32 negttl = 60;
int repeat = 0;
const domainname *name = &q.qname;
mDNSu32 hash = q.qnamehash;
if (response->h.numAuthorities && (ptr = LocateAuthorities(response, end)) != mDNSNULL)
{
ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
if (ptr && m->rec.r.resrec.rrtype == kDNSType_SOA)
{
mDNSu32 ttl_s = m->rec.r.resrec.rroriginalttl < m->rec.r.resrec.rdata->u.soa.min ?
m->rec.r.resrec.rroriginalttl : m->rec.r.resrec.rdata->u.soa.min;
if (negttl < ttl_s) negttl = ttl_s;
if (q.qtype == kDNSType_SOA)
{
int qcount = CountLabels(&q.qname);
int scount = CountLabels(m->rec.r.resrec.name);
if (qcount - 1 > scount)
if (SameDomainName(SkipLeadingLabels(&q.qname, qcount - scount), m->rec.r.resrec.name))
repeat = qcount - 1 - scount;
}
}
m->rec.r.resrec.RecordType = 0; }
if (rr)
{
if (negttl < rr->resrec.rroriginalttl * 2)
negttl = rr->resrec.rroriginalttl * 2;
if (negttl > 3600)
negttl = 3600;
}
negttl = GetEffectiveTTL(LLQType, negttl);
if (rr) LogOperation("Renewing negative TTL from %d to %d %s", rr->resrec.rroriginalttl, negttl, CRDisplayString(m, rr));
if (rr)
RefreshCacheRecord(m, rr, negttl);
else while (1)
{
LogOperation("Making negative cache entry TTL %d for %##s (%s)", negttl, name->c, DNSTypeName(q.qtype));
MakeNegativeCacheRecord(m, name, hash, q.qtype, q.qclass, negttl);
CreateNewCacheEntry(m, slot, cg);
m->rec.r.resrec.RecordType = 0; if (!repeat) break;
repeat--;
name = (const domainname *)(name->c + 1 + name->c[0]);
hash = DomainNameHashValue(name);
slot = HashSlot(name);
cg = CacheGroupForName(m, slot, hash, name);
}
}
}
}
}
mDNSexport void MakeNegativeCacheRecord(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds)
{
m->rec.r.resrec.RecordType = kDNSRecordTypePacketNegative;
m->rec.r.resrec.InterfaceID = mDNSInterface_Any;
m->rec.r.resrec.name = name; m->rec.r.resrec.rrtype = rrtype;
m->rec.r.resrec.rrclass = rrclass;
m->rec.r.resrec.rroriginalttl = ttl_seconds;
m->rec.r.resrec.rdlength = 0;
m->rec.r.resrec.rdestimate = 0;
m->rec.r.resrec.namehash = namehash;
m->rec.r.resrec.rdatahash = 0;
m->rec.r.resrec.rdata = (RData*)&m->rec.r.rdatastorage;
m->rec.r.resrec.rdata->MaxRDLength = m->rec.r.resrec.rdlength;
m->rec.r.NextInKAList = mDNSNULL;
m->rec.r.TimeRcvd = m->timenow;
m->rec.r.DelayDelivery = 0;
m->rec.r.NextRequiredQuery = m->timenow;
m->rec.r.LastUsed = m->timenow;
m->rec.r.CRActiveQuestion = mDNSNULL;
m->rec.r.UnansweredQueries = 0;
m->rec.r.LastUnansweredTime = 0;
m->rec.r.MPUnansweredQ = 0;
m->rec.r.MPLastUnansweredQT = 0;
m->rec.r.MPUnansweredKA = 0;
m->rec.r.MPExpectingKA = mDNSfalse;
m->rec.r.NextInCFList = mDNSNULL;
}
mDNSexport void mDNSCoreReceive(mDNS *const m, void *const pkt, const mDNSu8 *const end,
const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, const mDNSIPPort dstport,
const mDNSInterfaceID InterfaceID)
{
mDNSInterfaceID ifid = InterfaceID;
DNSMessage *msg = (DNSMessage *)pkt;
const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery;
const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
const mDNSu8 UpdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update;
mDNSu8 QR_OP;
mDNSu8 *ptr = mDNSNULL;
mDNSBool TLS = (dstaddr == (mDNSAddr *)1); if (TLS) dstaddr = mDNSNULL;
#ifndef UNICAST_DISABLED
if (mDNSSameAddress(srcaddr, &m->Router))
{
if (mDNSSameIPPort(srcport, NATPMPPort))
{
mDNS_Lock(m);
uDNS_ReceiveNATPMPPacket(m, InterfaceID, pkt, (mDNSu16)(end - (mDNSu8 *)pkt));
mDNS_Unlock(m);
return;
}
#ifdef _LEGACY_NAT_TRAVERSAL_
if (mDNSSameIPPort(srcport, SSDPPort))
{
mDNS_Lock(m);
LNT_ConfigureRouterInfo(m, InterfaceID, pkt, (mDNSu16)(end - (mDNSu8 *)pkt));
mDNS_Unlock(m);
return;
}
#endif
}
#endif
if ((unsigned)(end - (mDNSu8 *)pkt) < sizeof(DNSMessageHeader)) { LogMsg("DNS Message too short"); return; }
QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
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 (srcaddr && !mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; }
mDNS_Lock(m);
m->PktNum++;
#ifndef UNICAST_DISABLED
if (!dstaddr || (!mDNSAddressIsAllDNSLinkGroup(dstaddr) && (QR_OP == StdR || QR_OP == UpdR)))
{
if (!mDNSOpaque16IsZero(msg->h.id)) ifid = mDNSInterface_Any;
if (mDNS_LogLevel >= MDNS_LOG_VERBOSE_DEBUG)
DumpPacket(m, mDNSfalse, TLS ? "TLS" : !dstaddr ? "TCP" : "UDP", srcaddr, srcport, msg, end);
uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport);
}
#endif
if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid);
else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid);
else if (QR_OP != UpdR)
{
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 - Searcher Functions
#endif
#define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \
(mDNSSameAddress(&(A)->Target, &(B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort)))
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->AuthInfo == question->AuthInfo && q->LongLived == question->LongLived && q->qnamehash == question->qnamehash &&
SameDomainName(&q->qname, &question->qname)) return(q);
return(mDNSNULL);
}
mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (q->DuplicateOf == question) if ((q->DuplicateOf = FindDuplicateQuestion(m, q)) == mDNSNULL)
{
q->LastQTime = question->LastQTime;
q->ThisQInterval = question->ThisQInterval;
q->ExpectUnicastResp = question->ExpectUnicastResp;
q->LastAnswerPktNum = question->LastAnswerPktNum;
q->RecentAnswerPkts = question->RecentAnswerPkts;
q->RequestUnicast = question->RequestUnicast;
q->LastQTxTime = question->LastQTxTime;
q->CNAMEReferrals = question->CNAMEReferrals;
q->nta = question->nta;
q->servAddr = question->servAddr;
q->servPort = question->servPort;
q->state = question->state;
q->eventPort = question->eventPort;
q->origLease = question->origLease;
q->expire = question->expire;
q->ntries = question->ntries;
q->id = question->id;
question->nta = mDNSNULL; if (q->nta)
{
LogOperation("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
q->nta->ZoneDataContext = q;
}
if (question->tcp) LogOperation("UpdateQuestionDuplicates did not transfer tcp pointer");
SetNextQueryTime(m,q);
}
}
mDNSlocal DNSServer *GetServerForName(mDNS *m, const domainname *name)
{
DNSServer *curmatch = mDNSNULL, *p;
int curmatchlen = -1, ncount = name ? CountLabels(name) : 0;
for (p = m->DNSServers; p; p = p->next)
{
int scount = CountLabels(&p->domain);
if (!p->del && ncount >= scount && scount > curmatchlen)
if (SameDomainName(SkipLeadingLabels(name, ncount - scount), &p->domain))
{ curmatch = p; curmatchlen = scount; }
}
return(curmatch);
}
#define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \
(mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort)))
mDNSlocal void ActivateUnicastQuery(mDNS *const m, DNSQuestion *const question)
{
#if APPLE_OSX_mDNSResponder
if (question->qtype == kDNSType_AAAA && question->AuthInfo && question->AuthInfo->AutoTunnel && question->QuestionCallback != AutoTunnelCallback)
{
question->NoAnswer = NoAnswer_Suspended;
AddNewClientTunnel(m, question);
return;
}
#endif // APPLE_OSX_mDNSResponder
if (!question->DuplicateOf)
{
if (question->LongLived)
{
question->ThisQInterval = 0; question->LastQTime = m->timenow;
LogOperation("uDNS_InitLongLivedQuery: %##s %s %s %d",
question->qname.c, DNSTypeName(question->qtype), question->AuthInfo ? "(Private)" : "", question->ThisQInterval);
if (question->nta) CancelGetZoneData(m, question->nta);
question->state = LLQ_GetZoneInfo; question->nta = StartGetZoneData(m, &question->qname, ZoneServiceLLQ, startLLQHandshakeCallback, question);
if (!question->nta) LogMsg("ERROR: startLLQ - StartGetZoneData failed");
}
else
{
question->ThisQInterval = InitialQuestionInterval;
question->LastQTime = m->timenow - question->ThisQInterval;
}
}
}
mDNSexport mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question)
{
if (question->Target.type && !ValidQuestionTarget(question))
{
LogMsg("Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery?)",
question->Target.type, mDNSVal16(question->TargetPort));
question->Target.type = mDNSAddrType_None;
}
if (!question->Target.type) {
question->TargetPort = zeroIPPort;
question->TargetQID = zeroID;
}
#ifndef UNICAST_DISABLED
if (question->InterfaceID == mDNSInterface_LocalOnly || question->ForceMCast || IsLocalDomain(&question->qname))
question->TargetQID = zeroID;
else
question->TargetQID = mDNS_NewMessageID(m);
#else
question->TargetQID = zeroID;
#endif // UNICAST_DISABLED
debugf("mDNS_StartQuery: %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
if (m->rrcache_size == 0) return(mStatus_NoCache);
else
{
int i;
DNSQuestion **q;
if (!ValidateDomainName(&question->qname))
{
LogMsg("Attempt to start query with invalid qname %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
return(mStatus_Invalid);
}
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);
}
*q = question;
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)
LogMsg("Note: InterfaceID %p for question %##s (%s) not currently found in active interface list",
question->InterfaceID, question->qname.c, DNSTypeName(question->qtype));
}
question->next = mDNSNULL;
question->qnamehash = DomainNameHashValue(&question->qname); question->DelayAnswering = CheckForSoonToExpireRecords(m, &question->qname, question->qnamehash, HashSlot(&question->qname));
question->LastQTime = m->timenow;
question->ThisQInterval = InitialQuestionInterval; question->ExpectUnicastResp = 0;
question->LastAnswerPktNum = m->PktNum;
question->RecentAnswerPkts = 0;
question->CurrentAnswers = 0;
question->LargeAnswers = 0;
question->UniqueAnswers = 0;
question->FlappingInterface1 = mDNSNULL;
question->FlappingInterface2 = mDNSNULL;
question->AuthInfo = (question->QuestionCallback == GetZoneData_QuestionCallback) ? mDNSNULL
: GetAuthInfoForName_internal(m, &question->qname);
question->DuplicateOf = FindDuplicateQuestion(m, question);
question->NextInDQList = mDNSNULL;
question->SendQNow = mDNSNULL;
question->SendOnAll = mDNSfalse;
question->RequestUnicast = 0;
question->LastQTxTime = m->timenow;
question->CNAMEReferrals = 0;
question->qDNSServer = mDNSNULL;
question->nta = mDNSNULL;
question->servAddr = zeroAddr;
question->servPort = zeroIPPort;
question->tcp = mDNSNULL;
question->NoAnswer = NoAnswer_Normal;
question->state = LLQ_GetZoneInfo;
mDNSPlatformMemZero(&question->NATInfoUDP, sizeof(question->NATInfoUDP));
question->eventPort = zeroIPPort;
question->origLease = 0;
question->expire = 0;
question->ntries = 0;
question->id = zeroOpaque64;
for (i=0; i<DupSuppressInfoSize; i++)
question->DupSuppress[i].InterfaceID = mDNSNULL;
if (!question->DuplicateOf)
debugf("mDNS_StartQuery: Question %##s (%s) %p %d (%p) started",
question->qname.c, DNSTypeName(question->qtype), question->InterfaceID,
question->LastQTime + question->ThisQInterval - m->timenow, question);
else
debugf("mDNS_StartQuery: Question %##s (%s) %p %d (%p) duplicate of (%p)",
question->qname.c, DNSTypeName(question->qtype), question->InterfaceID,
question->LastQTime + question->ThisQInterval - m->timenow, question, question->DuplicateOf);
if (question->InterfaceID == mDNSInterface_LocalOnly)
{
if (!m->NewLocalOnlyQuestions) m->NewLocalOnlyQuestions = question;
}
else
{
if (!m->NewQuestions) m->NewQuestions = question;
if (!mDNSOpaque16IsZero(question->TargetQID))
{
question->qDNSServer = GetServerForName(m, &question->qname);
ActivateUnicastQuery(m, question);
}
SetNextQueryTime(m,question);
}
return(mStatus_NoError);
}
}
mDNSexport void CancelGetZoneData(mDNS *const m, ZoneData *nta)
{
LogOperation("CancelGetZoneData %##s (%s)", nta->question.qname.c, DNSTypeName(nta->question.qtype));
mDNS_StopQuery_internal(m, &nta->question);
mDNSPlatformMemFree(nta);
}
mDNSexport mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question)
{
const mDNSu32 slot = HashSlot(&question->qname);
CacheGroup *cg = CacheGroupForName(m, slot, question->qnamehash, &question->qname);
CacheRecord *rr;
DNSQuestion **q = &m->Questions;
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));
#if ForceAlerts
*(long*)0 = 0;
#endif
return(mStatus_BadReferenceErr);
}
UpdateQuestionDuplicates(m, question);
question->ThisQInterval = -1;
for (rr = cg ? cg->members : mDNSNULL; 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;
debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s", q, CRDisplayString(m,rr));
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;
if (question->nta) CancelGetZoneData(m, question->nta);
if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; }
if (!mDNSOpaque16IsZero(question->TargetQID) && question->LongLived) uDNS_StopLongLivedQuery(m, question);
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_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question)
{
mStatus status;
DNSQuestion *qq;
mDNS_Lock(m);
for (qq = m->NewQuestions; qq; qq=qq->next) if (qq == question) break;
status = mDNS_StopQuery_internal(m, question);
if (status == mStatus_NoError && !qq)
{
CacheRecord *rr;
const mDNSu32 slot = HashSlot(&question->qname);
CacheGroup *const cg = CacheGroupForName(m, slot, question->qnamehash, &question->qname);
LogOperation("Generating terminal removes for %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
if (rr->resrec.RecordType != kDNSRecordTypePacketNegative && SameNameRecordAnswersQuestion(&rr->resrec, question))
{
if (question->QuestionCallback)
question->QuestionCallback(m, question, &rr->resrec, mDNSfalse);
}
}
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const cr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0);
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);
debugf("mDNS_ReconfirmByValue: %p %s", cr, RRDisplayString(m, rr));
if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0);
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, mDNSBool ForceMCast, mDNSQuestionCallback *Callback, void *Context)
{
question->InterfaceID = InterfaceID;
question->Target = zeroAddr;
question->qtype = kDNSType_PTR;
question->qclass = kDNSClass_IN;
question->LongLived = mDNSfalse;
question->ExpectUnique = mDNSfalse;
question->ForceMCast = ForceMCast;
question->ReturnIntermed = mDNSfalse;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) return(mStatus_BadParamErr);
#ifndef UNICAST_DISABLED
if (question->InterfaceID != mDNSInterface_LocalOnly && !question->ForceMCast && !IsLocalDomain(&question->qname))
{
question->LongLived = mDNStrue;
question->ThisQInterval = InitialQuestionInterval;
question->LastQTime = m->timenow - question->ThisQInterval;
}
#endif // UNICAST_DISABLED
return(mDNS_StartQuery(m, question));
}
mDNSlocal mDNSBool MachineHasActiveIPv6(mDNS *const m)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->ip.type == mDNSAddrType_IPv6) return(mDNStrue);
return(mDNSfalse);
}
mDNSlocal void FoundServiceInfoSRV(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
mDNSBool PortChanged = !mDNSSameIPPort(query->info->port, answer->rdata->u.srv.port);
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(m, &query->qAv4);
if (MachineHasActiveIPv6(m)) mDNS_StartQuery(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(m, &query->qAv4);
if (query->qAv6.ThisQInterval >= 0) mDNS_StopQuery(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 (%s)", query->qAv4.qname.c, DNSTypeName(query->qAv4.qtype));
mDNS_StartQuery(m, &query->qAv4);
if (MachineHasActiveIPv6(m)) mDNS_StartQuery(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, QC_result 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(query->info->TXTinfo, answer->rdata->u.txt.c, 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, QC_result 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.ipv4;
}
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%ld: %##s GotTXT=%d", query->info->ip.type, query->info->name.c, query->GotTXT);
if (query->ServiceInfoQueryCallback && query->GotTXT)
{
if (++query->Answers >= 100)
debugf(answer->rrtype == kDNSType_A ?
"**** WARNING **** have given %lu answers for %##s (A) %.4a" :
"**** WARNING **** have given %lu answers for %##s (AAAA) %.16a",
query->Answers, query->qSRV.qname.c, &answer->rdata->u.data);
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.LongLived = mDNSfalse;
query->qSRV.ExpectUnique = mDNStrue;
query->qSRV.ForceMCast = mDNSfalse;
query->qSRV.ReturnIntermed = mDNSfalse;
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.LongLived = mDNSfalse;
query->qTXT.ExpectUnique = mDNStrue;
query->qTXT.ForceMCast = mDNSfalse;
query->qTXT.ReturnIntermed = mDNSfalse;
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.LongLived = mDNSfalse;
query->qAv4.ExpectUnique = mDNStrue;
query->qAv4.ForceMCast = mDNSfalse;
query->qAv4.ReturnIntermed = mDNSfalse;
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.LongLived = mDNSfalse;
query->qAv6.ExpectUnique = mDNStrue;
query->qAv6.ForceMCast = mDNSfalse;
query->qAv6.ReturnIntermed = mDNSfalse;
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 *q)
{
mDNS_Lock(m);
if (q->qSRV.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qSRV);
if (q->qTXT.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qTXT);
if (q->qAv4.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qAv4);
if (q->qAv6.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->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->LongLived = mDNSfalse;
question->ExpectUnique = mDNSfalse;
question->ForceMCast = mDNSfalse;
question->ReturnIntermed = mDNSfalse;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
if (DomainType > mDNS_DomainTypeMax) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
if (!dom) dom = &localdomain;
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 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)
{
#ifndef UNICAST_DISABLED
mDNSBool unicast = !(rr->resrec.InterfaceID == mDNSInterface_LocalOnly || IsLocalDomain(rr->resrec.name));
#else
mDNSBool unicast = mDNSfalse;
#endif
if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata))
{
LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(&rr->resrec, &newrdata->u, m->MsgBuffer));
return(mStatus_Invalid);
}
mDNS_Lock(m);
if (newttl == 0) newttl = rr->resrec.rroriginalttl;
if (!unicast && 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 (unicast) { mStatus status = uDNS_UpdateRecord(m, rr); mDNS_Unlock(m); return(status); }
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);
rr->AnnounceCount = InitialAnnounceCount;
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 = NonZeroTime(m->timenow + kUpdateCreditRefreshInterval);
if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1);
if (rr->UpdateCredits <= 5)
{
mDNSu32 delay = 6 - rr->UpdateCredits; if (!rr->UpdateBlocked) rr->UpdateBlocked = NonZeroTime(m->timenow + (mDNSs32)delay * mDNSPlatformOneSecond);
rr->ThisAPInterval *= 4;
rr->LastAPTime = rr->UpdateBlocked - rr->ThisAPInterval;
LogMsg("Excessive update rate for %##s; delaying announcement by %ld 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);
}
mDNSlocal 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[MAX_REVERSE_MAPPING_NAME];
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
if (!primary) primary = set;
mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kHostNameTTL, kDNSRecordTypeUnique, mDNS_HostNameCallback, set);
mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kHostNameTTL, kDNSRecordTypeUnique, mDNSNULL, mDNSNULL);
#if ANSWER_REMOTE_HOSTNAME_QUERIES
set->RR_A .AllowRemoteQuery = mDNStrue;
set->RR_PTR .AllowRemoteQuery = mDNStrue;
set->RR_HINFO.AllowRemoteQuery = mDNStrue;
#endif
AssignDomainName(&set->RR_A.namestorage, &m->MulticastHostname);
if (set->ip.type == mDNSAddrType_IPv4)
{
set->RR_A.resrec.rrtype = kDNSType_A;
set->RR_A.resrec.rdata->u.ipv4 = 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.namestorage, buffer);
set->RR_PTR.AutoTarget = Target_AutoHost; set->RR_PTR.ForceMCast = mDNStrue;
set->RR_A.RRSet = &primary->RR_A;
mDNS_Register_internal(m, &set->RR_A);
mDNS_Register_internal(m, &set->RR_PTR);
if (!NO_HINFO && 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.namestorage, &m->MulticastHostname);
set->RR_HINFO.DependentOn = &set->RR_A;
mDNSPlatformMemCopy(p, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]);
p += 1 + (int)p[0];
mDNSPlatformMemCopy(p, &m->HISoftware, 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);
}
mDNSexport void mDNS_SetFQDN(mDNS *const m)
{
domainname newmname;
NetworkInterfaceInfo *intf;
AuthRecord *rr;
newmname.c[0] = 0;
if (!AppendDomainLabel(&newmname, &m->hostlabel)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
if (!AppendLiteralLabelString(&newmname, "local")) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
if (SameDomainNameCS(&m->MulticastHostname, &newmname)) { LogMsg("mDNS_SetFQDN - hostname unchanged"); return; }
mDNS_Lock(m);
AssignDomainName(&m->MulticastHostname, &newmname);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise) DeadvertiseInterface(m, intf);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise) AdvertiseInterface(m, intf);
for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->AutoTarget) SetTargetToHostName(m, rr);
for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->AutoTarget) SetTargetToHostName(m, rr);
mDNS_Unlock(m);
}
mDNSlocal 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->MainCallback(m, mStatus_NoError);
}
else if (result == mStatus_NameConflict)
{
domainlabel oldlabel = m->hostlabel;
if (m->MainCallback)
m->MainCallback(m, mStatus_NameConflict);
if (SameDomainLabelCS(m->hostlabel.c, oldlabel.c))
IncrementLabelSuffix(&m->hostlabel, mDNSfalse);
mDNS_SetFQDN(m);
LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead", oldlabel.c, m->hostlabel.c);
}
else if (result == mStatus_MemFree)
{
debugf("mDNS_HostNameCallback: MemFree (ignored)");
}
else
LogMsg("mDNS_HostNameCallback: Unknown error %ld 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 flapping)
{
mDNSBool FirstOfType = mDNStrue;
NetworkInterfaceInfo **p = &m->HostInterfaces;
if (!set->InterfaceID)
{ LogMsg("Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID", &set->ip); return(mStatus_Invalid); }
if (!mDNSAddressIsValidNonZero(&set->mask))
{ LogMsg("Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a", &set->ip, &set->mask); return(mStatus_Invalid); }
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;
if (set->Advertise)
AdvertiseInterface(m, set);
LogOperation("mDNS_RegisterInterface: InterfaceID %p %s (%#a) %s", set->InterfaceID, set->ifname, &set->ip,
set->InterfaceActive ?
"not represented in list; marking active and retriggering queries" :
"already represented in list; marking inactive for now");
if (set->McastTxRx && ((m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) || FirstOfType || set->InterfaceActive))
{
DNSQuestion *q;
AuthRecord *rr;
mDNSs32 delay = flapping ? mDNSPlatformOneSecond * 5 : 0;
mDNSu8 announce = flapping ? (mDNSu8)1 : InitialAnnounceCount;
if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
if (flapping)
{
LogMsg("Note: Frequent transitions for interface %s (%#a); network traffic reduction measures in effect", set->ifname, &set->ip);
if (!m->SuppressProbes ||
m->SuppressProbes - (m->timenow + delay) < 0)
m->SuppressProbes = (m->timenow + delay);
}
for (q = m->Questions; q; q=q->next) if (mDNSOpaque16IsZero(q->TargetQID))
if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) { mDNSBool dodelay = flapping && (q->FlappingInterface1 == set->InterfaceID || q->FlappingInterface2 == set->InterfaceID);
mDNSs32 initial = dodelay ? InitialQuestionInterval * QuestionIntervalStep2 : InitialQuestionInterval;
mDNSs32 qdelay = dodelay ? mDNSPlatformOneSecond * 5 : 0;
if (dodelay) LogOperation("No cache records for expired %##s (%s); okay to delay questions a little", q->qname.c, DNSTypeName(q->qtype));
if (!q->ThisQInterval || q->ThisQInterval > initial)
{
q->ThisQInterval = initial;
q->RequestUnicast = 2; }
q->LastQTime = m->timenow - q->ThisQInterval + qdelay;
q->RecentAnswerPkts = 0;
SetNextQueryTime(m,q);
}
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 < announce) rr->AnnounceCount = announce;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
}
mDNS_Unlock(m);
return(mStatus_NoError);
}
mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping)
{
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)
{
LogOperation("mDNS_DeregisterInterface: Another representative of InterfaceID %p %s (%#a) exists;"
" making it active", set->InterfaceID, set->ifname, &set->ip);
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
{
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *rr;
DNSQuestion *q;
DNSServer *s;
LogOperation("mDNS_DeregisterInterface: Last representative of InterfaceID %p %s (%#a) deregistered;"
" marking questions etc. dormant", set->InterfaceID, set->ifname, &set->ip);
if (flapping)
LogMsg("Note: Frequent transitions for interface %s (%#a); network traffic reduction measures in effect",
set->ifname, &set->ip);
for (q = m->Questions; q; q=q->next)
{
if (q->InterfaceID == set->InterfaceID) q->ThisQInterval = 0;
if (!q->InterfaceID || q->InterfaceID == set->InterfaceID)
{
q->FlappingInterface2 = q->FlappingInterface1;
q->FlappingInterface1 = set->InterfaceID; }
}
revalidate = mDNSfalse; FORALL_CACHERECORDS(slot, cg, rr)
if (rr->resrec.InterfaceID == set->InterfaceID)
{
if (!flapping) mDNS_PurgeCacheResourceRecord(m, rr);
else
{
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface);
rr->UnansweredQueries = MaxUnansweredQueries;
}
}
for (s = m->DNSServers; s; s = s->next)
if (s->interface == set->InterfaceID)
{
s->interface = mDNSInterface_Any;
s->teststate = DNSServer_Disabled;
}
}
}
if (set->Advertise) DeadvertiseInterface(m, set);
if (revalidate && !m->mDNS_shutdown)
{
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *rr;
m->NextCacheCheck = m->timenow;
FORALL_CACHERECORDS(slot, cg, rr)
if (rr->resrec.InterfaceID == set->InterfaceID)
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface);
}
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_NoError && rr != &sr->RR_SRV) return;
if (result == mStatus_NameConflict)
{
sr->Conflict = mDNStrue; 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);
}
mDNSlocal void NSSCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext;
if (sr->ServiceCallback)
sr->ServiceCallback(m, sr, result);
}
mDNSlocal mStatus uDNS_RegisterService(mDNS *const m, ServiceRecordSet *srs)
{
mDNSu32 i;
ServiceRecordSet **p = &m->ServiceRegistrations;
while (*p && *p != srs) p=&(*p)->uDNS_next;
if (*p) { LogMsg("uDNS_RegisterService: %p %##s already in list", srs, srs->RR_SRV.resrec.name->c); return(mStatus_AlreadyRegistered); }
srs->uDNS_next = mDNSNULL;
*p = srs;
srs->RR_SRV.resrec.rroriginalttl = kHostNameTTL;
srs->RR_TXT.resrec.rroriginalttl = kStandardTTL;
srs->RR_PTR.resrec.rroriginalttl = kStandardTTL;
for (i = 0; i < srs->NumSubTypes;i++) srs->SubTypes[i].resrec.rroriginalttl = kStandardTTL;
srs->srs_uselease = mDNStrue;
if (srs->RR_SRV.AutoTarget)
{
DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, srs->RR_SRV.resrec.name);
if (!AuthInfo || !AuthInfo->AutoTunnel) srs->RR_SRV.AutoTarget = Target_AutoHostAndNATMAP;
}
if (!GetServiceTarget(m, srs))
{
debugf("uDNS_RegisterService - no target for %##s", srs->RR_SRV.resrec.name->c);
srs->state = regState_NoTarget;
srs->nta = mDNSNULL;
return mStatus_NoError;
}
srs->state = regState_FetchingZoneData;
srs->nta = StartGetZoneData(m, srs->RR_SRV.resrec.name, ZoneServiceUpdate, ServiceRegistrationZoneDataComplete, srs);
return srs->nta ? mStatus_NoError : mStatus_NoMemoryErr;
}
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->state = regState_Zero;
sr->srs_uselease = 0;
sr->expire = 0;
sr->TestForSelfConflict = 0;
sr->Private = 0;
sr->id = zeroID;
sr->zone.c[0] = 0;
sr->ns = zeroAddr;
sr->SRSUpdatePort = zeroIPPort;
mDNSPlatformMemZero(&sr->NATinfo, sizeof(sr->NATinfo));
sr->ClientCallbackDeferred = 0;
sr->DeferredStatus = 0;
sr->SRVUpdateDeferred = 0;
sr->SRVChanged = 0;
sr->tcp = mDNSNULL;
sr->ServiceCallback = Callback;
sr->ServiceContext = Context;
sr->Conflict = mDNSfalse;
sr->Extras = mDNSNULL;
sr->NumSubTypes = NumSubTypes;
sr->SubTypes = SubTypes;
mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeAdvisory, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, kHostNameTTL, kDNSRecordTypeUnique, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kStandardTTL, kDNSRecordTypeUnique, ServiceCallback, sr);
if (mDNSIPPortIsZero(port))
return(mDNS_RegisterNoSuchService(m, &sr->RR_SRV, name, type, domain, mDNSNULL, mDNSInterface_Any, NSSCallback, sr));
if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen)
sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen;
if (ConstructServiceName(&sr->RR_ADV.namestorage, (const domainlabel*)"\x09_services", (const domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL)
return(mStatus_BadParamErr);
if (ConstructServiceName(&sr->RR_PTR.namestorage, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
if (ConstructServiceName(&sr->RR_SRV.namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
AssignDomainName(&sr->RR_TXT.namestorage, 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++)
{
domainname st;
AssignDomainName(&st, sr->SubTypes[i].resrec.name);
st.c[1+st.c[0]] = 0; AppendDomainName(&st, type);
mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, ServiceCallback, sr);
if (ConstructServiceName(&sr->SubTypes[i].namestorage, mDNSNULL, &st, domain) == mDNSNULL) return(mStatus_BadParamErr);
AssignDomainName(&sr->SubTypes[i].resrec.rdata->u.name, &sr->RR_SRV.namestorage);
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 (host && host->c[0]) AssignDomainName(&sr->RR_SRV.resrec.rdata->u.srv.target, host);
else { sr->RR_SRV.AutoTarget = Target_AutoHost; 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(sr->RR_TXT.resrec.rdata->u.txt.c, txtinfo, txtlen);
}
sr->RR_TXT.DependentOn = &sr->RR_SRV;
#ifndef UNICAST_DISABLED
if (!(InterfaceID == mDNSInterface_LocalOnly || IsLocalDomain(&sr->RR_SRV.namestorage)))
{
mStatus status;
mDNS_Lock(m);
if (!sr->RR_TXT.resrec.rdlength) { sr->RR_TXT.resrec.rdlength = 1; sr->RR_TXT.resrec.rdata->u.txt.c[0] = 0; }
status = uDNS_RegisterService(m, sr);
mDNS_Unlock(m);
return(status);
}
#endif
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);
}
mDNSlocal void DummyCallback(mDNS *const m, AuthRecord *rr, mStatus result)
{
(void)m; (void)rr; (void)result; LogOperation("DummyCallback %d %s", result, ARDisplayString(m, rr));
}
mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr,
ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl)
{
ExtraResourceRecord **e;
mStatus status;
extra->next = mDNSNULL;
mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID,
extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, ServiceCallback, sr);
AssignDomainName(&extra->r.namestorage, sr->RR_SRV.resrec.name);
mDNS_Lock(m);
e = &sr->Extras;
while (*e) e = &(*e)->next;
if (ttl == 0) ttl = kStandardTTL;
extra->r.DependentOn = &sr->RR_SRV;
debugf("mDNS_AddRecordToService adding record to %##s %s %d",
extra->r.resrec.name->c, DNSTypeName(extra->r.resrec.rrtype), extra->r.resrec.rdlength);
status = mDNS_Register_internal(m, &extra->r);
if (status == mStatus_NoError)
{
*e = extra;
#ifndef UNICAST_DISABLED
if (sr->RR_SRV.resrec.InterfaceID != mDNSInterface_LocalOnly && !IsLocalDomain(sr->RR_SRV.resrec.name))
{
extra->r.resrec.RecordType = kDNSRecordTypeShared; extra->r.RecordCallback = DummyCallback; if (sr->state != regState_Registered && sr->state != regState_Refresh) extra->r.state = regState_ExtraQueued;
}
#endif
}
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra,
mDNSRecordCallback MemFreeCallback, void *Context)
{
ExtraResourceRecord **e;
mStatus status;
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);
extra->r.RecordCallback = MemFreeCallback;
extra->r.RecordContext = Context;
*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;
const domainname *host = sr->RR_SRV.AutoTarget ? mDNSNULL : &sr->RR_SRV.resrec.rdata->u.srv.target;
ExtraResourceRecord *extras = sr->Extras;
mStatus err;
DeconstructServiceName(sr->RR_SRV.resrec.name, &name1, &type, &domain);
if (!newname)
{
name2 = name1;
IncrementLabelSuffix(&name2, mDNStrue);
newname = &name2;
}
if (SameDomainName(&domain, &localdomain))
LogMsg("%##s service renamed from \"%#s\" to \"%#s\"", type.c, name1.c, newname->c);
else LogMsg("%##s service (domain %##s) renamed from \"%#s\" to \"%#s\"",type.c, domain.c, name1.c, newname->c);
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 (mDNSIPPortIsZero(sr->RR_SRV.resrec.rdata->u.srv.port)) return(mDNS_DeregisterNoSuchService(m, &sr->RR_SRV));
#ifndef UNICAST_DISABLED
if (!(sr->RR_SRV.resrec.InterfaceID == mDNSInterface_LocalOnly || IsLocalDomain(sr->RR_SRV.resrec.name)))
{
mStatus status;
mDNS_Lock(m);
status = uDNS_DeregisterService(m, sr);
mDNS_Unlock(m);
return(status);
}
#endif
if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered)
{
debugf("Service set for %##s already deregistered", sr->RR_SRV.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_SRV.resrec.name->c);
sr->Conflict = mDNSfalse;
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, kHostNameTTL, kDNSRecordTypeUnique, Callback, Context);
if (ConstructServiceName(&rr->namestorage, 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->AutoTarget = Target_AutoHost;
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, kStandardTTL, kDNSRecordTypeShared, mDNSNULL, mDNSNULL);
if (!MakeDomainNameFromDNSNameString(&rr->namestorage, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr);
return(mDNS_Register(m, rr));
}
mDNSOpaque16 mDNS_NewMessageID(mDNS * const m)
{
static mDNSBool randomized = mDNSfalse;
if (!randomized) { m->NextMessageID = (mDNSu16)mDNSRandom(0xFFFF); randomized = mDNStrue; }
if (m->NextMessageID == 0) m->NextMessageID++;
return mDNSOpaque16fromIntVal(m->NextMessageID++);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Startup and Shutdown
#endif
mDNSlocal void mDNS_GrowCache_internal(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords)
{
if (storage && numrecords)
{
mDNSu32 i;
debugf("Adding cache storage for %d more records (%d bytes)", numrecords, numrecords*sizeof(CacheEntity));
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, CacheEntity *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,
CacheEntity *rrcachestorage, mDNSu32 rrcachesize,
mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context)
{
mDNSu32 slot;
mDNSs32 timenow;
mStatus result;
if (!rrcachestorage) rrcachesize = 0;
m->p = p;
m->KnownBugs = 0;
m->CanReceiveUnicastOn5353 = mDNSfalse; m->AdvertiseLocalAddresses = AdvertiseLocalAddresses;
m->mDNSPlatformStatus = mStatus_Waiting;
m->UnicastPort4 = zeroIPPort;
m->UnicastPort6 = zeroIPPort;
m->MainCallback = Callback;
m->MainContext = Context;
m->rec.r.resrec.RecordType = 0;
m->mDNS_busy = 0;
m->mDNS_reentrancy = 0;
m->mDNS_shutdown = mDNSfalse;
m->lock_rrcache = 0;
m->lock_Questions = 0;
m->lock_Records = 0;
result = mDNSPlatformTimeInit();
if (result != mStatus_NoError) return(result);
m->timenow_adjust = (mDNSs32)mDNSRandom(0xFFFFFFFF);
timenow = mDNS_TimeNow_NoLock(m);
m->timenow = 0; m->timenow_last = timenow;
m->NextScheduledEvent = timenow;
m->SuppressSending = timenow;
m->NextCacheCheck = timenow + 0x78000000;
m->NextScheduledQuery = timenow + 0x78000000;
m->NextScheduledProbe = timenow + 0x78000000;
m->NextScheduledResponse = timenow + 0x78000000;
m->NextScheduledNATOp = timenow + 0x78000000;
m->RandomQueryDelay = 0;
m->RandomReconfirmDelay = 0;
m->PktNum = 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;
mDNS_GrowCache_internal(m, rrcachestorage, rrcachesize);
m->hostlabel.c[0] = 0;
m->nicelabel.c[0] = 0;
m->MulticastHostname.c[0] = 0;
m->HIHardware.c[0] = 0;
m->HISoftware.c[0] = 0;
m->ResourceRecords = mDNSNULL;
m->DuplicateRecords = mDNSNULL;
m->NewLocalRecords = mDNSNULL;
m->CurrentRecord = mDNSNULL;
m->HostInterfaces = mDNSNULL;
m->ProbeFailTime = 0;
m->NumFailedProbes = 0;
m->SuppressProbes = 0;
#ifndef UNICAST_DISABLED
m->NextuDNSEvent = timenow + 0x78000000;
m->NextSRVUpdate = timenow + 0x78000000;
m->SuppressStdPort53Queries = 0;
m->ServiceRegistrations = mDNSNULL;
m->NextMessageID = 0;
m->DNSServers = mDNSNULL;
m->Router = zeroAddr;
m->AdvertisedV4 = zeroAddr;
m->AdvertisedV6 = zeroAddr;
m->AuthInfoList = mDNSNULL;
m->ReverseMap.ThisQInterval = -1;
m->StaticHostname.c[0] = 0;
m->FQDN.c[0] = 0;
m->Hostnames = mDNSNULL;
m->AutoTunnelHostAddr.b[0] = 0;
m->AutoTunnelHostAddrActive = mDNSfalse;
m->AutoTunnelLabel.c[0] = 0;
m->RegisterSearchDomains = mDNSfalse;
m->NATTraversals = mDNSNULL;
m->CurrentNATTraversal = mDNSNULL;
m->retryIntervalGetAddr = 0; m->retryGetAddr = timenow + 0x78000000; m->ExternalAddress = zerov4Addr;
m->NATMcastRecvskt = mDNSNULL;
m->NATMcastRecvsk2 = mDNSNULL;
m->LastNATupseconds = 0;
m->LastNATReplyLocalTime = timenow;
m->UPnPInterfaceID = 0;
m->UPnPRouterPort = zeroIPPort;
m->UPnPSOAPPort = zeroIPPort;
m->UPnPRouterURL = mDNSNULL;
m->UPnPSOAPURL = mDNSNULL;
m->UPnPRouterAddressString = mDNSNULL;
m->UPnPSOAPAddressString = mDNSNULL;
#endif
#if APPLE_OSX_mDNSResponder
m->TunnelClients = mDNSNULL;
#endif
result = mDNSPlatformInit(m);
#ifndef UNICAST_DISABLED
uDNS_SetupDNSConfig(m); #endif
return(result);
}
mDNSlocal void DynDNSHostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
(void)m; debugf("NameStatusCallback: result %d for registration of name %##s", result, rr->resrec.name->c);
mDNSPlatformDynDNSHostNameStatusChanged(rr->resrec.name, result);
}
mDNSexport mStatus uDNS_SetupDNSConfig(mDNS *const m)
{
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *cr;
mDNSAddr v4, v6, r;
domainname fqdn;
DNSServer *ptr, **p = &m->DNSServers;
DNSQuestion *q;
if (m->RegisterSearchDomains) uDNS_RegisterSearchDomains(m);
mDNS_Lock(m);
for (ptr = m->DNSServers; ptr; ptr = ptr->next) ptr->del = mDNStrue;
mDNSPlatformSetDNSConfig(m, mDNStrue, mDNSfalse, &fqdn, mDNSNULL, mDNSNULL);
for (q = m->Questions; q; q=q->next)
if (!mDNSOpaque16IsZero(q->TargetQID))
{
DNSServer *s = GetServerForName(m, &q->qname);
if (q->qDNSServer != s)
{
LogOperation("Updating DNS Server from %#a:%d to %#a:%d for %##s (%s)",
q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL, mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort),
s ? &s->addr : mDNSNULL, mDNSVal16(s ? s->port : zeroIPPort),
q->qname.c, DNSTypeName(q->qtype));
q->qDNSServer = s;
ActivateUnicastQuery(m, q);
}
}
while (*p)
{
if ((*p)->del)
{
ptr = *p;
ptr->del = mDNSfalse; FORALL_CACHERECORDS(slot, cg, cr)
if (!cr->resrec.InterfaceID && GetServerForName(m, cr->resrec.name) == ptr)
mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
*p = (*p)->next;
mDNSPlatformMemFree(ptr);
}
else
p = &(*p)->next;
}
if (!m->DNSServers) FORALL_CACHERECORDS(slot, cg, cr) if (!cr->resrec.InterfaceID) mDNS_PurgeCacheResourceRecord(m, cr);
if (!SameDomainName(&fqdn, &m->FQDN))
{
if (m->FQDN.c[0]) mDNS_RemoveDynDNSHostName(m, &m->FQDN);
AssignDomainName(&m->FQDN, &fqdn);
if (m->FQDN.c[0])
{
mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1);
mDNS_AddDynDNSHostName(m, &m->FQDN, DynDNSHostNameCallback, mDNSNULL);
}
}
mDNS_Unlock(m);
v4 = v6 = r = zeroAddr;
v4.type = r.type = mDNSAddrType_IPv4;
if (mDNSPlatformGetPrimaryInterface(m, &v4, &v6, &r) == mStatus_NoError && !mDNSv4AddressIsLinkLocal(&v4.ip.v4))
{
mDNS_SetPrimaryInterfaceInfo(m,
!mDNSIPv4AddressIsZero(v4.ip.v4) ? &v4 : mDNSNULL,
!mDNSIPv6AddressIsZero(v6.ip.v6) ? &v6 : mDNSNULL,
!mDNSIPv4AddressIsZero(r .ip.v4) ? &r : mDNSNULL);
}
else
{
mDNS_SetPrimaryInterfaceInfo(m, mDNSNULL, mDNSNULL, mDNSNULL);
if (m->FQDN.c[0]) mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); }
return mStatus_NoError;
}
mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result)
{
m->mDNSPlatformStatus = result;
if (m->MainCallback)
{
mDNS_Lock(m);
mDNS_DropLockBeforeCallback(); m->MainCallback(m, mStatus_NoError);
mDNS_ReclaimLockAfterCallback(); mDNS_Unlock(m);
}
}
mDNSexport void mDNS_Close(mDNS *const m)
{
mDNSu32 rrcache_active = 0;
mDNSu32 rrcache_totalused = 0;
mDNSu32 slot;
NetworkInterfaceInfo *intf;
AuthRecord *rr;
mDNS_Lock(m);
m->mDNS_shutdown = mDNStrue;
#ifndef UNICAST_DISABLED
uDNS_Sleep(m);
while (m->Hostnames) mDNS_RemoveDynDNSHostName(m, &m->Hostnames->fqdn);
#endif
rrcache_totalused = m->rrcache_totalused;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
while (m->rrcache_hash[slot])
{
CacheGroup *cg = m->rrcache_hash[slot];
while (cg->members)
{
CacheRecord *cr = cg->members;
cg->members = cg->members->next;
if (cr->CRActiveQuestion) rrcache_active++;
ReleaseCacheRecord(m, cr);
}
cg->rrcache_tail = &cg->members;
ReleaseCacheGroup(m, &m->rrcache_hash[slot]);
}
}
debugf("mDNS_Close: RR Cache was using %ld records, %lu 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);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise)
DeadvertiseInterface(m, intf);
while (m->NATTraversals)
{
NATTraversalInfo *t = m->NATTraversals;
mDNS_StopNATOperation_internal(m, t);
t->ExternalAddress = zerov4Addr;
t->ExternalPort = zeroIPPort;
t->Lifetime = 0;
t->Result = mStatus_NoError;
}
if (m->CurrentRecord)
LogMsg("mDNS_Close ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
else
m->CurrentRecord = rr->next;
}
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
if (rr->resrec.RecordType != kDNSRecordTypeDeregistering)
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
else
m->CurrentRecord = rr->next;
}
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 if (m->ResourceRecords) SendResponses(m);
for (rr = m->ResourceRecords; rr; rr = rr->next)
LogMsg("mDNS_Close failed to send goodbye for: %s", ARDisplayString(m, rr));
mDNS_Unlock(m);
debugf("mDNS_Close: mDNSPlatformClose");
mDNSPlatformClose(m);
debugf("mDNS_Close: done");
}