1 /* -*- Mode: C; tab-width: 4 -*-
3 * Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 * This code is completely 100% portable C. It does not depend on any external header files
18 * from outside the mDNS project -- all the types it expects to find are defined right here.
20 * The previous point is very important: This file does not depend on any external
21 * header files. It should compile on *any* platform that has a C compiler, without
22 * making *any* assumptions about availability of so-called "standard" C functions,
23 * routines, or types (which may or may not be present on any given platform).
26 * This code follows the "Whitesmiths style" C indentation rules. Plenty of discussion
27 * on C indentation can be found on the web, such as <http://www.kafejo.com/komp/1tbs.htm>,
28 * but for the sake of brevity here I will say just this: Curly braces are not syntactially
29 * part of an "if" statement; they are the beginning and ending markers of a compound statement;
30 * therefore common sense dictates that if they are part of a compound statement then they
31 * should be indented to the same level as everything else in that compound statement.
32 * Indenting curly braces at the same level as the "if" implies that curly braces are
33 * part of the "if", which is false. (This is as misleading as people who write "char* x,y;"
34 * thinking that variables x and y are both of type "char*" -- and anyone who doesn't
35 * understand why variable y is not of type "char*" just proves the point that poor code
36 * layout leads people to unfortunate misunderstandings about how the C language really works.)
39 #include "DNSCommon.h" // Defines general DNS untility routines
40 #include "uDNS.h" // Defines entry points into unicast-specific routines
42 // Disable certain benign warnings with Microsoft compilers
43 #if(defined(_MSC_VER))
44 // Disable "conditional expression is constant" warning for debug macros.
45 // Otherwise, this generates warnings for the perfectly natural construct "while(1)"
46 // If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know
47 #pragma warning(disable:4127)
49 // Disable "assignment within conditional expression".
50 // Other compilers understand the convention that if you place the assignment expression within an extra pair
51 // of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary.
52 // The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal
53 // to the compiler that the assignment is intentional, we have to just turn this warning off completely.
54 #pragma warning(disable:4706)
57 #if APPLE_OSX_mDNSResponder
59 #include <WebFilterDNS/WebFilterDNS.h>
62 WCFConnection
*WCFConnectionNew(void) __attribute__((weak_import
));
63 void WCFConnectionDealloc(WCFConnection
* c
) __attribute__((weak_import
));
65 // Do we really need to define a macro for "if"?
66 #define CHECK_WCF_FUNCTION(X) if (X)
72 #endif // APPLE_OSX_mDNSResponder
74 // Forward declarations
75 mDNSlocal
void BeginSleepProcessing(mDNS
*const m
);
76 mDNSlocal
void RetrySPSRegistrations(mDNS
*const m
);
77 mDNSlocal
void SendWakeup(mDNS
*const m
, mDNSInterfaceID InterfaceID
, mDNSEthAddr
*EthAddr
, mDNSOpaque48
*password
);
78 mDNSlocal mDNSBool
CacheRecordRmvEventsForQuestion(mDNS
*const m
, DNSQuestion
*q
);
79 mDNSlocal mDNSBool
LocalRecordRmvEventsForQuestion(mDNS
*const m
, DNSQuestion
*q
);
80 mDNSlocal
void mDNS_PurgeBeforeResolve(mDNS
*const m
, DNSQuestion
*q
);
82 // ***************************************************************************
83 #if COMPILER_LIKES_PRAGMA_MARK
84 #pragma mark - Program Constants
90 // Any records bigger than this are considered 'large' records
91 #define SmallRecordLimit 1024
93 #define kMaxUpdateCredits 10
94 #define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6)
96 mDNSexport
const char *const mDNS_DomainTypeNames
[] =
98 "b._dns-sd._udp.", // Browse
99 "db._dns-sd._udp.", // Default Browse
100 "lb._dns-sd._udp.", // Automatic Browse
101 "r._dns-sd._udp.", // Registration
102 "dr._dns-sd._udp." // Default Registration
105 #ifdef UNICAST_DISABLED
106 #define uDNS_IsActiveQuery(q, u) mDNSfalse
109 // ***************************************************************************
110 #if COMPILER_LIKES_PRAGMA_MARK
112 #pragma mark - General Utility Functions
115 // If there is a authoritative LocalOnly record that answers questions of type A, AAAA and CNAME
116 // this returns true. Main use is to handle /etc/hosts records.
117 #define LORecordAnswersAddressType(rr) ((rr)->ARType == AuthRecordLocalOnly && \
118 (rr)->resrec.RecordType & kDNSRecordTypeUniqueMask && \
119 ((rr)->resrec.rrtype == kDNSType_A || (rr)->resrec.rrtype == kDNSType_AAAA || \
120 (rr)->resrec.rrtype == kDNSType_CNAME))
122 #define FollowCNAME(q, rr, AddRecord) (AddRecord && (q)->qtype != kDNSType_CNAME && \
123 (rr)->RecordType != kDNSRecordTypePacketNegative && \
124 (rr)->rrtype == kDNSType_CNAME)
126 mDNSlocal
void SetNextQueryStopTime(mDNS
*const m
, const DNSQuestion
*const q
)
128 if (m
->mDNS_busy
!= m
->mDNS_reentrancy
+1)
129 LogMsg("SetNextQueryTime: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m
->mDNS_busy
, m
->mDNS_reentrancy
);
132 if (m
->mDNS_busy
!= m
->mDNS_reentrancy
+1) *(long*)0 = 0;
135 if (m
->NextScheduledStopTime
- q
->StopTime
> 0)
136 m
->NextScheduledStopTime
= q
->StopTime
;
139 mDNSexport
void SetNextQueryTime(mDNS
*const m
, const DNSQuestion
*const q
)
141 if (m
->mDNS_busy
!= m
->mDNS_reentrancy
+1)
142 LogMsg("SetNextQueryTime: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m
->mDNS_busy
, m
->mDNS_reentrancy
);
145 if (m
->mDNS_busy
!= m
->mDNS_reentrancy
+1) *(long*)0 = 0;
148 if (ActiveQuestion(q
))
150 // Depending on whether this is a multicast or unicast question we want to set either:
151 // m->NextScheduledQuery = NextQSendTime(q) or
152 // m->NextuDNSEvent = NextQSendTime(q)
153 mDNSs32
*const timer
= mDNSOpaque16IsZero(q
->TargetQID
) ? &m
->NextScheduledQuery
: &m
->NextuDNSEvent
;
154 if (*timer
- NextQSendTime(q
) > 0)
155 *timer
= NextQSendTime(q
);
159 mDNSlocal
void ReleaseAuthEntity(AuthHash
*r
, AuthEntity
*e
)
161 #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1
163 for (i
=0; i
<sizeof(*e
); i
++) ((char*)e
)[i
] = 0xFF;
165 e
->next
= r
->rrauth_free
;
167 r
->rrauth_totalused
--;
170 mDNSlocal
void ReleaseAuthGroup(AuthHash
*r
, AuthGroup
**cp
)
172 AuthEntity
*e
= (AuthEntity
*)(*cp
);
173 LogMsg("ReleaseAuthGroup: Releasing AuthGroup %##s", (*cp
)->name
->c
);
174 if ((*cp
)->rrauth_tail
!= &(*cp
)->members
)
175 LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrauth_tail != &(*cp)->members)");
176 if ((*cp
)->name
!= (domainname
*)((*cp
)->namestorage
)) mDNSPlatformMemFree((*cp
)->name
);
177 (*cp
)->name
= mDNSNULL
;
178 *cp
= (*cp
)->next
; // Cut record from list
179 ReleaseAuthEntity(r
, e
);
182 mDNSlocal AuthEntity
*GetAuthEntity(AuthHash
*r
, const AuthGroup
*const PreserveAG
)
184 AuthEntity
*e
= mDNSNULL
;
186 if (r
->rrauth_lock
) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL
); }
191 // We allocate just one AuthEntity at a time because we need to be able
192 // free them all individually which normally happens when we parse /etc/hosts into
193 // AuthHash where we add the "new" entries and discard (free) the already added
194 // entries. If we allocate as chunks, we can't free them individually.
195 AuthEntity
*storage
= mDNSPlatformMemAllocate(sizeof(AuthEntity
));
196 storage
->next
= mDNSNULL
;
197 r
->rrauth_free
= storage
;
200 // If we still have no free records, recycle all the records we can.
201 // Enumerating the entire auth is moderately expensive, so when we do it, we reclaim all the records we can in one pass.
204 mDNSu32 oldtotalused
= r
->rrauth_totalused
;
206 for (slot
= 0; slot
< AUTH_HASH_SLOTS
; slot
++)
208 AuthGroup
**cp
= &r
->rrauth_hash
[slot
];
211 if ((*cp
)->members
|| (*cp
)==PreserveAG
) cp
=&(*cp
)->next
;
212 else ReleaseAuthGroup(r
, cp
);
215 LogInfo("GetAuthEntity: Recycled %d records to reduce auth cache from %d to %d",
216 oldtotalused
- r
->rrauth_totalused
, oldtotalused
, r
->rrauth_totalused
);
219 if (r
->rrauth_free
) // If there are records in the free list, take one
222 r
->rrauth_free
= e
->next
;
223 if (++r
->rrauth_totalused
>= r
->rrauth_report
)
225 LogInfo("RR Auth now using %ld objects", r
->rrauth_totalused
);
226 if (r
->rrauth_report
< 100) r
->rrauth_report
+= 10;
227 else if (r
->rrauth_report
< 1000) r
->rrauth_report
+= 100;
228 else r
->rrauth_report
+= 1000;
230 mDNSPlatformMemZero(e
, sizeof(*e
));
238 mDNSexport AuthGroup
*AuthGroupForName(AuthHash
*r
, const mDNSu32 slot
, const mDNSu32 namehash
, const domainname
*const name
)
241 for (ag
= r
->rrauth_hash
[slot
]; ag
; ag
=ag
->next
)
242 if (ag
->namehash
== namehash
&& SameDomainName(ag
->name
, name
))
247 mDNSexport AuthGroup
*AuthGroupForRecord(AuthHash
*r
, const mDNSu32 slot
, const ResourceRecord
*const rr
)
249 return(AuthGroupForName(r
, slot
, rr
->namehash
, rr
->name
));
252 mDNSlocal AuthGroup
*GetAuthGroup(AuthHash
*r
, const mDNSu32 slot
, const ResourceRecord
*const rr
)
254 mDNSu16 namelen
= DomainNameLength(rr
->name
);
255 AuthGroup
*ag
= (AuthGroup
*)GetAuthEntity(r
, mDNSNULL
);
256 if (!ag
) { LogMsg("GetAuthGroup: Failed to allocate memory for %##s", rr
->name
->c
); return(mDNSNULL
); }
257 ag
->next
= r
->rrauth_hash
[slot
];
258 ag
->namehash
= rr
->namehash
;
259 ag
->members
= mDNSNULL
;
260 ag
->rrauth_tail
= &ag
->members
;
261 ag
->name
= (domainname
*)ag
->namestorage
;
262 ag
->NewLocalOnlyRecords
= mDNSNULL
;
263 if (namelen
> InlineCacheGroupNameSize
) ag
->name
= mDNSPlatformMemAllocate(namelen
);
266 LogMsg("GetAuthGroup: Failed to allocate name storage for %##s", rr
->name
->c
);
267 ReleaseAuthEntity(r
, (AuthEntity
*)ag
);
270 AssignDomainName(ag
->name
, rr
->name
);
272 if (AuthGroupForRecord(r
, slot
, rr
)) LogMsg("GetAuthGroup: Already have AuthGroup for %##s", rr
->name
->c
);
273 r
->rrauth_hash
[slot
] = ag
;
274 if (AuthGroupForRecord(r
, slot
, rr
) != ag
) LogMsg("GetAuthGroup: Not finding AuthGroup for %##s", rr
->name
->c
);
279 // Returns the AuthGroup in which the AuthRecord was inserted
280 mDNSexport AuthGroup
*InsertAuthRecord(mDNS
*const m
, AuthHash
*r
, AuthRecord
*rr
)
283 const mDNSu32 slot
= AuthHashSlot(rr
->resrec
.name
);
284 ag
= AuthGroupForRecord(r
, slot
, &rr
->resrec
);
285 if (!ag
) ag
= GetAuthGroup(r
, slot
, &rr
->resrec
); // If we don't have a AuthGroup for this name, make one now
288 LogInfo("InsertAuthRecord: inserting auth record %s from table", ARDisplayString(m
, rr
));
289 *(ag
->rrauth_tail
) = rr
; // Append this record to tail of cache slot list
290 ag
->rrauth_tail
= &(rr
->next
); // Advance tail pointer
295 mDNSexport AuthGroup
*RemoveAuthRecord(mDNS
*const m
, AuthHash
*r
, AuthRecord
*rr
)
300 const mDNSu32 slot
= AuthHashSlot(rr
->resrec
.name
);
302 a
= AuthGroupForRecord(r
, slot
, &rr
->resrec
);
303 if (!a
) { LogMsg("RemoveAuthRecord: ERROR!! AuthGroup not found for %s", ARDisplayString(m
, rr
)); return mDNSNULL
; }
304 rp
= &(*ag
)->members
;
311 // We don't break here, so that we can set the tail below without tracking "prev" pointers
313 LogInfo("RemoveAuthRecord: removing auth record %s from table", ARDisplayString(m
, rr
));
314 *rp
= (*rp
)->next
; // Cut record from list
317 // TBD: If there are no more members, release authgroup ?
318 (*ag
)->rrauth_tail
= rp
;
322 mDNSexport CacheGroup
*CacheGroupForName(const mDNS
*const m
, const mDNSu32 slot
, const mDNSu32 namehash
, const domainname
*const name
)
325 for (cg
= m
->rrcache_hash
[slot
]; cg
; cg
=cg
->next
)
326 if (cg
->namehash
== namehash
&& SameDomainName(cg
->name
, name
))
331 mDNSlocal CacheGroup
*CacheGroupForRecord(const mDNS
*const m
, const mDNSu32 slot
, const ResourceRecord
*const rr
)
333 return(CacheGroupForName(m
, slot
, rr
->namehash
, rr
->name
));
336 mDNSexport mDNSBool
mDNS_AddressIsLocalSubnet(mDNS
*const m
, const mDNSInterfaceID InterfaceID
, const mDNSAddr
*addr
)
338 NetworkInterfaceInfo
*intf
;
340 if (addr
->type
== mDNSAddrType_IPv4
)
342 // Normally we resist touching the NotAnInteger fields, but here we're doing tricky bitwise masking so we make an exception
343 if (mDNSv4AddressIsLinkLocal(&addr
->ip
.v4
)) return(mDNStrue
);
344 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
345 if (intf
->ip
.type
== addr
->type
&& intf
->InterfaceID
== InterfaceID
&& intf
->McastTxRx
)
346 if (((intf
->ip
.ip
.v4
.NotAnInteger
^ addr
->ip
.v4
.NotAnInteger
) & intf
->mask
.ip
.v4
.NotAnInteger
) == 0)
350 if (addr
->type
== mDNSAddrType_IPv6
)
352 if (mDNSv6AddressIsLinkLocal(&addr
->ip
.v6
)) return(mDNStrue
);
353 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
354 if (intf
->ip
.type
== addr
->type
&& intf
->InterfaceID
== InterfaceID
&& intf
->McastTxRx
)
355 if ((((intf
->ip
.ip
.v6
.l
[0] ^ addr
->ip
.v6
.l
[0]) & intf
->mask
.ip
.v6
.l
[0]) == 0) &&
356 (((intf
->ip
.ip
.v6
.l
[1] ^ addr
->ip
.v6
.l
[1]) & intf
->mask
.ip
.v6
.l
[1]) == 0) &&
357 (((intf
->ip
.ip
.v6
.l
[2] ^ addr
->ip
.v6
.l
[2]) & intf
->mask
.ip
.v6
.l
[2]) == 0) &&
358 (((intf
->ip
.ip
.v6
.l
[3] ^ addr
->ip
.v6
.l
[3]) & intf
->mask
.ip
.v6
.l
[3]) == 0))
365 mDNSlocal NetworkInterfaceInfo
*FirstInterfaceForID(mDNS
*const m
, const mDNSInterfaceID InterfaceID
)
367 NetworkInterfaceInfo
*intf
= m
->HostInterfaces
;
368 while (intf
&& intf
->InterfaceID
!= InterfaceID
) intf
= intf
->next
;
372 mDNSexport
char *InterfaceNameForID(mDNS
*const m
, const mDNSInterfaceID InterfaceID
)
374 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, InterfaceID
);
375 return(intf
? intf
->ifname
: mDNSNULL
);
378 // Caller should hold the lock
379 mDNSlocal
void GenerateNegativeResponse(mDNS
*const m
)
382 if (!m
->CurrentQuestion
) { LogMsg("GenerateNegativeResponse: ERROR!! CurrentQuestion not set"); return; }
383 q
= m
->CurrentQuestion
;
384 LogInfo("GenerateNegativeResponse: Generating negative response for question %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
386 MakeNegativeCacheRecord(m
, &m
->rec
.r
, &q
->qname
, q
->qnamehash
, q
->qtype
, q
->qclass
, 60, mDNSInterface_Any
, mDNSNULL
);
387 AnswerCurrentQuestionWithResourceRecord(m
, &m
->rec
.r
, QC_addnocache
);
388 if (m
->CurrentQuestion
== q
) { q
->ThisQInterval
= 0; } // Deactivate this question
389 // Don't touch the question after this
390 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
393 mDNSlocal
void AnswerQuestionByFollowingCNAME(mDNS
*const m
, DNSQuestion
*q
, ResourceRecord
*rr
)
395 const mDNSBool selfref
= SameDomainName(&q
->qname
, &rr
->rdata
->u
.name
);
396 if (q
->CNAMEReferrals
>= 10 || selfref
)
397 LogMsg("AnswerQuestionByFollowingCNAME: %p %##s (%s) NOT following CNAME referral %d%s for %s",
398 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), q
->CNAMEReferrals
, selfref
? " (Self-Referential)" : "", RRDisplayString(m
, rr
));
401 const mDNSu32 c
= q
->CNAMEReferrals
+ 1; // Stash a copy of the new q->CNAMEReferrals value
403 // The SameDomainName check above is to ignore bogus CNAME records that point right back at
404 // themselves. Without that check we can get into a case where we have two duplicate questions,
405 // A and B, and when we stop question A, UpdateQuestionDuplicates copies the value of CNAMEReferrals
406 // from A to B, and then A is re-appended to the end of the list as a duplicate of B (because
407 // the target name is still the same), and then when we stop question B, UpdateQuestionDuplicates
408 // copies the B's value of CNAMEReferrals back to A, and we end up not incrementing CNAMEReferrals
409 // for either of them. This is not a problem for CNAME loops of two or more records because in
410 // those cases the newly re-appended question A has a different target name and therefore cannot be
411 // a duplicate of any other question ('B') which was itself a duplicate of the previous question A.
413 // Right now we just stop and re-use the existing query. If we really wanted to be 100% perfect,
414 // and track CNAMEs coming and going, we should really create a subordinate query here,
415 // which we would subsequently cancel and retract if the CNAME referral record were removed.
416 // In reality this is such a corner case we'll ignore it until someone actually needs it.
418 LogInfo("AnswerQuestionByFollowingCNAME: %p %##s (%s) following CNAME referral %d for %s",
419 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), q
->CNAMEReferrals
, RRDisplayString(m
, rr
));
421 mDNS_StopQuery_internal(m
, q
); // Stop old query
422 AssignDomainName(&q
->qname
, &rr
->rdata
->u
.name
); // Update qname
423 q
->qnamehash
= DomainNameHashValue(&q
->qname
); // and namehash
424 // If a unicast query results in a CNAME that points to a .local, we need to re-try
425 // this as unicast. Setting the mDNSInterface_Unicast tells mDNS_StartQuery_internal
426 // to try this as unicast query even though it is a .local name
427 if (!mDNSOpaque16IsZero(q
->TargetQID
) && IsLocalDomain(&q
->qname
))
429 LogInfo("AnswerQuestionByFollowingCNAME: Resolving a .local CNAME %p %##s (%s) Record %s",
430 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), RRDisplayString(m
, rr
));
431 q
->InterfaceID
= mDNSInterface_Unicast
;
433 mDNS_StartQuery_internal(m
, q
); // start new query
434 // Record how many times we've done this. We need to do this *after* mDNS_StartQuery_internal,
435 // because mDNS_StartQuery_internal re-initializes CNAMEReferrals to zero
436 q
->CNAMEReferrals
= c
;
440 // For a single given DNSQuestion pointed to by CurrentQuestion, deliver an add/remove result for the single given AuthRecord
441 // Note: All the callers should use the m->CurrentQuestion to see if the question is still valid or not
442 mDNSlocal
void AnswerLocalQuestionWithLocalAuthRecord(mDNS
*const m
, AuthRecord
*rr
, QC_result AddRecord
)
444 DNSQuestion
*q
= m
->CurrentQuestion
;
445 mDNSBool followcname
;
449 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: ERROR!! CurrentQuestion NULL while answering with %s", ARDisplayString(m
, rr
));
453 followcname
= FollowCNAME(q
, &rr
->resrec
, AddRecord
);
455 // We should not be delivering results for record types Unregistered, Deregistering, and (unverified) Unique
456 if (!(rr
->resrec
.RecordType
& kDNSRecordTypeActiveMask
))
458 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: *NOT* delivering %s event for local record type %X %s",
459 AddRecord
? "Add" : "Rmv", rr
->resrec
.RecordType
, ARDisplayString(m
, rr
));
463 // Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it
464 if (AddRecord
) rr
->AnsweredLocalQ
= mDNStrue
;
465 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
466 if (q
->QuestionCallback
&& !q
->NoAnswer
)
468 q
->CurrentAnswers
+= AddRecord
? 1 : -1;
469 if (LORecordAnswersAddressType(rr
))
471 if (!followcname
|| q
->ReturnIntermed
)
473 // Don't send this packet on the wire as we answered from /etc/hosts
474 q
->ThisQInterval
= 0;
475 q
->LOAddressAnswers
+= AddRecord
? 1 : -1;
476 q
->QuestionCallback(m
, q
, &rr
->resrec
, AddRecord
);
478 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
479 // The callback above could have caused the question to stop. Detect that
480 // using m->CurrentQuestion
481 if (followcname
&& m
->CurrentQuestion
== q
)
482 AnswerQuestionByFollowingCNAME(m
, q
, &rr
->resrec
);
486 q
->QuestionCallback(m
, q
, &rr
->resrec
, AddRecord
);
488 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
491 mDNSlocal
void AnswerInterfaceAnyQuestionsWithLocalAuthRecord(mDNS
*const m
, AuthRecord
*rr
, QC_result AddRecord
)
493 if (m
->CurrentQuestion
)
494 LogMsg("AnswerInterfaceAnyQuestionsWithLocalAuthRecord: ERROR m->CurrentQuestion already set: %##s (%s)",
495 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
496 m
->CurrentQuestion
= m
->Questions
;
497 while (m
->CurrentQuestion
&& m
->CurrentQuestion
!= m
->NewQuestions
)
500 DNSQuestion
*q
= m
->CurrentQuestion
;
502 answered
= ResourceRecordAnswersQuestion(&rr
->resrec
, q
);
504 answered
= LocalOnlyRecordAnswersQuestion(rr
, q
);
506 AnswerLocalQuestionWithLocalAuthRecord(m
, rr
, AddRecord
); // MUST NOT dereference q again
507 if (m
->CurrentQuestion
== q
) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
508 m
->CurrentQuestion
= q
->next
;
510 m
->CurrentQuestion
= mDNSNULL
;
513 // When a new local AuthRecord is created or deleted, AnswerAllLocalQuestionsWithLocalAuthRecord()
514 // delivers the appropriate add/remove events to listening questions:
515 // 1. It runs though all our LocalOnlyQuestions delivering answers as appropriate,
516 // stopping if it reaches a NewLocalOnlyQuestion -- brand-new questions are handled by AnswerNewLocalOnlyQuestion().
517 // 2. If the AuthRecord is marked mDNSInterface_LocalOnly or mDNSInterface_P2P, then it also runs though
518 // our main question list, delivering answers to mDNSInterface_Any questions as appropriate,
519 // stopping if it reaches a NewQuestion -- brand-new questions are handled by AnswerNewQuestion().
521 // AnswerAllLocalQuestionsWithLocalAuthRecord is used by the m->NewLocalRecords loop in mDNS_Execute(),
522 // and by mDNS_Deregister_internal()
524 mDNSlocal
void AnswerAllLocalQuestionsWithLocalAuthRecord(mDNS
*const m
, AuthRecord
*rr
, QC_result AddRecord
)
526 if (m
->CurrentQuestion
)
527 LogMsg("AnswerAllLocalQuestionsWithLocalAuthRecord ERROR m->CurrentQuestion already set: %##s (%s)",
528 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
530 m
->CurrentQuestion
= m
->LocalOnlyQuestions
;
531 while (m
->CurrentQuestion
&& m
->CurrentQuestion
!= m
->NewLocalOnlyQuestions
)
534 DNSQuestion
*q
= m
->CurrentQuestion
;
535 // We are called with both LocalOnly/P2P record or a regular AuthRecord
537 answered
= ResourceRecordAnswersQuestion(&rr
->resrec
, q
);
539 answered
= LocalOnlyRecordAnswersQuestion(rr
, q
);
541 AnswerLocalQuestionWithLocalAuthRecord(m
, rr
, AddRecord
); // MUST NOT dereference q again
542 if (m
->CurrentQuestion
== q
) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
543 m
->CurrentQuestion
= q
->next
;
546 m
->CurrentQuestion
= mDNSNULL
;
548 // If this AuthRecord is marked LocalOnly or P2P, then we want to deliver it to all local 'mDNSInterface_Any' questions
549 if (rr
->ARType
== AuthRecordLocalOnly
|| rr
->ARType
== AuthRecordP2P
)
550 AnswerInterfaceAnyQuestionsWithLocalAuthRecord(m
, rr
, AddRecord
);
554 // ***************************************************************************
555 #if COMPILER_LIKES_PRAGMA_MARK
557 #pragma mark - Resource Record Utility Functions
560 #define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA)
562 #define ResourceRecordIsValidAnswer(RR) ( ((RR)-> resrec.RecordType & kDNSRecordTypeActiveMask) && \
563 ((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
564 ((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
565 ((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) )
567 #define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \
568 (ResourceRecordIsValidAnswer(RR) && \
569 ((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID)))
571 #define DefaultProbeCountForTypeUnique ((mDNSu8)3)
572 #define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)
574 #define InitialAnnounceCount ((mDNSu8)8)
576 // For goodbye packets we set the count to 3, and for wakeups we set it to 18
577 // (which will be up to 15 wakeup attempts over the course of 30 seconds,
578 // and then if the machine fails to wake, 3 goodbye packets).
579 #define GoodbyeCount ((mDNSu8)3)
580 #define WakeupCount ((mDNSu8)18)
582 // Number of wakeups we send if WakeOnResolve is set in the question
583 #define InitialWakeOnResolveCount ((mDNSu8)3)
585 // Note that the announce intervals use exponential backoff, doubling each time. The probe intervals do not.
586 // This means that because the announce interval is doubled after sending the first packet, the first
587 // observed on-the-wire inter-packet interval between announcements is actually one second.
588 // The half-second value here may be thought of as a conceptual (non-existent) half-second delay *before* the first packet is sent.
589 #define DefaultProbeIntervalForTypeUnique (mDNSPlatformOneSecond/4)
590 #define DefaultAnnounceIntervalForTypeShared (mDNSPlatformOneSecond/2)
591 #define DefaultAnnounceIntervalForTypeUnique (mDNSPlatformOneSecond/2)
593 #define DefaultAPIntervalForRecordType(X) ((X) & kDNSRecordTypeActiveSharedMask ? DefaultAnnounceIntervalForTypeShared : \
594 (X) & kDNSRecordTypeUnique ? DefaultProbeIntervalForTypeUnique : \
595 (X) & kDNSRecordTypeActiveUniqueMask ? DefaultAnnounceIntervalForTypeUnique : 0)
597 #define TimeToAnnounceThisRecord(RR,time) ((RR)->AnnounceCount && (time) - ((RR)->LastAPTime + (RR)->ThisAPInterval) >= 0)
598 #define TimeToSendThisRecord(RR,time) ((TimeToAnnounceThisRecord(RR,time) || (RR)->ImmedAnswer) && ResourceRecordIsValidAnswer(RR))
599 #define TicksTTL(RR) ((mDNSs32)(RR)->resrec.rroriginalttl * mDNSPlatformOneSecond)
600 #define RRExpireTime(RR) ((RR)->TimeRcvd + TicksTTL(RR))
602 #define MaxUnansweredQueries 4
604 // SameResourceRecordSignature returns true if two resources records have the same name, type, and class, and may be sent
605 // (or were received) on the same interface (i.e. if *both* records specify an interface, then it has to match).
606 // TTL and rdata may differ.
607 // This is used for cache flush management:
608 // When sending a unique record, all other records matching "SameResourceRecordSignature" must also be sent
609 // When receiving a unique record, all old cache records matching "SameResourceRecordSignature" are flushed
611 // SameResourceRecordNameClassInterface is functionally the same as SameResourceRecordSignature, except rrtype does not have to match
613 #define SameResourceRecordSignature(A,B) (A)->resrec.rrtype == (B)->resrec.rrtype && SameResourceRecordNameClassInterface((A),(B))
615 mDNSlocal mDNSBool
SameResourceRecordNameClassInterface(const AuthRecord
*const r1
, const AuthRecord
*const r2
)
617 if (!r1
) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse
); }
618 if (!r2
) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse
); }
619 if (r1
->resrec
.InterfaceID
&&
620 r2
->resrec
.InterfaceID
&&
621 r1
->resrec
.InterfaceID
!= r2
->resrec
.InterfaceID
) return(mDNSfalse
);
623 r1
->resrec
.rrclass
== r2
->resrec
.rrclass
&&
624 r1
->resrec
.namehash
== r2
->resrec
.namehash
&&
625 SameDomainName(r1
->resrec
.name
, r2
->resrec
.name
));
628 // PacketRRMatchesSignature behaves as SameResourceRecordSignature, except that types may differ if our
629 // authoratative record is unique (as opposed to shared). For unique records, we are supposed to have
630 // complete ownership of *all* types for this name, so *any* record type with the same name is a conflict.
631 // In addition, when probing we send our questions with the wildcard type kDNSQType_ANY,
632 // so a response of any type should match, even if it is not actually the type the client plans to use.
634 // For now, to make it easier to avoid false conflicts, we treat SPS Proxy records like shared records,
635 // and require the rrtypes to match for the rdata to be considered potentially conflicting
636 mDNSlocal mDNSBool
PacketRRMatchesSignature(const CacheRecord
*const pktrr
, const AuthRecord
*const authrr
)
638 if (!pktrr
) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse
); }
639 if (!authrr
) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL"); return(mDNSfalse
); }
640 if (pktrr
->resrec
.InterfaceID
&&
641 authrr
->resrec
.InterfaceID
&&
642 pktrr
->resrec
.InterfaceID
!= authrr
->resrec
.InterfaceID
) return(mDNSfalse
);
643 if (!(authrr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
) || authrr
->WakeUp
.HMAC
.l
[0])
644 if (pktrr
->resrec
.rrtype
!= authrr
->resrec
.rrtype
) return(mDNSfalse
);
646 pktrr
->resrec
.rrclass
== authrr
->resrec
.rrclass
&&
647 pktrr
->resrec
.namehash
== authrr
->resrec
.namehash
&&
648 SameDomainName(pktrr
->resrec
.name
, authrr
->resrec
.name
));
651 // CacheRecord *ka is the CacheRecord from the known answer list in the query.
652 // This is the information that the requester believes to be correct.
653 // AuthRecord *rr is the answer we are proposing to give, if not suppressed.
654 // This is the information that we believe to be correct.
655 // We've already determined that we plan to give this answer on this interface
656 // (either the record is non-specific, or it is specific to this interface)
657 // so now we just need to check the name, type, class, rdata and TTL.
658 mDNSlocal mDNSBool
ShouldSuppressKnownAnswer(const CacheRecord
*const ka
, const AuthRecord
*const rr
)
660 // If RR signature is different, or data is different, then don't suppress our answer
661 if (!IdenticalResourceRecord(&ka
->resrec
, &rr
->resrec
)) return(mDNSfalse
);
663 // If the requester's indicated TTL is less than half the real TTL,
664 // we need to give our answer before the requester's copy expires.
665 // If the requester's indicated TTL is at least half the real TTL,
666 // then we can suppress our answer this time.
667 // If the requester's indicated TTL is greater than the TTL we believe,
668 // then that's okay, and we don't need to do anything about it.
669 // (If two responders on the network are offering the same information,
670 // that's okay, and if they are offering the information with different TTLs,
671 // the one offering the lower TTL should defer to the one offering the higher TTL.)
672 return(mDNSBool
)(ka
->resrec
.rroriginalttl
>= rr
->resrec
.rroriginalttl
/ 2);
675 mDNSlocal
void SetNextAnnounceProbeTime(mDNS
*const m
, const AuthRecord
*const rr
)
677 if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
)
679 if ((rr
->LastAPTime
+ rr
->ThisAPInterval
) - m
->timenow
> mDNSPlatformOneSecond
* 10)
681 LogMsg("SetNextAnnounceProbeTime: ProbeCount %d Next in %d %s", rr
->ProbeCount
, (rr
->LastAPTime
+ rr
->ThisAPInterval
) - m
->timenow
, ARDisplayString(m
, rr
));
682 LogMsg("SetNextAnnounceProbeTime: m->SuppressProbes %d m->timenow %d diff %d", m
->SuppressProbes
, m
->timenow
, m
->SuppressProbes
- m
->timenow
);
684 if (m
->NextScheduledProbe
- (rr
->LastAPTime
+ rr
->ThisAPInterval
) >= 0)
685 m
->NextScheduledProbe
= (rr
->LastAPTime
+ rr
->ThisAPInterval
);
686 // Some defensive code:
687 // If (rr->LastAPTime + rr->ThisAPInterval) happens to be far in the past, we don't want to allow
688 // NextScheduledProbe to be set excessively in the past, because that can cause bad things to happen.
689 // See: <rdar://problem/7795434> mDNS: Sometimes advertising stops working and record interval is set to zero
690 if (m
->NextScheduledProbe
- m
->timenow
< 0)
691 m
->NextScheduledProbe
= m
->timenow
;
693 else if (rr
->AnnounceCount
&& (ResourceRecordIsValidAnswer(rr
) || rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
))
695 if (m
->NextScheduledResponse
- (rr
->LastAPTime
+ rr
->ThisAPInterval
) >= 0)
696 m
->NextScheduledResponse
= (rr
->LastAPTime
+ rr
->ThisAPInterval
);
700 mDNSlocal
void InitializeLastAPTime(mDNS
*const m
, AuthRecord
*const rr
)
702 // For reverse-mapping Sleep Proxy PTR records, probe interval is one second
703 rr
->ThisAPInterval
= rr
->AddressProxy
.type
? mDNSPlatformOneSecond
: DefaultAPIntervalForRecordType(rr
->resrec
.RecordType
);
705 // * If this is a record type that's going to probe, then we use the m->SuppressProbes time.
706 // * Otherwise, if it's not going to probe, but m->SuppressProbes is set because we have other
707 // records that are going to probe, then we delay its first announcement so that it will
708 // go out synchronized with the first announcement for the other records that *are* probing.
709 // This is a minor performance tweak that helps keep groups of related records synchronized together.
710 // The addition of "interval / 2" is to make sure that, in the event that any of the probes are
711 // delayed by a few milliseconds, this announcement does not inadvertently go out *before* the probing is complete.
712 // When the probing is complete and those records begin to announce, these records will also be picked up and accelerated,
713 // because they will meet the criterion of being at least half-way to their scheduled announcement time.
714 // * If it's not going to probe and m->SuppressProbes is not already set then we should announce immediately.
718 // If we have no probe suppression time set, or it is in the past, set it now
719 if (m
->SuppressProbes
== 0 || m
->SuppressProbes
- m
->timenow
< 0)
721 // To allow us to aggregate probes when a group of services are registered together,
722 // the first probe is delayed 1/4 second. This means the common-case behaviour is:
723 // 1/4 second wait; probe
724 // 1/4 second wait; probe
725 // 1/4 second wait; probe
726 // 1/4 second wait; announce (i.e. service is normally announced exactly one second after being registered)
727 m
->SuppressProbes
= NonZeroTime(m
->timenow
+ DefaultProbeIntervalForTypeUnique
/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique
/2));
729 // If we already have a *probe* scheduled to go out sooner, then use that time to get better aggregation
730 if (m
->SuppressProbes
- m
->NextScheduledProbe
>= 0)
731 m
->SuppressProbes
= NonZeroTime(m
->NextScheduledProbe
);
732 if (m
->SuppressProbes
- m
->timenow
< 0) // Make sure we don't set m->SuppressProbes excessively in the past
733 m
->SuppressProbes
= m
->timenow
;
735 // If we already have a *query* scheduled to go out sooner, then use that time to get better aggregation
736 if (m
->SuppressProbes
- m
->NextScheduledQuery
>= 0)
737 m
->SuppressProbes
= NonZeroTime(m
->NextScheduledQuery
);
738 if (m
->SuppressProbes
- m
->timenow
< 0) // Make sure we don't set m->SuppressProbes excessively in the past
739 m
->SuppressProbes
= m
->timenow
;
741 // except... don't expect to be able to send before the m->SuppressSending timer fires
742 if (m
->SuppressSending
&& m
->SuppressProbes
- m
->SuppressSending
< 0)
743 m
->SuppressProbes
= NonZeroTime(m
->SuppressSending
);
745 if (m
->SuppressProbes
- m
->timenow
> mDNSPlatformOneSecond
* 8)
747 LogMsg("InitializeLastAPTime ERROR m->SuppressProbes %d m->NextScheduledProbe %d m->NextScheduledQuery %d m->SuppressSending %d %d",
748 m
->SuppressProbes
- m
->timenow
,
749 m
->NextScheduledProbe
- m
->timenow
,
750 m
->NextScheduledQuery
- m
->timenow
,
752 m
->SuppressSending
- m
->timenow
);
753 m
->SuppressProbes
= NonZeroTime(m
->timenow
+ DefaultProbeIntervalForTypeUnique
/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique
/2));
756 rr
->LastAPTime
= m
->SuppressProbes
- rr
->ThisAPInterval
;
758 else if (m
->SuppressProbes
&& m
->SuppressProbes
- m
->timenow
>= 0)
759 rr
->LastAPTime
= m
->SuppressProbes
- rr
->ThisAPInterval
+ DefaultProbeIntervalForTypeUnique
* DefaultProbeCountForTypeUnique
+ rr
->ThisAPInterval
/ 2;
761 rr
->LastAPTime
= m
->timenow
- rr
->ThisAPInterval
;
763 // For reverse-mapping Sleep Proxy PTR records we don't want to start probing instantly -- we
764 // wait one second to give the client a chance to go to sleep, and then start our ARP/NDP probing.
765 // After three probes one second apart with no answer, we conclude the client is now sleeping
766 // and we can begin broadcasting our announcements to take over ownership of that IP address.
767 // If we don't wait for the client to go to sleep, then when the client sees our ARP Announcements there's a risk
768 // (depending on the OS and networking stack it's using) that it might interpret it as a conflict and change its IP address.
769 if (rr
->AddressProxy
.type
) rr
->LastAPTime
= m
->timenow
;
771 // Unsolicited Neighbor Advertisements (RFC 2461 Section 7.2.6) give us fast address cache updating,
772 // but some older IPv6 clients get confused by them, so for now we don't send them. Without Unsolicited
773 // Neighbor Advertisements we have to rely on Neighbor Unreachability Detection instead, which is slower.
774 // Given this, we'll do our best to wake for existing IPv6 connections, but we don't want to encourage
775 // new ones for sleeping clients, so we'll we send deletions for our SPS clients' AAAA records.
776 if (m
->KnownBugs
& mDNS_KnownBug_LimitedIPv6
)
777 if (rr
->WakeUp
.HMAC
.l
[0] && rr
->resrec
.rrtype
== kDNSType_AAAA
)
778 rr
->LastAPTime
= m
->timenow
- rr
->ThisAPInterval
+ mDNSPlatformOneSecond
* 10;
780 // Set LastMCTime to now, to inhibit multicast responses
781 // (no need to send additional multicast responses when we're announcing anyway)
782 rr
->LastMCTime
= m
->timenow
;
783 rr
->LastMCInterface
= mDNSInterfaceMark
;
785 SetNextAnnounceProbeTime(m
, rr
);
788 mDNSlocal
const domainname
*SetUnicastTargetToHostName(mDNS
*const m
, AuthRecord
*rr
)
790 const domainname
*target
;
793 // For autotunnel services pointing at our IPv6 ULA we don't need or want a NAT mapping, but for all other
794 // advertised services referencing our uDNS hostname, we want NAT mappings automatically created as appropriate,
795 // with the port number in our advertised SRV record automatically tracking the external mapped port.
796 DomainAuthInfo
*AuthInfo
= GetAuthInfoForName_internal(m
, rr
->resrec
.name
);
797 if (!AuthInfo
|| !AuthInfo
->AutoTunnel
) rr
->AutoTarget
= Target_AutoHostAndNATMAP
;
800 target
= GetServiceTarget(m
, rr
);
801 if (!target
|| target
->c
[0] == 0)
803 // defer registration until we've got a target
804 LogInfo("SetUnicastTargetToHostName No target for %s", ARDisplayString(m
, rr
));
805 rr
->state
= regState_NoTarget
;
810 LogInfo("SetUnicastTargetToHostName target %##s for resource record %s", target
->c
, ARDisplayString(m
,rr
));
815 // Right now this only applies to mDNS (.local) services where the target host is always m->MulticastHostname
816 // Eventually we should unify this with GetServiceTarget() in uDNS.c
817 mDNSlocal
void SetTargetToHostName(mDNS
*const m
, AuthRecord
*const rr
)
819 domainname
*const target
= GetRRDomainNameTarget(&rr
->resrec
);
820 const domainname
*newname
= &m
->MulticastHostname
;
822 if (!target
) LogInfo("SetTargetToHostName: Don't know how to set the target of rrtype %s", DNSTypeName(rr
->resrec
.rrtype
));
824 if (!(rr
->ForceMCast
|| rr
->ARType
== AuthRecordLocalOnly
|| rr
->ARType
== AuthRecordP2P
|| IsLocalDomain(&rr
->namestorage
)))
826 const domainname
*const n
= SetUnicastTargetToHostName(m
, rr
);
828 else { target
->c
[0] = 0; SetNewRData(&rr
->resrec
, mDNSNULL
, 0); return; }
831 if (target
&& SameDomainName(target
, newname
))
832 debugf("SetTargetToHostName: Target of %##s is already %##s", rr
->resrec
.name
->c
, target
->c
);
834 if (target
&& !SameDomainName(target
, newname
))
836 AssignDomainName(target
, newname
);
837 SetNewRData(&rr
->resrec
, mDNSNULL
, 0); // Update rdlength, rdestimate, rdatahash
839 // If we're in the middle of probing this record, we need to start again,
840 // because changing its rdata may change the outcome of the tie-breaker.
841 // (If the record type is kDNSRecordTypeUnique (unconfirmed unique) then DefaultProbeCountForRecordType is non-zero.)
842 rr
->ProbeCount
= DefaultProbeCountForRecordType(rr
->resrec
.RecordType
);
844 // If we've announced this record, we really should send a goodbye packet for the old rdata before
845 // changing to the new rdata. However, in practice, we only do SetTargetToHostName for unique records,
846 // so when we announce them we'll set the kDNSClass_UniqueRRSet and clear any stale data that way.
847 if (rr
->RequireGoodbye
&& rr
->resrec
.RecordType
== kDNSRecordTypeShared
)
848 debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating",
849 rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
851 rr
->AnnounceCount
= InitialAnnounceCount
;
852 rr
->RequireGoodbye
= mDNSfalse
;
853 InitializeLastAPTime(m
, rr
);
857 mDNSlocal
void AcknowledgeRecord(mDNS
*const m
, AuthRecord
*const rr
)
859 if (rr
->RecordCallback
)
861 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
862 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
863 rr
->Acknowledged
= mDNStrue
;
864 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
865 rr
->RecordCallback(m
, rr
, mStatus_NoError
);
866 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
870 mDNSexport
void ActivateUnicastRegistration(mDNS
*const m
, AuthRecord
*const rr
)
872 // Make sure that we don't activate the SRV record and associated service records, if it is in
873 // NoTarget state. First time when a service is being instantiated, SRV record may be in NoTarget state.
874 // We should not activate any of the other reords (PTR, TXT) that are part of the service. When
875 // the target becomes available, the records will be reregistered.
876 if (rr
->resrec
.rrtype
!= kDNSType_SRV
)
878 AuthRecord
*srvRR
= mDNSNULL
;
879 if (rr
->resrec
.rrtype
== kDNSType_PTR
)
880 srvRR
= rr
->Additional1
;
881 else if (rr
->resrec
.rrtype
== kDNSType_TXT
)
882 srvRR
= rr
->DependentOn
;
885 if (srvRR
->resrec
.rrtype
!= kDNSType_SRV
)
887 LogMsg("ActivateUnicastRegistration: ERROR!! Resource record %s wrong, expecting SRV type", ARDisplayString(m
, srvRR
));
891 LogInfo("ActivateUnicastRegistration: Found Service Record %s in state %d for %##s (%s)",
892 ARDisplayString(m
, srvRR
), srvRR
->state
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
893 rr
->state
= srvRR
->state
;
898 if (rr
->state
== regState_NoTarget
)
900 LogInfo("ActivateUnicastRegistration record %s in regState_NoTarget, not activating", ARDisplayString(m
, rr
));
903 // When we wake up from sleep, we call ActivateUnicastRegistration. It is possible that just before we went to sleep,
904 // the service/record was being deregistered. In that case, we should not try to register again. For the cases where
905 // the records are deregistered due to e.g., no target for the SRV record, we would have returned from above if it
906 // was already in NoTarget state. If it was in the process of deregistration but did not complete fully before we went
907 // to sleep, then it is okay to start in Pending state as we will go back to NoTarget state if we don't have a target.
908 if (rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
)
910 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to DeregPending", ARDisplayString(m
, rr
), rr
->state
);
911 rr
->state
= regState_DeregPending
;
915 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to Pending", ARDisplayString(m
, rr
), rr
->state
);
916 rr
->state
= regState_Pending
;
919 rr
->AnnounceCount
= 0;
920 rr
->ThisAPInterval
= INIT_RECORD_REG_INTERVAL
;
921 rr
->LastAPTime
= m
->timenow
- rr
->ThisAPInterval
;
922 rr
->expire
= 0; // Forget about all the leases, start fresh
923 rr
->uselease
= mDNStrue
;
924 rr
->updateid
= zeroID
;
925 rr
->SRVChanged
= mDNSfalse
;
926 rr
->updateError
= mStatus_NoError
;
927 // RestartRecordGetZoneData calls this function whenever a new interface gets registered with core.
928 // The records might already be registered with the server and hence could have NAT state.
929 if (rr
->NATinfo
.clientContext
)
931 mDNS_StopNATOperation_internal(m
, &rr
->NATinfo
);
932 rr
->NATinfo
.clientContext
= mDNSNULL
;
934 if (rr
->nta
) { CancelGetZoneData(m
, rr
->nta
); rr
->nta
= mDNSNULL
; }
935 if (rr
->tcp
) { DisposeTCPConn(rr
->tcp
); rr
->tcp
= mDNSNULL
; }
936 if (m
->NextuDNSEvent
- (rr
->LastAPTime
+ rr
->ThisAPInterval
) >= 0)
937 m
->NextuDNSEvent
= (rr
->LastAPTime
+ rr
->ThisAPInterval
);
940 // Two records qualify to be local duplicates if:
941 // (a) the RecordTypes are the same, or
942 // (b) one is Unique and the other Verified
943 // (c) either is in the process of deregistering
944 #define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || \
945 ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified) || \
946 ((A)->resrec.RecordType == kDNSRecordTypeDeregistering || (B)->resrec.RecordType == kDNSRecordTypeDeregistering))
948 #define RecordIsLocalDuplicate(A,B) \
949 ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(&(A)->resrec, &(B)->resrec))
951 mDNSlocal AuthRecord
*CheckAuthIdenticalRecord(AuthHash
*r
, AuthRecord
*rr
)
956 const mDNSu32 slot
= AuthHashSlot(rr
->resrec
.name
);
958 a
= AuthGroupForRecord(r
, slot
, &rr
->resrec
);
959 if (!a
) return mDNSNULL
;
960 rp
= &(*ag
)->members
;
963 if (!RecordIsLocalDuplicate(*rp
, rr
))
967 if ((*rp
)->resrec
.RecordType
== kDNSRecordTypeDeregistering
)
969 (*rp
)->AnnounceCount
= 0;
978 mDNSlocal mDNSBool
CheckAuthRecordConflict(AuthHash
*r
, AuthRecord
*rr
)
983 const mDNSu32 slot
= AuthHashSlot(rr
->resrec
.name
);
985 a
= AuthGroupForRecord(r
, slot
, &rr
->resrec
);
986 if (!a
) return mDNSfalse
;
987 rp
= &(*ag
)->members
;
990 const AuthRecord
*s1
= rr
->RRSet
? rr
->RRSet
: rr
;
991 const AuthRecord
*s2
= (*rp
)->RRSet
? (*rp
)->RRSet
: *rp
;
992 if (s1
!= s2
&& SameResourceRecordSignature((*rp
), rr
) && !IdenticalSameNameRecord(&(*rp
)->resrec
, &rr
->resrec
))
1000 // checks to see if "rr" is already present
1001 mDNSlocal AuthRecord
*CheckAuthSameRecord(AuthHash
*r
, AuthRecord
*rr
)
1004 AuthGroup
**ag
= &a
;
1006 const mDNSu32 slot
= AuthHashSlot(rr
->resrec
.name
);
1008 a
= AuthGroupForRecord(r
, slot
, &rr
->resrec
);
1009 if (!a
) return mDNSNULL
;
1010 rp
= &(*ag
)->members
;
1023 // Exported so uDNS.c can call this
1024 mDNSexport mStatus
mDNS_Register_internal(mDNS
*const m
, AuthRecord
*const rr
)
1026 domainname
*target
= GetRRDomainNameTarget(&rr
->resrec
);
1028 AuthRecord
**p
= &m
->ResourceRecords
;
1029 AuthRecord
**d
= &m
->DuplicateRecords
;
1031 if ((mDNSs32
)rr
->resrec
.rroriginalttl
<= 0)
1032 { LogMsg("mDNS_Register_internal: TTL %X should be 1 - 0x7FFFFFFF %s", rr
->resrec
.rroriginalttl
, ARDisplayString(m
, rr
)); return(mStatus_BadParamErr
); }
1034 if (!rr
->resrec
.RecordType
)
1035 { LogMsg("mDNS_Register_internal: RecordType must be non-zero %s", ARDisplayString(m
, rr
)); return(mStatus_BadParamErr
); }
1037 if (m
->ShutdownTime
)
1038 { LogMsg("mDNS_Register_internal: Shutting down, can't register %s", ARDisplayString(m
, rr
)); return(mStatus_ServiceNotRunning
); }
1040 if (m
->DivertMulticastAdvertisements
&& !AuthRecord_uDNS(rr
))
1042 mDNSInterfaceID previousID
= rr
->resrec
.InterfaceID
;
1043 if (rr
->resrec
.InterfaceID
== mDNSInterface_Any
|| rr
->resrec
.InterfaceID
== mDNSInterface_P2P
)
1045 rr
->resrec
.InterfaceID
= mDNSInterface_LocalOnly
;
1046 rr
->ARType
= AuthRecordLocalOnly
;
1048 if (rr
->resrec
.InterfaceID
!= mDNSInterface_LocalOnly
)
1050 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, rr
->resrec
.InterfaceID
);
1051 if (intf
&& !intf
->Advertise
){ rr
->resrec
.InterfaceID
= mDNSInterface_LocalOnly
; rr
->ARType
= AuthRecordLocalOnly
; }
1053 if (rr
->resrec
.InterfaceID
!= previousID
)
1054 LogInfo("mDNS_Register_internal: Diverting record to local-only %s", ARDisplayString(m
, rr
));
1057 if (RRLocalOnly(rr
))
1059 if (CheckAuthSameRecord(&m
->rrauth
, rr
))
1061 LogMsg("mDNS_Register_internal: ERROR!! Tried to register LocalOnly AuthRecord %p %##s (%s) that's already in the list",
1062 rr
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1063 return(mStatus_AlreadyRegistered
);
1068 while (*p
&& *p
!= rr
) p
=&(*p
)->next
;
1071 LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the list",
1072 rr
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1073 return(mStatus_AlreadyRegistered
);
1077 while (*d
&& *d
!= rr
) d
=&(*d
)->next
;
1080 LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the Duplicate list",
1081 rr
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1082 return(mStatus_AlreadyRegistered
);
1085 if (rr
->DependentOn
)
1087 if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
)
1088 rr
->resrec
.RecordType
= kDNSRecordTypeVerified
;
1091 LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique",
1092 rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1093 return(mStatus_Invalid
);
1095 if (!(rr
->DependentOn
->resrec
.RecordType
& (kDNSRecordTypeUnique
| kDNSRecordTypeVerified
| kDNSRecordTypeKnownUnique
)))
1097 LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X",
1098 rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
), rr
->DependentOn
->resrec
.RecordType
);
1099 return(mStatus_Invalid
);
1103 // If this resource record is referencing a specific interface, make sure it exists.
1104 // Skip checks for LocalOnly and P2P as they are not valid InterfaceIDs. Also, for scoped
1105 // entries in /etc/hosts skip that check as that interface may not be valid at this time.
1106 if (rr
->resrec
.InterfaceID
&& rr
->ARType
!= AuthRecordLocalOnly
&& rr
->ARType
!= AuthRecordP2P
)
1108 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, rr
->resrec
.InterfaceID
);
1111 debugf("mDNS_Register_internal: Bogus InterfaceID %p in resource record", rr
->resrec
.InterfaceID
);
1112 return(mStatus_BadReferenceErr
);
1116 rr
->next
= mDNSNULL
;
1118 // Field Group 1: The actual information pertaining to this resource record
1119 // Set up by client prior to call
1121 // Field Group 2: Persistent metadata for Authoritative Records
1122 // rr->Additional1 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1123 // rr->Additional2 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1124 // rr->DependentOn = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1125 // rr->RRSet = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
1126 // rr->Callback = already set in mDNS_SetupResourceRecord
1127 // rr->Context = already set in mDNS_SetupResourceRecord
1128 // rr->RecordType = already set in mDNS_SetupResourceRecord
1129 // rr->HostTarget = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client
1130 // rr->AllowRemoteQuery = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client
1131 // Make sure target is not uninitialized data, or we may crash writing debugging log messages
1132 if (rr
->AutoTarget
&& target
) target
->c
[0] = 0;
1134 // Field Group 3: Transient state for Authoritative Records
1135 rr
->Acknowledged
= mDNSfalse
;
1136 rr
->ProbeCount
= DefaultProbeCountForRecordType(rr
->resrec
.RecordType
);
1137 rr
->AnnounceCount
= InitialAnnounceCount
;
1138 rr
->RequireGoodbye
= mDNSfalse
;
1139 rr
->AnsweredLocalQ
= mDNSfalse
;
1140 rr
->IncludeInProbe
= mDNSfalse
;
1141 rr
->ImmedUnicast
= mDNSfalse
;
1142 rr
->SendNSECNow
= mDNSNULL
;
1143 rr
->ImmedAnswer
= mDNSNULL
;
1144 rr
->ImmedAdditional
= mDNSNULL
;
1145 rr
->SendRNow
= mDNSNULL
;
1146 rr
->v4Requester
= zerov4Addr
;
1147 rr
->v6Requester
= zerov6Addr
;
1148 rr
->NextResponse
= mDNSNULL
;
1149 rr
->NR_AnswerTo
= mDNSNULL
;
1150 rr
->NR_AdditionalTo
= mDNSNULL
;
1151 if (!rr
->AutoTarget
) InitializeLastAPTime(m
, rr
);
1152 // rr->LastAPTime = Set for us in InitializeLastAPTime()
1153 // rr->LastMCTime = Set for us in InitializeLastAPTime()
1154 // rr->LastMCInterface = Set for us in InitializeLastAPTime()
1155 rr
->NewRData
= mDNSNULL
;
1156 rr
->newrdlength
= 0;
1157 rr
->UpdateCallback
= mDNSNULL
;
1158 rr
->UpdateCredits
= kMaxUpdateCredits
;
1159 rr
->NextUpdateCredit
= 0;
1160 rr
->UpdateBlocked
= 0;
1162 // For records we're holding as proxy (except reverse-mapping PTR records) two announcements is sufficient
1163 if (rr
->WakeUp
.HMAC
.l
[0] && !rr
->AddressProxy
.type
) rr
->AnnounceCount
= 2;
1165 // Field Group 4: Transient uDNS state for Authoritative Records
1166 rr
->state
= regState_Zero
;
1170 rr
->updateid
= zeroID
;
1171 rr
->zone
= rr
->resrec
.name
;
1176 rr
->InFlightRData
= 0;
1177 rr
->InFlightRDLen
= 0;
1178 rr
->QueuedRData
= 0;
1179 rr
->QueuedRDLen
= 0;
1180 //mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo));
1181 // We should be recording the actual internal port for this service record here. Once we initiate our NAT mapping
1182 // request we'll subsequently overwrite srv.port with the allocated external NAT port -- potentially multiple
1183 // times with different values if the external NAT port changes during the lifetime of the service registration.
1184 //if (rr->resrec.rrtype == kDNSType_SRV) rr->NATinfo.IntPort = rr->resrec.rdata->u.srv.port;
1186 // rr->resrec.interface = already set in mDNS_SetupResourceRecord
1187 // rr->resrec.name->c = MUST be set by client
1188 // rr->resrec.rrtype = already set in mDNS_SetupResourceRecord
1189 // rr->resrec.rrclass = already set in mDNS_SetupResourceRecord
1190 // rr->resrec.rroriginalttl = already set in mDNS_SetupResourceRecord
1191 // rr->resrec.rdata = MUST be set by client, unless record type is CNAME or PTR and rr->HostTarget is set
1193 // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,
1194 // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".
1195 // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.
1196 if (rr
->resrec
.rrtype
== kDNSType_TXT
&& rr
->resrec
.rdlength
== 0) { rr
->resrec
.rdlength
= 1; rr
->resrec
.rdata
->u
.txt
.c
[0] = 0; }
1200 SetTargetToHostName(m
, rr
); // Also sets rdlength and rdestimate for us, and calls InitializeLastAPTime();
1201 #ifndef UNICAST_DISABLED
1202 // If we have no target record yet, SetTargetToHostName will set rr->state == regState_NoTarget
1203 // In this case we leave the record half-formed in the list, and later we'll remove it from the list and re-add it properly.
1204 if (rr
->state
== regState_NoTarget
)
1206 // Initialize the target so that we don't crash while logging etc.
1207 domainname
*tar
= GetRRDomainNameTarget(&rr
->resrec
);
1208 if (tar
) tar
->c
[0] = 0;
1209 LogInfo("mDNS_Register_internal: record %s in NoTarget state", ARDisplayString(m
, rr
));
1215 rr
->resrec
.rdlength
= GetRDLength(&rr
->resrec
, mDNSfalse
);
1216 rr
->resrec
.rdestimate
= GetRDLength(&rr
->resrec
, mDNStrue
);
1219 if (!ValidateDomainName(rr
->resrec
.name
))
1220 { LogMsg("Attempt to register record with invalid name: %s", ARDisplayString(m
, rr
)); return(mStatus_Invalid
); }
1222 // Don't do this until *after* we've set rr->resrec.rdlength
1223 if (!ValidateRData(rr
->resrec
.rrtype
, rr
->resrec
.rdlength
, rr
->resrec
.rdata
))
1224 { LogMsg("Attempt to register record with invalid rdata: %s", ARDisplayString(m
, rr
)); return(mStatus_Invalid
); }
1226 rr
->resrec
.namehash
= DomainNameHashValue(rr
->resrec
.name
);
1227 rr
->resrec
.rdatahash
= target
? DomainNameHashValue(target
) : RDataHashValue(&rr
->resrec
);
1229 if (RRLocalOnly(rr
))
1231 // If this is supposed to be unique, make sure we don't have any name conflicts.
1232 // If we found a conflict, we may still want to insert the record in the list but mark it appropriately
1233 // (kDNSRecordTypeDeregistering) so that we deliver RMV events to the application. But this causes more
1234 // complications and not clear whether there are any benefits. See rdar:9304275 for details.
1235 // Hence, just bail out.
1236 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
1238 if (CheckAuthRecordConflict(&m
->rrauth
, rr
))
1240 LogInfo("mDNS_Register_internal: Name conflict %s (%p), InterfaceID %p", ARDisplayString(m
, rr
), rr
, rr
->resrec
.InterfaceID
);
1241 return mStatus_NameConflict
;
1246 // For uDNS records, we don't support duplicate checks at this time.
1247 #ifndef UNICAST_DISABLED
1248 if (AuthRecord_uDNS(rr
))
1250 if (!m
->NewLocalRecords
) m
->NewLocalRecords
= rr
;
1251 // When we called SetTargetToHostName, it may have caused mDNS_Register_internal to be re-entered, appending new
1252 // records to the list, so we now need to update p to advance to the new end to the list before appending our new record.
1253 // Note that for AutoTunnel this should never happen, but this check makes the code future-proof.
1254 while (*p
) p
=&(*p
)->next
;
1256 if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
) rr
->resrec
.RecordType
= kDNSRecordTypeVerified
;
1258 rr
->AnnounceCount
= 0;
1259 if (rr
->state
!= regState_NoTarget
) ActivateUnicastRegistration(m
, rr
);
1260 return(mStatus_NoError
); // <--- Note: For unicast records, code currently bails out at this point
1264 // Now that we've finished building our new record, make sure it's not identical to one we already have
1265 if (RRLocalOnly(rr
))
1268 rr
->AnnounceCount
= 0;
1269 r
= CheckAuthIdenticalRecord(&m
->rrauth
, rr
);
1273 for (r
= m
->ResourceRecords
; r
; r
=r
->next
)
1274 if (RecordIsLocalDuplicate(r
, rr
))
1276 if (r
->resrec
.RecordType
== kDNSRecordTypeDeregistering
) r
->AnnounceCount
= 0;
1283 debugf("mDNS_Register_internal:Adding to duplicate list %s", ARDisplayString(m
,rr
));
1285 // If the previous copy of this record is already verified unique,
1286 // then indicate that we should move this record promptly to kDNSRecordTypeUnique state.
1287 // Setting ProbeCount to zero will cause SendQueries() to advance this record to
1288 // kDNSRecordTypeVerified state and call the client callback at the next appropriate time.
1289 if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
&& r
->resrec
.RecordType
== kDNSRecordTypeVerified
)
1294 debugf("mDNS_Register_internal: Adding to active record list %s", ARDisplayString(m
,rr
));
1295 if (RRLocalOnly(rr
))
1298 ag
= InsertAuthRecord(m
, &m
->rrauth
, rr
);
1299 if (ag
&& !ag
->NewLocalOnlyRecords
) {
1300 m
->NewLocalOnlyRecords
= mDNStrue
;
1301 ag
->NewLocalOnlyRecords
= rr
;
1303 // No probing for LocalOnly records, Acknowledge them right away
1304 if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
) rr
->resrec
.RecordType
= kDNSRecordTypeVerified
;
1305 AcknowledgeRecord(m
, rr
);
1306 return(mStatus_NoError
);
1310 if (!m
->NewLocalRecords
) m
->NewLocalRecords
= rr
;
1315 if (!AuthRecord_uDNS(rr
)) // This check is superfluous, given that for unicast records we (currently) bail out above
1317 // For records that are not going to probe, acknowledge them right away
1318 if (rr
->resrec
.RecordType
!= kDNSRecordTypeUnique
&& rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
)
1319 AcknowledgeRecord(m
, rr
);
1321 // Adding a record may affect whether or not we should sleep
1322 mDNS_UpdateAllowSleep(m
);
1325 return(mStatus_NoError
);
1328 mDNSlocal
void RecordProbeFailure(mDNS
*const m
, const AuthRecord
*const rr
)
1330 m
->ProbeFailTime
= m
->timenow
;
1331 m
->NumFailedProbes
++;
1332 // If we've had fifteen or more probe failures, rate-limit to one every five seconds.
1333 // If a bunch of hosts have all been configured with the same name, then they'll all
1334 // conflict and run through the same series of names: name-2, name-3, name-4, etc.,
1335 // up to name-10. After that they'll start adding random increments in the range 1-100,
1336 // so they're more likely to branch out in the available namespace and settle on a set of
1337 // unique names quickly. If after five more tries the host is still conflicting, then we
1338 // may have a serious problem, so we start rate-limiting so we don't melt down the network.
1339 if (m
->NumFailedProbes
>= 15)
1341 m
->SuppressProbes
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
* 5);
1342 LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect",
1343 m
->NumFailedProbes
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1347 mDNSlocal
void CompleteRDataUpdate(mDNS
*const m
, AuthRecord
*const rr
)
1349 RData
*OldRData
= rr
->resrec
.rdata
;
1350 mDNSu16 OldRDLen
= rr
->resrec
.rdlength
;
1351 SetNewRData(&rr
->resrec
, rr
->NewRData
, rr
->newrdlength
); // Update our rdata
1352 rr
->NewRData
= mDNSNULL
; // Clear the NewRData pointer ...
1353 if (rr
->UpdateCallback
)
1354 rr
->UpdateCallback(m
, rr
, OldRData
, OldRDLen
); // ... and let the client know
1357 // Note: mDNS_Deregister_internal can call a user callback, which may change the record list and/or question list.
1358 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
1359 // Exported so uDNS.c can call this
1360 mDNSexport mStatus
mDNS_Deregister_internal(mDNS
*const m
, AuthRecord
*const rr
, mDNS_Dereg_type drt
)
1363 mDNSu8 RecordType
= rr
->resrec
.RecordType
;
1364 AuthRecord
**p
= &m
->ResourceRecords
; // Find this record in our list of active records
1365 mDNSBool dupList
= mDNSfalse
;
1367 if (RRLocalOnly(rr
))
1370 AuthGroup
**ag
= &a
;
1372 const mDNSu32 slot
= AuthHashSlot(rr
->resrec
.name
);
1374 a
= AuthGroupForRecord(&m
->rrauth
, slot
, &rr
->resrec
);
1375 if (!a
) return mDNSfalse
;
1376 rp
= &(*ag
)->members
;
1377 while (*rp
&& *rp
!= rr
) rp
=&(*rp
)->next
;
1382 while (*p
&& *p
!= rr
) p
=&(*p
)->next
;
1387 // We found our record on the main list. See if there are any duplicates that need special handling.
1388 if (drt
== mDNS_Dereg_conflict
) // If this was a conflict, see that all duplicates get the same treatment
1390 // Scan for duplicates of rr, and mark them for deregistration at the end of this routine, after we've finished
1391 // deregistering rr. We need to do this scan *before* we give the client the chance to free and reuse the rr memory.
1392 for (r2
= m
->DuplicateRecords
; r2
; r2
=r2
->next
) if (RecordIsLocalDuplicate(r2
, rr
)) r2
->ProbeCount
= 0xFF;
1396 // Before we delete the record (and potentially send a goodbye packet)
1397 // first see if we have a record on the duplicate list ready to take over from it.
1398 AuthRecord
**d
= &m
->DuplicateRecords
;
1399 while (*d
&& !RecordIsLocalDuplicate(*d
, rr
)) d
=&(*d
)->next
;
1402 AuthRecord
*dup
= *d
;
1403 debugf("mDNS_Register_internal: Duplicate record %p taking over from %p %##s (%s)",
1404 dup
, rr
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1405 *d
= dup
->next
; // Cut replacement record from DuplicateRecords list
1406 if (RRLocalOnly(rr
))
1408 dup
->next
= mDNSNULL
;
1409 if (!InsertAuthRecord(m
, &m
->rrauth
, dup
)) LogMsg("mDNS_Deregister_internal: ERROR!! cannot insert %s", ARDisplayString(m
, dup
));
1413 dup
->next
= rr
->next
; // And then...
1414 rr
->next
= dup
; // ... splice it in right after the record we're about to delete
1416 dup
->resrec
.RecordType
= rr
->resrec
.RecordType
;
1417 dup
->ProbeCount
= rr
->ProbeCount
;
1418 dup
->AnnounceCount
= rr
->AnnounceCount
;
1419 dup
->RequireGoodbye
= rr
->RequireGoodbye
;
1420 dup
->AnsweredLocalQ
= rr
->AnsweredLocalQ
;
1421 dup
->ImmedAnswer
= rr
->ImmedAnswer
;
1422 dup
->ImmedUnicast
= rr
->ImmedUnicast
;
1423 dup
->ImmedAdditional
= rr
->ImmedAdditional
;
1424 dup
->v4Requester
= rr
->v4Requester
;
1425 dup
->v6Requester
= rr
->v6Requester
;
1426 dup
->ThisAPInterval
= rr
->ThisAPInterval
;
1427 dup
->LastAPTime
= rr
->LastAPTime
;
1428 dup
->LastMCTime
= rr
->LastMCTime
;
1429 dup
->LastMCInterface
= rr
->LastMCInterface
;
1430 dup
->Private
= rr
->Private
;
1431 dup
->state
= rr
->state
;
1432 rr
->RequireGoodbye
= mDNSfalse
;
1433 rr
->AnsweredLocalQ
= mDNSfalse
;
1439 // We didn't find our record on the main list; try the DuplicateRecords list instead.
1440 p
= &m
->DuplicateRecords
;
1441 while (*p
&& *p
!= rr
) p
=&(*p
)->next
;
1442 // If we found our record on the duplicate list, then make sure we don't send a goodbye for it
1443 if (*p
) { rr
->RequireGoodbye
= mDNSfalse
; dupList
= mDNStrue
; }
1444 if (*p
) debugf("mDNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)",
1445 rr
, rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1450 // No need to log an error message if we already know this is a potentially repeated deregistration
1451 if (drt
!= mDNS_Dereg_repeat
)
1452 LogMsg("mDNS_Deregister_internal: Record %p not found in list %s", rr
, ARDisplayString(m
,rr
));
1453 return(mStatus_BadReferenceErr
);
1456 // If this is a shared record and we've announced it at least once,
1457 // we need to retract that announcement before we delete the record
1459 // If this is a record (including mDNSInterface_LocalOnly records) for which we've given local-only answers then
1460 // it's tempting to just do "AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse)" here, but that would not not be safe.
1461 // The AnswerAllLocalQuestionsWithLocalAuthRecord routine walks the question list invoking client callbacks, using the "m->CurrentQuestion"
1462 // mechanism to cope with the client callback modifying the question list while that's happening.
1463 // However, mDNS_Deregister could have been called from a client callback (e.g. from the domain enumeration callback FoundDomain)
1464 // which means that the "m->CurrentQuestion" mechanism is already in use to protect that list, so we can't use it twice.
1465 // More generally, if we invoke callbacks from within a client callback, then those callbacks could deregister other
1466 // records, thereby invoking yet more callbacks, without limit.
1467 // The solution is to defer delivering the "Remove" events until mDNS_Execute time, just like we do for sending
1468 // actual goodbye packets.
1470 #ifndef UNICAST_DISABLED
1471 if (AuthRecord_uDNS(rr
))
1473 if (rr
->RequireGoodbye
)
1475 if (rr
->tcp
) { DisposeTCPConn(rr
->tcp
); rr
->tcp
= mDNSNULL
; }
1476 rr
->resrec
.RecordType
= kDNSRecordTypeDeregistering
;
1477 m
->LocalRemoveEvents
= mDNStrue
;
1478 uDNS_DeregisterRecord(m
, rr
);
1479 // At this point unconditionally we bail out
1480 // Either uDNS_DeregisterRecord will have completed synchronously, and called CompleteDeregistration,
1481 // which calls us back here with RequireGoodbye set to false, or it will have initiated the deregistration
1482 // process and will complete asynchronously. Either way we don't need to do anything more here.
1483 return(mStatus_NoError
);
1485 // Sometimes the records don't complete proper deregistration i.e., don't wait for a response
1486 // from the server. In that case, if the records have been part of a group update, clear the
1487 // state here. Some recors e.g., AutoTunnel gets reused without ever being completely initialized
1488 rr
->updateid
= zeroID
;
1490 // We defer cleaning up NAT state only after sending goodbyes. This is important because
1491 // RecordRegistrationGotZoneData guards against creating NAT state if clientContext is non-NULL.
1492 // This happens today when we turn on/off interface where we get multiple network transitions
1493 // and RestartRecordGetZoneData triggers re-registration of the resource records even though
1494 // they may be in Registered state which causes NAT information to be setup multiple times. Defering
1495 // the cleanup here keeps clientContext non-NULL and hence prevents that. Note that cleaning up
1496 // NAT state here takes care of the case where we did not send goodbyes at all.
1497 if (rr
->NATinfo
.clientContext
)
1499 mDNS_StopNATOperation_internal(m
, &rr
->NATinfo
);
1500 rr
->NATinfo
.clientContext
= mDNSNULL
;
1502 if (rr
->nta
) { CancelGetZoneData(m
, rr
->nta
); rr
->nta
= mDNSNULL
; }
1503 if (rr
->tcp
) { DisposeTCPConn(rr
->tcp
); rr
->tcp
= mDNSNULL
; }
1505 #endif // UNICAST_DISABLED
1507 if (RecordType
== kDNSRecordTypeUnregistered
)
1508 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered", ARDisplayString(m
, rr
));
1509 else if (RecordType
== kDNSRecordTypeDeregistering
)
1511 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering", ARDisplayString(m
, rr
));
1512 return(mStatus_BadReferenceErr
);
1515 // <rdar://problem/7457925> Local-only questions don't get remove events for unique records
1516 // We may want to consider changing this code so that we generate local-only question "rmv"
1517 // events (and maybe goodbye packets too) for unique records as well as for shared records
1518 // Note: If we change the logic for this "if" statement, need to ensure that the code in
1519 // CompleteDeregistration() sets the appropriate state variables to gaurantee that "else"
1520 // clause will execute here and the record will be cut from the list.
1521 if (rr
->WakeUp
.HMAC
.l
[0] ||
1522 (RecordType
== kDNSRecordTypeShared
&& (rr
->RequireGoodbye
|| rr
->AnsweredLocalQ
)))
1524 verbosedebugf("mDNS_Deregister_internal: Starting deregistration for %s", ARDisplayString(m
, rr
));
1525 rr
->resrec
.RecordType
= kDNSRecordTypeDeregistering
;
1526 rr
->resrec
.rroriginalttl
= 0;
1527 rr
->AnnounceCount
= rr
->WakeUp
.HMAC
.l
[0] ? WakeupCount
: (drt
== mDNS_Dereg_rapid
) ? 1 : GoodbyeCount
;
1528 rr
->ThisAPInterval
= mDNSPlatformOneSecond
* 2;
1529 rr
->LastAPTime
= m
->timenow
- rr
->ThisAPInterval
;
1530 m
->LocalRemoveEvents
= mDNStrue
;
1531 if (m
->NextScheduledResponse
- (m
->timenow
+ mDNSPlatformOneSecond
/10) >= 0)
1532 m
->NextScheduledResponse
= (m
->timenow
+ mDNSPlatformOneSecond
/10);
1536 if (!dupList
&& RRLocalOnly(rr
))
1538 AuthGroup
*ag
= RemoveAuthRecord(m
, &m
->rrauth
, rr
);
1539 if (ag
->NewLocalOnlyRecords
== rr
) ag
->NewLocalOnlyRecords
= rr
->next
;
1543 *p
= rr
->next
; // Cut this record from the list
1544 if (m
->NewLocalRecords
== rr
) m
->NewLocalRecords
= rr
->next
;
1546 // If someone is about to look at this, bump the pointer forward
1547 if (m
->CurrentRecord
== rr
) m
->CurrentRecord
= rr
->next
;
1548 rr
->next
= mDNSNULL
;
1550 // Should we generate local remove events here?
1551 // i.e. something like:
1552 // if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; }
1554 verbosedebugf("mDNS_Deregister_internal: Deleting record for %s", ARDisplayString(m
, rr
));
1555 rr
->resrec
.RecordType
= kDNSRecordTypeUnregistered
;
1557 if ((drt
== mDNS_Dereg_conflict
|| drt
== mDNS_Dereg_repeat
) && RecordType
== kDNSRecordTypeShared
)
1558 debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)",
1559 rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1561 // If we have an update queued up which never executed, give the client a chance to free that memory
1562 if (rr
->NewRData
) CompleteRDataUpdate(m
, rr
); // Update our rdata, clear the NewRData pointer, and return memory to the client
1565 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
1566 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
1567 // In this case the likely client action to the mStatus_MemFree message is to free the memory,
1568 // so any attempt to touch rr after this is likely to lead to a crash.
1569 if (drt
!= mDNS_Dereg_conflict
)
1571 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
1572 LogInfo("mDNS_Deregister_internal: mStatus_MemFree for %s", ARDisplayString(m
, rr
));
1573 if (rr
->RecordCallback
)
1574 rr
->RecordCallback(m
, rr
, mStatus_MemFree
); // MUST NOT touch rr after this
1575 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
1579 RecordProbeFailure(m
, rr
);
1580 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
1581 if (rr
->RecordCallback
)
1582 rr
->RecordCallback(m
, rr
, mStatus_NameConflict
); // MUST NOT touch rr after this
1583 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
1584 // Now that we've finished deregistering rr, check our DuplicateRecords list for any that we marked previously.
1585 // Note that with all the client callbacks going on, by the time we get here all the
1586 // records we marked may have been explicitly deregistered by the client anyway.
1587 r2
= m
->DuplicateRecords
;
1590 if (r2
->ProbeCount
!= 0xFF) r2
= r2
->next
;
1591 else { mDNS_Deregister_internal(m
, r2
, mDNS_Dereg_conflict
); r2
= m
->DuplicateRecords
; }
1595 mDNS_UpdateAllowSleep(m
);
1596 return(mStatus_NoError
);
1599 // ***************************************************************************
1600 #if COMPILER_LIKES_PRAGMA_MARK
1602 #pragma mark - Packet Sending Functions
1605 mDNSlocal
void AddRecordToResponseList(AuthRecord
***nrpp
, AuthRecord
*rr
, AuthRecord
*add
)
1607 if (rr
->NextResponse
== mDNSNULL
&& *nrpp
!= &rr
->NextResponse
)
1610 // NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo)
1611 // If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does
1612 // The referenced record will definitely be acceptable (by recursive application of this rule)
1613 if (add
&& add
->NR_AdditionalTo
) add
= add
->NR_AdditionalTo
;
1614 rr
->NR_AdditionalTo
= add
;
1615 *nrpp
= &rr
->NextResponse
;
1617 debugf("AddRecordToResponseList: %##s (%s) already in list", rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
));
1620 mDNSlocal
void AddAdditionalsToResponseList(mDNS
*const m
, AuthRecord
*ResponseRecords
, AuthRecord
***nrpp
, const mDNSInterfaceID InterfaceID
)
1622 AuthRecord
*rr
, *rr2
;
1623 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
) // For each record we plan to put
1625 // (Note: This is an "if", not a "while". If we add a record, we'll find it again
1626 // later in the "for" loop, and we will follow further "additional" links then.)
1627 if (rr
->Additional1
&& ResourceRecordIsValidInterfaceAnswer(rr
->Additional1
, InterfaceID
))
1628 AddRecordToResponseList(nrpp
, rr
->Additional1
, rr
);
1630 if (rr
->Additional2
&& ResourceRecordIsValidInterfaceAnswer(rr
->Additional2
, InterfaceID
))
1631 AddRecordToResponseList(nrpp
, rr
->Additional2
, rr
);
1633 // For SRV records, automatically add the Address record(s) for the target host
1634 if (rr
->resrec
.rrtype
== kDNSType_SRV
)
1636 for (rr2
=m
->ResourceRecords
; rr2
; rr2
=rr2
->next
) // Scan list of resource records
1637 if (RRTypeIsAddressType(rr2
->resrec
.rrtype
) && // For all address records (A/AAAA) ...
1638 ResourceRecordIsValidInterfaceAnswer(rr2
, InterfaceID
) && // ... which are valid for answer ...
1639 rr
->resrec
.rdatahash
== rr2
->resrec
.namehash
&& // ... whose name is the name of the SRV target
1640 SameDomainName(&rr
->resrec
.rdata
->u
.srv
.target
, rr2
->resrec
.name
))
1641 AddRecordToResponseList(nrpp
, rr2
, rr
);
1643 else if (RRTypeIsAddressType(rr
->resrec
.rrtype
)) // For A or AAAA, put counterpart as additional
1645 for (rr2
=m
->ResourceRecords
; rr2
; rr2
=rr2
->next
) // Scan list of resource records
1646 if (RRTypeIsAddressType(rr2
->resrec
.rrtype
) && // For all address records (A/AAAA) ...
1647 ResourceRecordIsValidInterfaceAnswer(rr2
, InterfaceID
) && // ... which are valid for answer ...
1648 rr
->resrec
.namehash
== rr2
->resrec
.namehash
&& // ... and have the same name
1649 SameDomainName(rr
->resrec
.name
, rr2
->resrec
.name
))
1650 AddRecordToResponseList(nrpp
, rr2
, rr
);
1652 else if (rr
->resrec
.rrtype
== kDNSType_PTR
) // For service PTR, see if we want to add DeviceInfo record
1654 if (ResourceRecordIsValidInterfaceAnswer(&m
->DeviceInfo
, InterfaceID
) &&
1655 SameDomainLabel(rr
->resrec
.rdata
->u
.name
.c
, m
->DeviceInfo
.resrec
.name
->c
))
1656 AddRecordToResponseList(nrpp
, &m
->DeviceInfo
, rr
);
1661 mDNSlocal
void SendDelayedUnicastResponse(mDNS
*const m
, const mDNSAddr
*const dest
, const mDNSInterfaceID InterfaceID
)
1664 AuthRecord
*ResponseRecords
= mDNSNULL
;
1665 AuthRecord
**nrp
= &ResponseRecords
;
1666 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, InterfaceID
);
1668 // Make a list of all our records that need to be unicast to this destination
1669 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
1671 // If we find we can no longer unicast this answer, clear ImmedUnicast
1672 if (rr
->ImmedAnswer
== mDNSInterfaceMark
||
1673 mDNSSameIPv4Address(rr
->v4Requester
, onesIPv4Addr
) ||
1674 mDNSSameIPv6Address(rr
->v6Requester
, onesIPv6Addr
) )
1675 rr
->ImmedUnicast
= mDNSfalse
;
1677 if (rr
->ImmedUnicast
&& rr
->ImmedAnswer
== InterfaceID
)
1679 if ((dest
->type
== mDNSAddrType_IPv4
&& mDNSSameIPv4Address(rr
->v4Requester
, dest
->ip
.v4
)) ||
1680 (dest
->type
== mDNSAddrType_IPv6
&& mDNSSameIPv6Address(rr
->v6Requester
, dest
->ip
.v6
)))
1682 rr
->ImmedAnswer
= mDNSNULL
; // Clear the state fields
1683 rr
->ImmedUnicast
= mDNSfalse
;
1684 rr
->v4Requester
= zerov4Addr
;
1685 rr
->v6Requester
= zerov6Addr
;
1687 // Only sent records registered for P2P over P2P interfaces
1688 if (intf
&& !mDNSPlatformValidRecordForInterface(rr
, intf
))
1690 LogInfo("SendDelayedUnicastResponse: Not sending %s, on %s", ARDisplayString(m
, rr
), InterfaceNameForID(m
, InterfaceID
));
1694 if (rr
->NextResponse
== mDNSNULL
&& nrp
!= &rr
->NextResponse
) // rr->NR_AnswerTo
1695 { rr
->NR_AnswerTo
= (mDNSu8
*)~0; *nrp
= rr
; nrp
= &rr
->NextResponse
; }
1700 AddAdditionalsToResponseList(m
, ResponseRecords
, &nrp
, InterfaceID
);
1702 while (ResponseRecords
)
1704 mDNSu8
*responseptr
= m
->omsg
.data
;
1706 InitializeDNSMessage(&m
->omsg
.h
, zeroID
, ResponseFlags
);
1708 // Put answers in the packet
1709 while (ResponseRecords
&& ResponseRecords
->NR_AnswerTo
)
1711 rr
= ResponseRecords
;
1712 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
1713 rr
->resrec
.rrclass
|= kDNSClass_UniqueRRSet
; // Temporarily set the cache flush bit so PutResourceRecord will set it
1714 newptr
= PutResourceRecord(&m
->omsg
, responseptr
, &m
->omsg
.h
.numAnswers
, &rr
->resrec
);
1715 rr
->resrec
.rrclass
&= ~kDNSClass_UniqueRRSet
; // Make sure to clear cache flush bit back to normal state
1716 if (!newptr
&& m
->omsg
.h
.numAnswers
) break; // If packet full, send it now
1717 if (newptr
) responseptr
= newptr
;
1718 ResponseRecords
= rr
->NextResponse
;
1719 rr
->NextResponse
= mDNSNULL
;
1720 rr
->NR_AnswerTo
= mDNSNULL
;
1721 rr
->NR_AdditionalTo
= mDNSNULL
;
1722 rr
->RequireGoodbye
= mDNStrue
;
1725 // Add additionals, if there's space
1726 while (ResponseRecords
&& !ResponseRecords
->NR_AnswerTo
)
1728 rr
= ResponseRecords
;
1729 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
1730 rr
->resrec
.rrclass
|= kDNSClass_UniqueRRSet
; // Temporarily set the cache flush bit so PutResourceRecord will set it
1731 newptr
= PutResourceRecord(&m
->omsg
, responseptr
, &m
->omsg
.h
.numAdditionals
, &rr
->resrec
);
1732 rr
->resrec
.rrclass
&= ~kDNSClass_UniqueRRSet
; // Make sure to clear cache flush bit back to normal state
1734 if (newptr
) responseptr
= newptr
;
1735 if (newptr
&& m
->omsg
.h
.numAnswers
) rr
->RequireGoodbye
= mDNStrue
;
1736 else if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
) rr
->ImmedAnswer
= mDNSInterfaceMark
;
1737 ResponseRecords
= rr
->NextResponse
;
1738 rr
->NextResponse
= mDNSNULL
;
1739 rr
->NR_AnswerTo
= mDNSNULL
;
1740 rr
->NR_AdditionalTo
= mDNSNULL
;
1743 if (m
->omsg
.h
.numAnswers
)
1744 mDNSSendDNSMessage(m
, &m
->omsg
, responseptr
, InterfaceID
, mDNSNULL
, dest
, MulticastDNSPort
, mDNSNULL
, mDNSNULL
);
1748 // CompleteDeregistration guarantees that on exit the record will have been cut from the m->ResourceRecords list
1749 // and the client's mStatus_MemFree callback will have been invoked
1750 mDNSexport
void CompleteDeregistration(mDNS
*const m
, AuthRecord
*rr
)
1752 LogInfo("CompleteDeregistration: called for Resource record %s", ARDisplayString(m
, rr
));
1753 // Clearing rr->RequireGoodbye signals mDNS_Deregister_internal() that
1754 // it should go ahead and immediately dispose of this registration
1755 rr
->resrec
.RecordType
= kDNSRecordTypeShared
;
1756 rr
->RequireGoodbye
= mDNSfalse
;
1757 rr
->WakeUp
.HMAC
= zeroEthAddr
;
1758 if (rr
->AnsweredLocalQ
) { AnswerAllLocalQuestionsWithLocalAuthRecord(m
, rr
, mDNSfalse
); rr
->AnsweredLocalQ
= mDNSfalse
; }
1759 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
); // Don't touch rr after this
1762 // DiscardDeregistrations is used on shutdown and sleep to discard (forcibly and immediately)
1763 // any deregistering records that remain in the m->ResourceRecords list.
1764 // DiscardDeregistrations calls mDNS_Deregister_internal which can call a user callback,
1765 // which may change the record list and/or question list.
1766 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
1767 mDNSlocal
void DiscardDeregistrations(mDNS
*const m
)
1769 if (m
->CurrentRecord
)
1770 LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
1771 m
->CurrentRecord
= m
->ResourceRecords
;
1773 while (m
->CurrentRecord
)
1775 AuthRecord
*rr
= m
->CurrentRecord
;
1776 if (!AuthRecord_uDNS(rr
) && rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
)
1777 CompleteDeregistration(m
, rr
); // Don't touch rr after this
1779 m
->CurrentRecord
= rr
->next
;
1783 mDNSlocal mStatus
GetLabelDecimalValue(const mDNSu8
*const src
, mDNSu8
*dst
)
1786 if (src
[0] < 1 || src
[0] > 3) return(mStatus_Invalid
);
1787 for (i
=1; i
<=src
[0]; i
++)
1789 if (src
[i
] < '0' || src
[i
] > '9') return(mStatus_Invalid
);
1790 val
= val
* 10 + src
[i
] - '0';
1792 if (val
> 255) return(mStatus_Invalid
);
1794 return(mStatus_NoError
);
1797 mDNSlocal mStatus
GetIPv4FromName(mDNSAddr
*const a
, const domainname
*const name
)
1799 int skip
= CountLabels(name
) - 6;
1800 if (skip
< 0) { LogMsg("GetIPFromName: Need six labels in IPv4 reverse mapping name %##s", name
); return mStatus_Invalid
; }
1801 if (GetLabelDecimalValue(SkipLeadingLabels(name
, skip
+3)->c
, &a
->ip
.v4
.b
[0]) ||
1802 GetLabelDecimalValue(SkipLeadingLabels(name
, skip
+2)->c
, &a
->ip
.v4
.b
[1]) ||
1803 GetLabelDecimalValue(SkipLeadingLabels(name
, skip
+1)->c
, &a
->ip
.v4
.b
[2]) ||
1804 GetLabelDecimalValue(SkipLeadingLabels(name
, skip
+0)->c
, &a
->ip
.v4
.b
[3])) return mStatus_Invalid
;
1805 a
->type
= mDNSAddrType_IPv4
;
1806 return(mStatus_NoError
);
1809 #define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0' ) : \
1810 ((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) : \
1811 ((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : -1)
1813 mDNSlocal mStatus
GetIPv6FromName(mDNSAddr
*const a
, const domainname
*const name
)
1816 const domainname
*n
;
1818 int skip
= CountLabels(name
) - 34;
1819 if (skip
< 0) { LogMsg("GetIPFromName: Need 34 labels in IPv6 reverse mapping name %##s", name
); return mStatus_Invalid
; }
1821 n
= SkipLeadingLabels(name
, skip
);
1822 for (i
=0; i
<16; i
++)
1824 if (n
->c
[0] != 1) return mStatus_Invalid
;
1825 l
= HexVal(n
->c
[1]);
1826 n
= (const domainname
*)(n
->c
+ 2);
1828 if (n
->c
[0] != 1) return mStatus_Invalid
;
1829 h
= HexVal(n
->c
[1]);
1830 n
= (const domainname
*)(n
->c
+ 2);
1832 if (l
<0 || h
<0) return mStatus_Invalid
;
1833 a
->ip
.v6
.b
[15-i
] = (mDNSu8
)((h
<< 4) | l
);
1836 a
->type
= mDNSAddrType_IPv6
;
1837 return(mStatus_NoError
);
1840 mDNSlocal mDNSs32
ReverseMapDomainType(const domainname
*const name
)
1842 int skip
= CountLabels(name
) - 2;
1845 const domainname
*suffix
= SkipLeadingLabels(name
, skip
);
1846 if (SameDomainName(suffix
, (const domainname
*)"\x7" "in-addr" "\x4" "arpa")) return mDNSAddrType_IPv4
;
1847 if (SameDomainName(suffix
, (const domainname
*)"\x3" "ip6" "\x4" "arpa")) return mDNSAddrType_IPv6
;
1849 return(mDNSAddrType_None
);
1852 mDNSlocal
void SendARP(mDNS
*const m
, const mDNSu8 op
, const AuthRecord
*const rr
,
1853 const mDNSv4Addr
*const spa
, const mDNSEthAddr
*const tha
, const mDNSv4Addr
*const tpa
, const mDNSEthAddr
*const dst
)
1856 mDNSu8
*ptr
= m
->omsg
.data
;
1857 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, rr
->resrec
.InterfaceID
);
1858 if (!intf
) { LogMsg("SendARP: No interface with InterfaceID %p found %s", rr
->resrec
.InterfaceID
, ARDisplayString(m
,rr
)); return; }
1860 // 0x00 Destination address
1861 for (i
=0; i
<6; i
++) *ptr
++ = dst
->b
[i
];
1863 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us)
1864 for (i
=0; i
<6; i
++) *ptr
++ = intf
->MAC
.b
[0];
1866 // 0x0C ARP Ethertype (0x0806)
1867 *ptr
++ = 0x08; *ptr
++ = 0x06;
1870 *ptr
++ = 0x00; *ptr
++ = 0x01; // Hardware address space; Ethernet = 1
1871 *ptr
++ = 0x08; *ptr
++ = 0x00; // Protocol address space; IP = 0x0800
1872 *ptr
++ = 6; // Hardware address length
1873 *ptr
++ = 4; // Protocol address length
1874 *ptr
++ = 0x00; *ptr
++ = op
; // opcode; Request = 1, Response = 2
1876 // 0x16 Sender hardware address (our MAC address)
1877 for (i
=0; i
<6; i
++) *ptr
++ = intf
->MAC
.b
[i
];
1879 // 0x1C Sender protocol address
1880 for (i
=0; i
<4; i
++) *ptr
++ = spa
->b
[i
];
1882 // 0x20 Target hardware address
1883 for (i
=0; i
<6; i
++) *ptr
++ = tha
->b
[i
];
1885 // 0x26 Target protocol address
1886 for (i
=0; i
<4; i
++) *ptr
++ = tpa
->b
[i
];
1888 // 0x2A Total ARP Packet length 42 bytes
1889 mDNSPlatformSendRawPacket(m
->omsg
.data
, ptr
, rr
->resrec
.InterfaceID
);
1892 mDNSlocal mDNSu16
CheckSum(const void *const data
, mDNSs32 length
, mDNSu32 sum
)
1894 const mDNSu16
*ptr
= data
;
1895 while (length
> 0) { length
-= 2; sum
+= *ptr
++; }
1896 sum
= (sum
& 0xFFFF) + (sum
>> 16);
1897 sum
= (sum
& 0xFFFF) + (sum
>> 16);
1898 return(sum
!= 0xFFFF ? sum
: 0);
1901 mDNSlocal mDNSu16
IPv6CheckSum(const mDNSv6Addr
*const src
, const mDNSv6Addr
*const dst
, const mDNSu8 protocol
, const void *const data
, const mDNSu32 length
)
1903 IPv6PseudoHeader ph
;
1906 ph
.len
.b
[0] = length
>> 24;
1907 ph
.len
.b
[1] = length
>> 16;
1908 ph
.len
.b
[2] = length
>> 8;
1909 ph
.len
.b
[3] = length
;
1913 ph
.pro
.b
[3] = protocol
;
1914 return CheckSum(&ph
, sizeof(ph
), CheckSum(data
, length
, 0));
1917 mDNSlocal
void SendNDP(mDNS
*const m
, const mDNSu8 op
, const mDNSu8 flags
, const AuthRecord
*const rr
,
1918 const mDNSv6Addr
*const spa
, const mDNSEthAddr
*const tha
, const mDNSv6Addr
*const tpa
, const mDNSEthAddr
*const dst
)
1921 mDNSOpaque16 checksum
;
1922 mDNSu8
*ptr
= m
->omsg
.data
;
1923 // Some recipient hosts seem to ignore Neighbor Solicitations if the IPv6-layer destination address is not the
1924 // appropriate IPv6 solicited node multicast address, so we use that IPv6-layer destination address, even though
1925 // at the Ethernet-layer we unicast the packet to the intended target, to avoid wasting network bandwidth.
1926 const mDNSv6Addr mc
= { { 0xFF,0x02,0x00,0x00, 0,0,0,0, 0,0,0,1, 0xFF,tpa
->b
[0xD],tpa
->b
[0xE],tpa
->b
[0xF] } };
1927 const mDNSv6Addr
*const v6dst
= (op
== NDP_Sol
) ? &mc
: tpa
;
1928 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, rr
->resrec
.InterfaceID
);
1929 if (!intf
) { LogMsg("SendNDP: No interface with InterfaceID %p found %s", rr
->resrec
.InterfaceID
, ARDisplayString(m
,rr
)); return; }
1931 // 0x00 Destination address
1932 for (i
=0; i
<6; i
++) *ptr
++ = dst
->b
[i
];
1933 // Right now we only send Neighbor Solicitations to verify whether the host we're proxying for has gone to sleep yet.
1934 // Since we know who we're looking for, we send it via Ethernet-layer unicast, rather than bothering every host on the
1935 // link with a pointless link-layer multicast.
1936 // Should we want to send traditional Neighbor Solicitations in the future, where we really don't know in advance what
1937 // Ethernet-layer address we're looking for, we'll need to send to the appropriate Ethernet-layer multicast address:
1941 // *ptr++ = tpa->b[0xD];
1942 // *ptr++ = tpa->b[0xE];
1943 // *ptr++ = tpa->b[0xF];
1945 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us)
1946 for (i
=0; i
<6; i
++) *ptr
++ = (tha
? *tha
: intf
->MAC
).b
[i
];
1948 // 0x0C IPv6 Ethertype (0x86DD)
1949 *ptr
++ = 0x86; *ptr
++ = 0xDD;
1952 *ptr
++ = 0x60; *ptr
++ = 0x00; *ptr
++ = 0x00; *ptr
++ = 0x00; // Version, Traffic Class, Flow Label
1953 *ptr
++ = 0x00; *ptr
++ = 0x20; // Length
1954 *ptr
++ = 0x3A; // Protocol == ICMPv6
1955 *ptr
++ = 0xFF; // Hop Limit
1957 // 0x16 Sender IPv6 address
1958 for (i
=0; i
<16; i
++) *ptr
++ = spa
->b
[i
];
1960 // 0x26 Destination IPv6 address
1961 for (i
=0; i
<16; i
++) *ptr
++ = v6dst
->b
[i
];
1964 *ptr
++ = op
; // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement
1965 *ptr
++ = 0x00; // Code
1966 *ptr
++ = 0x00; *ptr
++ = 0x00; // Checksum placeholder (0x38, 0x39)
1968 *ptr
++ = 0x00; *ptr
++ = 0x00; *ptr
++ = 0x00;
1970 if (op
== NDP_Sol
) // Neighbor Solicitation. The NDP "target" is the address we seek.
1973 for (i
=0; i
<16; i
++) *ptr
++ = tpa
->b
[i
];
1974 // 0x4E Source Link-layer Address
1975 // <http://www.ietf.org/rfc/rfc2461.txt>
1976 // MUST NOT be included when the source IP address is the unspecified address.
1977 // Otherwise, on link layers that have addresses this option MUST be included
1978 // in multicast solicitations and SHOULD be included in unicast solicitations.
1979 if (!mDNSIPv6AddressIsZero(*spa
))
1981 *ptr
++ = NDP_SrcLL
; // Option Type 1 == Source Link-layer Address
1982 *ptr
++ = 0x01; // Option length 1 (in units of 8 octets)
1983 for (i
=0; i
<6; i
++) *ptr
++ = (tha
? *tha
: intf
->MAC
).b
[i
];
1986 else // Neighbor Advertisement. The NDP "target" is the address we're giving information about.
1989 for (i
=0; i
<16; i
++) *ptr
++ = spa
->b
[i
];
1990 // 0x4E Target Link-layer Address
1991 *ptr
++ = NDP_TgtLL
; // Option Type 2 == Target Link-layer Address
1992 *ptr
++ = 0x01; // Option length 1 (in units of 8 octets)
1993 for (i
=0; i
<6; i
++) *ptr
++ = (tha
? *tha
: intf
->MAC
).b
[i
];
1996 // 0x4E or 0x56 Total NDP Packet length 78 or 86 bytes
1997 m
->omsg
.data
[0x13] = ptr
- &m
->omsg
.data
[0x36]; // Compute actual length
1998 checksum
.NotAnInteger
= ~IPv6CheckSum(spa
, v6dst
, 0x3A, &m
->omsg
.data
[0x36], m
->omsg
.data
[0x13]);
1999 m
->omsg
.data
[0x38] = checksum
.b
[0];
2000 m
->omsg
.data
[0x39] = checksum
.b
[1];
2002 mDNSPlatformSendRawPacket(m
->omsg
.data
, ptr
, rr
->resrec
.InterfaceID
);
2005 mDNSlocal
void SetupOwnerOpt(const mDNS
*const m
, const NetworkInterfaceInfo
*const intf
, rdataOPT
*const owner
)
2007 owner
->u
.owner
.vers
= 0;
2008 owner
->u
.owner
.seq
= m
->SleepSeqNum
;
2009 owner
->u
.owner
.HMAC
= m
->PrimaryMAC
;
2010 owner
->u
.owner
.IMAC
= intf
->MAC
;
2011 owner
->u
.owner
.password
= zeroEthAddr
;
2013 // Don't try to compute the optlen until *after* we've set up the data fields
2014 // Right now the DNSOpt_Owner_Space macro does not depend on the owner->u.owner being set up correctly, but in the future it might
2015 owner
->opt
= kDNSOpt_Owner
;
2016 owner
->optlen
= DNSOpt_Owner_Space(&m
->PrimaryMAC
, &intf
->MAC
) - 4;
2019 mDNSlocal
void GrantUpdateCredit(AuthRecord
*rr
)
2021 if (++rr
->UpdateCredits
>= kMaxUpdateCredits
) rr
->NextUpdateCredit
= 0;
2022 else rr
->NextUpdateCredit
= NonZeroTime(rr
->NextUpdateCredit
+ kUpdateCreditRefreshInterval
);
2025 // Note about acceleration of announcements to facilitate automatic coalescing of
2026 // multiple independent threads of announcements into a single synchronized thread:
2027 // The announcements in the packet may be at different stages of maturity;
2028 // One-second interval, two-second interval, four-second interval, and so on.
2029 // After we've put in all the announcements that are due, we then consider
2030 // whether there are other nearly-due announcements that are worth accelerating.
2031 // To be eligible for acceleration, a record MUST NOT be older (further along
2032 // its timeline) than the most mature record we've already put in the packet.
2033 // In other words, younger records can have their timelines accelerated to catch up
2034 // with their elder bretheren; this narrows the age gap and helps them eventually get in sync.
2035 // Older records cannot have their timelines accelerated; this would just widen
2036 // the gap between them and their younger bretheren and get them even more out of sync.
2038 // Note: SendResponses calls mDNS_Deregister_internal which can call a user callback, which may change
2039 // the record list and/or question list.
2040 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
2041 mDNSlocal
void SendResponses(mDNS
*const m
)
2044 AuthRecord
*rr
, *r2
;
2045 mDNSs32 maxExistingAnnounceInterval
= 0;
2046 const NetworkInterfaceInfo
*intf
= GetFirstActiveInterface(m
->HostInterfaces
);
2048 m
->NextScheduledResponse
= m
->timenow
+ 0x78000000;
2050 if (m
->SleepState
== SleepState_Transferring
) RetrySPSRegistrations(m
);
2052 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2053 if (rr
->ImmedUnicast
)
2055 mDNSAddr v4
= { mDNSAddrType_IPv4
, {{{0}}} };
2056 mDNSAddr v6
= { mDNSAddrType_IPv6
, {{{0}}} };
2057 v4
.ip
.v4
= rr
->v4Requester
;
2058 v6
.ip
.v6
= rr
->v6Requester
;
2059 if (!mDNSIPv4AddressIsZero(rr
->v4Requester
)) SendDelayedUnicastResponse(m
, &v4
, rr
->ImmedAnswer
);
2060 if (!mDNSIPv6AddressIsZero(rr
->v6Requester
)) SendDelayedUnicastResponse(m
, &v6
, rr
->ImmedAnswer
);
2061 if (rr
->ImmedUnicast
)
2063 LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s", ARDisplayString(m
, rr
));
2064 rr
->ImmedUnicast
= mDNSfalse
;
2069 // *** 1. Setup: Set the SendRNow and ImmedAnswer fields to indicate which interface(s) the records need to be sent on
2072 // Run through our list of records, and decide which ones we're going to announce on all interfaces
2073 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2075 while (rr
->NextUpdateCredit
&& m
->timenow
- rr
->NextUpdateCredit
>= 0) GrantUpdateCredit(rr
);
2076 if (TimeToAnnounceThisRecord(rr
, m
->timenow
))
2078 if (rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
)
2080 if (!rr
->WakeUp
.HMAC
.l
[0])
2082 if (rr
->AnnounceCount
) rr
->ImmedAnswer
= mDNSInterfaceMark
; // Send goodbye packet on all interfaces
2086 LogSPS("SendResponses: Sending wakeup %2d for %.6a %s", rr
->AnnounceCount
-3, &rr
->WakeUp
.IMAC
, ARDisplayString(m
, rr
));
2087 SendWakeup(m
, rr
->resrec
.InterfaceID
, &rr
->WakeUp
.IMAC
, &rr
->WakeUp
.password
);
2088 for (r2
= rr
; r2
; r2
=r2
->next
)
2089 if (r2
->AnnounceCount
&& r2
->resrec
.InterfaceID
== rr
->resrec
.InterfaceID
&& mDNSSameEthAddress(&r2
->WakeUp
.IMAC
, &rr
->WakeUp
.IMAC
))
2091 // For now we only want to send a single Unsolicited Neighbor Advertisement restoring the address to the original
2092 // owner, because these packets can cause some IPv6 stacks to falsely conclude that there's an address conflict.
2093 if (r2
->AddressProxy
.type
== mDNSAddrType_IPv6
&& r2
->AnnounceCount
== WakeupCount
)
2095 LogSPS("NDP Announcement %2d Releasing traffic for H-MAC %.6a I-MAC %.6a %s",
2096 r2
->AnnounceCount
-3, &r2
->WakeUp
.HMAC
, &r2
->WakeUp
.IMAC
, ARDisplayString(m
,r2
));
2097 SendNDP(m
, NDP_Adv
, NDP_Override
, r2
, &r2
->AddressProxy
.ip
.v6
, &r2
->WakeUp
.IMAC
, &AllHosts_v6
, &AllHosts_v6_Eth
);
2099 r2
->LastAPTime
= m
->timenow
;
2100 // After 15 wakeups without success (maybe host has left the network) send three goodbyes instead
2101 if (--r2
->AnnounceCount
<= GoodbyeCount
) r2
->WakeUp
.HMAC
= zeroEthAddr
;
2105 else if (ResourceRecordIsValidAnswer(rr
))
2107 if (rr
->AddressProxy
.type
)
2109 rr
->AnnounceCount
--;
2110 rr
->ThisAPInterval
*= 2;
2111 rr
->LastAPTime
= m
->timenow
;
2112 if (rr
->AddressProxy
.type
== mDNSAddrType_IPv4
)
2114 LogSPS("ARP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s",
2115 rr
->AnnounceCount
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
,rr
));
2116 SendARP(m
, 1, rr
, &rr
->AddressProxy
.ip
.v4
, &zeroEthAddr
, &rr
->AddressProxy
.ip
.v4
, &onesEthAddr
);
2118 else if (rr
->AddressProxy
.type
== mDNSAddrType_IPv6
)
2120 LogSPS("NDP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s",
2121 rr
->AnnounceCount
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
,rr
));
2122 SendNDP(m
, NDP_Adv
, NDP_Override
, rr
, &rr
->AddressProxy
.ip
.v6
, mDNSNULL
, &AllHosts_v6
, &AllHosts_v6_Eth
);
2127 rr
->ImmedAnswer
= mDNSInterfaceMark
; // Send on all interfaces
2128 if (maxExistingAnnounceInterval
< rr
->ThisAPInterval
)
2129 maxExistingAnnounceInterval
= rr
->ThisAPInterval
;
2130 if (rr
->UpdateBlocked
) rr
->UpdateBlocked
= 0;
2136 // Any interface-specific records we're going to send are marked as being sent on all appropriate interfaces (which is just one)
2137 // Eligible records that are more than half-way to their announcement time are accelerated
2138 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2139 if ((rr
->resrec
.InterfaceID
&& rr
->ImmedAnswer
) ||
2140 (rr
->ThisAPInterval
<= maxExistingAnnounceInterval
&&
2141 TimeToAnnounceThisRecord(rr
, m
->timenow
+ rr
->ThisAPInterval
/2) &&
2142 !rr
->AddressProxy
.type
&& // Don't include ARP Annoucements when considering which records to accelerate
2143 ResourceRecordIsValidAnswer(rr
)))
2144 rr
->ImmedAnswer
= mDNSInterfaceMark
; // Send on all interfaces
2146 // When sending SRV records (particularly when announcing a new service) automatically add related Address record(s) as additionals
2147 // Note: Currently all address records are interface-specific, so it's safe to set ImmedAdditional to their InterfaceID,
2148 // which will be non-null. If by some chance there is an address record that's not interface-specific (should never happen)
2149 // then all that means is that it won't get sent -- which would not be the end of the world.
2150 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2152 if (rr
->ImmedAnswer
&& rr
->resrec
.rrtype
== kDNSType_SRV
)
2153 for (r2
=m
->ResourceRecords
; r2
; r2
=r2
->next
) // Scan list of resource records
2154 if (RRTypeIsAddressType(r2
->resrec
.rrtype
) && // For all address records (A/AAAA) ...
2155 ResourceRecordIsValidAnswer(r2
) && // ... which are valid for answer ...
2156 rr
->LastMCTime
- r2
->LastMCTime
>= 0 && // ... which we have not sent recently ...
2157 rr
->resrec
.rdatahash
== r2
->resrec
.namehash
&& // ... whose name is the name of the SRV target
2158 SameDomainName(&rr
->resrec
.rdata
->u
.srv
.target
, r2
->resrec
.name
) &&
2159 (rr
->ImmedAnswer
== mDNSInterfaceMark
|| rr
->ImmedAnswer
== r2
->resrec
.InterfaceID
))
2160 r2
->ImmedAdditional
= r2
->resrec
.InterfaceID
; // ... then mark this address record for sending too
2161 // We also make sure we send the DeviceInfo TXT record too, if necessary
2162 // We check for RecordType == kDNSRecordTypeShared because we don't want to tag the
2163 // DeviceInfo TXT record onto a goodbye packet (RecordType == kDNSRecordTypeDeregistering).
2164 if (rr
->ImmedAnswer
&& rr
->resrec
.RecordType
== kDNSRecordTypeShared
&& rr
->resrec
.rrtype
== kDNSType_PTR
)
2165 if (ResourceRecordIsValidAnswer(&m
->DeviceInfo
) && SameDomainLabel(rr
->resrec
.rdata
->u
.name
.c
, m
->DeviceInfo
.resrec
.name
->c
))
2167 if (!m
->DeviceInfo
.ImmedAnswer
) m
->DeviceInfo
.ImmedAnswer
= rr
->ImmedAnswer
;
2168 else m
->DeviceInfo
.ImmedAnswer
= mDNSInterfaceMark
;
2172 // If there's a record which is supposed to be unique that we're going to send, then make sure that we give
2173 // the whole RRSet as an atomic unit. That means that if we have any other records with the same name/type/class
2174 // then we need to mark them for sending too. Otherwise, if we set the kDNSClass_UniqueRRSet bit on a
2175 // record, then other RRSet members that have not been sent recently will get flushed out of client caches.
2176 // -- If a record is marked to be sent on a certain interface, make sure the whole set is marked to be sent on that interface
2177 // -- If any record is marked to be sent on all interfaces, make sure the whole set is marked to be sent on all interfaces
2178 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2179 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
2181 if (rr
->ImmedAnswer
) // If we're sending this as answer, see that its whole RRSet is similarly marked
2183 for (r2
= m
->ResourceRecords
; r2
; r2
=r2
->next
)
2184 if (ResourceRecordIsValidAnswer(r2
))
2185 if (r2
->ImmedAnswer
!= mDNSInterfaceMark
&&
2186 r2
->ImmedAnswer
!= rr
->ImmedAnswer
&& SameResourceRecordSignature(r2
, rr
))
2187 r2
->ImmedAnswer
= !r2
->ImmedAnswer
? rr
->ImmedAnswer
: mDNSInterfaceMark
;
2189 else if (rr
->ImmedAdditional
) // If we're sending this as additional, see that its whole RRSet is similarly marked
2191 for (r2
= m
->ResourceRecords
; r2
; r2
=r2
->next
)
2192 if (ResourceRecordIsValidAnswer(r2
))
2193 if (r2
->ImmedAdditional
!= rr
->ImmedAdditional
&& SameResourceRecordSignature(r2
, rr
))
2194 r2
->ImmedAdditional
= rr
->ImmedAdditional
;
2198 // Now set SendRNow state appropriately
2199 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2201 if (rr
->ImmedAnswer
== mDNSInterfaceMark
) // Sending this record on all appropriate interfaces
2203 rr
->SendRNow
= !intf
? mDNSNULL
: (rr
->resrec
.InterfaceID
) ? rr
->resrec
.InterfaceID
: intf
->InterfaceID
;
2204 rr
->ImmedAdditional
= mDNSNULL
; // No need to send as additional if sending as answer
2205 rr
->LastMCTime
= m
->timenow
;
2206 rr
->LastMCInterface
= rr
->ImmedAnswer
;
2207 // If we're announcing this record, and it's at least half-way to its ordained time, then consider this announcement done
2208 if (TimeToAnnounceThisRecord(rr
, m
->timenow
+ rr
->ThisAPInterval
/2))
2210 rr
->AnnounceCount
--;
2211 if (rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
)
2212 rr
->ThisAPInterval
*= 2;
2213 rr
->LastAPTime
= m
->timenow
;
2214 debugf("Announcing %##s (%s) %d", rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
), rr
->AnnounceCount
);
2217 else if (rr
->ImmedAnswer
) // Else, just respond to a single query on single interface:
2219 rr
->SendRNow
= rr
->ImmedAnswer
; // Just respond on that interface
2220 rr
->ImmedAdditional
= mDNSNULL
; // No need to send as additional too
2221 rr
->LastMCTime
= m
->timenow
;
2222 rr
->LastMCInterface
= rr
->ImmedAnswer
;
2224 SetNextAnnounceProbeTime(m
, rr
);
2225 //if (rr->SendRNow) LogMsg("%-15.4a %s", &rr->v4Requester, ARDisplayString(m, rr));
2229 // *** 2. Loop through interface list, sending records as appropriate
2234 const int OwnerRecordSpace
= (m
->AnnounceOwner
&& intf
->MAC
.l
[0]) ? DNSOpt_Header_Space
+ DNSOpt_Owner_Space(&m
->PrimaryMAC
, &intf
->MAC
) : 0;
2236 int numAnnounce
= 0;
2238 mDNSu8
*responseptr
= m
->omsg
.data
;
2240 InitializeDNSMessage(&m
->omsg
.h
, zeroID
, ResponseFlags
);
2242 // First Pass. Look for:
2243 // 1. Deregistering records that need to send their goodbye packet
2244 // 2. Updated records that need to retract their old data
2245 // 3. Answers and announcements we need to send
2246 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2249 // Skip this interface if the record InterfaceID is *Any and the record is not
2250 // appropriate for the interface type.
2251 if ((rr
->SendRNow
== intf
->InterfaceID
) &&
2252 ((rr
->resrec
.InterfaceID
== mDNSInterface_Any
) && !mDNSPlatformValidRecordForInterface(rr
, intf
)))
2254 LogInfo("SendResponses: Not sending %s, on %s", ARDisplayString(m
, rr
), InterfaceNameForID(m
, rr
->SendRNow
));
2255 rr
->SendRNow
= GetNextActiveInterfaceID(intf
);
2257 else if (rr
->SendRNow
== intf
->InterfaceID
)
2259 RData
*OldRData
= rr
->resrec
.rdata
;
2260 mDNSu16 oldrdlength
= rr
->resrec
.rdlength
;
2261 mDNSu8 active
= (mDNSu8
)
2262 (rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
2263 (m
->SleepState
!= SleepState_Sleeping
|| intf
->SPSAddr
[0].type
|| intf
->SPSAddr
[1].type
|| intf
->SPSAddr
[2].type
));
2265 if (rr
->NewRData
&& active
)
2267 // See if we should send a courtesy "goodbye" for the old data before we replace it.
2268 if (ResourceRecordIsValidAnswer(rr
) && rr
->resrec
.RecordType
== kDNSRecordTypeShared
&& rr
->RequireGoodbye
)
2270 newptr
= PutRR_OS_TTL(responseptr
, &m
->omsg
.h
.numAnswers
, &rr
->resrec
, 0);
2271 if (newptr
) { responseptr
= newptr
; numDereg
++; rr
->RequireGoodbye
= mDNSfalse
; }
2272 else continue; // If this packet is already too full to hold the goodbye for this record, skip it for now and we'll retry later
2274 SetNewRData(&rr
->resrec
, rr
->NewRData
, rr
->newrdlength
);
2277 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
2278 rr
->resrec
.rrclass
|= kDNSClass_UniqueRRSet
; // Temporarily set the cache flush bit so PutResourceRecord will set it
2279 newptr
= PutRR_OS_TTL(responseptr
, &m
->omsg
.h
.numAnswers
, &rr
->resrec
, active
? rr
->resrec
.rroriginalttl
: 0);
2280 rr
->resrec
.rrclass
&= ~kDNSClass_UniqueRRSet
; // Make sure to clear cache flush bit back to normal state
2283 responseptr
= newptr
;
2284 rr
->RequireGoodbye
= active
;
2285 if (rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
) numDereg
++;
2286 else if (rr
->LastAPTime
== m
->timenow
) numAnnounce
++; else numAnswer
++;
2289 if (rr
->NewRData
&& active
)
2290 SetNewRData(&rr
->resrec
, OldRData
, oldrdlength
);
2292 // The first time through (pktcount==0), if this record is verified unique
2293 // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too.
2294 if (!pktcount
&& active
&& (rr
->resrec
.RecordType
& kDNSRecordTypeActiveUniqueMask
) && !rr
->SendNSECNow
)
2295 rr
->SendNSECNow
= mDNSInterfaceMark
;
2297 if (newptr
) // If succeeded in sending, advance to next interface
2299 // If sending on all interfaces, go to next interface; else we're finished now
2300 if (rr
->ImmedAnswer
== mDNSInterfaceMark
&& rr
->resrec
.InterfaceID
== mDNSInterface_Any
)
2301 rr
->SendRNow
= GetNextActiveInterfaceID(intf
);
2303 rr
->SendRNow
= mDNSNULL
;
2308 // Second Pass. Add additional records, if there's space.
2309 newptr
= responseptr
;
2310 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2311 if (rr
->ImmedAdditional
== intf
->InterfaceID
)
2312 if (ResourceRecordIsValidAnswer(rr
))
2314 // If we have at least one answer already in the packet, then plan to add additionals too
2315 mDNSBool SendAdditional
= (m
->omsg
.h
.numAnswers
> 0);
2317 // If we're not planning to send any additionals, but this record is a unique one, then
2318 // make sure we haven't already sent any other members of its RRSet -- if we have, then they
2319 // will have had the cache flush bit set, so now we need to finish the job and send the rest.
2320 if (!SendAdditional
&& (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
))
2322 const AuthRecord
*a
;
2323 for (a
= m
->ResourceRecords
; a
; a
=a
->next
)
2324 if (a
->LastMCTime
== m
->timenow
&&
2325 a
->LastMCInterface
== intf
->InterfaceID
&&
2326 SameResourceRecordSignature(a
, rr
)) { SendAdditional
= mDNStrue
; break; }
2328 if (!SendAdditional
) // If we don't want to send this after all,
2329 rr
->ImmedAdditional
= mDNSNULL
; // then cancel its ImmedAdditional field
2330 else if (newptr
) // Else, try to add it if we can
2332 // The first time through (pktcount==0), if this record is verified unique
2333 // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too.
2334 if (!pktcount
&& (rr
->resrec
.RecordType
& kDNSRecordTypeActiveUniqueMask
) && !rr
->SendNSECNow
)
2335 rr
->SendNSECNow
= mDNSInterfaceMark
;
2337 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
2338 rr
->resrec
.rrclass
|= kDNSClass_UniqueRRSet
; // Temporarily set the cache flush bit so PutResourceRecord will set it
2339 newptr
= PutRR_OS(newptr
, &m
->omsg
.h
.numAdditionals
, &rr
->resrec
);
2340 rr
->resrec
.rrclass
&= ~kDNSClass_UniqueRRSet
; // Make sure to clear cache flush bit back to normal state
2343 responseptr
= newptr
;
2344 rr
->ImmedAdditional
= mDNSNULL
;
2345 rr
->RequireGoodbye
= mDNStrue
;
2346 // If we successfully put this additional record in the packet, we record LastMCTime & LastMCInterface.
2347 // This matters particularly in the case where we have more than one IPv6 (or IPv4) address, because otherwise,
2348 // when we see our own multicast with the cache flush bit set, if we haven't set LastMCTime, then we'll get
2349 // all concerned and re-announce our record again to make sure it doesn't get flushed from peer caches.
2350 rr
->LastMCTime
= m
->timenow
;
2351 rr
->LastMCInterface
= intf
->InterfaceID
;
2356 // Third Pass. Add NSEC records, if there's space.
2357 // When we're generating an NSEC record in response to a specify query for that type
2358 // (recognized by rr->SendNSECNow == intf->InterfaceID) we should really put the NSEC in the Answer Section,
2359 // not Additional Section, but for now it's easier to handle both cases in this Additional Section loop here.
2360 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
2361 if (rr
->SendNSECNow
== mDNSInterfaceMark
|| rr
->SendNSECNow
== intf
->InterfaceID
)
2364 mDNS_SetupResourceRecord(&nsec
, mDNSNULL
, mDNSInterface_Any
, kDNSType_NSEC
, rr
->resrec
.rroriginalttl
, kDNSRecordTypeUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
2365 nsec
.resrec
.rrclass
|= kDNSClass_UniqueRRSet
;
2366 AssignDomainName(&nsec
.namestorage
, rr
->resrec
.name
);
2367 mDNSPlatformMemZero(nsec
.rdatastorage
.u
.nsec
.bitmap
, sizeof(nsec
.rdatastorage
.u
.nsec
.bitmap
));
2368 for (r2
= m
->ResourceRecords
; r2
; r2
=r2
->next
)
2369 if (ResourceRecordIsValidAnswer(r2
) && SameResourceRecordNameClassInterface(r2
, rr
))
2371 if (r2
->resrec
.rrtype
>= kDNSQType_ANY
) { LogMsg("Can't create NSEC for record %s", ARDisplayString(m
, r2
)); break; }
2372 else nsec
.rdatastorage
.u
.nsec
.bitmap
[r2
->resrec
.rrtype
>> 3] |= 128 >> (r2
->resrec
.rrtype
& 7);
2374 newptr
= responseptr
;
2375 if (!r2
) // If we successfully built our NSEC record, add it to the packet now
2377 newptr
= PutRR_OS(responseptr
, &m
->omsg
.h
.numAdditionals
, &nsec
.resrec
);
2378 if (newptr
) responseptr
= newptr
;
2381 // If we successfully put the NSEC record, clear the SendNSECNow flag
2382 // If we consider this NSEC optional, then we unconditionally clear the SendNSECNow flag, even if we fail to put this additional record
2383 if (newptr
|| rr
->SendNSECNow
== mDNSInterfaceMark
)
2385 rr
->SendNSECNow
= mDNSNULL
;
2386 // Run through remainder of list clearing SendNSECNow flag for all other records which would generate the same NSEC
2387 for (r2
= rr
->next
; r2
; r2
=r2
->next
)
2388 if (SameResourceRecordNameClassInterface(r2
, rr
))
2389 if (r2
->SendNSECNow
== mDNSInterfaceMark
|| r2
->SendNSECNow
== intf
->InterfaceID
)
2390 r2
->SendNSECNow
= mDNSNULL
;
2394 if (m
->omsg
.h
.numAnswers
|| m
->omsg
.h
.numAdditionals
)
2396 // If we have data to send, add OWNER option if necessary, then send packet
2398 if (OwnerRecordSpace
)
2401 mDNS_SetupResourceRecord(&opt
, mDNSNULL
, mDNSInterface_Any
, kDNSType_OPT
, kStandardTTL
, kDNSRecordTypeKnownUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
2402 opt
.resrec
.rrclass
= NormalMaxDNSMessageData
;
2403 opt
.resrec
.rdlength
= sizeof(rdataOPT
); // One option in this OPT record
2404 opt
.resrec
.rdestimate
= sizeof(rdataOPT
);
2405 SetupOwnerOpt(m
, intf
, &opt
.resrec
.rdata
->u
.opt
[0]);
2406 newptr
= PutResourceRecord(&m
->omsg
, responseptr
, &m
->omsg
.h
.numAdditionals
, &opt
.resrec
);
2407 if (newptr
) { responseptr
= newptr
; LogSPS("SendResponses put %s", ARDisplayString(m
, &opt
)); }
2408 else if (m
->omsg
.h
.numAnswers
+ m
->omsg
.h
.numAuthorities
+ m
->omsg
.h
.numAdditionals
== 1)
2409 LogSPS("SendResponses: No space in packet for Owner OPT record (%d/%d/%d/%d) %s",
2410 m
->omsg
.h
.numQuestions
, m
->omsg
.h
.numAnswers
, m
->omsg
.h
.numAuthorities
, m
->omsg
.h
.numAdditionals
, ARDisplayString(m
, &opt
));
2412 LogMsg("SendResponses: How did we fail to have space for Owner OPT record (%d/%d/%d/%d) %s",
2413 m
->omsg
.h
.numQuestions
, m
->omsg
.h
.numAnswers
, m
->omsg
.h
.numAuthorities
, m
->omsg
.h
.numAdditionals
, ARDisplayString(m
, &opt
));
2416 debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p",
2417 numDereg
, numDereg
== 1 ? "" : "s",
2418 numAnnounce
, numAnnounce
== 1 ? "" : "s",
2419 numAnswer
, numAnswer
== 1 ? "" : "s",
2420 m
->omsg
.h
.numAdditionals
, m
->omsg
.h
.numAdditionals
== 1 ? "" : "s", intf
->InterfaceID
);
2422 if (intf
->IPv4Available
) mDNSSendDNSMessage(m
, &m
->omsg
, responseptr
, intf
->InterfaceID
, mDNSNULL
, &AllDNSLinkGroup_v4
, MulticastDNSPort
, mDNSNULL
, mDNSNULL
);
2423 if (intf
->IPv6Available
) mDNSSendDNSMessage(m
, &m
->omsg
, responseptr
, intf
->InterfaceID
, mDNSNULL
, &AllDNSLinkGroup_v6
, MulticastDNSPort
, mDNSNULL
, mDNSNULL
);
2424 if (!m
->SuppressSending
) m
->SuppressSending
= NonZeroTime(m
->timenow
+ (mDNSPlatformOneSecond
+9)/10);
2425 if (++pktcount
>= 1000) { LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount
); break; }
2426 // There might be more things to send on this interface, so go around one more time and try again.
2428 else // Nothing more to send on this interface; go to next
2430 const NetworkInterfaceInfo
*next
= GetFirstActiveInterface(intf
->next
);
2431 #if MDNS_DEBUGMSGS && 0
2432 const char *const msg
= next
? "SendResponses: Nothing more on %p; moving to %p" : "SendResponses: Nothing more on %p";
2433 debugf(msg
, intf
, next
);
2436 pktcount
= 0; // When we move to a new interface, reset packet count back to zero -- NSEC generation logic uses it
2441 // *** 3. Cleanup: Now that everything is sent, call client callback functions, and reset state variables
2444 if (m
->CurrentRecord
)
2445 LogMsg("SendResponses ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
2446 m
->CurrentRecord
= m
->ResourceRecords
;
2447 while (m
->CurrentRecord
)
2449 rr
= m
->CurrentRecord
;
2450 m
->CurrentRecord
= rr
->next
;
2454 if (rr
->ARType
!= AuthRecordLocalOnly
&& rr
->ARType
!= AuthRecordP2P
)
2455 LogMsg("SendResponses: No active interface %p to send: %p %02X %s", rr
->SendRNow
, rr
->resrec
.InterfaceID
, rr
->resrec
.RecordType
, ARDisplayString(m
, rr
));
2456 rr
->SendRNow
= mDNSNULL
;
2459 if (rr
->ImmedAnswer
|| rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
)
2461 if (rr
->NewRData
) CompleteRDataUpdate(m
, rr
); // Update our rdata, clear the NewRData pointer, and return memory to the client
2463 if (rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
&& rr
->AnnounceCount
== 0)
2465 // For Unicast, when we get the response from the server, we will call CompleteDeregistration
2466 if (!AuthRecord_uDNS(rr
)) CompleteDeregistration(m
, rr
); // Don't touch rr after this
2470 rr
->ImmedAnswer
= mDNSNULL
;
2471 rr
->ImmedUnicast
= mDNSfalse
;
2472 rr
->v4Requester
= zerov4Addr
;
2473 rr
->v6Requester
= zerov6Addr
;
2477 verbosedebugf("SendResponses: Next in %ld ticks", m
->NextScheduledResponse
- m
->timenow
);
2480 // Calling CheckCacheExpiration() is an expensive operation because it has to look at the entire cache,
2481 // so we want to be lazy about how frequently we do it.
2482 // 1. If a cache record is currently referenced by *no* active questions,
2483 // then we don't mind expiring it up to a minute late (who will know?)
2484 // 2. Else, if a cache record is due for some of its final expiration queries,
2485 // we'll allow them to be late by up to 2% of the TTL
2486 // 3. Else, if a cache record has completed all its final expiration queries without success,
2487 // and is expiring, and had an original TTL more than ten seconds, we'll allow it to be one second late
2488 // 4. Else, it is expiring and had an original TTL of ten seconds or less (includes explicit goodbye packets),
2489 // so allow at most 1/10 second lateness
2490 // 5. For records with rroriginalttl set to zero, that means we really want to delete them immediately
2491 // (we have a new record with DelayDelivery set, waiting for the old record to go away before we can notify clients).
2492 #define CacheCheckGracePeriod(RR) ( \
2493 ((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \
2494 ((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \
2495 ((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : \
2496 ((RR)->resrec.rroriginalttl > 0 ) ? (mDNSPlatformOneSecond/10) : 0)
2498 #define NextCacheCheckEvent(RR) ((RR)->NextRequiredQuery + CacheCheckGracePeriod(RR))
2500 mDNSexport
void ScheduleNextCacheCheckTime(mDNS
*const m
, const mDNSu32 slot
, const mDNSs32 event
)
2502 if (m
->rrcache_nextcheck
[slot
] - event
> 0)
2503 m
->rrcache_nextcheck
[slot
] = event
;
2504 if (m
->NextCacheCheck
- event
> 0)
2505 m
->NextCacheCheck
= event
;
2508 // Note: MUST call SetNextCacheCheckTimeForRecord any time we change:
2510 // rr->resrec.rroriginalttl
2511 // rr->UnansweredQueries
2512 // rr->CRActiveQuestion
2513 mDNSlocal
void SetNextCacheCheckTimeForRecord(mDNS
*const m
, CacheRecord
*const rr
)
2515 rr
->NextRequiredQuery
= RRExpireTime(rr
);
2517 // If we have an active question, then see if we want to schedule a refresher query for this record.
2518 // Usually we expect to do four queries, at 80-82%, 85-87%, 90-92% and then 95-97% of the TTL.
2519 if (rr
->CRActiveQuestion
&& rr
->UnansweredQueries
< MaxUnansweredQueries
)
2521 rr
->NextRequiredQuery
-= TicksTTL(rr
)/20 * (MaxUnansweredQueries
- rr
->UnansweredQueries
);
2522 rr
->NextRequiredQuery
+= mDNSRandom((mDNSu32
)TicksTTL(rr
)/50);
2523 verbosedebugf("SetNextCacheCheckTimeForRecord: NextRequiredQuery in %ld sec CacheCheckGracePeriod %d ticks for %s",
2524 (rr
->NextRequiredQuery
- m
->timenow
) / mDNSPlatformOneSecond
, CacheCheckGracePeriod(rr
), CRDisplayString(m
,rr
));
2527 ScheduleNextCacheCheckTime(m
, HashSlot(rr
->resrec
.name
), NextCacheCheckEvent(rr
));
2530 #define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
2531 #define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5)
2532 #define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5)
2533 #define kDefaultReconfirmTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 30)
2535 mDNSlocal mStatus
mDNS_Reconfirm_internal(mDNS
*const m
, CacheRecord
*const rr
, mDNSu32 interval
)
2537 if (interval
< kMinimumReconfirmTime
)
2538 interval
= kMinimumReconfirmTime
;
2539 if (interval
> 0x10000000) // Make sure interval doesn't overflow when we multiply by four below
2540 interval
= 0x10000000;
2542 // If the expected expiration time for this record is more than interval+33%, then accelerate its expiration
2543 if (RRExpireTime(rr
) - m
->timenow
> (mDNSs32
)((interval
* 4) / 3))
2545 // Add a 33% random amount to the interval, to avoid synchronization between multiple hosts
2546 // For all the reconfirmations in a given batch, we want to use the same random value
2547 // so that the reconfirmation questions can be grouped into a single query packet
2548 if (!m
->RandomReconfirmDelay
) m
->RandomReconfirmDelay
= 1 + mDNSRandom(0x3FFFFFFF);
2549 interval
+= m
->RandomReconfirmDelay
% ((interval
/3) + 1);
2550 rr
->TimeRcvd
= m
->timenow
- (mDNSs32
)interval
* 3;
2551 rr
->resrec
.rroriginalttl
= (interval
* 4 + mDNSPlatformOneSecond
- 1) / mDNSPlatformOneSecond
;
2552 SetNextCacheCheckTimeForRecord(m
, rr
);
2554 debugf("mDNS_Reconfirm_internal:%6ld ticks to go for %s %p",
2555 RRExpireTime(rr
) - m
->timenow
, CRDisplayString(m
, rr
), rr
->CRActiveQuestion
);
2556 return(mStatus_NoError
);
2559 #define MaxQuestionInterval (3600 * mDNSPlatformOneSecond)
2561 // BuildQuestion puts a question into a DNS Query packet and if successful, updates the value of queryptr.
2562 // It also appends to the list of known answer records that need to be included,
2563 // and updates the forcast for the size of the known answer section.
2564 mDNSlocal mDNSBool
BuildQuestion(mDNS
*const m
, DNSMessage
*query
, mDNSu8
**queryptr
, DNSQuestion
*q
,
2565 CacheRecord
***kalistptrptr
, mDNSu32
*answerforecast
)
2567 mDNSBool ucast
= (q
->LargeAnswers
|| q
->RequestUnicast
) && m
->CanReceiveUnicastOn5353
;
2568 mDNSu16 ucbit
= (mDNSu16
)(ucast
? kDNSQClass_UnicastResponse
: 0);
2569 const mDNSu8
*const limit
= query
->data
+ NormalMaxDNSMessageData
;
2570 mDNSu8
*newptr
= putQuestion(query
, *queryptr
, limit
- *answerforecast
, &q
->qname
, q
->qtype
, (mDNSu16
)(q
->qclass
| ucbit
));
2573 debugf("BuildQuestion: No more space in this packet for question %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
2578 mDNSu32 forecast
= *answerforecast
;
2579 const mDNSu32 slot
= HashSlot(&q
->qname
);
2580 const CacheGroup
*const cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
2582 CacheRecord
**ka
= *kalistptrptr
; // Make a working copy of the pointer we're going to update
2584 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
) // If we have a resource record in our cache,
2585 if (rr
->resrec
.InterfaceID
== q
->SendQNow
&& // received on this interface
2586 !(rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
) && // which is a shared (i.e. not unique) record type
2587 rr
->NextInKAList
== mDNSNULL
&& ka
!= &rr
->NextInKAList
&& // which is not already in the known answer list
2588 rr
->resrec
.rdlength
<= SmallRecordLimit
&& // which is small enough to sensibly fit in the packet
2589 SameNameRecordAnswersQuestion(&rr
->resrec
, q
) && // which answers our question
2590 rr
->TimeRcvd
+ TicksTTL(rr
)/2 - m
->timenow
> // and its half-way-to-expiry time is at least 1 second away
2591 mDNSPlatformOneSecond
) // (also ensures we never include goodbye records with TTL=1)
2593 // We don't want to include unique records in the Known Answer section. The Known Answer section
2594 // is intended to suppress floods of shared-record replies from many other devices on the network.
2595 // That concept really does not apply to unique records, and indeed if we do send a query for
2596 // which we have a unique record already in our cache, then including that unique record as a
2597 // Known Answer, so as to suppress the only answer we were expecting to get, makes little sense.
2599 *ka
= rr
; // Link this record into our known answer chain
2600 ka
= &rr
->NextInKAList
;
2601 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
2602 forecast
+= 12 + rr
->resrec
.rdestimate
;
2603 // If we're trying to put more than one question in this packet, and it doesn't fit
2604 // then undo that last question and try again next time
2605 if (query
->h
.numQuestions
> 1 && newptr
+ forecast
>= limit
)
2607 debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d",
2608 q
->qname
.c
, DNSTypeName(q
->qtype
), newptr
+ forecast
- query
->data
);
2609 query
->h
.numQuestions
--;
2610 ka
= *kalistptrptr
; // Go back to where we started and retract these answer records
2611 while (*ka
) { CacheRecord
*c
= *ka
; *ka
= mDNSNULL
; ka
= &c
->NextInKAList
; }
2612 return(mDNSfalse
); // Return false, so we'll try again in the next packet
2616 // Success! Update our state pointers, increment UnansweredQueries as appropriate, and return
2617 *queryptr
= newptr
; // Update the packet pointer
2618 *answerforecast
= forecast
; // Update the forecast
2619 *kalistptrptr
= ka
; // Update the known answer list pointer
2620 if (ucast
) q
->ExpectUnicastResp
= NonZeroTime(m
->timenow
);
2622 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
) // For every resource record in our cache,
2623 if (rr
->resrec
.InterfaceID
== q
->SendQNow
&& // received on this interface
2624 rr
->NextInKAList
== mDNSNULL
&& ka
!= &rr
->NextInKAList
&& // which is not in the known answer list
2625 SameNameRecordAnswersQuestion(&rr
->resrec
, q
)) // which answers our question
2627 rr
->UnansweredQueries
++; // indicate that we're expecting a response
2628 rr
->LastUnansweredTime
= m
->timenow
;
2629 SetNextCacheCheckTimeForRecord(m
, rr
);
2636 // When we have a query looking for a specified name, but there appear to be no answers with
2637 // that name, ReconfirmAntecedents() is called with depth=0 to start the reconfirmation process
2638 // for any records in our cache that reference the given name (e.g. PTR and SRV records).
2639 // For any such cache record we find, we also recursively call ReconfirmAntecedents() for *its* name.
2640 // We increment depth each time we recurse, to guard against possible infinite loops, with a limit of 5.
2641 // A typical reconfirmation scenario might go like this:
2642 // Depth 0: Name "myhost.local" has no address records
2643 // Depth 1: SRV "My Service._example._tcp.local." refers to "myhost.local"; may be stale
2644 // Depth 2: PTR "_example._tcp.local." refers to "My Service"; may be stale
2645 // Depth 3: PTR "_services._dns-sd._udp.local." refers to "_example._tcp.local."; may be stale
2646 // Currently depths 4 and 5 are not expected to occur; if we did get to depth 5 we'd reconfim any records we
2647 // found referring to the given name, but not recursively descend any further reconfirm *their* antecedents.
2648 mDNSlocal
void ReconfirmAntecedents(mDNS
*const m
, const domainname
*const name
, const mDNSu32 namehash
, const int depth
)
2653 debugf("ReconfirmAntecedents (depth=%d) for %##s", depth
, name
->c
);
2654 FORALL_CACHERECORDS(slot
, cg
, cr
)
2656 domainname
*crtarget
= GetRRDomainNameTarget(&cr
->resrec
);
2657 if (crtarget
&& cr
->resrec
.rdatahash
== namehash
&& SameDomainName(crtarget
, name
))
2659 LogInfo("ReconfirmAntecedents: Reconfirming (depth=%d) %s", depth
, CRDisplayString(m
, cr
));
2660 mDNS_Reconfirm_internal(m
, cr
, kDefaultReconfirmTimeForNoAnswer
);
2661 if (depth
< 5) ReconfirmAntecedents(m
, cr
->resrec
.name
, cr
->resrec
.namehash
, depth
+1);
2666 // If we get no answer for a AAAA query, then before doing an automatic implicit ReconfirmAntecedents
2667 // we check if we have an address record for the same name. If we do have an IPv4 address for a given
2668 // name but not an IPv6 address, that's okay (it just means the device doesn't do IPv6) so the failure
2669 // to get a AAAA response is not grounds to doubt the PTR/SRV chain that lead us to that name.
2670 mDNSlocal
const CacheRecord
*CacheHasAddressTypeForName(mDNS
*const m
, const domainname
*const name
, const mDNSu32 namehash
)
2672 CacheGroup
*const cg
= CacheGroupForName(m
, HashSlot(name
), namehash
, name
);
2673 const CacheRecord
*cr
= cg
? cg
->members
: mDNSNULL
;
2674 while (cr
&& !RRTypeIsAddressType(cr
->resrec
.rrtype
)) cr
=cr
->next
;
2678 mDNSlocal
const CacheRecord
*FindSPSInCache1(mDNS
*const m
, const DNSQuestion
*const q
, const CacheRecord
*const c0
, const CacheRecord
*const c1
)
2680 CacheGroup
*const cg
= CacheGroupForName(m
, HashSlot(&q
->qname
), q
->qnamehash
, &q
->qname
);
2681 const CacheRecord
*cr
, *bestcr
= mDNSNULL
;
2682 mDNSu32 bestmetric
= 1000000;
2683 for (cr
= cg
? cg
->members
: mDNSNULL
; cr
; cr
=cr
->next
)
2684 if (cr
->resrec
.rrtype
== kDNSType_PTR
&& cr
->resrec
.rdlength
>= 6) // If record is PTR type, with long enough name,
2685 if (cr
!= c0
&& cr
!= c1
) // that's not one we've seen before,
2686 if (SameNameRecordAnswersQuestion(&cr
->resrec
, q
)) // and answers our browse query,
2687 if (!IdenticalSameNameRecord(&cr
->resrec
, &m
->SPSRecords
.RR_PTR
.resrec
)) // and is not our own advertised service...
2689 mDNSu32 metric
= SPSMetric(cr
->resrec
.rdata
->u
.name
.c
);
2690 if (bestmetric
> metric
) { bestmetric
= metric
; bestcr
= cr
; }
2695 // Finds the three best Sleep Proxies we currently have in our cache
2696 mDNSexport
void FindSPSInCache(mDNS
*const m
, const DNSQuestion
*const q
, const CacheRecord
*sps
[3])
2698 sps
[0] = FindSPSInCache1(m
, q
, mDNSNULL
, mDNSNULL
);
2699 sps
[1] = !sps
[0] ? mDNSNULL
: FindSPSInCache1(m
, q
, sps
[0], mDNSNULL
);
2700 sps
[2] = !sps
[1] ? mDNSNULL
: FindSPSInCache1(m
, q
, sps
[0], sps
[1]);
2703 // Only DupSuppressInfos newer than the specified 'time' are allowed to remain active
2704 mDNSlocal
void ExpireDupSuppressInfo(DupSuppressInfo ds
[DupSuppressInfoSize
], mDNSs32 time
)
2707 for (i
=0; i
<DupSuppressInfoSize
; i
++) if (ds
[i
].Time
- time
< 0) ds
[i
].InterfaceID
= mDNSNULL
;
2710 mDNSlocal
void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds
[DupSuppressInfoSize
], mDNSs32 time
, mDNSInterfaceID InterfaceID
)
2713 for (i
=0; i
<DupSuppressInfoSize
; i
++) if (ds
[i
].InterfaceID
== InterfaceID
&& ds
[i
].Time
- time
< 0) ds
[i
].InterfaceID
= mDNSNULL
;
2716 mDNSlocal mDNSBool
SuppressOnThisInterface(const DupSuppressInfo ds
[DupSuppressInfoSize
], const NetworkInterfaceInfo
* const intf
)
2719 mDNSBool v4
= !intf
->IPv4Available
; // If this interface doesn't do v4, we don't need to find a v4 duplicate of this query
2720 mDNSBool v6
= !intf
->IPv6Available
; // If this interface doesn't do v6, we don't need to find a v6 duplicate of this query
2721 for (i
=0; i
<DupSuppressInfoSize
; i
++)
2722 if (ds
[i
].InterfaceID
== intf
->InterfaceID
)
2724 if (ds
[i
].Type
== mDNSAddrType_IPv4
) v4
= mDNStrue
;
2725 else if (ds
[i
].Type
== mDNSAddrType_IPv6
) v6
= mDNStrue
;
2726 if (v4
&& v6
) return(mDNStrue
);
2731 mDNSlocal
int RecordDupSuppressInfo(DupSuppressInfo ds
[DupSuppressInfoSize
], mDNSs32 Time
, mDNSInterfaceID InterfaceID
, mDNSs32 Type
)
2735 // See if we have this one in our list somewhere already
2736 for (i
=0; i
<DupSuppressInfoSize
; i
++) if (ds
[i
].InterfaceID
== InterfaceID
&& ds
[i
].Type
== Type
) break;
2738 // If not, find a slot we can re-use
2739 if (i
>= DupSuppressInfoSize
)
2742 for (j
=1; j
<DupSuppressInfoSize
&& ds
[i
].InterfaceID
; j
++)
2743 if (!ds
[j
].InterfaceID
|| ds
[j
].Time
- ds
[i
].Time
< 0)
2747 // Record the info about this query we saw
2749 ds
[i
].InterfaceID
= InterfaceID
;
2755 mDNSlocal
void mDNSSendWakeOnResolve(mDNS
*const m
, DNSQuestion
*q
)
2758 mDNSInterfaceID InterfaceID
= q
->InterfaceID
;
2759 domainname
*d
= &q
->qname
;
2761 // We can't send magic packets without knowing which interface to send it on.
2762 if (InterfaceID
== mDNSInterface_Any
|| InterfaceID
== mDNSInterface_LocalOnly
|| InterfaceID
== mDNSInterface_P2P
)
2764 LogMsg("mDNSSendWakeOnResolve: ERROR!! Invalid InterfaceID %p for question %##s", InterfaceID
, q
->qname
.c
);
2768 // Split MAC@IPAddress and pass them separately
2772 for (i
= 1; i
< len
; i
++)
2776 char EthAddr
[18]; // ethernet adddress : 12 bytes + 5 ":" + 1 NULL byte
2777 char IPAddr
[47]; // Max IP address len: 46 bytes (IPv6) + 1 NULL byte
2780 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, cnt %d", q
->qname
.c
, cnt
);
2783 if ((i
- 1) > (int) (sizeof(EthAddr
) - 1))
2785 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, length %d", q
->qname
.c
, i
- 1);
2788 if ((len
- i
) > (int)(sizeof(IPAddr
) - 1))
2790 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed IP address %##s, length %d", q
->qname
.c
, len
- i
);
2793 mDNSPlatformMemCopy(EthAddr
, &d
->c
[1], i
- 1);
2795 mDNSPlatformMemCopy(IPAddr
, &d
->c
[i
+ 1], len
- i
);
2796 IPAddr
[len
- i
] = 0;
2797 mDNSPlatformSendWakeupPacket(m
, InterfaceID
, EthAddr
, IPAddr
, InitialWakeOnResolveCount
- q
->WakeOnResolveCount
);
2800 else if (d
->c
[i
] == ':')
2803 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed WakeOnResolve name %##s", q
->qname
.c
);
2807 mDNSlocal mDNSBool
AccelerateThisQuery(mDNS
*const m
, DNSQuestion
*q
)
2809 // If more than 90% of the way to the query time, we should unconditionally accelerate it
2810 if (TimeToSendThisQuestion(q
, m
->timenow
+ q
->ThisQInterval
/10))
2813 // If half-way to next scheduled query time, only accelerate if it will add less than 512 bytes to the packet
2814 if (TimeToSendThisQuestion(q
, m
->timenow
+ q
->ThisQInterval
/2))
2816 // We forecast: qname (n) type (2) class (2)
2817 mDNSu32 forecast
= (mDNSu32
)DomainNameLength(&q
->qname
) + 4;
2818 const mDNSu32 slot
= HashSlot(&q
->qname
);
2819 const CacheGroup
*const cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
2820 const CacheRecord
*rr
;
2821 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
) // If we have a resource record in our cache,
2822 if (rr
->resrec
.rdlength
<= SmallRecordLimit
&& // which is small enough to sensibly fit in the packet
2823 SameNameRecordAnswersQuestion(&rr
->resrec
, q
) && // which answers our question
2824 rr
->TimeRcvd
+ TicksTTL(rr
)/2 - m
->timenow
>= 0 && // and it is less than half-way to expiry
2825 rr
->NextRequiredQuery
- (m
->timenow
+ q
->ThisQInterval
) > 0)// and we'll ask at least once again before NextRequiredQuery
2827 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
2828 forecast
+= 12 + rr
->resrec
.rdestimate
;
2829 if (forecast
>= 512) return(mDNSfalse
); // If this would add 512 bytes or more to the packet, don't accelerate
2837 // How Standard Queries are generated:
2838 // 1. The Question Section contains the question
2839 // 2. The Additional Section contains answers we already know, to suppress duplicate responses
2841 // How Probe Queries are generated:
2842 // 1. The Question Section contains queries for the name we intend to use, with QType=ANY because
2843 // if some other host is already using *any* records with this name, we want to know about it.
2844 // 2. The Authority Section contains the proposed values we intend to use for one or more
2845 // of our records with that name (analogous to the Update section of DNS Update packets)
2846 // because if some other host is probing at the same time, we each want to know what the other is
2847 // planning, in order to apply the tie-breaking rule to see who gets to use the name and who doesn't.
2849 mDNSlocal
void SendQueries(mDNS
*const m
)
2857 // For explanation of maxExistingQuestionInterval logic, see comments for maxExistingAnnounceInterval
2858 mDNSs32 maxExistingQuestionInterval
= 0;
2859 const NetworkInterfaceInfo
*intf
= GetFirstActiveInterface(m
->HostInterfaces
);
2860 CacheRecord
*KnownAnswerList
= mDNSNULL
;
2862 // 1. If time for a query, work out what we need to do
2864 // We're expecting to send a query anyway, so see if any expiring cache records are close enough
2865 // to their NextRequiredQuery to be worth batching them together with this one
2866 FORALL_CACHERECORDS(slot
, cg
, cr
)
2867 if (cr
->CRActiveQuestion
&& cr
->UnansweredQueries
< MaxUnansweredQueries
)
2868 if (m
->timenow
+ TicksTTL(cr
)/50 - cr
->NextRequiredQuery
>= 0)
2870 debugf("Sending %d%% cache expiration query for %s", 80 + 5 * cr
->UnansweredQueries
, CRDisplayString(m
, cr
));
2871 q
= cr
->CRActiveQuestion
;
2872 ExpireDupSuppressInfoOnInterface(q
->DupSuppress
, m
->timenow
- TicksTTL(cr
)/20, cr
->resrec
.InterfaceID
);
2873 // For uDNS queries (TargetQID non-zero) we adjust LastQTime,
2874 // and bump UnansweredQueries so that we don't spin trying to send the same cache expiration query repeatedly
2875 if (q
->Target
.type
) q
->SendQNow
= mDNSInterfaceMark
; // If targeted query, mark it
2876 else if (!mDNSOpaque16IsZero(q
->TargetQID
)) { q
->LastQTime
= m
->timenow
- q
->ThisQInterval
; cr
->UnansweredQueries
++; }
2877 else if (q
->SendQNow
== mDNSNULL
) q
->SendQNow
= cr
->resrec
.InterfaceID
;
2878 else if (q
->SendQNow
!= cr
->resrec
.InterfaceID
) q
->SendQNow
= mDNSInterfaceMark
;
2881 // Scan our list of questions to see which:
2882 // *WideArea* queries need to be sent
2883 // *unicast* queries need to be sent
2884 // *multicast* queries we're definitely going to send
2885 if (m
->CurrentQuestion
)
2886 LogMsg("SendQueries ERROR m->CurrentQuestion already set: %##s (%s)", m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
2887 m
->CurrentQuestion
= m
->Questions
;
2888 while (m
->CurrentQuestion
&& m
->CurrentQuestion
!= m
->NewQuestions
)
2890 q
= m
->CurrentQuestion
;
2891 if (q
->Target
.type
&& (q
->SendQNow
|| TimeToSendThisQuestion(q
, m
->timenow
)))
2893 mDNSu8
*qptr
= m
->omsg
.data
;
2894 const mDNSu8
*const limit
= m
->omsg
.data
+ sizeof(m
->omsg
.data
);
2896 // If we fail to get a new on-demand socket (should only happen cases of the most extreme resource exhaustion), we'll try again next time
2897 if (!q
->LocalSocket
) q
->LocalSocket
= mDNSPlatformUDPSocket(m
, zeroIPPort
);
2900 InitializeDNSMessage(&m
->omsg
.h
, q
->TargetQID
, QueryFlags
);
2901 qptr
= putQuestion(&m
->omsg
, qptr
, limit
, &q
->qname
, q
->qtype
, q
->qclass
);
2902 mDNSSendDNSMessage(m
, &m
->omsg
, qptr
, mDNSInterface_Any
, q
->LocalSocket
, &q
->Target
, q
->TargetPort
, mDNSNULL
, mDNSNULL
);
2903 q
->ThisQInterval
*= QuestionIntervalStep
;
2905 if (q
->ThisQInterval
> MaxQuestionInterval
)
2906 q
->ThisQInterval
= MaxQuestionInterval
;
2907 q
->LastQTime
= m
->timenow
;
2908 q
->LastQTxTime
= m
->timenow
;
2909 q
->RecentAnswerPkts
= 0;
2910 q
->SendQNow
= mDNSNULL
;
2911 q
->ExpectUnicastResp
= NonZeroTime(m
->timenow
);
2913 else if (mDNSOpaque16IsZero(q
->TargetQID
) && !q
->Target
.type
&& TimeToSendThisQuestion(q
, m
->timenow
))
2915 //LogInfo("Time to send %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - NextQSendTime(q));
2916 q
->SendQNow
= mDNSInterfaceMark
; // Mark this question for sending on all interfaces
2917 if (maxExistingQuestionInterval
< q
->ThisQInterval
)
2918 maxExistingQuestionInterval
= q
->ThisQInterval
;
2920 // If m->CurrentQuestion wasn't modified out from under us, advance it now
2921 // We can't do this at the start of the loop because uDNS_CheckCurrentQuestion() depends on having
2922 // m->CurrentQuestion point to the right question
2923 if (q
== m
->CurrentQuestion
) m
->CurrentQuestion
= m
->CurrentQuestion
->next
;
2925 while (m
->CurrentQuestion
)
2927 LogInfo("SendQueries question loop 1: Skipping NewQuestion %##s (%s)", m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
2928 m
->CurrentQuestion
= m
->CurrentQuestion
->next
;
2930 m
->CurrentQuestion
= mDNSNULL
;
2932 // Scan our list of questions
2933 // (a) to see if there are any more that are worth accelerating, and
2934 // (b) to update the state variables for *all* the questions we're going to send
2935 // Note: Don't set NextScheduledQuery until here, because uDNS_CheckCurrentQuestion in the loop above can add new questions to the list,
2936 // which causes NextScheduledQuery to get (incorrectly) set to m->timenow. Setting it here is the right place, because the very
2937 // next thing we do is scan the list and call SetNextQueryTime() for every question we find, so we know we end up with the right value.
2938 m
->NextScheduledQuery
= m
->timenow
+ 0x78000000;
2939 for (q
= m
->Questions
; q
&& q
!= m
->NewQuestions
; q
=q
->next
)
2941 if (mDNSOpaque16IsZero(q
->TargetQID
) && (q
->SendQNow
||
2942 (!q
->Target
.type
&& ActiveQuestion(q
) && q
->ThisQInterval
<= maxExistingQuestionInterval
&& AccelerateThisQuery(m
,q
))))
2944 // If at least halfway to next query time, advance to next interval
2945 // If less than halfway to next query time, then
2946 // treat this as logically a repeat of the last transmission, without advancing the interval
2947 if (m
->timenow
- (q
->LastQTime
+ (q
->ThisQInterval
/2)) >= 0)
2949 //LogInfo("Accelerating %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - NextQSendTime(q));
2950 q
->SendQNow
= mDNSInterfaceMark
; // Mark this question for sending on all interfaces
2951 debugf("SendQueries: %##s (%s) next interval %d seconds RequestUnicast = %d",
2952 q
->qname
.c
, DNSTypeName(q
->qtype
), q
->ThisQInterval
/ InitialQuestionInterval
, q
->RequestUnicast
);
2953 q
->ThisQInterval
*= QuestionIntervalStep
;
2954 if (q
->ThisQInterval
> MaxQuestionInterval
)
2955 q
->ThisQInterval
= MaxQuestionInterval
;
2956 else if (q
->CurrentAnswers
== 0 && q
->ThisQInterval
== InitialQuestionInterval
* QuestionIntervalStep3
&& !q
->RequestUnicast
&&
2957 !(RRTypeIsAddressType(q
->qtype
) && CacheHasAddressTypeForName(m
, &q
->qname
, q
->qnamehash
)))
2959 // Generally don't need to log this.
2960 // It's not especially noteworthy if a query finds no results -- this usually happens for domain
2961 // enumeration queries in the LL subdomain (e.g. "db._dns-sd._udp.0.0.254.169.in-addr.arpa")
2962 // and when there simply happen to be no instances of the service the client is looking
2963 // for (e.g. iTunes is set to look for RAOP devices, and the current network has none).
2964 debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents",
2965 q
->qname
.c
, DNSTypeName(q
->qtype
));
2966 // Sending third query, and no answers yet; time to begin doubting the source
2967 ReconfirmAntecedents(m
, &q
->qname
, q
->qnamehash
, 0);
2971 // Mark for sending. (If no active interfaces, then don't even try.)
2972 q
->SendOnAll
= (q
->SendQNow
== mDNSInterfaceMark
);
2975 q
->SendQNow
= !intf
? mDNSNULL
: (q
->InterfaceID
) ? q
->InterfaceID
: intf
->InterfaceID
;
2976 q
->LastQTime
= m
->timenow
;
2979 // If we recorded a duplicate suppression for this question less than half an interval ago,
2980 // then we consider it recent enough that we don't need to do an identical query ourselves.
2981 ExpireDupSuppressInfo(q
->DupSuppress
, m
->timenow
- q
->ThisQInterval
/2);
2983 q
->LastQTxTime
= m
->timenow
;
2984 q
->RecentAnswerPkts
= 0;
2985 if (q
->RequestUnicast
) q
->RequestUnicast
--;
2987 // For all questions (not just the ones we're sending) check what the next scheduled event will be
2988 // We don't need to consider NewQuestions here because for those we'll set m->NextScheduledQuery in AnswerNewQuestion
2989 SetNextQueryTime(m
,q
);
2992 // 2. Scan our authoritative RR list to see what probes we might need to send
2994 m
->NextScheduledProbe
= m
->timenow
+ 0x78000000;
2996 if (m
->CurrentRecord
)
2997 LogMsg("SendQueries ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
2998 m
->CurrentRecord
= m
->ResourceRecords
;
2999 while (m
->CurrentRecord
)
3001 ar
= m
->CurrentRecord
;
3002 m
->CurrentRecord
= ar
->next
;
3003 if (!AuthRecord_uDNS(ar
) && ar
->resrec
.RecordType
== kDNSRecordTypeUnique
) // For all records that are still probing...
3005 // 1. If it's not reached its probe time, just make sure we update m->NextScheduledProbe correctly
3006 if (m
->timenow
- (ar
->LastAPTime
+ ar
->ThisAPInterval
) < 0)
3008 SetNextAnnounceProbeTime(m
, ar
);
3010 // 2. else, if it has reached its probe time, mark it for sending and then update m->NextScheduledProbe correctly
3011 else if (ar
->ProbeCount
)
3013 if (ar
->AddressProxy
.type
== mDNSAddrType_IPv4
)
3015 LogSPS("SendQueries ARP Probe %d %s %s", ar
->ProbeCount
, InterfaceNameForID(m
, ar
->resrec
.InterfaceID
), ARDisplayString(m
,ar
));
3016 SendARP(m
, 1, ar
, &zerov4Addr
, &zeroEthAddr
, &ar
->AddressProxy
.ip
.v4
, &ar
->WakeUp
.IMAC
);
3018 else if (ar
->AddressProxy
.type
== mDNSAddrType_IPv6
)
3020 LogSPS("SendQueries NDP Probe %d %s %s", ar
->ProbeCount
, InterfaceNameForID(m
, ar
->resrec
.InterfaceID
), ARDisplayString(m
,ar
));
3021 // IPv6 source = zero
3022 // No target hardware address
3023 // IPv6 target address is address we're probing
3024 // Ethernet destination address is Ethernet interface address of the Sleep Proxy client we're probing
3025 SendNDP(m
, NDP_Sol
, 0, ar
, &zerov6Addr
, mDNSNULL
, &ar
->AddressProxy
.ip
.v6
, &ar
->WakeUp
.IMAC
);
3027 // Mark for sending. (If no active interfaces, then don't even try.)
3028 ar
->SendRNow
= (!intf
|| ar
->WakeUp
.HMAC
.l
[0]) ? mDNSNULL
: ar
->resrec
.InterfaceID
? ar
->resrec
.InterfaceID
: intf
->InterfaceID
;
3029 ar
->LastAPTime
= m
->timenow
;
3030 // When we have a late conflict that resets a record to probing state we use a special marker value greater
3031 // than DefaultProbeCountForTypeUnique. Here we detect that state and reset ar->ProbeCount back to the right value.
3032 if (ar
->ProbeCount
> DefaultProbeCountForTypeUnique
)
3033 ar
->ProbeCount
= DefaultProbeCountForTypeUnique
;
3035 SetNextAnnounceProbeTime(m
, ar
);
3036 if (ar
->ProbeCount
== 0)
3038 // If this is the last probe for this record, then see if we have any matching records
3039 // on our duplicate list which should similarly have their ProbeCount cleared to zero...
3041 for (r2
= m
->DuplicateRecords
; r2
; r2
=r2
->next
)
3042 if (r2
->resrec
.RecordType
== kDNSRecordTypeUnique
&& RecordIsLocalDuplicate(r2
, ar
))
3044 // ... then acknowledge this record to the client.
3045 // We do this optimistically, just as we're about to send the third probe.
3046 // This helps clients that both advertise and browse, and want to filter themselves
3047 // from the browse results list, because it helps ensure that the registration
3048 // confirmation will be delivered 1/4 second *before* the browse "add" event.
3049 // A potential downside is that we could deliver a registration confirmation and then find out
3050 // moments later that there's a name conflict, but applications have to be prepared to handle
3051 // late conflicts anyway (e.g. on connection of network cable, etc.), so this is nothing new.
3052 if (!ar
->Acknowledged
) AcknowledgeRecord(m
, ar
);
3055 // else, if it has now finished probing, move it to state Verified,
3056 // and update m->NextScheduledResponse so it will be announced
3059 if (!ar
->Acknowledged
) AcknowledgeRecord(m
, ar
); // Defensive, just in case it got missed somehow
3060 ar
->resrec
.RecordType
= kDNSRecordTypeVerified
;
3061 ar
->ThisAPInterval
= DefaultAnnounceIntervalForTypeUnique
;
3062 ar
->LastAPTime
= m
->timenow
- DefaultAnnounceIntervalForTypeUnique
;
3063 SetNextAnnounceProbeTime(m
, ar
);
3067 m
->CurrentRecord
= m
->DuplicateRecords
;
3068 while (m
->CurrentRecord
)
3070 ar
= m
->CurrentRecord
;
3071 m
->CurrentRecord
= ar
->next
;
3072 if (ar
->resrec
.RecordType
== kDNSRecordTypeUnique
&& ar
->ProbeCount
== 0 && !ar
->Acknowledged
)
3073 AcknowledgeRecord(m
, ar
);
3076 // 3. Now we know which queries and probes we're sending,
3077 // go through our interface list sending the appropriate queries on each interface
3080 const int OwnerRecordSpace
= (m
->AnnounceOwner
&& intf
->MAC
.l
[0]) ? DNSOpt_Header_Space
+ DNSOpt_Owner_Space(&m
->PrimaryMAC
, &intf
->MAC
) : 0;
3081 mDNSu8
*queryptr
= m
->omsg
.data
;
3082 InitializeDNSMessage(&m
->omsg
.h
, zeroID
, QueryFlags
);
3083 if (KnownAnswerList
) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet");
3084 if (!KnownAnswerList
)
3086 // Start a new known-answer list
3087 CacheRecord
**kalistptr
= &KnownAnswerList
;
3088 mDNSu32 answerforecast
= OwnerRecordSpace
; // We start by assuming we'll need at least enough space to put the Owner Option
3090 // Put query questions in this packet
3091 for (q
= m
->Questions
; q
&& q
!= m
->NewQuestions
; q
=q
->next
)
3093 if (mDNSOpaque16IsZero(q
->TargetQID
) && (q
->SendQNow
== intf
->InterfaceID
))
3095 debugf("SendQueries: %s question for %##s (%s) at %d forecast total %d",
3096 SuppressOnThisInterface(q
->DupSuppress
, intf
) ? "Suppressing" : "Putting ",
3097 q
->qname
.c
, DNSTypeName(q
->qtype
), queryptr
- m
->omsg
.data
, queryptr
+ answerforecast
- m
->omsg
.data
);
3099 // If we're suppressing this question, or we successfully put it, update its SendQNow state
3100 if (SuppressOnThisInterface(q
->DupSuppress
, intf
) ||
3101 BuildQuestion(m
, &m
->omsg
, &queryptr
, q
, &kalistptr
, &answerforecast
))
3103 q
->SendQNow
= (q
->InterfaceID
|| !q
->SendOnAll
) ? mDNSNULL
: GetNextActiveInterfaceID(intf
);
3104 if (q
->WakeOnResolveCount
)
3106 mDNSSendWakeOnResolve(m
, q
);
3107 q
->WakeOnResolveCount
--;
3113 // Put probe questions in this packet
3114 for (ar
= m
->ResourceRecords
; ar
; ar
=ar
->next
)
3115 if (ar
->SendRNow
== intf
->InterfaceID
)
3117 mDNSBool ucast
= (ar
->ProbeCount
>= DefaultProbeCountForTypeUnique
-1) && m
->CanReceiveUnicastOn5353
;
3118 mDNSu16 ucbit
= (mDNSu16
)(ucast
? kDNSQClass_UnicastResponse
: 0);
3119 const mDNSu8
*const limit
= m
->omsg
.data
+ (m
->omsg
.h
.numQuestions
? NormalMaxDNSMessageData
: AbsoluteMaxDNSMessageData
);
3120 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
3121 mDNSu32 forecast
= answerforecast
+ 12 + ar
->resrec
.rdestimate
;
3122 mDNSu8
*newptr
= putQuestion(&m
->omsg
, queryptr
, limit
- forecast
, ar
->resrec
.name
, kDNSQType_ANY
, (mDNSu16
)(ar
->resrec
.rrclass
| ucbit
));
3126 answerforecast
= forecast
;
3127 ar
->SendRNow
= (ar
->resrec
.InterfaceID
) ? mDNSNULL
: GetNextActiveInterfaceID(intf
);
3128 ar
->IncludeInProbe
= mDNStrue
;
3129 verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d",
3130 ar
->resrec
.name
->c
, DNSTypeName(ar
->resrec
.rrtype
), ar
->ProbeCount
);
3135 // Put our known answer list (either new one from this question or questions, or remainder of old one from last time)
3136 while (KnownAnswerList
)
3138 CacheRecord
*ka
= KnownAnswerList
;
3139 mDNSu32 SecsSinceRcvd
= ((mDNSu32
)(m
->timenow
- ka
->TimeRcvd
)) / mDNSPlatformOneSecond
;
3140 mDNSu8
*newptr
= PutResourceRecordTTLWithLimit(&m
->omsg
, queryptr
, &m
->omsg
.h
.numAnswers
,
3141 &ka
->resrec
, ka
->resrec
.rroriginalttl
- SecsSinceRcvd
, m
->omsg
.data
+ NormalMaxDNSMessageData
- OwnerRecordSpace
);
3144 verbosedebugf("SendQueries: Put %##s (%s) at %d - %d",
3145 ka
->resrec
.name
->c
, DNSTypeName(ka
->resrec
.rrtype
), queryptr
- m
->omsg
.data
, newptr
- m
->omsg
.data
);
3147 KnownAnswerList
= ka
->NextInKAList
;
3148 ka
->NextInKAList
= mDNSNULL
;
3152 // If we ran out of space and we have more than one question in the packet, that's an error --
3153 // we shouldn't have put more than one question if there was a risk of us running out of space.
3154 if (m
->omsg
.h
.numQuestions
> 1)
3155 LogMsg("SendQueries: Put %d answers; No more space for known answers", m
->omsg
.h
.numAnswers
);
3156 m
->omsg
.h
.flags
.b
[0] |= kDNSFlag0_TC
;
3161 for (ar
= m
->ResourceRecords
; ar
; ar
=ar
->next
)
3162 if (ar
->IncludeInProbe
)
3164 mDNSu8
*newptr
= PutResourceRecord(&m
->omsg
, queryptr
, &m
->omsg
.h
.numAuthorities
, &ar
->resrec
);
3165 ar
->IncludeInProbe
= mDNSfalse
;
3166 if (newptr
) queryptr
= newptr
;
3167 else LogMsg("SendQueries: How did we fail to have space for the Update record %s", ARDisplayString(m
,ar
));
3170 if (queryptr
> m
->omsg
.data
)
3172 if (OwnerRecordSpace
)
3175 mDNS_SetupResourceRecord(&opt
, mDNSNULL
, mDNSInterface_Any
, kDNSType_OPT
, kStandardTTL
, kDNSRecordTypeKnownUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
3176 opt
.resrec
.rrclass
= NormalMaxDNSMessageData
;
3177 opt
.resrec
.rdlength
= sizeof(rdataOPT
); // One option in this OPT record
3178 opt
.resrec
.rdestimate
= sizeof(rdataOPT
);
3179 SetupOwnerOpt(m
, intf
, &opt
.resrec
.rdata
->u
.opt
[0]);
3180 LogSPS("SendQueries putting %s", ARDisplayString(m
, &opt
));
3181 queryptr
= PutResourceRecordTTLWithLimit(&m
->omsg
, queryptr
, &m
->omsg
.h
.numAdditionals
,
3182 &opt
.resrec
, opt
.resrec
.rroriginalttl
, m
->omsg
.data
+ AbsoluteMaxDNSMessageData
);
3184 LogMsg("SendQueries: How did we fail to have space for the OPT record (%d/%d/%d/%d) %s",
3185 m
->omsg
.h
.numQuestions
, m
->omsg
.h
.numAnswers
, m
->omsg
.h
.numAuthorities
, m
->omsg
.h
.numAdditionals
, ARDisplayString(m
, &opt
));
3186 if (queryptr
> m
->omsg
.data
+ NormalMaxDNSMessageData
)
3187 if (m
->omsg
.h
.numQuestions
!= 1 || m
->omsg
.h
.numAnswers
!= 0 || m
->omsg
.h
.numAuthorities
!= 1 || m
->omsg
.h
.numAdditionals
!= 1)
3188 LogMsg("SendQueries: Why did we generate oversized packet with OPT record %p %p %p (%d/%d/%d/%d) %s",
3189 m
->omsg
.data
, m
->omsg
.data
+ NormalMaxDNSMessageData
, queryptr
,
3190 m
->omsg
.h
.numQuestions
, m
->omsg
.h
.numAnswers
, m
->omsg
.h
.numAuthorities
, m
->omsg
.h
.numAdditionals
, ARDisplayString(m
, &opt
));
3193 if ((m
->omsg
.h
.flags
.b
[0] & kDNSFlag0_TC
) && m
->omsg
.h
.numQuestions
> 1)
3194 LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet", m
->omsg
.h
.numQuestions
);
3195 debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p",
3196 m
->omsg
.h
.numQuestions
, m
->omsg
.h
.numQuestions
== 1 ? "" : "s",
3197 m
->omsg
.h
.numAnswers
, m
->omsg
.h
.numAnswers
== 1 ? "" : "s",
3198 m
->omsg
.h
.numAuthorities
, m
->omsg
.h
.numAuthorities
== 1 ? "" : "s", intf
->InterfaceID
);
3199 if (intf
->IPv4Available
) mDNSSendDNSMessage(m
, &m
->omsg
, queryptr
, intf
->InterfaceID
, mDNSNULL
, &AllDNSLinkGroup_v4
, MulticastDNSPort
, mDNSNULL
, mDNSNULL
);
3200 if (intf
->IPv6Available
) mDNSSendDNSMessage(m
, &m
->omsg
, queryptr
, intf
->InterfaceID
, mDNSNULL
, &AllDNSLinkGroup_v6
, MulticastDNSPort
, mDNSNULL
, mDNSNULL
);
3201 if (!m
->SuppressSending
) m
->SuppressSending
= NonZeroTime(m
->timenow
+ (mDNSPlatformOneSecond
+9)/10);
3202 if (++pktcount
>= 1000)
3203 { LogMsg("SendQueries exceeded loop limit %d: giving up", pktcount
); break; }
3204 // There might be more records left in the known answer list, or more questions to send
3205 // on this interface, so go around one more time and try again.
3207 else // Nothing more to send on this interface; go to next
3209 const NetworkInterfaceInfo
*next
= GetFirstActiveInterface(intf
->next
);
3210 #if MDNS_DEBUGMSGS && 0
3211 const char *const msg
= next
? "SendQueries: Nothing more on %p; moving to %p" : "SendQueries: Nothing more on %p";
3212 debugf(msg
, intf
, next
);
3218 // 4. Final housekeeping
3220 // 4a. Debugging check: Make sure we announced all our records
3221 for (ar
= m
->ResourceRecords
; ar
; ar
=ar
->next
)
3224 if (ar
->ARType
!= AuthRecordLocalOnly
&& ar
->ARType
!= AuthRecordP2P
)
3225 LogMsg("SendQueries: No active interface %p to send probe: %p %s", ar
->SendRNow
, ar
->resrec
.InterfaceID
, ARDisplayString(m
, ar
));
3226 ar
->SendRNow
= mDNSNULL
;
3229 // 4b. When we have lingering cache records that we're keeping around for a few seconds in the hope
3230 // that their interface which went away might come back again, the logic will want to send queries
3231 // for those records, but we can't because their interface isn't here any more, so to keep the
3232 // state machine ticking over we just pretend we did so.
3233 // If the interface does not come back in time, the cache record will expire naturally
3234 FORALL_CACHERECORDS(slot
, cg
, cr
)
3235 if (cr
->CRActiveQuestion
&& cr
->UnansweredQueries
< MaxUnansweredQueries
)
3236 if (m
->timenow
+ TicksTTL(cr
)/50 - cr
->NextRequiredQuery
>= 0)
3238 cr
->UnansweredQueries
++;
3239 cr
->CRActiveQuestion
->SendQNow
= mDNSNULL
;
3240 SetNextCacheCheckTimeForRecord(m
, cr
);
3243 // 4c. Debugging check: Make sure we sent all our planned questions
3244 // Do this AFTER the lingering cache records check above, because that will prevent spurious warnings for questions
3245 // we legitimately couldn't send because the interface is no longer available
3246 for (q
= m
->Questions
; q
; q
=q
->next
)
3250 for (x
= m
->NewQuestions
; x
; x
=x
->next
) if (x
== q
) break; // Check if this question is a NewQuestion
3251 LogMsg("SendQueries: No active interface %p to send %s question: %p %##s (%s)", q
->SendQNow
, x
? "new" : "old", q
->InterfaceID
, q
->qname
.c
, DNSTypeName(q
->qtype
));
3252 q
->SendQNow
= mDNSNULL
;
3256 mDNSlocal
void SendWakeup(mDNS
*const m
, mDNSInterfaceID InterfaceID
, mDNSEthAddr
*EthAddr
, mDNSOpaque48
*password
)
3259 mDNSu8
*ptr
= m
->omsg
.data
;
3260 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, InterfaceID
);
3261 if (!intf
) { LogMsg("SendARP: No interface with InterfaceID %p found", InterfaceID
); return; }
3263 // 0x00 Destination address
3264 for (i
=0; i
<6; i
++) *ptr
++ = EthAddr
->b
[i
];
3266 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us)
3267 for (i
=0; i
<6; i
++) *ptr
++ = intf
->MAC
.b
[0];
3269 // 0x0C Ethertype (0x0842)
3273 // 0x0E Wakeup sync sequence
3274 for (i
=0; i
<6; i
++) *ptr
++ = 0xFF;
3277 for (j
=0; j
<16; j
++) for (i
=0; i
<6; i
++) *ptr
++ = EthAddr
->b
[i
];
3280 for (i
=0; i
<6; i
++) *ptr
++ = password
->b
[i
];
3282 mDNSPlatformSendRawPacket(m
->omsg
.data
, ptr
, InterfaceID
);
3284 // For Ethernet switches that don't flood-foward packets with unknown unicast destination MAC addresses,
3285 // broadcast is the only reliable way to get a wakeup packet to the intended target machine.
3286 // For 802.11 WPA networks, where a sleeping target machine may have missed a broadcast/multicast
3287 // key rotation, unicast is the only way to get a wakeup packet to the intended target machine.
3288 // So, we send one of each, unicast first, then broadcast second.
3289 for (i
=0; i
<6; i
++) m
->omsg
.data
[i
] = 0xFF;
3290 mDNSPlatformSendRawPacket(m
->omsg
.data
, ptr
, InterfaceID
);
3293 // ***************************************************************************
3294 #if COMPILER_LIKES_PRAGMA_MARK
3296 #pragma mark - RR List Management & Task Management
3299 // Note: AnswerCurrentQuestionWithResourceRecord can call a user callback, which may change the record list and/or question list.
3300 // Any code walking either list must use the m->CurrentQuestion (and possibly m->CurrentRecord) mechanism to protect against this.
3301 // In fact, to enforce this, the routine will *only* answer the question currently pointed to by m->CurrentQuestion,
3302 // which will be auto-advanced (possibly to NULL) if the client callback cancels the question.
3303 mDNSexport
void AnswerCurrentQuestionWithResourceRecord(mDNS
*const m
, CacheRecord
*const rr
, const QC_result AddRecord
)
3305 DNSQuestion
*const q
= m
->CurrentQuestion
;
3306 mDNSBool followcname
= FollowCNAME(q
, &rr
->resrec
, AddRecord
);
3308 verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s",
3309 q
->CurrentAnswers
, AddRecord
? "Add" : "Rmv", rr
->resrec
.rroriginalttl
, CRDisplayString(m
, rr
));
3311 // Normally we don't send out the unicast query if we have answered using our local only auth records e.g., /etc/hosts.
3312 // But if the query for "A" record has a local answer but query for "AAAA" record has no local answer, we might
3313 // send the AAAA query out which will come back with CNAME and will also answer the "A" query. To prevent that,
3314 // we check to see if that query already has a unique local answer.
3315 if (q
->LOAddressAnswers
)
3317 LogInfo("AnswerCurrentQuestionWithResourceRecord: Question %p %##s (%s) not answering with record %s due to "
3318 "LOAddressAnswers %d", q
, q
->qname
.c
, DNSTypeName(q
->qtype
), ARDisplayString(m
, rr
),
3319 q
->LOAddressAnswers
);
3323 if (QuerySuppressed(q
))
3325 // If the query is suppressed, then we don't want to answer from the cache. But if this query is
3326 // supposed to time out, we still want to callback the clients. We do this only for TimeoutQuestions
3327 // that are timing out, which we know are answered with Negative cache record when timing out.
3328 if (!q
->TimeoutQuestion
|| rr
->resrec
.RecordType
!= kDNSRecordTypePacketNegative
|| (m
->timenow
- q
->StopTime
< 0))
3332 // Note: Use caution here. In the case of records with rr->DelayDelivery set, AnswerCurrentQuestionWithResourceRecord(... mDNStrue)
3333 // may be called twice, once when the record is received, and again when it's time to notify local clients.
3334 // If any counters or similar are added here, care must be taken to ensure that they are not double-incremented by this.
3336 rr
->LastUsed
= m
->timenow
;
3337 if (AddRecord
== QC_add
&& !q
->DuplicateOf
&& rr
->CRActiveQuestion
!= q
)
3339 if (!rr
->CRActiveQuestion
) m
->rrcache_active
++; // If not previously active, increment rrcache_active count
3340 debugf("AnswerCurrentQuestionWithResourceRecord: Updating CRActiveQuestion from %p to %p for cache record %s, CurrentAnswer %d",
3341 rr
->CRActiveQuestion
, q
, CRDisplayString(m
,rr
), q
->CurrentAnswers
);
3342 rr
->CRActiveQuestion
= q
; // We know q is non-null
3343 SetNextCacheCheckTimeForRecord(m
, rr
);
3347 // (a) a no-cache add, where we've already done at least one 'QM' query, or
3348 // (b) a normal add, where we have at least one unique-type answer,
3349 // then there's no need to keep polling the network.
3350 // (If we have an answer in the cache, then we'll automatically ask again in time to stop it expiring.)
3351 // We do this for mDNS questions and uDNS one-shot questions, but not for
3352 // uDNS LongLived questions, because that would mess up our LLQ lease renewal timing.
3353 if ((AddRecord
== QC_addnocache
&& !q
->RequestUnicast
) ||
3354 (AddRecord
== QC_add
&& (q
->ExpectUnique
|| (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
))))
3355 if (ActiveQuestion(q
) && (mDNSOpaque16IsZero(q
->TargetQID
) || !q
->LongLived
))
3357 q
->LastQTime
= m
->timenow
;
3358 q
->LastQTxTime
= m
->timenow
;
3359 q
->RecentAnswerPkts
= 0;
3360 q
->ThisQInterval
= MaxQuestionInterval
;
3361 q
->RequestUnicast
= mDNSfalse
;
3362 debugf("AnswerCurrentQuestionWithResourceRecord: Set MaxQuestionInterval for %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
3365 if (rr
->DelayDelivery
) return; // We'll come back later when CacheRecordDeferredAdd() calls us
3367 // Only deliver negative answers if client has explicitly requested them
3368 if (rr
->resrec
.RecordType
== kDNSRecordTypePacketNegative
|| (q
->qtype
!= kDNSType_NSEC
&& RRAssertsNonexistence(&rr
->resrec
, q
->qtype
)))
3369 if (!AddRecord
|| !q
->ReturnIntermed
) return;
3371 // For CNAME results to non-CNAME questions, only inform the client if they explicitly requested that
3372 if (q
->QuestionCallback
&& !q
->NoAnswer
&& (!followcname
|| q
->ReturnIntermed
))
3374 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls
3375 if (q
->qtype
!= kDNSType_NSEC
&& RRAssertsNonexistence(&rr
->resrec
, q
->qtype
))
3378 MakeNegativeCacheRecord(m
, &neg
, &q
->qname
, q
->qnamehash
, q
->qtype
, q
->qclass
, 1, rr
->resrec
.InterfaceID
, q
->qDNSServer
);
3379 q
->QuestionCallback(m
, q
, &neg
.resrec
, AddRecord
);
3382 q
->QuestionCallback(m
, q
, &rr
->resrec
, AddRecord
);
3383 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
3385 // Note: Proceed with caution here because client callback function is allowed to do anything,
3386 // including starting/stopping queries, registering/deregistering records, etc.
3388 if (followcname
&& m
->CurrentQuestion
== q
)
3389 AnswerQuestionByFollowingCNAME(m
, q
, &rr
->resrec
);
3392 // New Questions are answered through AnswerNewQuestion. But there may not have been any
3393 // matching cache records for the questions when it is called. There are two possibilities.
3395 // 1) There are no cache records
3396 // 2) There are cache records but the DNSServers between question and cache record don't match.
3398 // In the case of (1), where there are no cache records and later we add them when we get a response,
3399 // CacheRecordAdd/CacheRecordDeferredAdd will take care of adding the cache and delivering the ADD
3400 // events to the application. If we already have a cache entry, then no ADD events are delivered
3401 // unless the RDATA has changed
3403 // In the case of (2) where we had the cache records and did not answer because of the DNSServer mismatch,
3404 // we need to answer them whenever we change the DNSServer. But we can't do it at the instant the DNSServer
3405 // changes because when we do the callback, the question can get deleted and the calling function would not
3406 // know how to handle it. So, we run this function from mDNS_Execute to handle DNSServer changes on the
3409 mDNSlocal
void AnswerQuestionsForDNSServerChanges(mDNS
*const m
)
3417 if (m
->CurrentQuestion
)
3418 LogMsg("AnswerQuestionsForDNSServerChanges: ERROR m->CurrentQuestion already set: %##s (%s)",
3419 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3421 for (q
= m
->Questions
; q
&& q
!= m
->NewQuestions
; q
= qnext
)
3425 // multicast or DNSServers did not change.
3426 if (mDNSOpaque16IsZero(q
->TargetQID
)) continue;
3427 if (!q
->deliverAddEvents
) continue;
3429 // We are going to look through the cache for this question since it changed
3430 // its DNSserver last time. Reset it so that we don't call them again. Calling
3431 // them again will deliver duplicate events to the application
3432 q
->deliverAddEvents
= mDNSfalse
;
3433 if (QuerySuppressed(q
)) continue;
3434 m
->CurrentQuestion
= q
;
3435 slot
= HashSlot(&q
->qname
);
3436 cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
3437 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
3439 if (SameNameRecordAnswersQuestion(&rr
->resrec
, q
))
3441 LogInfo("AnswerQuestionsForDNSServerChanges: Calling AnswerCurrentQuestionWithResourceRecord for question %p %##s using resource record %s",
3442 q
, q
->qname
.c
, CRDisplayString(m
, rr
));
3443 // When this question penalizes a DNS server and has no more DNS servers to pick, we normally
3444 // deliver a negative cache response and suspend the question for 60 seconds (see uDNS_CheckCurrentQuestion).
3445 // But sometimes we may already find the negative cache entry and deliver that here as the process
3446 // of changing DNS servers. When the cache entry is about to expire, we will resend the question and
3447 // that time, we need to make sure that we have a valid DNS server. Otherwise, we will deliver
3448 // a negative cache response without trying the server.
3449 if (!q
->qDNSServer
&& !q
->DuplicateOf
&& rr
->resrec
.RecordType
== kDNSRecordTypePacketNegative
)
3452 SetValidDNSServers(m
, q
);
3453 q
->qDNSServer
= GetServerForQuestion(m
, q
);
3454 for (qptr
= q
->next
; qptr
; qptr
= qptr
->next
)
3455 if (qptr
->DuplicateOf
== q
) { qptr
->validDNSServers
= q
->validDNSServers
; qptr
->qDNSServer
= q
->qDNSServer
; }
3457 q
->CurrentAnswers
++;
3458 if (rr
->resrec
.rdlength
> SmallRecordLimit
) q
->LargeAnswers
++;
3459 if (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) q
->UniqueAnswers
++;
3460 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_add
);
3461 if (m
->CurrentQuestion
!= q
) break; // If callback deleted q, then we're finished here
3465 m
->CurrentQuestion
= mDNSNULL
;
3468 mDNSlocal
void CacheRecordDeferredAdd(mDNS
*const m
, CacheRecord
*rr
)
3470 rr
->DelayDelivery
= 0;
3471 if (m
->CurrentQuestion
)
3472 LogMsg("CacheRecordDeferredAdd ERROR m->CurrentQuestion already set: %##s (%s)",
3473 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3474 m
->CurrentQuestion
= m
->Questions
;
3475 while (m
->CurrentQuestion
&& m
->CurrentQuestion
!= m
->NewQuestions
)
3477 DNSQuestion
*q
= m
->CurrentQuestion
;
3478 if (ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
3479 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_add
);
3480 if (m
->CurrentQuestion
== q
) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
3481 m
->CurrentQuestion
= q
->next
;
3483 m
->CurrentQuestion
= mDNSNULL
;
3486 mDNSlocal mDNSs32
CheckForSoonToExpireRecords(mDNS
*const m
, const domainname
*const name
, const mDNSu32 namehash
, const mDNSu32 slot
)
3488 const mDNSs32 threshhold
= m
->timenow
+ mDNSPlatformOneSecond
; // See if there are any records expiring within one second
3489 const mDNSs32 start
= m
->timenow
- 0x10000000;
3490 mDNSs32 delay
= start
;
3491 CacheGroup
*cg
= CacheGroupForName(m
, slot
, namehash
, name
);
3492 const CacheRecord
*rr
;
3493 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
3494 if (threshhold
- RRExpireTime(rr
) >= 0) // If we have records about to expire within a second
3495 if (delay
- RRExpireTime(rr
) < 0) // then delay until after they've been deleted
3496 delay
= RRExpireTime(rr
);
3497 if (delay
- start
> 0) return(NonZeroTime(delay
));
3501 // CacheRecordAdd is only called from CreateNewCacheEntry, *never* directly as a result of a client API call.
3502 // If new questions are created as a result of invoking client callbacks, they will be added to
3503 // the end of the question list, and m->NewQuestions will be set to indicate the first new question.
3504 // rr is a new CacheRecord just received into our cache
3505 // (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique).
3506 // Note: CacheRecordAdd calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
3507 // which may change the record list and/or question list.
3508 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
3509 mDNSlocal
void CacheRecordAdd(mDNS
*const m
, CacheRecord
*rr
)
3513 // We stop when we get to NewQuestions -- if we increment their CurrentAnswers/LargeAnswers/UniqueAnswers
3514 // counters here we'll end up double-incrementing them when we do it again in AnswerNewQuestion().
3515 for (q
= m
->Questions
; q
&& q
!= m
->NewQuestions
; q
=q
->next
)
3517 if (ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
3519 // If this question is one that's actively sending queries, and it's received ten answers within one
3520 // second of sending the last query packet, then that indicates some radical network topology change,
3521 // so reset its exponential backoff back to the start. We must be at least at the eight-second interval
3522 // to do this. If we're at the four-second interval, or less, there's not much benefit accelerating
3523 // because we will anyway send another query within a few seconds. The first reset query is sent out
3524 // randomized over the next four seconds to reduce possible synchronization between machines.
3525 if (q
->LastAnswerPktNum
!= m
->PktNum
)
3527 q
->LastAnswerPktNum
= m
->PktNum
;
3528 if (mDNSOpaque16IsZero(q
->TargetQID
) && ActiveQuestion(q
) && ++q
->RecentAnswerPkts
>= 10 &&
3529 q
->ThisQInterval
> InitialQuestionInterval
* QuestionIntervalStep3
&& m
->timenow
- q
->LastQTxTime
< mDNSPlatformOneSecond
)
3531 LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst (%d); restarting exponential backoff sequence (%d)",
3532 q
->qname
.c
, DNSTypeName(q
->qtype
), q
->RecentAnswerPkts
, q
->ThisQInterval
);
3533 q
->LastQTime
= m
->timenow
- InitialQuestionInterval
+ (mDNSs32
)mDNSRandom((mDNSu32
)mDNSPlatformOneSecond
*4);
3534 q
->ThisQInterval
= InitialQuestionInterval
;
3535 SetNextQueryTime(m
,q
);
3538 verbosedebugf("CacheRecordAdd %p %##s (%s) %lu %#a:%d question %p", rr
, rr
->resrec
.name
->c
,
3539 DNSTypeName(rr
->resrec
.rrtype
), rr
->resrec
.rroriginalttl
, rr
->resrec
.rDNSServer
?
3540 &rr
->resrec
.rDNSServer
->addr
: mDNSNULL
, mDNSVal16(rr
->resrec
.rDNSServer
?
3541 rr
->resrec
.rDNSServer
->port
: zeroIPPort
), q
);
3542 q
->CurrentAnswers
++;
3543 q
->unansweredQueries
= 0;
3544 if (rr
->resrec
.rdlength
> SmallRecordLimit
) q
->LargeAnswers
++;
3545 if (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) q
->UniqueAnswers
++;
3546 if (q
->CurrentAnswers
> 4000)
3548 static int msgcount
= 0;
3549 if (msgcount
++ < 10)
3550 LogMsg("CacheRecordAdd: %##s (%s) has %d answers; shedding records to resist DOS attack",
3551 q
->qname
.c
, DNSTypeName(q
->qtype
), q
->CurrentAnswers
);
3552 rr
->resrec
.rroriginalttl
= 0;
3553 rr
->UnansweredQueries
= MaxUnansweredQueries
;
3558 if (!rr
->DelayDelivery
)
3560 if (m
->CurrentQuestion
)
3561 LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set: %##s (%s)", m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3562 m
->CurrentQuestion
= m
->Questions
;
3563 while (m
->CurrentQuestion
&& m
->CurrentQuestion
!= m
->NewQuestions
)
3565 q
= m
->CurrentQuestion
;
3566 if (ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
3567 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_add
);
3568 if (m
->CurrentQuestion
== q
) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
3569 m
->CurrentQuestion
= q
->next
;
3571 m
->CurrentQuestion
= mDNSNULL
;
3574 SetNextCacheCheckTimeForRecord(m
, rr
);
3577 // NoCacheAnswer is only called from mDNSCoreReceiveResponse, *never* directly as a result of a client API call.
3578 // If new questions are created as a result of invoking client callbacks, they will be added to
3579 // the end of the question list, and m->NewQuestions will be set to indicate the first new question.
3580 // rr is a new CacheRecord just received from the wire (kDNSRecordTypePacketAns/AnsUnique/Add/AddUnique)
3581 // but we don't have any place to cache it. We'll deliver question 'add' events now, but we won't have any
3582 // way to deliver 'remove' events in future, nor will we be able to include this in known-answer lists,
3583 // so we immediately bump ThisQInterval up to MaxQuestionInterval to avoid pounding the network.
3584 // Note: NoCacheAnswer calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
3585 // which may change the record list and/or question list.
3586 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
3587 mDNSlocal
void NoCacheAnswer(mDNS
*const m
, CacheRecord
*rr
)
3589 LogMsg("No cache space: Delivering non-cached result for %##s", m
->rec
.r
.resrec
.name
->c
);
3590 if (m
->CurrentQuestion
)
3591 LogMsg("NoCacheAnswer ERROR m->CurrentQuestion already set: %##s (%s)", m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3592 m
->CurrentQuestion
= m
->Questions
;
3593 // We do this for *all* questions, not stopping when we get to m->NewQuestions,
3594 // since we're not caching the record and we'll get no opportunity to do this later
3595 while (m
->CurrentQuestion
)
3597 DNSQuestion
*q
= m
->CurrentQuestion
;
3598 if (ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
3599 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_addnocache
); // QC_addnocache means "don't expect remove events for this"
3600 if (m
->CurrentQuestion
== q
) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
3601 m
->CurrentQuestion
= q
->next
;
3603 m
->CurrentQuestion
= mDNSNULL
;
3606 // CacheRecordRmv is only called from CheckCacheExpiration, which is called from mDNS_Execute.
3607 // Note that CacheRecordRmv is *only* called for records that are referenced by at least one active question.
3608 // If new questions are created as a result of invoking client callbacks, they will be added to
3609 // the end of the question list, and m->NewQuestions will be set to indicate the first new question.
3610 // rr is an existing cache CacheRecord that just expired and is being deleted
3611 // (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique).
3612 // Note: CacheRecordRmv calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
3613 // which may change the record list and/or question list.
3614 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
3615 mDNSlocal
void CacheRecordRmv(mDNS
*const m
, CacheRecord
*rr
)
3617 if (m
->CurrentQuestion
)
3618 LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set: %##s (%s)",
3619 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3620 m
->CurrentQuestion
= m
->Questions
;
3622 // We stop when we get to NewQuestions -- for new questions their CurrentAnswers/LargeAnswers/UniqueAnswers counters
3623 // will all still be zero because we haven't yet gone through the cache counting how many answers we have for them.
3624 while (m
->CurrentQuestion
&& m
->CurrentQuestion
!= m
->NewQuestions
)
3626 DNSQuestion
*q
= m
->CurrentQuestion
;
3627 // When a question enters suppressed state, we generate RMV events and generate a negative
3628 // response. A cache may be present that answers this question e.g., cache entry generated
3629 // before the question became suppressed. We need to skip the suppressed questions here as
3630 // the RMV event has already been generated.
3631 if (!QuerySuppressed(q
) && ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
3633 verbosedebugf("CacheRecordRmv %p %s", rr
, CRDisplayString(m
, rr
));
3634 q
->FlappingInterface1
= mDNSNULL
;
3635 q
->FlappingInterface2
= mDNSNULL
;
3637 // When a question changes DNS server, it is marked with deliverAddEvents if we find any
3638 // cache entry corresponding to the new DNS server. Before we deliver the ADD event, the
3639 // cache entry may be removed in which case CurrentAnswers can be zero.
3640 if (q
->deliverAddEvents
&& !q
->CurrentAnswers
)
3642 LogInfo("CacheRecordRmv: Question %p %##s (%s) deliverAddEvents set, DNSServer %#a:%d",
3643 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), q
->qDNSServer
? &q
->qDNSServer
->addr
: mDNSNULL
,
3644 mDNSVal16(q
->qDNSServer
? q
->qDNSServer
->port
: zeroIPPort
));
3645 m
->CurrentQuestion
= q
->next
;
3648 if (q
->CurrentAnswers
== 0)
3649 LogMsg("CacheRecordRmv ERROR!!: How can CurrentAnswers already be zero for %p %##s (%s) DNSServer %#a:%d",
3650 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), q
->qDNSServer
? &q
->qDNSServer
->addr
: mDNSNULL
,
3651 mDNSVal16(q
->qDNSServer
? q
->qDNSServer
->port
: zeroIPPort
));
3654 q
->CurrentAnswers
--;
3655 if (rr
->resrec
.rdlength
> SmallRecordLimit
) q
->LargeAnswers
--;
3656 if (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) q
->UniqueAnswers
--;
3658 if (rr
->resrec
.rdata
->MaxRDLength
) // Never generate "remove" events for negative results
3660 if (q
->CurrentAnswers
== 0)
3662 LogInfo("CacheRecordRmv: Last answer for %##s (%s) expired from cache; will reconfirm antecedents",
3663 q
->qname
.c
, DNSTypeName(q
->qtype
));
3664 ReconfirmAntecedents(m
, &q
->qname
, q
->qnamehash
, 0);
3666 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_rmv
);
3669 if (m
->CurrentQuestion
== q
) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
3670 m
->CurrentQuestion
= q
->next
;
3672 m
->CurrentQuestion
= mDNSNULL
;
3675 mDNSlocal
void ReleaseCacheEntity(mDNS
*const m
, CacheEntity
*e
)
3677 #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1
3679 for (i
=0; i
<sizeof(*e
); i
++) ((char*)e
)[i
] = 0xFF;
3681 e
->next
= m
->rrcache_free
;
3682 m
->rrcache_free
= e
;
3683 m
->rrcache_totalused
--;
3686 mDNSlocal
void ReleaseCacheGroup(mDNS
*const m
, CacheGroup
**cp
)
3688 CacheEntity
*e
= (CacheEntity
*)(*cp
);
3689 //LogMsg("ReleaseCacheGroup: Releasing CacheGroup for %p, %##s", (*cp)->name->c, (*cp)->name->c);
3690 if ((*cp
)->rrcache_tail
!= &(*cp
)->members
)
3691 LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrcache_tail != &(*cp)->members)");
3692 //if ((*cp)->name != (domainname*)((*cp)->namestorage))
3693 // LogMsg("ReleaseCacheGroup: %##s, %p %p", (*cp)->name->c, (*cp)->name, (domainname*)((*cp)->namestorage));
3694 if ((*cp
)->name
!= (domainname
*)((*cp
)->namestorage
)) mDNSPlatformMemFree((*cp
)->name
);
3695 (*cp
)->name
= mDNSNULL
;
3696 *cp
= (*cp
)->next
; // Cut record from list
3697 ReleaseCacheEntity(m
, e
);
3700 mDNSlocal
void ReleaseCacheRecord(mDNS
*const m
, CacheRecord
*r
)
3702 //LogMsg("ReleaseCacheRecord: Releasing %s", CRDisplayString(m, r));
3703 if (r
->resrec
.rdata
&& r
->resrec
.rdata
!= (RData
*)&r
->smallrdatastorage
) mDNSPlatformMemFree(r
->resrec
.rdata
);
3704 r
->resrec
.rdata
= mDNSNULL
;
3705 ReleaseCacheEntity(m
, (CacheEntity
*)r
);
3708 // Note: We want to be careful that we deliver all the CacheRecordRmv calls before delivering
3709 // CacheRecordDeferredAdd calls. The in-order nature of the cache lists ensures that all
3710 // callbacks for old records are delivered before callbacks for newer records.
3711 mDNSlocal
void CheckCacheExpiration(mDNS
*const m
, const mDNSu32 slot
, CacheGroup
*const cg
)
3713 CacheRecord
**rp
= &cg
->members
;
3715 if (m
->lock_rrcache
) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; }
3716 m
->lock_rrcache
= 1;
3720 CacheRecord
*const rr
= *rp
;
3721 mDNSs32 event
= RRExpireTime(rr
);
3722 if (m
->timenow
- event
>= 0) // If expired, delete it
3724 *rp
= rr
->next
; // Cut it from the list
3725 verbosedebugf("CheckCacheExpiration: Deleting%7d %7d %p %s",
3726 m
->timenow
- rr
->TimeRcvd
, rr
->resrec
.rroriginalttl
, rr
->CRActiveQuestion
, CRDisplayString(m
, rr
));
3727 if (rr
->CRActiveQuestion
) // If this record has one or more active questions, tell them it's going away
3729 DNSQuestion
*q
= rr
->CRActiveQuestion
;
3730 // When a cache record is about to expire, we expect to do four queries at 80-82%, 85-87%, 90-92% and
3731 // then 95-97% of the TTL. If the DNS server does not respond, then we will remove the cache entry
3732 // before we pick a new DNS server. As the question interval is set to MaxQuestionInterval, we may
3733 // not send out a query anytime soon. Hence, we need to reset the question interval. If this is
3734 // a normal deferred ADD case, then AnswerCurrentQuestionWithResourceRecord will reset it to
3735 // MaxQuestionInterval. If we have inactive questions referring to negative cache entries,
3736 // don't ressurect them as they will deliver duplicate "No such Record" ADD events
3737 if (!mDNSOpaque16IsZero(q
->TargetQID
) && !q
->LongLived
&& ActiveQuestion(q
))
3739 q
->ThisQInterval
= InitialQuestionInterval
;
3740 q
->LastQTime
= m
->timenow
- q
->ThisQInterval
;
3741 SetNextQueryTime(m
, q
);
3743 CacheRecordRmv(m
, rr
);
3744 m
->rrcache_active
--;
3746 ReleaseCacheRecord(m
, rr
);
3748 else // else, not expired; see if we need to query
3750 // If waiting to delay delivery, do nothing until then
3751 if (rr
->DelayDelivery
&& rr
->DelayDelivery
- m
->timenow
> 0)
3752 event
= rr
->DelayDelivery
;
3755 if (rr
->DelayDelivery
) CacheRecordDeferredAdd(m
, rr
);
3756 if (rr
->CRActiveQuestion
&& rr
->UnansweredQueries
< MaxUnansweredQueries
)
3758 if (m
->timenow
- rr
->NextRequiredQuery
< 0) // If not yet time for next query
3759 event
= NextCacheCheckEvent(rr
); // then just record when we want the next query
3760 else // else trigger our question to go out now
3762 // Set NextScheduledQuery to timenow so that SendQueries() will run.
3763 // SendQueries() will see that we have records close to expiration, and send FEQs for them.
3764 m
->NextScheduledQuery
= m
->timenow
;
3765 // After sending the query we'll increment UnansweredQueries and call SetNextCacheCheckTimeForRecord(),
3766 // which will correctly update m->NextCacheCheck for us.
3767 event
= m
->timenow
+ 0x3FFFFFFF;
3771 verbosedebugf("CheckCacheExpiration:%6d %5d %s",
3772 (event
- m
->timenow
) / mDNSPlatformOneSecond
, CacheCheckGracePeriod(rr
), CRDisplayString(m
, rr
));
3773 if (m
->rrcache_nextcheck
[slot
] - event
> 0)
3774 m
->rrcache_nextcheck
[slot
] = event
;
3778 if (cg
->rrcache_tail
!= rp
) verbosedebugf("CheckCacheExpiration: Updating CacheGroup tail from %p to %p", cg
->rrcache_tail
, rp
);
3779 cg
->rrcache_tail
= rp
;
3780 m
->lock_rrcache
= 0;
3783 mDNSlocal
void AnswerNewQuestion(mDNS
*const m
)
3785 mDNSBool ShouldQueryImmediately
= mDNStrue
;
3786 DNSQuestion
*const q
= m
->NewQuestions
; // Grab the question we're going to answer
3787 mDNSu32 slot
= HashSlot(&q
->qname
);
3788 CacheGroup
*const cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
3791 mDNSBool AnsweredFromCache
= mDNSfalse
;
3793 verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
3795 if (cg
) CheckCacheExpiration(m
, slot
, cg
);
3796 if (m
->NewQuestions
!= q
) { LogInfo("AnswerNewQuestion: Question deleted while doing CheckCacheExpiration"); goto exit
; }
3797 m
->NewQuestions
= q
->next
;
3798 // Advance NewQuestions to the next *after* calling CheckCacheExpiration, because if we advance it first
3799 // then CheckCacheExpiration may give this question add/remove callbacks, and it's not yet ready for that.
3801 // Also, CheckCacheExpiration() calls CacheRecordDeferredAdd() and CacheRecordRmv(), which invoke
3802 // client callbacks, which may delete their own or any other question. Our mechanism for detecting
3803 // whether our current m->NewQuestions question got deleted by one of these callbacks is to store the
3804 // value of m->NewQuestions in 'q' before calling CheckCacheExpiration(), and then verify afterwards
3805 // that they're still the same. If m->NewQuestions has changed (because mDNS_StopQuery_internal
3806 // advanced it), that means the question was deleted, so we no longer need to worry about answering
3807 // it (and indeed 'q' is now a dangling pointer, so dereferencing it at all would be bad, and the
3808 // values we computed for slot and cg are now stale and relate to a question that no longer exists).
3810 // We can't use the usual m->CurrentQuestion mechanism for this because CacheRecordDeferredAdd() and
3811 // CacheRecordRmv() both use that themselves when walking the list of (non-new) questions generating callbacks.
3812 // Fortunately mDNS_StopQuery_internal auto-advances both m->CurrentQuestion *AND* m->NewQuestions when
3813 // deleting a question, so luckily we have an easy alternative way of detecting if our question got deleted.
3815 if (m
->lock_rrcache
) LogMsg("AnswerNewQuestion ERROR! Cache already locked!");
3816 // This should be safe, because calling the client's question callback may cause the
3817 // question list to be modified, but should not ever cause the rrcache list to be modified.
3818 // If the client's question callback deletes the question, then m->CurrentQuestion will
3819 // be advanced, and we'll exit out of the loop
3820 m
->lock_rrcache
= 1;
3821 if (m
->CurrentQuestion
)
3822 LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set: %##s (%s)",
3823 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3824 m
->CurrentQuestion
= q
; // Indicate which question we're answering, so we'll know if it gets deleted
3826 if (q
->NoAnswer
== NoAnswer_Fail
)
3828 LogMsg("AnswerNewQuestion: NoAnswer_Fail %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
3829 MakeNegativeCacheRecord(m
, &m
->rec
.r
, &q
->qname
, q
->qnamehash
, q
->qtype
, q
->qclass
, 60, mDNSInterface_Any
, q
->qDNSServer
);
3830 q
->NoAnswer
= NoAnswer_Normal
; // Temporarily turn off answer suppression
3831 AnswerCurrentQuestionWithResourceRecord(m
, &m
->rec
.r
, QC_addnocache
);
3832 // Don't touch the question if it has been stopped already
3833 if (m
->CurrentQuestion
== q
) q
->NoAnswer
= NoAnswer_Fail
; // Restore NoAnswer state
3834 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
3836 if (m
->CurrentQuestion
!= q
) { LogInfo("AnswerNewQuestion: Question deleted while generating NoAnswer_Fail response"); goto exit
; }
3838 // See if we want to tell it about LocalOnly records
3839 if (m
->CurrentRecord
)
3840 LogMsg("AnswerNewQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
3841 slot
= AuthHashSlot(&q
->qname
);
3842 ag
= AuthGroupForName(&m
->rrauth
, slot
, q
->qnamehash
, &q
->qname
);
3845 m
->CurrentRecord
= ag
->members
;
3846 while (m
->CurrentRecord
&& m
->CurrentRecord
!= ag
->NewLocalOnlyRecords
)
3848 AuthRecord
*rr
= m
->CurrentRecord
;
3849 m
->CurrentRecord
= rr
->next
;
3851 // If the question is mDNSInterface_LocalOnly, all records local to the machine should be used
3852 // to answer the query. This is handled in AnswerNewLocalOnlyQuestion.
3854 // We handle mDNSInterface_Any and scoped questions here. See LocalOnlyRecordAnswersQuestion for more
3855 // details on how we handle this case. For P2P we just handle "Interface_Any" questions. For LocalOnly
3856 // we handle both mDNSInterface_Any and scoped questions.
3858 if (rr
->ARType
== AuthRecordLocalOnly
|| (rr
->ARType
== AuthRecordP2P
&& q
->InterfaceID
== mDNSInterface_Any
))
3859 if (LocalOnlyRecordAnswersQuestion(rr
, q
))
3861 AnswerLocalQuestionWithLocalAuthRecord(m
, rr
, mDNStrue
);
3862 if (m
->CurrentQuestion
!= q
) break; // If callback deleted q, then we're finished here
3866 m
->CurrentRecord
= mDNSNULL
;
3868 if (m
->CurrentQuestion
!= q
) { LogInfo("AnswerNewQuestion: Question deleted while while giving LocalOnly record answers"); goto exit
; }
3870 if (q
->LOAddressAnswers
)
3872 LogInfo("AnswerNewQuestion: Question %p %##s (%s) answered using local auth records LOAddressAnswers %d",
3873 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), q
->LOAddressAnswers
);
3877 // Before we go check the cache and ship this query on the wire, we have to be sure that there are
3878 // no local records that could possibly answer this question. As we did not check the NewLocalRecords, we
3879 // need to just peek at them to see whether it will answer this question. If it would answer, pretend
3880 // that we answered. AnswerAllLocalQuestionsWithLocalAuthRecord will answer shortly. This happens normally
3881 // when we add new /etc/hosts entries and restart the question. It is a new question and also a new record.
3884 lr
= ag
->NewLocalOnlyRecords
;
3887 if (LORecordAnswersAddressType(lr
) && LocalOnlyRecordAnswersQuestion(lr
, q
))
3889 LogInfo("AnswerNewQuestion: Question %p %##s (%s) will be answered using new local auth records "
3890 " LOAddressAnswers %d", q
, q
->qname
.c
, DNSTypeName(q
->qtype
), q
->LOAddressAnswers
);
3898 // If we are not supposed to answer this question, generate a negative response.
3899 // Temporarily suspend the SuppressQuery so that AnswerCurrentQuestionWithResourceRecord can answer the question
3900 if (QuerySuppressed(q
)) { q
->SuppressQuery
= mDNSfalse
; GenerateNegativeResponse(m
); q
->SuppressQuery
= mDNStrue
; }
3904 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
3905 if (SameNameRecordAnswersQuestion(&rr
->resrec
, q
))
3907 // SecsSinceRcvd is whole number of elapsed seconds, rounded down
3908 mDNSu32 SecsSinceRcvd
= ((mDNSu32
)(m
->timenow
- rr
->TimeRcvd
)) / mDNSPlatformOneSecond
;
3909 if (rr
->resrec
.rroriginalttl
<= SecsSinceRcvd
)
3911 LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %s %d %d",
3912 rr
->resrec
.rroriginalttl
, SecsSinceRcvd
, CRDisplayString(m
, rr
), m
->timenow
, rr
->TimeRcvd
);
3913 continue; // Go to next one in loop
3916 // If this record set is marked unique, then that means we can reasonably assume we have the whole set
3917 // -- we don't need to rush out on the network and query immediately to see if there are more answers out there
3918 if ((rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) || (q
->ExpectUnique
))
3919 ShouldQueryImmediately
= mDNSfalse
;
3920 q
->CurrentAnswers
++;
3921 if (rr
->resrec
.rdlength
> SmallRecordLimit
) q
->LargeAnswers
++;
3922 if (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) q
->UniqueAnswers
++;
3923 AnsweredFromCache
= mDNStrue
;
3924 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_add
);
3925 if (m
->CurrentQuestion
!= q
) break; // If callback deleted q, then we're finished here
3927 else if (RRTypeIsAddressType(rr
->resrec
.rrtype
) && RRTypeIsAddressType(q
->qtype
))
3928 ShouldQueryImmediately
= mDNSfalse
;
3930 // We don't use LogInfo for this "Question deleted" message because it happens so routinely that
3931 // it's not remotely remarkable, and therefore unlikely to be of much help tracking down bugs.
3932 if (m
->CurrentQuestion
!= q
) { debugf("AnswerNewQuestion: Question deleted while giving cache answers"); goto exit
; }
3934 // Neither a local record nor a cache entry could answer this question. If this question need to be retried
3935 // with search domains, generate a negative response which will now retry after appending search domains.
3936 // If the query was suppressed above, we already generated a negative response. When it gets unsuppressed,
3937 // we will retry with search domains.
3938 if (!QuerySuppressed(q
) && !AnsweredFromCache
&& q
->RetryWithSearchDomains
)
3940 LogInfo("AnswerNewQuestion: Generating response for retrying with search domains %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
3941 GenerateNegativeResponse(m
);
3944 if (m
->CurrentQuestion
!= q
) { debugf("AnswerNewQuestion: Question deleted while giving negative answer"); goto exit
; }
3946 // Note: When a query gets suppressed or retried with search domains, we de-activate the question.
3947 // Hence we don't execute the following block of code for those cases.
3948 if (ShouldQueryImmediately
&& ActiveQuestion(q
))
3950 debugf("AnswerNewQuestion: ShouldQueryImmediately %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
3951 q
->ThisQInterval
= InitialQuestionInterval
;
3952 q
->LastQTime
= m
->timenow
- q
->ThisQInterval
;
3953 if (mDNSOpaque16IsZero(q
->TargetQID
)) // For mDNS, spread packets to avoid a burst of simultaneous queries
3955 // Compute random delay in the range 1-6 seconds, then divide by 50 to get 20-120ms
3956 if (!m
->RandomQueryDelay
)
3957 m
->RandomQueryDelay
= (mDNSPlatformOneSecond
+ mDNSRandom(mDNSPlatformOneSecond
*5) - 1) / 50 + 1;
3958 q
->LastQTime
+= m
->RandomQueryDelay
;
3962 // IN ALL CASES make sure that m->NextScheduledQuery is set appropriately.
3963 // In cases where m->NewQuestions->DelayAnswering is set, we may have delayed generating our
3964 // answers for this question until *after* its scheduled transmission time, in which case
3965 // m->NextScheduledQuery may now be set to 'never', and in that case -- even though we're *not* doing
3966 // ShouldQueryImmediately -- we still need to make sure we set m->NextScheduledQuery correctly.
3967 SetNextQueryTime(m
,q
);
3970 m
->CurrentQuestion
= mDNSNULL
;
3971 m
->lock_rrcache
= 0;
3974 // When a NewLocalOnlyQuestion is created, AnswerNewLocalOnlyQuestion runs though our ResourceRecords delivering any
3975 // appropriate answers, stopping if it reaches a NewLocalOnlyRecord -- these will be handled by AnswerAllLocalQuestionsWithLocalAuthRecord
3976 mDNSlocal
void AnswerNewLocalOnlyQuestion(mDNS
*const m
)
3980 DNSQuestion
*q
= m
->NewLocalOnlyQuestions
; // Grab the question we're going to answer
3981 m
->NewLocalOnlyQuestions
= q
->next
; // Advance NewLocalOnlyQuestions to the next (if any)
3983 debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
3985 if (m
->CurrentQuestion
)
3986 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentQuestion already set: %##s (%s)",
3987 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
3988 m
->CurrentQuestion
= q
; // Indicate which question we're answering, so we'll know if it gets deleted
3990 if (m
->CurrentRecord
)
3991 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
3993 // 1. First walk the LocalOnly records answering the LocalOnly question
3994 // 2. As LocalOnly questions should also be answered by any other Auth records local to the machine,
3995 // walk the ResourceRecords list delivering the answers
3996 slot
= AuthHashSlot(&q
->qname
);
3997 ag
= AuthGroupForName(&m
->rrauth
, slot
, q
->qnamehash
, &q
->qname
);
4000 m
->CurrentRecord
= ag
->members
;
4001 while (m
->CurrentRecord
&& m
->CurrentRecord
!= ag
->NewLocalOnlyRecords
)
4003 AuthRecord
*rr
= m
->CurrentRecord
;
4004 m
->CurrentRecord
= rr
->next
;
4005 if (LocalOnlyRecordAnswersQuestion(rr
, q
))
4007 AnswerLocalQuestionWithLocalAuthRecord(m
, rr
, mDNStrue
);
4008 if (m
->CurrentQuestion
!= q
) break; // If callback deleted q, then we're finished here
4013 if (m
->CurrentQuestion
== q
)
4015 m
->CurrentRecord
= m
->ResourceRecords
;
4017 while (m
->CurrentRecord
&& m
->CurrentRecord
!= m
->NewLocalRecords
)
4019 AuthRecord
*rr
= m
->CurrentRecord
;
4020 m
->CurrentRecord
= rr
->next
;
4021 if (ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
4023 AnswerLocalQuestionWithLocalAuthRecord(m
, rr
, mDNStrue
);
4024 if (m
->CurrentQuestion
!= q
) break; // If callback deleted q, then we're finished here
4029 m
->CurrentQuestion
= mDNSNULL
;
4030 m
->CurrentRecord
= mDNSNULL
;
4033 mDNSlocal CacheEntity
*GetCacheEntity(mDNS
*const m
, const CacheGroup
*const PreserveCG
)
4035 CacheEntity
*e
= mDNSNULL
;
4037 if (m
->lock_rrcache
) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL
); }
4038 m
->lock_rrcache
= 1;
4040 // If we have no free records, ask the client layer to give us some more memory
4041 if (!m
->rrcache_free
&& m
->MainCallback
)
4043 if (m
->rrcache_totalused
!= m
->rrcache_size
)
4044 LogMsg("GetFreeCacheRR: count mismatch: m->rrcache_totalused %lu != m->rrcache_size %lu",
4045 m
->rrcache_totalused
, m
->rrcache_size
);
4047 // We don't want to be vulnerable to a malicious attacker flooding us with an infinite
4048 // number of bogus records so that we keep growing our cache until the machine runs out of memory.
4049 // To guard against this, if our cache grows above 512kB (approx 3168 records at 164 bytes each),
4050 // and we're actively using less than 1/32 of that cache, then we purge all the unused records
4051 // and recycle them, instead of allocating more memory.
4052 if (m
->rrcache_size
> 5000 && m
->rrcache_size
/ 32 > m
->rrcache_active
)
4053 LogInfo("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
4054 m
->rrcache_size
, m
->rrcache_active
);
4057 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
4058 m
->MainCallback(m
, mStatus_GrowCache
);
4059 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
4063 // If we still have no free records, recycle all the records we can.
4064 // Enumerating the entire cache is moderately expensive, so when we do it, we reclaim all the records we can in one pass.
4065 if (!m
->rrcache_free
)
4067 mDNSu32 oldtotalused
= m
->rrcache_totalused
;
4069 for (slot
= 0; slot
< CACHE_HASH_SLOTS
; slot
++)
4071 CacheGroup
**cp
= &m
->rrcache_hash
[slot
];
4074 CacheRecord
**rp
= &(*cp
)->members
;
4077 // Records that answer still-active questions are not candidates for recycling
4078 // Records that are currently linked into the CacheFlushRecords list may not be recycled, or we'll crash
4079 if ((*rp
)->CRActiveQuestion
|| (*rp
)->NextInCFList
)
4083 CacheRecord
*rr
= *rp
;
4084 *rp
= (*rp
)->next
; // Cut record from list
4085 ReleaseCacheRecord(m
, rr
);
4088 if ((*cp
)->rrcache_tail
!= rp
)
4089 verbosedebugf("GetFreeCacheRR: Updating rrcache_tail[%lu] from %p to %p", slot
, (*cp
)->rrcache_tail
, rp
);
4090 (*cp
)->rrcache_tail
= rp
;
4091 if ((*cp
)->members
|| (*cp
)==PreserveCG
) cp
=&(*cp
)->next
;
4092 else ReleaseCacheGroup(m
, cp
);
4095 LogInfo("GetCacheEntity recycled %d records to reduce cache from %d to %d",
4096 oldtotalused
- m
->rrcache_totalused
, oldtotalused
, m
->rrcache_totalused
);
4099 if (m
->rrcache_free
) // If there are records in the free list, take one
4101 e
= m
->rrcache_free
;
4102 m
->rrcache_free
= e
->next
;
4103 if (++m
->rrcache_totalused
>= m
->rrcache_report
)
4105 LogInfo("RR Cache now using %ld objects", m
->rrcache_totalused
);
4106 if (m
->rrcache_report
< 100) m
->rrcache_report
+= 10;
4107 else if (m
->rrcache_report
< 1000) m
->rrcache_report
+= 100;
4108 else m
->rrcache_report
+= 1000;
4110 mDNSPlatformMemZero(e
, sizeof(*e
));
4113 m
->lock_rrcache
= 0;
4118 mDNSlocal CacheRecord
*GetCacheRecord(mDNS
*const m
, CacheGroup
*cg
, mDNSu16 RDLength
)
4120 CacheRecord
*r
= (CacheRecord
*)GetCacheEntity(m
, cg
);
4123 r
->resrec
.rdata
= (RData
*)&r
->smallrdatastorage
; // By default, assume we're usually going to be using local storage
4124 if (RDLength
> InlineCacheRDSize
) // If RDLength is too big, allocate extra storage
4126 r
->resrec
.rdata
= (RData
*)mDNSPlatformMemAllocate(sizeofRDataHeader
+ RDLength
);
4127 if (r
->resrec
.rdata
) r
->resrec
.rdata
->MaxRDLength
= r
->resrec
.rdlength
= RDLength
;
4128 else { ReleaseCacheEntity(m
, (CacheEntity
*)r
); r
= mDNSNULL
; }
4134 mDNSlocal CacheGroup
*GetCacheGroup(mDNS
*const m
, const mDNSu32 slot
, const ResourceRecord
*const rr
)
4136 mDNSu16 namelen
= DomainNameLength(rr
->name
);
4137 CacheGroup
*cg
= (CacheGroup
*)GetCacheEntity(m
, mDNSNULL
);
4138 if (!cg
) { LogMsg("GetCacheGroup: Failed to allocate memory for %##s", rr
->name
->c
); return(mDNSNULL
); }
4139 cg
->next
= m
->rrcache_hash
[slot
];
4140 cg
->namehash
= rr
->namehash
;
4141 cg
->members
= mDNSNULL
;
4142 cg
->rrcache_tail
= &cg
->members
;
4143 cg
->name
= (domainname
*)cg
->namestorage
;
4144 //LogMsg("GetCacheGroup: %-10s %d-byte cache name %##s",
4145 // (namelen > InlineCacheGroupNameSize) ? "Allocating" : "Inline", namelen, rr->name->c);
4146 if (namelen
> InlineCacheGroupNameSize
) cg
->name
= mDNSPlatformMemAllocate(namelen
);
4149 LogMsg("GetCacheGroup: Failed to allocate name storage for %##s", rr
->name
->c
);
4150 ReleaseCacheEntity(m
, (CacheEntity
*)cg
);
4153 AssignDomainName(cg
->name
, rr
->name
);
4155 if (CacheGroupForRecord(m
, slot
, rr
)) LogMsg("GetCacheGroup: Already have CacheGroup for %##s", rr
->name
->c
);
4156 m
->rrcache_hash
[slot
] = cg
;
4157 if (CacheGroupForRecord(m
, slot
, rr
) != cg
) LogMsg("GetCacheGroup: Not finding CacheGroup for %##s", rr
->name
->c
);
4162 mDNSexport
void mDNS_PurgeCacheResourceRecord(mDNS
*const m
, CacheRecord
*rr
)
4164 if (m
->mDNS_busy
!= m
->mDNS_reentrancy
+1)
4165 LogMsg("mDNS_PurgeCacheResourceRecord: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m
->mDNS_busy
, m
->mDNS_reentrancy
);
4166 // Make sure we mark this record as thoroughly expired -- we don't ever want to give
4167 // a positive answer using an expired record (e.g. from an interface that has gone away).
4168 // We don't want to clear CRActiveQuestion here, because that would leave the record subject to
4169 // summary deletion without giving the proper callback to any questions that are monitoring it.
4170 // By setting UnansweredQueries to MaxUnansweredQueries we ensure it won't trigger any further expiration queries.
4171 rr
->TimeRcvd
= m
->timenow
- mDNSPlatformOneSecond
* 60;
4172 rr
->UnansweredQueries
= MaxUnansweredQueries
;
4173 rr
->resrec
.rroriginalttl
= 0;
4174 SetNextCacheCheckTimeForRecord(m
, rr
);
4177 mDNSexport mDNSs32
mDNS_TimeNow(const mDNS
*const m
)
4180 mDNSPlatformLock(m
);
4183 LogMsg("mDNS_TimeNow called while holding mDNS lock. This is incorrect. Code protected by lock should just use m->timenow.");
4184 if (!m
->timenow
) LogMsg("mDNS_TimeNow: m->mDNS_busy is %ld but m->timenow not set", m
->mDNS_busy
);
4187 if (m
->timenow
) time
= m
->timenow
;
4188 else time
= mDNS_TimeNow_NoLock(m
);
4189 mDNSPlatformUnlock(m
);
4193 // To avoid pointless CPU thrash, we use SetSPSProxyListChanged(X) to record the last interface that
4194 // had its Sleep Proxy client list change, and defer to actual BPF reconfiguration to mDNS_Execute().
4195 // (GetNextScheduledEvent() returns "now" when m->SPSProxyListChanged is set)
4196 #define SetSPSProxyListChanged(X) do { \
4197 if (m->SPSProxyListChanged && m->SPSProxyListChanged != (X)) mDNSPlatformUpdateProxyList(m, m->SPSProxyListChanged); \
4198 m->SPSProxyListChanged = (X); } while(0)
4200 // Called from mDNS_Execute() to expire stale proxy records
4201 mDNSlocal
void CheckProxyRecords(mDNS
*const m
, AuthRecord
*list
)
4203 m
->CurrentRecord
= list
;
4204 while (m
->CurrentRecord
)
4206 AuthRecord
*rr
= m
->CurrentRecord
;
4207 if (rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&& rr
->WakeUp
.HMAC
.l
[0])
4209 // If m->SPSSocket is NULL that means we're not acting as a sleep proxy any more,
4210 // so we need to cease proxying for *all* records we may have, expired or not.
4211 if (m
->SPSSocket
&& m
->timenow
- rr
->TimeExpire
< 0) // If proxy record not expired yet, update m->NextScheduledSPS
4213 if (m
->NextScheduledSPS
- rr
->TimeExpire
> 0)
4214 m
->NextScheduledSPS
= rr
->TimeExpire
;
4216 else // else proxy record expired, so remove it
4218 LogSPS("CheckProxyRecords: Removing %d H-MAC %.6a I-MAC %.6a %d %s",
4219 m
->ProxyRecords
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, rr
->WakeUp
.seq
, ARDisplayString(m
, rr
));
4220 SetSPSProxyListChanged(rr
->resrec
.InterfaceID
);
4221 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
4222 // Don't touch rr after this -- memory may have been free'd
4225 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
4226 // new records could have been added to the end of the list as a result of that call.
4227 if (m
->CurrentRecord
== rr
) // If m->CurrentRecord was not advanced for us, do it now
4228 m
->CurrentRecord
= rr
->next
;
4232 mDNSlocal
void CheckRmvEventsForLocalRecords(mDNS
*const m
)
4234 while (m
->CurrentRecord
)
4236 AuthRecord
*rr
= m
->CurrentRecord
;
4237 if (rr
->AnsweredLocalQ
&& rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
)
4239 debugf("CheckRmvEventsForLocalRecords: Generating local RMV events for %s", ARDisplayString(m
, rr
));
4240 rr
->resrec
.RecordType
= kDNSRecordTypeShared
;
4241 AnswerAllLocalQuestionsWithLocalAuthRecord(m
, rr
, mDNSfalse
);
4242 if (m
->CurrentRecord
== rr
) // If rr still exists in list, restore its state now
4244 rr
->resrec
.RecordType
= kDNSRecordTypeDeregistering
;
4245 rr
->AnsweredLocalQ
= mDNSfalse
;
4246 // SendResponses normally calls CompleteDeregistration after sending goodbyes.
4247 // For LocalOnly records, we don't do that and hence we need to do that here.
4248 if (RRLocalOnly(rr
)) CompleteDeregistration(m
, rr
);
4251 if (m
->CurrentRecord
== rr
) // If m->CurrentRecord was not auto-advanced, do it ourselves now
4252 m
->CurrentRecord
= rr
->next
;
4256 mDNSlocal
void TimeoutQuestions(mDNS
*const m
)
4258 m
->NextScheduledStopTime
= m
->timenow
+ 0x3FFFFFFF;
4259 if (m
->CurrentQuestion
)
4260 LogMsg("TimeoutQuestions ERROR m->CurrentQuestion already set: %##s (%s)", m
->CurrentQuestion
->qname
.c
,
4261 DNSTypeName(m
->CurrentQuestion
->qtype
));
4262 m
->CurrentQuestion
= m
->Questions
;
4263 while (m
->CurrentQuestion
)
4265 DNSQuestion
*const q
= m
->CurrentQuestion
;
4268 if (m
->timenow
- q
->StopTime
>= 0)
4270 LogInfo("TimeoutQuestions: question %##s timed out, time %d", q
->qname
.c
, m
->timenow
- q
->StopTime
);
4271 GenerateNegativeResponse(m
);
4272 if (m
->CurrentQuestion
== q
) q
->StopTime
= 0;
4276 if (m
->NextScheduledStopTime
- q
->StopTime
> 0)
4277 m
->NextScheduledStopTime
= q
->StopTime
;
4280 // If m->CurrentQuestion wasn't modified out from under us, advance it now
4281 // We can't do this at the start of the loop because GenerateNegativeResponse
4282 // depends on having m->CurrentQuestion point to the right question
4283 if (m
->CurrentQuestion
== q
)
4284 m
->CurrentQuestion
= q
->next
;
4286 m
->CurrentQuestion
= mDNSNULL
;
4289 mDNSlocal
void mDNSCoreFreeProxyRR(mDNS
*const m
)
4291 NetworkInterfaceInfo
*intf
= m
->HostInterfaces
;
4292 AuthRecord
*rrPtr
= mDNSNULL
, *rrNext
= mDNSNULL
;
4295 rrPtr
= intf
->SPSRRSet
;
4298 rrNext
= rrPtr
->next
;
4299 mDNSPlatformMemFree(rrPtr
);
4302 intf
->SPSRRSet
= mDNSNULL
;
4307 mDNSexport mDNSs32
mDNS_Execute(mDNS
*const m
)
4309 mDNS_Lock(m
); // Must grab lock before trying to read m->timenow
4311 if (m
->timenow
- m
->NextScheduledEvent
>= 0)
4314 AuthRecord
*head
, *tail
;
4318 verbosedebugf("mDNS_Execute");
4320 if (m
->CurrentQuestion
)
4321 LogMsg("mDNS_Execute: ERROR m->CurrentQuestion already set: %##s (%s)",
4322 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
4324 if (m
->CurrentRecord
)
4325 LogMsg("mDNS_Execute: ERROR m->CurrentRecord already set: %s", ARDisplayString(m
, m
->CurrentRecord
));
4327 // 1. If we're past the probe suppression time, we can clear it
4328 if (m
->SuppressProbes
&& m
->timenow
- m
->SuppressProbes
>= 0) m
->SuppressProbes
= 0;
4330 // 2. If it's been more than ten seconds since the last probe failure, we can clear the counter
4331 if (m
->NumFailedProbes
&& m
->timenow
- m
->ProbeFailTime
>= mDNSPlatformOneSecond
* 10) m
->NumFailedProbes
= 0;
4333 // 3. Purge our cache of stale old records
4334 if (m
->rrcache_size
&& m
->timenow
- m
->NextCacheCheck
>= 0)
4336 mDNSu32 numchecked
= 0;
4337 m
->NextCacheCheck
= m
->timenow
+ 0x3FFFFFFF;
4338 for (slot
= 0; slot
< CACHE_HASH_SLOTS
; slot
++)
4340 if (m
->timenow
- m
->rrcache_nextcheck
[slot
] >= 0)
4342 CacheGroup
**cp
= &m
->rrcache_hash
[slot
];
4343 m
->rrcache_nextcheck
[slot
] = m
->timenow
+ 0x3FFFFFFF;
4346 debugf("m->NextCacheCheck %4d Slot %3d %##s", numchecked
, slot
, *cp
? (*cp
)->name
: (domainname
*)"\x04NULL");
4348 CheckCacheExpiration(m
, slot
, *cp
);
4349 if ((*cp
)->members
) cp
=&(*cp
)->next
;
4350 else ReleaseCacheGroup(m
, cp
);
4353 // Even if we didn't need to actually check this slot yet, still need to
4354 // factor its nextcheck time into our overall NextCacheCheck value
4355 if (m
->NextCacheCheck
- m
->rrcache_nextcheck
[slot
] > 0)
4356 m
->NextCacheCheck
= m
->rrcache_nextcheck
[slot
];
4358 debugf("m->NextCacheCheck %4d checked, next in %d", numchecked
, m
->NextCacheCheck
- m
->timenow
);
4361 if (m
->timenow
- m
->NextScheduledSPS
>= 0)
4363 m
->NextScheduledSPS
= m
->timenow
+ 0x3FFFFFFF;
4364 CheckProxyRecords(m
, m
->DuplicateRecords
); // Clear m->DuplicateRecords first, then m->ResourceRecords
4365 CheckProxyRecords(m
, m
->ResourceRecords
);
4368 SetSPSProxyListChanged(mDNSNULL
); // Perform any deferred BPF reconfiguration now
4370 // Clear AnnounceOwner if necessary. (Do this *before* SendQueries() and SendResponses().)
4371 if (m
->AnnounceOwner
&& m
->timenow
- m
->AnnounceOwner
>= 0)
4373 m
->AnnounceOwner
= 0;
4374 // Also free the stored records that we had registered with the sleep proxy
4375 mDNSCoreFreeProxyRR(m
);
4378 if (m
->DelaySleep
&& m
->timenow
- m
->DelaySleep
>= 0)
4381 if (m
->SleepState
== SleepState_Transferring
)
4383 LogSPS("Re-sleep delay passed; now checking for Sleep Proxy Servers");
4384 BeginSleepProcessing(m
);
4388 // 4. See if we can answer any of our new local questions from the cache
4389 for (i
=0; m
->NewQuestions
&& i
<1000; i
++)
4391 if (m
->NewQuestions
->DelayAnswering
&& m
->timenow
- m
->NewQuestions
->DelayAnswering
< 0) break;
4392 AnswerNewQuestion(m
);
4394 if (i
>= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
4396 // Make sure we deliver *all* local RMV events, and clear the corresponding rr->AnsweredLocalQ flags, *before*
4397 // we begin generating *any* new ADD events in the m->NewLocalOnlyQuestions and m->NewLocalRecords loops below.
4398 for (i
=0; i
<1000 && m
->LocalRemoveEvents
; i
++)
4400 m
->LocalRemoveEvents
= mDNSfalse
;
4401 m
->CurrentRecord
= m
->ResourceRecords
;
4402 CheckRmvEventsForLocalRecords(m
);
4403 // Walk the LocalOnly records and deliver the RMV events
4404 for (slot
= 0; slot
< AUTH_HASH_SLOTS
; slot
++)
4405 for (ag
= m
->rrauth
.rrauth_hash
[slot
]; ag
; ag
= ag
->next
)
4407 m
->CurrentRecord
= ag
->members
;
4408 if (m
->CurrentRecord
) CheckRmvEventsForLocalRecords(m
);
4412 if (i
>= 1000) LogMsg("mDNS_Execute: m->LocalRemoveEvents exceeded loop limit");
4414 for (i
=0; m
->NewLocalOnlyQuestions
&& i
<1000; i
++) AnswerNewLocalOnlyQuestion(m
);
4415 if (i
>= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
4417 head
= tail
= mDNSNULL
;
4418 for (i
=0; i
<1000 && m
->NewLocalRecords
&& m
->NewLocalRecords
!= head
; i
++)
4420 AuthRecord
*rr
= m
->NewLocalRecords
;
4421 m
->NewLocalRecords
= m
->NewLocalRecords
->next
;
4422 if (LocalRecordReady(rr
))
4424 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m
, rr
));
4425 AnswerAllLocalQuestionsWithLocalAuthRecord(m
, rr
, mDNStrue
);
4429 // If we have just one record that is not ready, we don't have to unlink and
4430 // reinsert. As the NewLocalRecords will be NULL for this case, the loop will
4431 // terminate and set the NewLocalRecords to rr.
4432 debugf("mDNS_Execute: Just one LocalAuthRecord %s, breaking out of the loop early", ARDisplayString(m
, rr
));
4433 if (head
!= mDNSNULL
|| m
->NewLocalRecords
!= mDNSNULL
)
4434 LogMsg("mDNS_Execute: ERROR!!: head %p, NewLocalRecords %p", head
, m
->NewLocalRecords
);
4440 AuthRecord
**p
= &m
->ResourceRecords
; // Find this record in our list of active records
4441 debugf("mDNS_Execute: Skipping LocalAuthRecord %s", ARDisplayString(m
, rr
));
4442 // if this is the first record we are skipping, move to the end of the list.
4443 // if we have already skipped records before, append it at the end.
4444 while (*p
&& *p
!= rr
) p
=&(*p
)->next
;
4445 if (*p
) *p
= rr
->next
; // Cut this record from the list
4446 else { LogMsg("mDNS_Execute: ERROR!! Cannot find record %s in ResourceRecords list", ARDisplayString(m
, rr
)); break; }
4449 while (*p
) p
=&(*p
)->next
;
4458 rr
->next
= mDNSNULL
;
4461 m
->NewLocalRecords
= head
;
4462 debugf("mDNS_Execute: Setting NewLocalRecords to %s", (head
? ARDisplayString(m
, head
) : "NULL"));
4464 if (i
>= 1000) LogMsg("mDNS_Execute: m->NewLocalRecords exceeded loop limit");
4466 // Check to see if we have any new LocalOnly/P2P records to examine for delivering
4467 // to our local questions
4468 if (m
->NewLocalOnlyRecords
)
4470 m
->NewLocalOnlyRecords
= mDNSfalse
;
4471 for (slot
= 0; slot
< AUTH_HASH_SLOTS
; slot
++)
4472 for (ag
= m
->rrauth
.rrauth_hash
[slot
]; ag
; ag
= ag
->next
)
4474 for (i
=0; i
<100 && ag
->NewLocalOnlyRecords
; i
++)
4476 AuthRecord
*rr
= ag
->NewLocalOnlyRecords
;
4477 ag
->NewLocalOnlyRecords
= ag
->NewLocalOnlyRecords
->next
;
4478 // LocalOnly records should always be ready as they never probe
4479 if (LocalRecordReady(rr
))
4481 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m
, rr
));
4482 AnswerAllLocalQuestionsWithLocalAuthRecord(m
, rr
, mDNStrue
);
4484 else LogMsg("mDNS_Execute: LocalOnlyRecord %s not ready", ARDisplayString(m
, rr
));
4486 // We limit about 100 per AuthGroup that can be serviced at a time
4487 if (i
>= 100) LogMsg("mDNS_Execute: ag->NewLocalOnlyRecords exceeded loop limit");
4491 // 5. Some questions may have picked a new DNS server and the cache may answer these questions now.
4492 AnswerQuestionsForDNSServerChanges(m
);
4494 // 6. See what packets we need to send
4495 if (m
->mDNSPlatformStatus
!= mStatus_NoError
|| (m
->SleepState
== SleepState_Sleeping
))
4496 DiscardDeregistrations(m
);
4497 if (m
->mDNSPlatformStatus
== mStatus_NoError
&& (m
->SuppressSending
== 0 || m
->timenow
- m
->SuppressSending
>= 0))
4499 // If the platform code is ready, and we're not suppressing packet generation right now
4500 // then send our responses, probes, and questions.
4501 // We check the cache first, because there might be records close to expiring that trigger questions to refresh them.
4502 // We send queries next, because there might be final-stage probes that complete their probing here, causing
4503 // them to advance to announcing state, and we want those to be included in any announcements we send out.
4504 // Finally, we send responses, including the previously mentioned records that just completed probing.
4505 m
->SuppressSending
= 0;
4507 // 7. Send Query packets. This may cause some probing records to advance to announcing state
4508 if (m
->timenow
- m
->NextScheduledQuery
>= 0 || m
->timenow
- m
->NextScheduledProbe
>= 0) SendQueries(m
);
4509 if (m
->timenow
- m
->NextScheduledQuery
>= 0)
4512 LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second",
4513 m
->timenow
, m
->NextScheduledQuery
, m
->timenow
- m
->NextScheduledQuery
);
4514 m
->NextScheduledQuery
= m
->timenow
+ mDNSPlatformOneSecond
;
4515 for (q
= m
->Questions
; q
&& q
!= m
->NewQuestions
; q
=q
->next
)
4516 if (ActiveQuestion(q
) && m
->timenow
- NextQSendTime(q
) >= 0)
4517 LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
4519 if (m
->timenow
- m
->NextScheduledProbe
>= 0)
4521 LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second",
4522 m
->timenow
, m
->NextScheduledProbe
, m
->timenow
- m
->NextScheduledProbe
);
4523 m
->NextScheduledProbe
= m
->timenow
+ mDNSPlatformOneSecond
;
4526 // 8. Send Response packets, including probing records just advanced to announcing state
4527 if (m
->timenow
- m
->NextScheduledResponse
>= 0) SendResponses(m
);
4528 if (m
->timenow
- m
->NextScheduledResponse
>= 0)
4530 LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second");
4531 m
->NextScheduledResponse
= m
->timenow
+ mDNSPlatformOneSecond
;
4535 // Clear RandomDelay values, ready to pick a new different value next time
4536 m
->RandomQueryDelay
= 0;
4537 m
->RandomReconfirmDelay
= 0;
4539 if (m
->NextScheduledStopTime
&& m
->timenow
- m
->NextScheduledStopTime
>= 0) TimeoutQuestions(m
);
4540 #ifndef UNICAST_DISABLED
4541 if (m
->NextSRVUpdate
&& m
->timenow
- m
->NextSRVUpdate
>= 0) UpdateAllSRVRecords(m
);
4542 if (m
->timenow
- m
->NextScheduledNATOp
>= 0) CheckNATMappings(m
);
4543 if (m
->timenow
- m
->NextuDNSEvent
>= 0) uDNS_Tasks(m
);
4547 // Note about multi-threaded systems:
4548 // On a multi-threaded system, some other thread could run right after the mDNS_Unlock(),
4549 // performing mDNS API operations that change our next scheduled event time.
4551 // On multi-threaded systems (like the current Windows implementation) that have a single main thread
4552 // calling mDNS_Execute() (and other threads allowed to call mDNS API routines) it is the responsibility
4553 // of the mDNSPlatformUnlock() routine to signal some kind of stateful condition variable that will
4554 // signal whatever blocking primitive the main thread is using, so that it will wake up and execute one
4555 // more iteration of its loop, and immediately call mDNS_Execute() again. The signal has to be stateful
4556 // in the sense that if the main thread has not yet entered its blocking primitive, then as soon as it
4557 // does, the state of the signal will be noticed, causing the blocking primitive to return immediately
4558 // without blocking. This avoids the race condition between the signal from the other thread arriving
4559 // just *before* or just *after* the main thread enters the blocking primitive.
4561 // On multi-threaded systems (like the current Mac OS 9 implementation) that are entirely timer-driven,
4562 // with no main mDNS_Execute() thread, it is the responsibility of the mDNSPlatformUnlock() routine to
4563 // set the timer according to the m->NextScheduledEvent value, and then when the timer fires, the timer
4564 // callback function should call mDNS_Execute() (and ignore the return value, which may already be stale
4565 // by the time it gets to the timer callback function).
4567 mDNS_Unlock(m
); // Calling mDNS_Unlock is what gives m->NextScheduledEvent its new value
4568 return(m
->NextScheduledEvent
);
4571 mDNSlocal
void SuspendLLQs(mDNS
*m
)
4574 for (q
= m
->Questions
; q
; q
= q
->next
)
4575 if (ActiveQuestion(q
) && !mDNSOpaque16IsZero(q
->TargetQID
) && q
->LongLived
&& q
->state
== LLQ_Established
)
4576 { q
->ReqLease
= 0; sendLLQRefresh(m
, q
); }
4579 mDNSlocal mDNSBool
QuestionHasLocalAnswers(mDNS
*const m
, DNSQuestion
*q
)
4585 slot
= AuthHashSlot(&q
->qname
);
4586 ag
= AuthGroupForName(&m
->rrauth
, slot
, q
->qnamehash
, &q
->qname
);
4589 for (rr
= ag
->members
; rr
; rr
=rr
->next
)
4590 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME
4591 if (LORecordAnswersAddressType(rr
) && LocalOnlyRecordAnswersQuestion(rr
, q
))
4593 LogInfo("QuestionHasLocalAnswers: Question %p %##s (%s) has local answer %s", q
, q
->qname
.c
, DNSTypeName(q
->qtype
), ARDisplayString(m
, rr
));
4600 // ActivateUnicastQuery() is called from three places:
4601 // 1. When a new question is created
4602 // 2. On wake from sleep
4603 // 3. When the DNS configuration changes
4604 // In case 1 we don't want to mess with our established ThisQInterval and LastQTime (ScheduleImmediately is false)
4605 // In cases 2 and 3 we do want to cause the question to be resent immediately (ScheduleImmediately is true)
4606 mDNSlocal
void ActivateUnicastQuery(mDNS
*const m
, DNSQuestion
*const question
, mDNSBool ScheduleImmediately
)
4608 // For now this AutoTunnel stuff is specific to Mac OS X.
4609 // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer
4610 #if APPLE_OSX_mDNSResponder
4611 // Even though BTMM client tunnels are only useful for AAAA queries, we need to treat v4 and v6 queries equally.
4612 // Otherwise we can get the situation where the A query completes really fast (with an NXDOMAIN result) and the
4613 // caller then gives up waiting for the AAAA result while we're still in the process of setting up the tunnel.
4614 // To level the playing field, we block both A and AAAA queries while tunnel setup is in progress, and then
4615 // returns results for both at the same time. If we are looking for the _autotunnel6 record, then skip this logic
4616 // as this would trigger looking up _autotunnel6._autotunnel6 and end up failing the original query.
4618 if (RRTypeIsAddressType(question
->qtype
) && PrivateQuery(question
) &&
4619 !SameDomainLabel(question
->qname
.c
, (const mDNSu8
*)"\x0c_autotunnel6")&& question
->QuestionCallback
!= AutoTunnelCallback
)
4621 question
->NoAnswer
= NoAnswer_Suspended
;
4622 AddNewClientTunnel(m
, question
);
4625 #endif // APPLE_OSX_mDNSResponder
4627 if (!question
->DuplicateOf
)
4629 debugf("ActivateUnicastQuery: %##s %s%s%s",
4630 question
->qname
.c
, DNSTypeName(question
->qtype
), PrivateQuery(question
) ? " (Private)" : "", ScheduleImmediately
? " ScheduleImmediately" : "");
4631 question
->CNAMEReferrals
= 0;
4632 if (question
->nta
) { CancelGetZoneData(m
, question
->nta
); question
->nta
= mDNSNULL
; }
4633 if (question
->LongLived
)
4635 question
->state
= LLQ_InitialRequest
;
4636 question
->id
= zeroOpaque64
;
4637 question
->servPort
= zeroIPPort
;
4638 if (question
->tcp
) { DisposeTCPConn(question
->tcp
); question
->tcp
= mDNSNULL
; }
4640 // If the question has local answers, then we don't want answers from outside
4641 if (ScheduleImmediately
&& !QuestionHasLocalAnswers(m
, question
))
4643 question
->ThisQInterval
= InitialQuestionInterval
;
4644 question
->LastQTime
= m
->timenow
- question
->ThisQInterval
;
4645 SetNextQueryTime(m
, question
);
4650 // Caller should hold the lock
4651 mDNSexport
void mDNSCoreRestartAddressQueries(mDNS
*const m
, mDNSBool SearchDomainsChanged
, FlushCache flushCacheRecords
,
4652 CallbackBeforeStartQuery BeforeStartCallback
, void *context
)
4655 DNSQuestion
*restart
= mDNSNULL
;
4657 if (!m
->mDNS_busy
) LogMsg("mDNSCoreRestartAddressQueries: ERROR!! Lock not held");
4659 // 1. Flush the cache records
4660 if (flushCacheRecords
) flushCacheRecords(m
);
4662 // 2. Even though we may have purged the cache records above, before it can generate RMV event
4663 // we are going to stop the question. Hence we need to deliver the RMV event before we
4664 // stop the question.
4666 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the
4667 // application callback can potentially stop the current question (detected by CurrentQuestion) or
4668 // *any* other question which could be the next one that we may process here. RestartQuestion
4669 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal
4670 // if the "next" question is stopped while the CurrentQuestion is stopped
4672 if (m
->RestartQuestion
)
4673 LogMsg("mDNSCoreRestartAddressQueries: ERROR!! m->RestartQuestion already set: %##s (%s)",
4674 m
->RestartQuestion
->qname
.c
, DNSTypeName(m
->RestartQuestion
->qtype
));
4676 m
->RestartQuestion
= m
->Questions
;
4677 while (m
->RestartQuestion
)
4679 q
= m
->RestartQuestion
;
4680 m
->RestartQuestion
= q
->next
;
4681 // GetZoneData questions are referenced by other questions (original query that started the GetZoneData
4682 // question) through their "nta" pointer. Normally when the original query stops, it stops the
4683 // GetZoneData question and also frees the memory (See CancelGetZoneData). If we stop the GetZoneData
4684 // question followed by the original query that refers to this GetZoneData question, we will end up
4685 // freeing the GetZoneData question and then start the "freed" question at the end.
4687 if (IsGetZoneDataQuestion(q
))
4689 DNSQuestion
*refq
= q
->next
;
4690 LogInfo("mDNSCoreRestartAddressQueries: Skipping GetZoneDataQuestion %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
4691 // debug stuff, we just try to find the referencing question and don't do much with it
4694 if (q
== &refq
->nta
->question
)
4696 LogInfo("mDNSCoreRestartAddressQueries: Question %p %##s (%s) referring to GetZoneDataQuestion %p, not stopping", refq
, refq
->qname
.c
, DNSTypeName(refq
->qtype
), q
);
4703 // This function is called when /etc/hosts changes and that could affect A, AAAA and CNAME queries
4704 if (q
->qtype
!= kDNSType_A
&& q
->qtype
!= kDNSType_AAAA
&& q
->qtype
!= kDNSType_CNAME
) continue;
4706 // If the search domains did not change, then we restart all the queries. Otherwise, only
4707 // for queries for which we "might" have appended search domains ("might" because we may
4708 // find results before we apply search domains even though AppendSearchDomains is set to 1)
4709 if (!SearchDomainsChanged
|| q
->AppendSearchDomains
)
4711 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero
4712 // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before
4713 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers). Let us say that
4714 // /etc/hosts has an A Record for web.apple.com. Any queries for web.apple.com will be answered locally.
4715 // But this can't prevent a CNAME/AAAA query to not to be sent on the wire. When it is sent on the wire,
4716 // it could create cache entries. When we are restarting queries, we can't deliver the cache RMV events
4717 // for the original query using these cache entries as ADDs were never delivered using these cache
4718 // entries and hence this order is needed.
4720 // If the query is suppressed, the RMV events won't be delivered
4721 if (!CacheRecordRmvEventsForQuestion(m
, q
)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Cache Record RMV events"); continue; }
4723 // SuppressQuery status does not affect questions that are answered using local records
4724 if (!LocalRecordRmvEventsForQuestion(m
, q
)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Local Record RMV events"); continue; }
4726 LogInfo("mDNSCoreRestartAddressQueries: Stop question %p %##s (%s), AppendSearchDomains %d, qnameOrig %p", q
,
4727 q
->qname
.c
, DNSTypeName(q
->qtype
), q
->AppendSearchDomains
, q
->qnameOrig
);
4728 mDNS_StopQuery_internal(m
, q
);
4729 // Reset state so that it looks like it was in the beginning i.e it should look at /etc/hosts, cache
4730 // and then search domains should be appended. At the beginning, qnameOrig was NULL.
4733 LogInfo("mDNSCoreRestartAddressQueries: qnameOrig %##s", q
->qnameOrig
);
4734 AssignDomainName(&q
->qname
, q
->qnameOrig
);
4735 mDNSPlatformMemFree(q
->qnameOrig
);
4736 q
->qnameOrig
= mDNSNULL
;
4737 q
->RetryWithSearchDomains
= ApplySearchDomainsFirst(q
) ? 1 : 0;
4739 q
->SearchListIndex
= 0;
4745 // 3. Callback before we start the query
4746 if (BeforeStartCallback
) BeforeStartCallback(m
, context
);
4748 // 4. Restart all the stopped queries
4752 restart
= restart
->next
;
4754 LogInfo("mDNSCoreRestartAddressQueries: Start question %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
4755 mDNS_StartQuery_internal(m
, q
);
4759 mDNSexport
void mDNSCoreRestartQueries(mDNS
*const m
)
4763 #ifndef UNICAST_DISABLED
4764 // Retrigger all our uDNS questions
4765 if (m
->CurrentQuestion
)
4766 LogMsg("mDNSCoreRestartQueries: ERROR m->CurrentQuestion already set: %##s (%s)",
4767 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
4768 m
->CurrentQuestion
= m
->Questions
;
4769 while (m
->CurrentQuestion
)
4771 q
= m
->CurrentQuestion
;
4772 m
->CurrentQuestion
= m
->CurrentQuestion
->next
;
4773 if (!mDNSOpaque16IsZero(q
->TargetQID
) && ActiveQuestion(q
)) ActivateUnicastQuery(m
, q
, mDNStrue
);
4777 // Retrigger all our mDNS questions
4778 for (q
= m
->Questions
; q
; q
=q
->next
) // Scan our list of questions
4779 if (mDNSOpaque16IsZero(q
->TargetQID
) && ActiveQuestion(q
))
4781 q
->ThisQInterval
= InitialQuestionInterval
; // MUST be > zero for an active question
4782 q
->RequestUnicast
= 2; // Set to 2 because is decremented once *before* we check it
4783 q
->LastQTime
= m
->timenow
- q
->ThisQInterval
;
4784 q
->RecentAnswerPkts
= 0;
4785 ExpireDupSuppressInfo(q
->DupSuppress
, m
->timenow
);
4786 m
->NextScheduledQuery
= m
->timenow
;
4790 // ***************************************************************************
4791 #if COMPILER_LIKES_PRAGMA_MARK
4793 #pragma mark - Power Management (Sleep/Wake)
4796 mDNSexport
void mDNS_UpdateAllowSleep(mDNS
*const m
)
4798 #ifndef IDLESLEEPCONTROL_DISABLED
4799 mDNSBool allowSleep
= mDNStrue
;
4804 if (m
->SystemSleepOnlyIfWakeOnLAN
)
4806 // Don't sleep if we are a proxy for any services
4807 if (m
->ProxyRecords
)
4809 allowSleep
= mDNSfalse
;
4810 mDNS_snprintf(reason
, sizeof(reason
), "sleep proxy for %d records", m
->ProxyRecords
);
4811 LogInfo("Sleep disabled because we are proxying %d records", m
->ProxyRecords
);
4814 if (allowSleep
&& mDNSCoreHaveAdvertisedMulticastServices(m
))
4816 // Scan the list of active interfaces
4817 NetworkInterfaceInfo
*intf
;
4818 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
4820 if (intf
->McastTxRx
&& !intf
->Loopback
)
4822 // Disallow sleep if this interface doesn't support NetWake
4825 allowSleep
= mDNSfalse
;
4826 mDNS_snprintf(reason
, sizeof(reason
), "%s does not support NetWake", intf
->ifname
);
4827 LogInfo("Sleep disabled because %s does not support NetWake", intf
->ifname
);
4831 // Disallow sleep if there is no sleep proxy server
4832 if (FindSPSInCache1(m
, &intf
->NetWakeBrowse
, mDNSNULL
, mDNSNULL
) == mDNSNULL
)
4834 allowSleep
= mDNSfalse
;
4835 mDNS_snprintf(reason
, sizeof(reason
), "%s does not support NetWake", intf
->ifname
);
4836 LogInfo("Sleep disabled because %s has no sleep proxy", intf
->ifname
);
4844 // Call the platform code to enable/disable sleep
4845 mDNSPlatformSetAllowSleep(m
, allowSleep
, reason
);
4846 #endif /* !defined(IDLESLEEPCONTROL_DISABLED) */
4849 mDNSlocal
void SendSPSRegistrationForOwner(mDNS
*const m
, NetworkInterfaceInfo
*const intf
, const mDNSOpaque16 id
, const OwnerOptData
*const owner
)
4851 const int optspace
= DNSOpt_Header_Space
+ DNSOpt_LeaseData_Space
+ DNSOpt_Owner_Space(&m
->PrimaryMAC
, &intf
->MAC
);
4852 const int sps
= intf
->NextSPSAttempt
/ 3;
4855 if (!intf
->SPSAddr
[sps
].type
)
4857 intf
->NextSPSAttemptTime
= m
->timenow
+ mDNSPlatformOneSecond
;
4858 if (m
->NextScheduledSPRetry
- intf
->NextSPSAttemptTime
> 0)
4859 m
->NextScheduledSPRetry
= intf
->NextSPSAttemptTime
;
4860 LogSPS("SendSPSRegistration: %s SPS %d (%d) %##s not yet resolved", intf
->ifname
, intf
->NextSPSAttempt
, sps
, intf
->NetWakeResolve
[sps
].qname
.c
);
4864 // Mark our mDNS records (not unicast records) for transfer to SPS
4865 if (mDNSOpaque16IsZero(id
))
4866 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
4867 if (rr
->resrec
.RecordType
> kDNSRecordTypeDeregistering
)
4868 if (rr
->resrec
.InterfaceID
== intf
->InterfaceID
|| (!rr
->resrec
.InterfaceID
&& (rr
->ForceMCast
|| IsLocalDomain(rr
->resrec
.name
))))
4869 if (mDNSPlatformMemSame(owner
, &rr
->WakeUp
, sizeof(*owner
)))
4870 rr
->SendRNow
= mDNSInterfaceMark
; // mark it now
4874 mDNSu8
*p
= m
->omsg
.data
;
4875 // To comply with RFC 2782, PutResourceRecord suppresses name compression for SRV records in unicast updates.
4876 // For now we follow that same logic for SPS registrations too.
4877 // If we decide to compress SRV records in SPS registrations in the future, we can achieve that by creating our
4878 // initial DNSMessage with h.flags set to zero, and then update it to UpdateReqFlags right before sending the packet.
4879 InitializeDNSMessage(&m
->omsg
.h
, mDNSOpaque16IsZero(id
) ? mDNS_NewMessageID(m
) : id
, UpdateReqFlags
);
4881 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
4882 if (rr
->SendRNow
|| (!mDNSOpaque16IsZero(id
) && !AuthRecord_uDNS(rr
) && mDNSSameOpaque16(rr
->updateid
, id
) && m
->timenow
- (rr
->LastAPTime
+ rr
->ThisAPInterval
) >= 0))
4883 if (mDNSPlatformMemSame(owner
, &rr
->WakeUp
, sizeof(*owner
)))
4886 const mDNSu8
*const limit
= m
->omsg
.data
+ (m
->omsg
.h
.mDNS_numUpdates
? NormalMaxDNSMessageData
: AbsoluteMaxDNSMessageData
) - optspace
;
4887 if (rr
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)
4888 rr
->resrec
.rrclass
|= kDNSClass_UniqueRRSet
; // Temporarily set the 'unique' bit so PutResourceRecord will set it
4889 newptr
= PutResourceRecordTTLWithLimit(&m
->omsg
, p
, &m
->omsg
.h
.mDNS_numUpdates
, &rr
->resrec
, rr
->resrec
.rroriginalttl
, limit
);
4890 rr
->resrec
.rrclass
&= ~kDNSClass_UniqueRRSet
; // Make sure to clear 'unique' bit back to normal state
4892 LogSPS("SendSPSRegistration put %s FAILED %d/%d %s", intf
->ifname
, p
- m
->omsg
.data
, limit
- m
->omsg
.data
, ARDisplayString(m
, rr
));
4895 LogSPS("SendSPSRegistration put %s %s", intf
->ifname
, ARDisplayString(m
, rr
));
4896 rr
->SendRNow
= mDNSNULL
;
4897 rr
->ThisAPInterval
= mDNSPlatformOneSecond
;
4898 rr
->LastAPTime
= m
->timenow
;
4899 rr
->updateid
= m
->omsg
.h
.id
;
4900 if (m
->NextScheduledResponse
- (rr
->LastAPTime
+ rr
->ThisAPInterval
) >= 0)
4901 m
->NextScheduledResponse
= (rr
->LastAPTime
+ rr
->ThisAPInterval
);
4906 if (!m
->omsg
.h
.mDNS_numUpdates
) break;
4910 mDNS_SetupResourceRecord(&opt
, mDNSNULL
, mDNSInterface_Any
, kDNSType_OPT
, kStandardTTL
, kDNSRecordTypeKnownUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
4911 opt
.resrec
.rrclass
= NormalMaxDNSMessageData
;
4912 opt
.resrec
.rdlength
= sizeof(rdataOPT
) * 2; // Two options in this OPT record
4913 opt
.resrec
.rdestimate
= sizeof(rdataOPT
) * 2;
4914 opt
.resrec
.rdata
->u
.opt
[0].opt
= kDNSOpt_Lease
;
4915 opt
.resrec
.rdata
->u
.opt
[0].optlen
= DNSOpt_LeaseData_Space
- 4;
4916 opt
.resrec
.rdata
->u
.opt
[0].u
.updatelease
= DEFAULT_UPDATE_LEASE
;
4917 if (!owner
->HMAC
.l
[0]) // If no owner data,
4918 SetupOwnerOpt(m
, intf
, &opt
.resrec
.rdata
->u
.opt
[1]); // use our own interface information
4919 else // otherwise, use the owner data we were given
4921 opt
.resrec
.rdata
->u
.opt
[1].u
.owner
= *owner
;
4922 opt
.resrec
.rdata
->u
.opt
[1].opt
= kDNSOpt_Owner
;
4923 opt
.resrec
.rdata
->u
.opt
[1].optlen
= DNSOpt_Owner_Space(&owner
->HMAC
, &owner
->IMAC
) - 4;
4925 LogSPS("SendSPSRegistration put %s %s", intf
->ifname
, ARDisplayString(m
, &opt
));
4926 p
= PutResourceRecordTTLWithLimit(&m
->omsg
, p
, &m
->omsg
.h
.numAdditionals
, &opt
.resrec
, opt
.resrec
.rroriginalttl
, m
->omsg
.data
+ AbsoluteMaxDNSMessageData
);
4928 LogMsg("SendSPSRegistration: Failed to put OPT record (%d updates) %s", m
->omsg
.h
.mDNS_numUpdates
, ARDisplayString(m
, &opt
));
4933 LogSPS("SendSPSRegistration: Sending Update %s %d (%d) id %5d with %d records %d bytes to %#a:%d", intf
->ifname
, intf
->NextSPSAttempt
, sps
,
4934 mDNSVal16(m
->omsg
.h
.id
), m
->omsg
.h
.mDNS_numUpdates
, p
- m
->omsg
.data
, &intf
->SPSAddr
[sps
], mDNSVal16(intf
->SPSPort
[sps
]));
4935 // if (intf->NextSPSAttempt < 5) m->omsg.h.flags = zeroID; // For simulating packet loss
4936 err
= mDNSSendDNSMessage(m
, &m
->omsg
, p
, intf
->InterfaceID
, mDNSNULL
, &intf
->SPSAddr
[sps
], intf
->SPSPort
[sps
], mDNSNULL
, mDNSNULL
);
4937 if (err
) LogSPS("SendSPSRegistration: mDNSSendDNSMessage err %d", err
);
4938 if (err
&& intf
->SPSAddr
[sps
].type
== mDNSAddrType_IPv6
&& intf
->NetWakeResolve
[sps
].ThisQInterval
== -1)
4940 LogSPS("SendSPSRegistration %d %##s failed to send to IPv6 address; will try IPv4 instead", sps
, intf
->NetWakeResolve
[sps
].qname
.c
);
4941 intf
->NetWakeResolve
[sps
].qtype
= kDNSType_A
;
4942 mDNS_StartQuery_internal(m
, &intf
->NetWakeResolve
[sps
]);
4949 intf
->NextSPSAttemptTime
= m
->timenow
+ mDNSPlatformOneSecond
* 10; // If successful, update NextSPSAttemptTime
4952 if (mDNSOpaque16IsZero(id
) && intf
->NextSPSAttempt
< 8) intf
->NextSPSAttempt
++;
4955 mDNSlocal mDNSBool
RecordIsFirstOccurrenceOfOwner(mDNS
*const m
, const AuthRecord
*const rr
)
4958 for (ar
= m
->ResourceRecords
; ar
&& ar
!= rr
; ar
=ar
->next
)
4959 if (mDNSPlatformMemSame(&rr
->WakeUp
, &ar
->WakeUp
, sizeof(rr
->WakeUp
))) return mDNSfalse
;
4964 mDNSlocal
void SendSPSRegistration(mDNS
*const m
, NetworkInterfaceInfo
*const intf
, const mDNSOpaque16 id
)
4967 OwnerOptData owner
= zeroOwner
;
4969 SendSPSRegistrationForOwner(m
, intf
, id
, &owner
);
4971 for (ar
= m
->ResourceRecords
; ar
; ar
=ar
->next
)
4973 if (!mDNSPlatformMemSame(&owner
, &ar
->WakeUp
, sizeof(owner
)) && RecordIsFirstOccurrenceOfOwner(m
, ar
))
4976 SendSPSRegistrationForOwner(m
, intf
, id
, &owner
);
4981 mDNSlocal
void mDNSCoreStoreProxyRR(mDNS
*const m
, const mDNSInterfaceID InterfaceID
, AuthRecord
*const rr
)
4983 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, InterfaceID
);
4984 AuthRecord
*newRR
= mDNSPlatformMemAllocate(sizeof(AuthRecord
));
4986 if ((intf
== mDNSNULL
) || (newRR
== mDNSNULL
))
4988 mDNSPlatformMemZero(newRR
, sizeof(AuthRecord
));
4989 mDNS_SetupResourceRecord(newRR
, mDNSNULL
, InterfaceID
, rr
->resrec
.rrtype
,
4990 rr
->resrec
.rroriginalttl
, rr
->resrec
.RecordType
,
4991 rr
->ARType
, mDNSNULL
, mDNSNULL
);
4992 AssignDomainName(&newRR
->namestorage
, &rr
->namestorage
);
4993 newRR
->resrec
.rdlength
= DomainNameLength(rr
->resrec
.name
);
4994 newRR
->resrec
.rdata
->u
.name
.c
[0] = 0;
4995 AssignDomainName(&newRR
->resrec
.rdata
->u
.name
, rr
->resrec
.name
);
4996 newRR
->resrec
.namehash
= DomainNameHashValue(newRR
->resrec
.name
);
4997 newRR
->resrec
.rrclass
= rr
->resrec
.rrclass
;
4998 if (intf
->ip
.type
== mDNSAddrType_IPv4
)
4999 newRR
->resrec
.rdata
->u
.ipv4
= rr
->resrec
.rdata
->u
.ipv4
;
5001 newRR
->resrec
.rdata
->u
.ipv6
= rr
->resrec
.rdata
->u
.ipv6
;
5002 SetNewRData(&newRR
->resrec
, mDNSNULL
, 0);
5003 // Insert the new node at the head of the list.
5004 newRR
->next
= intf
->SPSRRSet
;
5005 intf
->SPSRRSet
= newRR
;
5008 mDNSlocal
void SPSInitRecordsBeforeUpdate(mDNS
*const m
, mDNSOpaque64 updateIntID
)
5011 LogSPS("SPSInitRecordsBeforeUpdate: UpdateIntID 0x%x 0x%x", updateIntID
.l
[1], updateIntID
.l
[0]);
5013 // Before we store the A and AAAA records that we are going to register with the sleep proxy,
5014 // make sure that the old sleep proxy records are removed.
5015 mDNSCoreFreeProxyRR(m
);
5017 for (ar
= m
->ResourceRecords
; ar
; ar
=ar
->next
)
5019 if (AuthRecord_uDNS(ar
))
5021 // Store the A and AAAA records that we registered with the sleep proxy.
5022 // We will use this to prevent spurious name conflicts that may occur when we wake up
5023 if (ar
->resrec
.rrtype
== kDNSType_A
|| ar
->resrec
.rrtype
== kDNSType_AAAA
)
5025 mDNSCoreStoreProxyRR(m
, ar
->resrec
.InterfaceID
, ar
);
5030 // RetrySPSRegistrations is called from SendResponses, with the lock held
5031 mDNSlocal
void RetrySPSRegistrations(mDNS
*const m
)
5034 NetworkInterfaceInfo
*intf
;
5036 // First make sure none of our interfaces' NextSPSAttemptTimes are inadvertently set to m->timenow + mDNSPlatformOneSecond * 10
5037 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5038 if (intf
->NextSPSAttempt
&& intf
->NextSPSAttemptTime
== m
->timenow
+ mDNSPlatformOneSecond
* 10)
5039 intf
->NextSPSAttemptTime
++;
5041 // Retry any record registrations that are due
5042 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
5043 if (!AuthRecord_uDNS(rr
) && !mDNSOpaque16IsZero(rr
->updateid
) && m
->timenow
- (rr
->LastAPTime
+ rr
->ThisAPInterval
) >= 0)
5044 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5045 if (!rr
->resrec
.InterfaceID
|| rr
->resrec
.InterfaceID
== intf
->InterfaceID
)
5047 LogSPS("RetrySPSRegistrations: %s", ARDisplayString(m
, rr
));
5048 SendSPSRegistration(m
, intf
, rr
->updateid
);
5051 // For interfaces where we did an SPS registration attempt, increment intf->NextSPSAttempt
5052 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5053 if (intf
->NextSPSAttempt
&& intf
->NextSPSAttemptTime
== m
->timenow
+ mDNSPlatformOneSecond
* 10 && intf
->NextSPSAttempt
< 8)
5054 intf
->NextSPSAttempt
++;
5057 mDNSlocal
void NetWakeResolve(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
, QC_result AddRecord
)
5059 NetworkInterfaceInfo
*intf
= (NetworkInterfaceInfo
*)question
->QuestionContext
;
5060 int sps
= (int)(question
- intf
->NetWakeResolve
);
5062 LogSPS("NetWakeResolve: SPS: %d Add: %d %s", sps
, AddRecord
, RRDisplayString(m
, answer
));
5064 if (!AddRecord
) return; // Don't care about REMOVE events
5065 if (answer
->rrtype
!= question
->qtype
) return; // Don't care about CNAMEs
5067 // if (answer->rrtype == kDNSType_AAAA && sps == 0) return; // To test failing to resolve sleep proxy's address
5069 if (answer
->rrtype
== kDNSType_SRV
)
5071 // 1. Got the SRV record; now look up the target host's IPv6 link-local address
5072 mDNS_StopQuery(m
, question
);
5073 intf
->SPSPort
[sps
] = answer
->rdata
->u
.srv
.port
;
5074 AssignDomainName(&question
->qname
, &answer
->rdata
->u
.srv
.target
);
5075 question
->qtype
= kDNSType_AAAA
;
5076 mDNS_StartQuery(m
, question
);
5078 else if (answer
->rrtype
== kDNSType_AAAA
&& answer
->rdlength
== sizeof(mDNSv6Addr
) && mDNSv6AddressIsLinkLocal(&answer
->rdata
->u
.ipv6
))
5080 // 2. Got the target host's IPv6 link-local address; record address and initiate an SPS registration if appropriate
5081 mDNS_StopQuery(m
, question
);
5082 question
->ThisQInterval
= -1;
5083 intf
->SPSAddr
[sps
].type
= mDNSAddrType_IPv6
;
5084 intf
->SPSAddr
[sps
].ip
.v6
= answer
->rdata
->u
.ipv6
;
5086 if (sps
== intf
->NextSPSAttempt
/3) SendSPSRegistration(m
, intf
, zeroID
); // If we're ready for this result, use it now
5089 else if (answer
->rrtype
== kDNSType_AAAA
&& answer
->rdlength
== 0)
5091 // 3. Got negative response -- target host apparently has IPv6 disabled -- so try looking up the target host's IPv4 address(es) instead
5092 mDNS_StopQuery(m
, question
);
5093 LogSPS("NetWakeResolve: SPS %d %##s has no IPv6 address, will try IPv4 instead", sps
, question
->qname
.c
);
5094 question
->qtype
= kDNSType_A
;
5095 mDNS_StartQuery(m
, question
);
5097 else if (answer
->rrtype
== kDNSType_A
&& answer
->rdlength
== sizeof(mDNSv4Addr
))
5099 // 4. Got an IPv4 address for the target host; record address and initiate an SPS registration if appropriate
5100 mDNS_StopQuery(m
, question
);
5101 question
->ThisQInterval
= -1;
5102 intf
->SPSAddr
[sps
].type
= mDNSAddrType_IPv4
;
5103 intf
->SPSAddr
[sps
].ip
.v4
= answer
->rdata
->u
.ipv4
;
5105 if (sps
== intf
->NextSPSAttempt
/3) SendSPSRegistration(m
, intf
, zeroID
); // If we're ready for this result, use it now
5110 mDNSexport mDNSBool
mDNSCoreHaveAdvertisedMulticastServices(mDNS
*const m
)
5113 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
5114 if (rr
->resrec
.rrtype
== kDNSType_SRV
&& !AuthRecord_uDNS(rr
) && !mDNSSameIPPort(rr
->resrec
.rdata
->u
.srv
.port
, DiscardPort
))
5119 mDNSlocal
void SendSleepGoodbyes(mDNS
*const m
)
5122 m
->SleepState
= SleepState_Sleeping
;
5124 #ifndef UNICAST_DISABLED
5125 SleepRecordRegistrations(m
); // If we have no SPS, need to deregister our uDNS records
5126 #endif /* UNICAST_DISABLED */
5128 // Mark all the records we need to deregister and send them
5129 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
5130 if (rr
->resrec
.RecordType
== kDNSRecordTypeShared
&& rr
->RequireGoodbye
)
5131 rr
->ImmedAnswer
= mDNSInterfaceMark
;
5135 // BeginSleepProcessing is called, with the lock held, from either mDNS_Execute or mDNSCoreMachineSleep
5136 mDNSlocal
void BeginSleepProcessing(mDNS
*const m
)
5138 mDNSBool SendGoodbyes
= mDNStrue
;
5139 const CacheRecord
*sps
[3] = { mDNSNULL
};
5140 mDNSOpaque64 updateIntID
= zeroOpaque64
;
5142 m
->NextScheduledSPRetry
= m
->timenow
;
5144 if (!m
->SystemWakeOnLANEnabled
) LogSPS("BeginSleepProcessing: m->SystemWakeOnLANEnabled is false");
5145 else if (!mDNSCoreHaveAdvertisedMulticastServices(m
)) LogSPS("BeginSleepProcessing: No advertised services");
5146 else // If we have at least one advertised service
5148 NetworkInterfaceInfo
*intf
;
5149 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5151 if (!intf
->NetWake
) LogSPS("BeginSleepProcessing: %-6s not capable of magic packet wakeup", intf
->ifname
);
5152 #if APPLE_OSX_mDNSResponder
5153 else if (ActivateLocalProxy(m
, intf
->ifname
) == mStatus_NoError
)
5155 SendGoodbyes
= mDNSfalse
;
5156 LogSPS("BeginSleepProcessing: %-6s using local proxy", intf
->ifname
);
5157 // This will leave m->SleepState set to SleepState_Transferring,
5158 // which is okay because with no outstanding resolves, or updates in flight,
5159 // mDNSCoreReadyForSleep() will conclude correctly that all the updates have already completed
5161 #endif // APPLE_OSX_mDNSResponder
5164 FindSPSInCache(m
, &intf
->NetWakeBrowse
, sps
);
5165 if (!sps
[0]) LogSPS("BeginSleepProcessing: %-6s %#a No Sleep Proxy Server found (Next Browse Q in %d, interval %d)",
5166 intf
->ifname
, &intf
->ip
, NextQSendTime(&intf
->NetWakeBrowse
) - m
->timenow
, intf
->NetWakeBrowse
.ThisQInterval
);
5171 SendGoodbyes
= mDNSfalse
;
5172 intf
->NextSPSAttempt
= 0;
5173 intf
->NextSPSAttemptTime
= m
->timenow
+ mDNSPlatformOneSecond
;
5175 scopeid
= mDNSPlatformInterfaceIndexfromInterfaceID(m
, intf
->InterfaceID
, mDNStrue
);
5176 // Now we know for sure that we have to wait for registration to complete on this interface.
5177 if (scopeid
< (sizeof(updateIntID
) * mDNSNBBY
))
5178 bit_set_opaque64(updateIntID
, scopeid
);
5179 // Don't need to set m->NextScheduledSPRetry here because we already set "m->NextScheduledSPRetry = m->timenow" above
5183 if (intf
->SPSAddr
[i
].type
)
5184 { LogMsg("BeginSleepProcessing: %s %d intf->SPSAddr[i].type %d", intf
->ifname
, i
, intf
->SPSAddr
[i
].type
); *(long*)0 = 0; }
5185 if (intf
->NetWakeResolve
[i
].ThisQInterval
>= 0)
5186 { LogMsg("BeginSleepProcessing: %s %d intf->NetWakeResolve[i].ThisQInterval %d", intf
->ifname
, i
, intf
->NetWakeResolve
[i
].ThisQInterval
); *(long*)0 = 0; }
5188 intf
->SPSAddr
[i
].type
= mDNSAddrType_None
;
5189 if (intf
->NetWakeResolve
[i
].ThisQInterval
>= 0) mDNS_StopQuery(m
, &intf
->NetWakeResolve
[i
]);
5190 intf
->NetWakeResolve
[i
].ThisQInterval
= -1;
5193 LogSPS("BeginSleepProcessing: %-6s Found Sleep Proxy Server %d TTL %d %s", intf
->ifname
, i
, sps
[i
]->resrec
.rroriginalttl
, CRDisplayString(m
, sps
[i
]));
5194 mDNS_SetupQuestion(&intf
->NetWakeResolve
[i
], intf
->InterfaceID
, &sps
[i
]->resrec
.rdata
->u
.name
, kDNSType_SRV
, NetWakeResolve
, intf
);
5195 intf
->NetWakeResolve
[i
].ReturnIntermed
= mDNStrue
;
5196 mDNS_StartQuery_internal(m
, &intf
->NetWakeResolve
[i
]);
5203 // If we have at least one interface on which we are registering with an external sleep proxy,
5204 // initialize all the records appropriately.
5205 if (!mDNSOpaque64IsZero(&updateIntID
)) SPSInitRecordsBeforeUpdate(m
, updateIntID
);
5206 if (SendGoodbyes
) // If we didn't find even one Sleep Proxy
5208 LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server");
5209 SendSleepGoodbyes(m
);
5213 // Call mDNSCoreMachineSleep(m, mDNStrue) when the machine is about to go to sleep.
5214 // Call mDNSCoreMachineSleep(m, mDNSfalse) when the machine is has just woken up.
5215 // Normally, the platform support layer below mDNSCore should call this, not the client layer above.
5216 mDNSexport
void mDNSCoreMachineSleep(mDNS
*const m
, mDNSBool sleep
)
5220 LogSPS("%s (old state %d) at %ld", sleep
? "Sleeping" : "Waking", m
->SleepState
, m
->timenow
);
5222 if (sleep
&& !m
->SleepState
) // Going to sleep
5225 // If we're going to sleep, need to stop advertising that we're a Sleep Proxy Server
5228 mDNSu8 oldstate
= m
->SPSState
;
5229 mDNS_DropLockBeforeCallback(); // mDNS_DeregisterService expects to be called without the lock held, so we emulate that here
5231 if (oldstate
== 1) mDNS_DeregisterService(m
, &m
->SPSRecords
);
5232 mDNS_ReclaimLockAfterCallback();
5235 m
->SleepState
= SleepState_Transferring
;
5236 if (m
->SystemWakeOnLANEnabled
&& m
->DelaySleep
)
5238 // If we just woke up moments ago, allow ten seconds for networking to stabilize before going back to sleep
5239 LogSPS("mDNSCoreMachineSleep: Re-sleeping immediately after waking; will delay for %d ticks", m
->DelaySleep
- m
->timenow
);
5240 m
->SleepLimit
= NonZeroTime(m
->DelaySleep
+ mDNSPlatformOneSecond
* 10);
5245 m
->SleepLimit
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
* 10);
5246 BeginSleepProcessing(m
);
5249 #ifndef UNICAST_DISABLED
5253 // RemoveAutoTunnel6Record needs to be called outside the lock, as it grabs the lock also.
5254 #if APPLE_OSX_mDNSResponder
5255 RemoveAutoTunnel6Record(m
);
5257 LogSPS("mDNSCoreMachineSleep: m->SleepState %d (%s) seq %d", m
->SleepState
,
5258 m
->SleepState
== SleepState_Transferring
? "Transferring" :
5259 m
->SleepState
== SleepState_Sleeping
? "Sleeping" : "?", m
->SleepSeqNum
);
5261 else if (!sleep
) // Waking up
5266 NetworkInterfaceInfo
*intf
;
5269 // Reset SleepLimit back to 0 now that we're awake again.
5272 // If we were previously sleeping, but now we're not, increment m->SleepSeqNum to indicate that we're entering a new period of wakefulness
5273 if (m
->SleepState
!= SleepState_Awake
)
5275 m
->SleepState
= SleepState_Awake
;
5277 // If the machine wakes and then immediately tries to sleep again (e.g. a maintenance wake)
5278 // then we enforce a minimum delay of 16 seconds before we begin sleep processing.
5279 // This is to allow time for the Ethernet link to come up, DHCP to get an address, mDNS to issue queries, etc.,
5280 // before we make our determination of whether there's a Sleep Proxy out there we should register with.
5281 m
->DelaySleep
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
* 16);
5284 if (m
->SPSState
== 3)
5287 mDNSCoreBeSleepProxyServer_internal(m
, m
->SPSType
, m
->SPSPortability
, m
->SPSMarginalPower
, m
->SPSTotalPower
);
5290 // In case we gave up waiting and went to sleep before we got an ack from the Sleep Proxy,
5291 // on wake we go through our record list and clear updateid back to zero
5292 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
) rr
->updateid
= zeroID
;
5294 // ... and the same for NextSPSAttempt
5295 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
)) intf
->NextSPSAttempt
= -1;
5297 // Restart unicast and multicast queries
5298 mDNSCoreRestartQueries(m
);
5300 // and reactivtate service registrations
5301 m
->NextSRVUpdate
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
);
5302 LogInfo("mDNSCoreMachineSleep waking: NextSRVUpdate in %d %d", m
->NextSRVUpdate
- m
->timenow
, m
->timenow
);
5304 // 2. Re-validate our cache records
5305 FORALL_CACHERECORDS(slot
, cg
, cr
)
5306 mDNS_Reconfirm_internal(m
, cr
, kDefaultReconfirmTimeForWake
);
5308 // 3. Retrigger probing and announcing for all our authoritative records
5309 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
5310 if (AuthRecord_uDNS(rr
))
5312 ActivateUnicastRegistration(m
, rr
);
5316 if (rr
->resrec
.RecordType
== kDNSRecordTypeVerified
&& !rr
->DependentOn
) rr
->resrec
.RecordType
= kDNSRecordTypeUnique
;
5317 rr
->ProbeCount
= DefaultProbeCountForRecordType(rr
->resrec
.RecordType
);
5318 rr
->AnnounceCount
= InitialAnnounceCount
;
5319 rr
->SendNSECNow
= mDNSNULL
;
5320 InitializeLastAPTime(m
, rr
);
5323 // 4. Refresh NAT mappings
5324 // We don't want to have to assume that all hardware can necessarily keep accurate
5325 // track of passage of time while asleep, so on wake we refresh our NAT mappings
5326 // We typically wake up with no interfaces active, so there's no need to rush to try to find our external address.
5327 // When we get a network configuration change, mDNSMacOSXNetworkChanged calls uDNS_SetupDNSConfig, which calls
5328 // mDNS_SetPrimaryInterfaceInfo, which then sets m->retryGetAddr to immediately request our external address from the NAT gateway.
5329 m
->retryIntervalGetAddr
= NATMAP_INIT_RETRY
;
5330 m
->retryGetAddr
= m
->timenow
+ mDNSPlatformOneSecond
* 5;
5331 LogInfo("mDNSCoreMachineSleep: retryGetAddr in %d %d", m
->retryGetAddr
- m
->timenow
, m
->timenow
);
5332 RecreateNATMappings(m
);
5337 mDNSexport mDNSBool
mDNSCoreReadyForSleep(mDNS
*m
, mDNSs32 now
)
5341 NetworkInterfaceInfo
*intf
;
5345 if (m
->DelaySleep
) goto notready
;
5347 // If we've not hit the sleep limit time, and it's not time for our next retry, we can skip these checks
5348 if (m
->SleepLimit
- now
> 0 && m
->NextScheduledSPRetry
- now
> 0) goto notready
;
5350 m
->NextScheduledSPRetry
= now
+ 0x40000000UL
;
5352 // See if we might need to retransmit any lost Sleep Proxy Registrations
5353 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5354 if (intf
->NextSPSAttempt
>= 0)
5356 if (now
- intf
->NextSPSAttemptTime
>= 0)
5358 LogSPS("mDNSCoreReadyForSleep: retrying for %s SPS %d try %d",
5359 intf
->ifname
, intf
->NextSPSAttempt
/3, intf
->NextSPSAttempt
);
5360 SendSPSRegistration(m
, intf
, zeroID
);
5361 // Don't need to "goto notready" here, because if we do still have record registrations
5362 // that have not been acknowledged yet, we'll catch that in the record list scan below.
5365 if (m
->NextScheduledSPRetry
- intf
->NextSPSAttemptTime
> 0)
5366 m
->NextScheduledSPRetry
= intf
->NextSPSAttemptTime
;
5369 // Scan list of interfaces, and see if we're still waiting for any sleep proxy resolves to complete
5370 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5372 int sps
= (intf
->NextSPSAttempt
== 0) ? 0 : (intf
->NextSPSAttempt
-1)/3;
5373 if (intf
->NetWakeResolve
[sps
].ThisQInterval
>= 0)
5375 LogSPS("mDNSCoreReadyForSleep: waiting for SPS Resolve %s %##s (%s)",
5376 intf
->ifname
, intf
->NetWakeResolve
[sps
].qname
.c
, DNSTypeName(intf
->NetWakeResolve
[sps
].qtype
));
5381 // Scan list of registered records
5382 for (rr
= m
->ResourceRecords
; rr
; rr
= rr
->next
)
5383 if (!AuthRecord_uDNS(rr
))
5384 if (!mDNSOpaque16IsZero(rr
->updateid
))
5385 { LogSPS("mDNSCoreReadyForSleep: waiting for SPS Update ID %d %s", mDNSVal16(rr
->updateid
), ARDisplayString(m
,rr
)); goto spsnotready
; }
5387 // Scan list of private LLQs, and make sure they've all completed their handshake with the server
5388 for (q
= m
->Questions
; q
; q
= q
->next
)
5389 if (!mDNSOpaque16IsZero(q
->TargetQID
) && q
->LongLived
&& q
->ReqLease
== 0 && q
->tcp
)
5391 LogSPS("mDNSCoreReadyForSleep: waiting for LLQ %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
5395 // Scan list of registered records
5396 for (rr
= m
->ResourceRecords
; rr
; rr
= rr
->next
)
5397 if (AuthRecord_uDNS(rr
))
5399 if (rr
->state
== regState_Refresh
&& rr
->tcp
)
5400 { LogSPS("mDNSCoreReadyForSleep: waiting for Record Update ID %d %s", mDNSVal16(rr
->updateid
), ARDisplayString(m
,rr
)); goto notready
; }
5401 #if APPLE_OSX_mDNSResponder
5402 if (!RecordReadyForSleep(m
, rr
)) { LogSPS("mDNSCoreReadyForSleep: waiting for %s", ARDisplayString(m
, rr
)); goto notready
; }
5411 // If we failed to complete sleep proxy registration within ten seconds, we give up on that
5412 // and allow up to ten seconds more to complete wide-area deregistration instead
5413 if (now
- m
->SleepLimit
>= 0)
5415 LogMsg("Failed to register with SPS, now sending goodbyes");
5417 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
5418 if (intf
->NetWakeBrowse
.ThisQInterval
>= 0)
5420 LogSPS("ReadyForSleep mDNS_DeactivateNetWake %s %##s (%s)",
5421 intf
->ifname
, intf
->NetWakeResolve
[0].qname
.c
, DNSTypeName(intf
->NetWakeResolve
[0].qtype
));
5422 mDNS_DeactivateNetWake_internal(m
, intf
);
5425 for (rr
= m
->ResourceRecords
; rr
; rr
= rr
->next
)
5426 if (!AuthRecord_uDNS(rr
))
5427 if (!mDNSOpaque16IsZero(rr
->updateid
))
5429 LogSPS("ReadyForSleep clearing updateid for %s", ARDisplayString(m
, rr
));
5430 rr
->updateid
= zeroID
;
5433 // We'd really like to allow up to ten seconds more here,
5434 // but if we don't respond to the sleep notification within 30 seconds
5435 // we'll be put back to sleep forcibly without the chance to schedule the next maintenance wake.
5436 // Right now we wait 16 sec after wake for all the interfaces to come up, then we wait up to 10 seconds
5437 // more for SPS resolves and record registrations to complete, which puts us at 26 seconds.
5438 // If we allow just one more second to send our goodbyes, that puts us at 27 seconds.
5439 m
->SleepLimit
= now
+ mDNSPlatformOneSecond
* 1;
5441 SendSleepGoodbyes(m
);
5449 mDNSexport mDNSs32
mDNSCoreIntervalToNextWake(mDNS
*const m
, mDNSs32 now
)
5453 // Even when we have no wake-on-LAN-capable interfaces, or we failed to find a sleep proxy, or we have other
5454 // failure scenarios, we still want to wake up in at most 120 minutes, to see if the network environment has changed.
5455 // E.g. we might wake up and find no wireless network because the base station got rebooted just at that moment,
5456 // and if that happens we don't want to just give up and go back to sleep and never try again.
5457 mDNSs32 e
= now
+ (120 * 60 * mDNSPlatformOneSecond
); // Sleep for at most 120 minutes
5459 NATTraversalInfo
*nat
;
5460 for (nat
= m
->NATTraversals
; nat
; nat
=nat
->next
)
5461 if (nat
->Protocol
&& nat
->ExpiryTime
&& nat
->ExpiryTime
- now
> mDNSPlatformOneSecond
*4)
5463 mDNSs32 t
= nat
->ExpiryTime
- (nat
->ExpiryTime
- now
) / 10; // Wake up when 90% of the way to the expiry time
5464 if (e
- t
> 0) e
= t
;
5465 LogSPS("ComputeWakeTime: %p %s Int %5d Ext %5d Err %d Retry %5d Interval %5d Expire %5d Wake %5d",
5466 nat
, nat
->Protocol
== NATOp_MapTCP
? "TCP" : "UDP",
5467 mDNSVal16(nat
->IntPort
), mDNSVal16(nat
->ExternalPort
), nat
->Result
,
5468 nat
->retryPortMap
? (nat
->retryPortMap
- now
) / mDNSPlatformOneSecond
: 0,
5469 nat
->retryInterval
/ mDNSPlatformOneSecond
,
5470 nat
->ExpiryTime
? (nat
->ExpiryTime
- now
) / mDNSPlatformOneSecond
: 0,
5471 (t
- now
) / mDNSPlatformOneSecond
);
5474 // This loop checks both the time we need to renew wide-area registrations,
5475 // and the time we need to renew Sleep Proxy registrations
5476 for (ar
= m
->ResourceRecords
; ar
; ar
= ar
->next
)
5477 if (ar
->expire
&& ar
->expire
- now
> mDNSPlatformOneSecond
*4)
5479 mDNSs32 t
= ar
->expire
- (ar
->expire
- now
) / 10; // Wake up when 90% of the way to the expiry time
5480 if (e
- t
> 0) e
= t
;
5481 LogSPS("ComputeWakeTime: %p Int %7d Next %7d Expire %7d Wake %7d %s",
5482 ar
, ar
->ThisAPInterval
/ mDNSPlatformOneSecond
,
5483 (ar
->LastAPTime
+ ar
->ThisAPInterval
- now
) / mDNSPlatformOneSecond
,
5484 ar
->expire
? (ar
->expire
- now
) / mDNSPlatformOneSecond
: 0,
5485 (t
- now
) / mDNSPlatformOneSecond
, ARDisplayString(m
, ar
));
5491 // ***************************************************************************
5492 #if COMPILER_LIKES_PRAGMA_MARK
5494 #pragma mark - Packet Reception Functions
5497 #define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo)
5499 mDNSlocal mDNSu8
*GenerateUnicastResponse(const DNSMessage
*const query
, const mDNSu8
*const end
,
5500 const mDNSInterfaceID InterfaceID
, mDNSBool LegacyQuery
, DNSMessage
*const response
, AuthRecord
*ResponseRecords
)
5502 mDNSu8
*responseptr
= response
->data
;
5503 const mDNSu8
*const limit
= response
->data
+ sizeof(response
->data
);
5504 const mDNSu8
*ptr
= query
->data
;
5506 mDNSu32 maxttl
= 0x70000000;
5509 // Initialize the response fields so we can answer the questions
5510 InitializeDNSMessage(&response
->h
, query
->h
.id
, ResponseFlags
);
5513 // *** 1. Write out the list of questions we are actually going to answer with this packet
5517 maxttl
= kStaticCacheTTL
;
5518 for (i
=0; i
<query
->h
.numQuestions
; i
++) // For each question...
5521 ptr
= getQuestion(query
, ptr
, end
, InterfaceID
, &q
); // get the question...
5522 if (!ptr
) return(mDNSNULL
);
5524 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
) // and search our list of proposed answers
5526 if (rr
->NR_AnswerTo
== ptr
) // If we're going to generate a record answering this question
5527 { // then put the question in the question section
5528 responseptr
= putQuestion(response
, responseptr
, limit
, &q
.qname
, q
.qtype
, q
.qclass
);
5529 if (!responseptr
) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL
); }
5530 break; // break out of the ResponseRecords loop, and go on to the next question
5535 if (response
->h
.numQuestions
== 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL
); }
5539 // *** 2. Write Answers
5541 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
)
5542 if (rr
->NR_AnswerTo
)
5544 mDNSu8
*p
= PutResourceRecordTTL(response
, responseptr
, &response
->h
.numAnswers
, &rr
->resrec
,
5545 maxttl
< rr
->resrec
.rroriginalttl
? maxttl
: rr
->resrec
.rroriginalttl
);
5546 if (p
) responseptr
= p
;
5547 else { debugf("GenerateUnicastResponse: Ran out of space for answers!"); response
->h
.flags
.b
[0] |= kDNSFlag0_TC
; }
5551 // *** 3. Write Additionals
5553 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
)
5554 if (rr
->NR_AdditionalTo
&& !rr
->NR_AnswerTo
)
5556 mDNSu8
*p
= PutResourceRecordTTL(response
, responseptr
, &response
->h
.numAdditionals
, &rr
->resrec
,
5557 maxttl
< rr
->resrec
.rroriginalttl
? maxttl
: rr
->resrec
.rroriginalttl
);
5558 if (p
) responseptr
= p
;
5559 else debugf("GenerateUnicastResponse: No more space for additionals");
5562 return(responseptr
);
5565 // AuthRecord *our is our Resource Record
5566 // CacheRecord *pkt is the Resource Record from the response packet we've witnessed on the network
5567 // Returns 0 if there is no conflict
5568 // Returns +1 if there was a conflict and we won
5569 // Returns -1 if there was a conflict and we lost and have to rename
5570 mDNSlocal
int CompareRData(const AuthRecord
*const our
, const CacheRecord
*const pkt
)
5572 mDNSu8 ourdata
[256], *ourptr
= ourdata
, *ourend
;
5573 mDNSu8 pktdata
[256], *pktptr
= pktdata
, *pktend
;
5574 if (!our
) { LogMsg("CompareRData ERROR: our is NULL"); return(+1); }
5575 if (!pkt
) { LogMsg("CompareRData ERROR: pkt is NULL"); return(+1); }
5577 ourend
= putRData(mDNSNULL
, ourdata
, ourdata
+ sizeof(ourdata
), &our
->resrec
);
5578 pktend
= putRData(mDNSNULL
, pktdata
, pktdata
+ sizeof(pktdata
), &pkt
->resrec
);
5579 while (ourptr
< ourend
&& pktptr
< pktend
&& *ourptr
== *pktptr
) { ourptr
++; pktptr
++; }
5580 if (ourptr
>= ourend
&& pktptr
>= pktend
) return(0); // If data identical, not a conflict
5582 if (ourptr
>= ourend
) return(-1); // Our data ran out first; We lost
5583 if (pktptr
>= pktend
) return(+1); // Packet data ran out first; We won
5584 if (*pktptr
> *ourptr
) return(-1); // Our data is numerically lower; We lost
5585 if (*pktptr
< *ourptr
) return(+1); // Packet data is numerically lower; We won
5587 LogMsg("CompareRData ERROR: Invalid state");
5591 // See if we have an authoritative record that's identical to this packet record,
5592 // whose canonical DependentOn record is the specified master record.
5593 // The DependentOn pointer is typically used for the TXT record of service registrations
5594 // It indicates that there is no inherent conflict detection for the TXT record
5595 // -- it depends on the SRV record to resolve name conflicts
5596 // If we find any identical ResourceRecords in our authoritative list, then follow their DependentOn
5597 // pointer chain (if any) to make sure we reach the canonical DependentOn record
5598 // If the record has no DependentOn, then just return that record's pointer
5599 // Returns NULL if we don't have any local RRs that are identical to the one from the packet
5600 mDNSlocal mDNSBool
MatchDependentOn(const mDNS
*const m
, const CacheRecord
*const pktrr
, const AuthRecord
*const master
)
5602 const AuthRecord
*r1
;
5603 for (r1
= m
->ResourceRecords
; r1
; r1
=r1
->next
)
5605 if (IdenticalResourceRecord(&r1
->resrec
, &pktrr
->resrec
))
5607 const AuthRecord
*r2
= r1
;
5608 while (r2
->DependentOn
) r2
= r2
->DependentOn
;
5609 if (r2
== master
) return(mDNStrue
);
5612 for (r1
= m
->DuplicateRecords
; r1
; r1
=r1
->next
)
5614 if (IdenticalResourceRecord(&r1
->resrec
, &pktrr
->resrec
))
5616 const AuthRecord
*r2
= r1
;
5617 while (r2
->DependentOn
) r2
= r2
->DependentOn
;
5618 if (r2
== master
) return(mDNStrue
);
5624 // Find the canonical RRSet pointer for this RR received in a packet.
5625 // If we find any identical AuthRecord in our authoritative list, then follow its RRSet
5626 // pointers (if any) to make sure we return the canonical member of this name/type/class
5627 // Returns NULL if we don't have any local RRs that are identical to the one from the packet
5628 mDNSlocal
const AuthRecord
*FindRRSet(const mDNS
*const m
, const CacheRecord
*const pktrr
)
5630 const AuthRecord
*rr
;
5631 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
5633 if (IdenticalResourceRecord(&rr
->resrec
, &pktrr
->resrec
))
5635 while (rr
->RRSet
&& rr
!= rr
->RRSet
) rr
= rr
->RRSet
;
5642 // PacketRRConflict is called when we've received an RR (pktrr) which has the same name
5643 // as one of our records (our) but different rdata.
5644 // 1. If our record is not a type that's supposed to be unique, we don't care.
5645 // 2a. If our record is marked as dependent on some other record for conflict detection, ignore this one.
5646 // 2b. If the packet rr exactly matches one of our other RRs, and *that* record's DependentOn pointer
5647 // points to our record, ignore this conflict (e.g. the packet record matches one of our
5648 // TXT records, and that record is marked as dependent on 'our', its SRV record).
5649 // 3. If we have some *other* RR that exactly matches the one from the packet, and that record and our record
5650 // are members of the same RRSet, then this is not a conflict.
5651 mDNSlocal mDNSBool
PacketRRConflict(const mDNS
*const m
, const AuthRecord
*const our
, const CacheRecord
*const pktrr
)
5653 // If not supposed to be unique, not a conflict
5654 if (!(our
->resrec
.RecordType
& kDNSRecordTypeUniqueMask
)) return(mDNSfalse
);
5656 // If a dependent record, not a conflict
5657 if (our
->DependentOn
|| MatchDependentOn(m
, pktrr
, our
)) return(mDNSfalse
);
5660 // If the pktrr matches a member of ourset, not a conflict
5661 const AuthRecord
*ourset
= our
->RRSet
? our
->RRSet
: our
;
5662 const AuthRecord
*pktset
= FindRRSet(m
, pktrr
);
5663 if (pktset
== ourset
) return(mDNSfalse
);
5665 // For records we're proxying, where we don't know the full
5666 // relationship between the records, having any matching record
5667 // in our AuthRecords list is sufficient evidence of non-conflict
5668 if (our
->WakeUp
.HMAC
.l
[0] && pktset
) return(mDNSfalse
);
5671 // Okay, this is a conflict
5675 // Note: ResolveSimultaneousProbe calls mDNS_Deregister_internal which can call a user callback, which may change
5676 // the record list and/or question list.
5677 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
5678 mDNSlocal
void ResolveSimultaneousProbe(mDNS
*const m
, const DNSMessage
*const query
, const mDNSu8
*const end
,
5679 DNSQuestion
*q
, AuthRecord
*our
)
5682 const mDNSu8
*ptr
= LocateAuthorities(query
, end
);
5683 mDNSBool FoundUpdate
= mDNSfalse
;
5685 for (i
= 0; i
< query
->h
.numAuthorities
; i
++)
5687 ptr
= GetLargeResourceRecord(m
, query
, ptr
, end
, q
->InterfaceID
, kDNSRecordTypePacketAuth
, &m
->rec
);
5689 if (m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
&& ResourceRecordAnswersQuestion(&m
->rec
.r
.resrec
, q
))
5691 FoundUpdate
= mDNStrue
;
5692 if (PacketRRConflict(m
, our
, &m
->rec
.r
))
5694 int result
= (int)our
->resrec
.rrclass
- (int)m
->rec
.r
.resrec
.rrclass
;
5695 if (!result
) result
= (int)our
->resrec
.rrtype
- (int)m
->rec
.r
.resrec
.rrtype
;
5696 if (!result
) result
= CompareRData(our
, &m
->rec
.r
);
5699 const char *const msg
= (result
< 0) ? "lost:" : (result
> 0) ? "won: " : "tie: ";
5700 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q
->InterfaceID
, m
->rec
.r
.resrec
.rdatahash
, CRDisplayString(m
, &m
->rec
.r
));
5701 LogMsg("ResolveSimultaneousProbe: %p Our Record %d %s %08lX %s", our
->resrec
.InterfaceID
, our
->ProbeCount
, msg
, our
->resrec
.rdatahash
, ARDisplayString(m
, our
));
5703 // If we lost the tie-break for simultaneous probes, we don't immediately give up, because we might be seeing stale packets on the network.
5704 // Instead we pause for one second, to give the other host (if real) a chance to establish its name, and then try probing again.
5705 // If there really is another live host out there with the same name, it will answer our probes and we'll then rename.
5708 m
->SuppressProbes
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
);
5709 our
->ProbeCount
= DefaultProbeCountForTypeUnique
;
5710 our
->AnnounceCount
= InitialAnnounceCount
;
5711 InitializeLastAPTime(m
, our
);
5718 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q
->InterfaceID
, m
->rec
.r
.resrec
.rdatahash
, CRDisplayString(m
, &m
->rec
.r
));
5719 LogMsg("ResolveSimultaneousProbe: %p Our Record %d ign: %08lX %s", our
->resrec
.InterfaceID
, our
->ProbeCount
, our
->resrec
.rdatahash
, ARDisplayString(m
, our
));
5723 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
5726 LogInfo("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our
->resrec
.name
->c
, DNSTypeName(our
->resrec
.rrtype
));
5728 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
5731 mDNSlocal CacheRecord
*FindIdenticalRecordInCache(const mDNS
*const m
, const ResourceRecord
*const pktrr
)
5733 mDNSu32 slot
= HashSlot(pktrr
->name
);
5734 CacheGroup
*cg
= CacheGroupForRecord(m
, slot
, pktrr
);
5737 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
5739 match
= !pktrr
->InterfaceID
? pktrr
->rDNSServer
== rr
->resrec
.rDNSServer
: pktrr
->InterfaceID
== rr
->resrec
.InterfaceID
;
5740 if (match
&& IdenticalSameNameRecord(pktrr
, &rr
->resrec
)) break;
5745 // Called from mDNSCoreReceiveUpdate when we get a sleep proxy registration request,
5746 // to check our lists and discard any stale duplicates of this record we already have
5747 mDNSlocal
void ClearIdenticalProxyRecords(mDNS
*const m
, const OwnerOptData
*const owner
, AuthRecord
*const thelist
)
5749 if (m
->CurrentRecord
)
5750 LogMsg("ClearIdenticalProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
5751 m
->CurrentRecord
= thelist
;
5752 while (m
->CurrentRecord
)
5754 AuthRecord
*const rr
= m
->CurrentRecord
;
5755 if (m
->rec
.r
.resrec
.InterfaceID
== rr
->resrec
.InterfaceID
&& mDNSSameEthAddress(&owner
->HMAC
, &rr
->WakeUp
.HMAC
))
5756 if (IdenticalResourceRecord(&rr
->resrec
, &m
->rec
.r
.resrec
))
5758 LogSPS("ClearIdenticalProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s",
5759 m
->ProxyRecords
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, rr
->WakeUp
.seq
, owner
->seq
, ARDisplayString(m
, rr
));
5760 rr
->WakeUp
.HMAC
= zeroEthAddr
; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host
5761 rr
->RequireGoodbye
= mDNSfalse
; // and we don't want to send goodbye for it
5762 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
5763 SetSPSProxyListChanged(m
->rec
.r
.resrec
.InterfaceID
);
5765 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
5766 // new records could have been added to the end of the list as a result of that call.
5767 if (m
->CurrentRecord
== rr
) // If m->CurrentRecord was not advanced for us, do it now
5768 m
->CurrentRecord
= rr
->next
;
5772 // Called from ProcessQuery when we get an mDNS packet with an owner record in it
5773 mDNSlocal
void ClearProxyRecords(mDNS
*const m
, const OwnerOptData
*const owner
, AuthRecord
*const thelist
)
5775 if (m
->CurrentRecord
)
5776 LogMsg("ClearProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
5777 m
->CurrentRecord
= thelist
;
5778 while (m
->CurrentRecord
)
5780 AuthRecord
*const rr
= m
->CurrentRecord
;
5781 if (m
->rec
.r
.resrec
.InterfaceID
== rr
->resrec
.InterfaceID
&& mDNSSameEthAddress(&owner
->HMAC
, &rr
->WakeUp
.HMAC
))
5782 if (owner
->seq
!= rr
->WakeUp
.seq
|| m
->timenow
- rr
->TimeRcvd
> mDNSPlatformOneSecond
* 60)
5784 if (rr
->AddressProxy
.type
== mDNSAddrType_IPv6
)
5786 // We don't do this here because we know that the host is waking up at this point, so we don't send
5787 // Unsolicited Neighbor Advertisements -- even Neighbor Advertisements agreeing with what the host should be
5788 // saying itself -- because it can cause some IPv6 stacks to falsely conclude that there's an address conflict.
5789 #if MDNS_USE_Unsolicited_Neighbor_Advertisements
5790 LogSPS("NDP Announcement -- Releasing traffic for H-MAC %.6a I-MAC %.6a %s",
5791 &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
,rr
));
5792 SendNDP(m
, NDP_Adv
, NDP_Override
, rr
, &rr
->AddressProxy
.ip
.v6
, &rr
->WakeUp
.IMAC
, &AllHosts_v6
, &AllHosts_v6_Eth
);
5795 LogSPS("ClearProxyRecords: Removing %3d AC %2d %02X H-MAC %.6a I-MAC %.6a %d %d %s",
5796 m
->ProxyRecords
, rr
->AnnounceCount
, rr
->resrec
.RecordType
,
5797 &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, rr
->WakeUp
.seq
, owner
->seq
, ARDisplayString(m
, rr
));
5798 if (rr
->resrec
.RecordType
== kDNSRecordTypeDeregistering
) rr
->resrec
.RecordType
= kDNSRecordTypeShared
;
5799 rr
->WakeUp
.HMAC
= zeroEthAddr
; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host
5800 rr
->RequireGoodbye
= mDNSfalse
; // and we don't want to send goodbye for it, since real host is now back and functional
5801 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
5802 SetSPSProxyListChanged(m
->rec
.r
.resrec
.InterfaceID
);
5804 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
5805 // new records could have been added to the end of the list as a result of that call.
5806 if (m
->CurrentRecord
== rr
) // If m->CurrentRecord was not advanced for us, do it now
5807 m
->CurrentRecord
= rr
->next
;
5811 // ProcessQuery examines a received query to see if we have any answers to give
5812 mDNSlocal mDNSu8
*ProcessQuery(mDNS
*const m
, const DNSMessage
*const query
, const mDNSu8
*const end
,
5813 const mDNSAddr
*srcaddr
, const mDNSInterfaceID InterfaceID
, mDNSBool LegacyQuery
, mDNSBool QueryWasMulticast
,
5814 mDNSBool QueryWasLocalUnicast
, DNSMessage
*const response
)
5816 mDNSBool FromLocalSubnet
= srcaddr
&& mDNS_AddressIsLocalSubnet(m
, InterfaceID
, srcaddr
);
5817 AuthRecord
*ResponseRecords
= mDNSNULL
;
5818 AuthRecord
**nrp
= &ResponseRecords
;
5819 CacheRecord
*ExpectedAnswers
= mDNSNULL
; // Records in our cache we expect to see updated
5820 CacheRecord
**eap
= &ExpectedAnswers
;
5821 DNSQuestion
*DupQuestions
= mDNSNULL
; // Our questions that are identical to questions in this packet
5822 DNSQuestion
**dqp
= &DupQuestions
;
5823 mDNSs32 delayresponse
= 0;
5824 mDNSBool SendLegacyResponse
= mDNSfalse
;
5826 mDNSu8
*responseptr
= mDNSNULL
;
5831 // *** 1. Look in Additional Section for an OPT record
5833 ptr
= LocateOptRR(query
, end
, DNSOpt_OwnerData_ID_Space
);
5836 ptr
= GetLargeResourceRecord(m
, query
, ptr
, end
, InterfaceID
, kDNSRecordTypePacketAdd
, &m
->rec
);
5837 if (ptr
&& m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
&& m
->rec
.r
.resrec
.rrtype
== kDNSType_OPT
)
5839 const rdataOPT
*opt
;
5840 const rdataOPT
*const e
= (const rdataOPT
*)&m
->rec
.r
.resrec
.rdata
->u
.data
[m
->rec
.r
.resrec
.rdlength
];
5841 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently
5842 // delete all our own AuthRecords (which are identified by having zero MAC tags on them).
5843 for (opt
= &m
->rec
.r
.resrec
.rdata
->u
.opt
[0]; opt
< e
; opt
++)
5844 if (opt
->opt
== kDNSOpt_Owner
&& opt
->u
.owner
.vers
== 0 && opt
->u
.owner
.HMAC
.l
[0])
5846 ClearProxyRecords(m
, &opt
->u
.owner
, m
->DuplicateRecords
);
5847 ClearProxyRecords(m
, &opt
->u
.owner
, m
->ResourceRecords
);
5850 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
5854 // *** 2. Parse Question Section and mark potential answers
5857 for (i
=0; i
<query
->h
.numQuestions
; i
++) // For each question...
5859 mDNSBool QuestionNeedsMulticastResponse
;
5860 int NumAnswersForThisQuestion
= 0;
5861 AuthRecord
*NSECAnswer
= mDNSNULL
;
5862 DNSQuestion pktq
, *q
;
5863 ptr
= getQuestion(query
, ptr
, end
, InterfaceID
, &pktq
); // get the question...
5864 if (!ptr
) goto exit
;
5866 // The only queries that *need* a multicast response are:
5867 // * Queries sent via multicast
5869 // * that don't have the kDNSQClass_UnicastResponse bit set
5870 // These queries need multicast responses because other clients will:
5871 // * suppress their own identical questions when they see these questions, and
5872 // * expire their cache records if they don't see the expected responses
5873 // For other queries, we may still choose to send the occasional multicast response anyway,
5874 // to keep our neighbours caches warm, and for ongoing conflict detection.
5875 QuestionNeedsMulticastResponse
= QueryWasMulticast
&& !LegacyQuery
&& !(pktq
.qclass
& kDNSQClass_UnicastResponse
);
5876 // Clear the UnicastResponse flag -- don't want to confuse the rest of the code that follows later
5877 pktq
.qclass
&= ~kDNSQClass_UnicastResponse
;
5879 // Note: We use the m->CurrentRecord mechanism here because calling ResolveSimultaneousProbe
5880 // can result in user callbacks which may change the record list and/or question list.
5881 // Also note: we just mark potential answer records here, without trying to build the
5882 // "ResponseRecords" list, because we don't want to risk user callbacks deleting records
5883 // from that list while we're in the middle of trying to build it.
5884 if (m
->CurrentRecord
)
5885 LogMsg("ProcessQuery ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
5886 m
->CurrentRecord
= m
->ResourceRecords
;
5887 while (m
->CurrentRecord
)
5889 rr
= m
->CurrentRecord
;
5890 m
->CurrentRecord
= rr
->next
;
5891 if (AnyTypeRecordAnswersQuestion(&rr
->resrec
, &pktq
) && (QueryWasMulticast
|| QueryWasLocalUnicast
|| rr
->AllowRemoteQuery
))
5893 if (RRTypeAnswersQuestionType(&rr
->resrec
, pktq
.qtype
))
5895 if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
)
5896 ResolveSimultaneousProbe(m
, query
, end
, &pktq
, rr
);
5897 else if (ResourceRecordIsValidAnswer(rr
))
5899 NumAnswersForThisQuestion
++;
5900 // Note: We should check here if this is a probe-type query, and if so, generate an immediate
5901 // unicast answer back to the source, because timeliness in answering probes is important.
5904 // NR_AnswerTo pointing into query packet means "answer via immediate legacy unicast" (may *also* choose to multicast)
5905 // NR_AnswerTo == (mDNSu8*)~1 means "answer via delayed unicast" (to modern querier; may promote to multicast instead)
5906 // NR_AnswerTo == (mDNSu8*)~0 means "definitely answer via multicast" (can't downgrade to unicast later)
5907 // If we're not multicasting this record because the kDNSQClass_UnicastResponse bit was set,
5908 // but the multicast querier is not on a matching subnet (e.g. because of overlaid subnets on one link)
5909 // then we'll multicast it anyway (if we unicast, the receiver will ignore it because it has an apparently non-local source)
5910 if (QuestionNeedsMulticastResponse
|| (!FromLocalSubnet
&& QueryWasMulticast
&& !LegacyQuery
))
5912 // We only mark this question for sending if it is at least one second since the last time we multicast it
5913 // on this interface. If it is more than a second, or LastMCInterface is different, then we may multicast it.
5914 // This is to guard against the case where someone blasts us with queries as fast as they can.
5915 if (m
->timenow
- (rr
->LastMCTime
+ mDNSPlatformOneSecond
) >= 0 ||
5916 (rr
->LastMCInterface
!= mDNSInterfaceMark
&& rr
->LastMCInterface
!= InterfaceID
))
5917 rr
->NR_AnswerTo
= (mDNSu8
*)~0;
5919 else if (!rr
->NR_AnswerTo
) rr
->NR_AnswerTo
= LegacyQuery
? ptr
: (mDNSu8
*)~1;
5922 else if ((rr
->resrec
.RecordType
& kDNSRecordTypeActiveUniqueMask
) && ResourceRecordIsValidAnswer(rr
))
5924 // If we don't have any answers for this question, but we do own another record with the same name,
5925 // then we'll want to mark it to generate an NSEC record on this interface
5926 if (!NSECAnswer
) NSECAnswer
= rr
;
5931 if (NumAnswersForThisQuestion
== 0 && NSECAnswer
)
5933 NumAnswersForThisQuestion
++;
5934 NSECAnswer
->SendNSECNow
= InterfaceID
;
5935 m
->NextScheduledResponse
= m
->timenow
;
5938 // If we couldn't answer this question, someone else might be able to,
5939 // so use random delay on response to reduce collisions
5940 if (NumAnswersForThisQuestion
== 0) delayresponse
= mDNSPlatformOneSecond
; // Divided by 50 = 20ms
5942 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
5943 if (QuestionNeedsMulticastResponse
)
5945 // We only do the following accelerated cache expiration and duplicate question suppression processing
5946 // for non-truncated multicast queries with multicast responses.
5947 // For any query generating a unicast response we don't do this because we can't assume we will see the response.
5948 // For truncated queries we don't do this because a response we're expecting might be suppressed by a subsequent
5949 // known-answer packet, and when there's packet loss we can't safely assume we'll receive *all* known-answer packets.
5950 if (QuestionNeedsMulticastResponse
&& !(query
->h
.flags
.b
[0] & kDNSFlag0_TC
))
5953 const mDNSu32 slot
= HashSlot(&pktq
.qname
);
5954 CacheGroup
*cg
= CacheGroupForName(m
, slot
, pktq
.qnamehash
, &pktq
.qname
);
5957 // Make a list indicating which of our own cache records we expect to see updated as a result of this query
5958 // Note: Records larger than 1K are not habitually multicast, so don't expect those to be updated
5959 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
5960 if (!(query
->h
.flags
.b
[0] & kDNSFlag0_TC
))
5962 for (cr
= cg
? cg
->members
: mDNSNULL
; cr
; cr
=cr
->next
)
5963 if (SameNameRecordAnswersQuestion(&cr
->resrec
, &pktq
) && cr
->resrec
.rdlength
<= SmallRecordLimit
)
5964 if (!cr
->NextInKAList
&& eap
!= &cr
->NextInKAList
)
5967 eap
= &cr
->NextInKAList
;
5968 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
5969 if (cr
->MPUnansweredQ
== 0 || m
->timenow
- cr
->MPLastUnansweredQT
>= mDNSPlatformOneSecond
)
5971 // Although MPUnansweredQ is only really used for multi-packet query processing,
5972 // we increment it for both single-packet and multi-packet queries, so that it stays in sync
5973 // with the MPUnansweredKA value, which by necessity is incremented for both query types.
5974 cr
->MPUnansweredQ
++;
5975 cr
->MPLastUnansweredQT
= m
->timenow
;
5976 cr
->MPExpectingKA
= mDNStrue
;
5981 // Check if this question is the same as any of mine.
5982 // We only do this for non-truncated queries. Right now it would be too complicated to try
5983 // to keep track of duplicate suppression state between multiple packets, especially when we
5984 // can't guarantee to receive all of the Known Answer packets that go with a particular query.
5985 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
5986 if (!(query
->h
.flags
.b
[0] & kDNSFlag0_TC
))
5988 for (q
= m
->Questions
; q
; q
=q
->next
)
5989 if (!q
->Target
.type
&& ActiveQuestion(q
) && m
->timenow
- q
->LastQTxTime
> mDNSPlatformOneSecond
/ 4)
5990 if (!q
->InterfaceID
|| q
->InterfaceID
== InterfaceID
)
5991 if (q
->NextInDQList
== mDNSNULL
&& dqp
!= &q
->NextInDQList
)
5992 if (q
->qtype
== pktq
.qtype
&&
5993 q
->qclass
== pktq
.qclass
&&
5994 q
->qnamehash
== pktq
.qnamehash
&& SameDomainName(&q
->qname
, &pktq
.qname
))
5995 { *dqp
= q
; dqp
= &q
->NextInDQList
; }
6000 // *** 3. Now we can safely build the list of marked answers
6002 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
) // Now build our list of potential answers
6003 if (rr
->NR_AnswerTo
) // If we marked the record...
6004 AddRecordToResponseList(&nrp
, rr
, mDNSNULL
); // ... add it to the list
6007 // *** 4. Add additional records
6009 AddAdditionalsToResponseList(m
, ResponseRecords
, &nrp
, InterfaceID
);
6012 // *** 5. Parse Answer Section and cancel any records disallowed by Known-Answer list
6014 for (i
=0; i
<query
->h
.numAnswers
; i
++) // For each record in the query's answer section...
6016 // Get the record...
6017 CacheRecord
*ourcacherr
;
6018 ptr
= GetLargeResourceRecord(m
, query
, ptr
, end
, InterfaceID
, kDNSRecordTypePacketAns
, &m
->rec
);
6019 if (!ptr
) goto exit
;
6020 if (m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
)
6022 // See if this Known-Answer suppresses any of our currently planned answers
6023 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
)
6024 if (MustSendRecord(rr
) && ShouldSuppressKnownAnswer(&m
->rec
.r
, rr
))
6025 { rr
->NR_AnswerTo
= mDNSNULL
; rr
->NR_AdditionalTo
= mDNSNULL
; }
6027 // See if this Known-Answer suppresses any previously scheduled answers (for multi-packet KA suppression)
6028 for (rr
=m
->ResourceRecords
; rr
; rr
=rr
->next
)
6030 // If we're planning to send this answer on this interface, and only on this interface, then allow KA suppression
6031 if (rr
->ImmedAnswer
== InterfaceID
&& ShouldSuppressKnownAnswer(&m
->rec
.r
, rr
))
6033 if (srcaddr
->type
== mDNSAddrType_IPv4
)
6035 if (mDNSSameIPv4Address(rr
->v4Requester
, srcaddr
->ip
.v4
)) rr
->v4Requester
= zerov4Addr
;
6037 else if (srcaddr
->type
== mDNSAddrType_IPv6
)
6039 if (mDNSSameIPv6Address(rr
->v6Requester
, srcaddr
->ip
.v6
)) rr
->v6Requester
= zerov6Addr
;
6041 if (mDNSIPv4AddressIsZero(rr
->v4Requester
) && mDNSIPv6AddressIsZero(rr
->v6Requester
))
6043 rr
->ImmedAnswer
= mDNSNULL
;
6044 rr
->ImmedUnicast
= mDNSfalse
;
6045 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
6046 LogMsg("Suppressed after%4d: %s", m
->timenow
- rr
->ImmedAnswerMarkTime
, ARDisplayString(m
, rr
));
6052 ourcacherr
= FindIdenticalRecordInCache(m
, &m
->rec
.r
.resrec
);
6054 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
6055 // See if this Known-Answer suppresses any answers we were expecting for our cache records. We do this always,
6056 // even if the TC bit is not set (the TC bit will *not* be set in the *last* packet of a multi-packet KA list).
6057 if (ourcacherr
&& ourcacherr
->MPExpectingKA
&& m
->timenow
- ourcacherr
->MPLastUnansweredQT
< mDNSPlatformOneSecond
)
6059 ourcacherr
->MPUnansweredKA
++;
6060 ourcacherr
->MPExpectingKA
= mDNSfalse
;
6064 // Having built our ExpectedAnswers list from the questions in this packet, we then remove
6065 // any records that are suppressed by the Known Answer list in this packet.
6066 eap
= &ExpectedAnswers
;
6069 CacheRecord
*cr
= *eap
;
6070 if (cr
->resrec
.InterfaceID
== InterfaceID
&& IdenticalResourceRecord(&m
->rec
.r
.resrec
, &cr
->resrec
))
6071 { *eap
= cr
->NextInKAList
; cr
->NextInKAList
= mDNSNULL
; }
6072 else eap
= &cr
->NextInKAList
;
6075 // See if this Known-Answer is a surprise to us. If so, we shouldn't suppress our own query.
6078 dqp
= &DupQuestions
;
6081 DNSQuestion
*q
= *dqp
;
6082 if (ResourceRecordAnswersQuestion(&m
->rec
.r
.resrec
, q
))
6083 { *dqp
= q
->NextInDQList
; q
->NextInDQList
= mDNSNULL
; }
6084 else dqp
= &q
->NextInDQList
;
6088 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
6092 // *** 6. Cancel any additionals that were added because of now-deleted records
6094 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
)
6095 if (rr
->NR_AdditionalTo
&& !MustSendRecord(rr
->NR_AdditionalTo
))
6096 { rr
->NR_AnswerTo
= mDNSNULL
; rr
->NR_AdditionalTo
= mDNSNULL
; }
6099 // *** 7. Mark the send flags on the records we plan to send
6101 for (rr
=ResponseRecords
; rr
; rr
=rr
->NextResponse
)
6103 if (rr
->NR_AnswerTo
)
6105 mDNSBool SendMulticastResponse
= mDNSfalse
; // Send modern multicast response
6106 mDNSBool SendUnicastResponse
= mDNSfalse
; // Send modern unicast response (not legacy unicast response)
6108 // If it's been a while since we multicast this, then send a multicast response for conflict detection, etc.
6109 if (m
->timenow
- (rr
->LastMCTime
+ TicksTTL(rr
)/4) >= 0)
6111 SendMulticastResponse
= mDNStrue
;
6112 // If this record was marked for modern (delayed) unicast response, then mark it as promoted to
6113 // multicast response instead (don't want to end up ALSO setting SendUnicastResponse in the check below).
6114 // If this record was marked for legacy unicast response, then we mustn't change the NR_AnswerTo value.
6115 if (rr
->NR_AnswerTo
== (mDNSu8
*)~1) rr
->NR_AnswerTo
= (mDNSu8
*)~0;
6118 // If the client insists on a multicast response, then we'd better send one
6119 if (rr
->NR_AnswerTo
== (mDNSu8
*)~0) SendMulticastResponse
= mDNStrue
;
6120 else if (rr
->NR_AnswerTo
== (mDNSu8
*)~1) SendUnicastResponse
= mDNStrue
;
6121 else if (rr
->NR_AnswerTo
) SendLegacyResponse
= mDNStrue
;
6123 if (SendMulticastResponse
|| SendUnicastResponse
)
6125 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
6126 rr
->ImmedAnswerMarkTime
= m
->timenow
;
6128 m
->NextScheduledResponse
= m
->timenow
;
6129 // If we're already planning to send this on another interface, just send it on all interfaces
6130 if (rr
->ImmedAnswer
&& rr
->ImmedAnswer
!= InterfaceID
)
6131 rr
->ImmedAnswer
= mDNSInterfaceMark
;
6134 rr
->ImmedAnswer
= InterfaceID
; // Record interface to send it on
6135 if (SendUnicastResponse
) rr
->ImmedUnicast
= mDNStrue
;
6136 if (srcaddr
->type
== mDNSAddrType_IPv4
)
6138 if (mDNSIPv4AddressIsZero(rr
->v4Requester
)) rr
->v4Requester
= srcaddr
->ip
.v4
;
6139 else if (!mDNSSameIPv4Address(rr
->v4Requester
, srcaddr
->ip
.v4
)) rr
->v4Requester
= onesIPv4Addr
;
6141 else if (srcaddr
->type
== mDNSAddrType_IPv6
)
6143 if (mDNSIPv6AddressIsZero(rr
->v6Requester
)) rr
->v6Requester
= srcaddr
->ip
.v6
;
6144 else if (!mDNSSameIPv6Address(rr
->v6Requester
, srcaddr
->ip
.v6
)) rr
->v6Requester
= onesIPv6Addr
;
6148 // If TC flag is set, it means we should expect that additional known answers may be coming in another packet,
6149 // so we allow roughly half a second before deciding to reply (we've observed inter-packet delays of 100-200ms on 802.11)
6150 // else, if record is a shared one, spread responses over 100ms to avoid implosion of simultaneous responses
6151 // else, for a simple unique record reply, we can reply immediately; no need for delay
6152 if (query
->h
.flags
.b
[0] & kDNSFlag0_TC
) delayresponse
= mDNSPlatformOneSecond
* 20; // Divided by 50 = 400ms
6153 else if (rr
->resrec
.RecordType
== kDNSRecordTypeShared
) delayresponse
= mDNSPlatformOneSecond
; // Divided by 50 = 20ms
6155 else if (rr
->NR_AdditionalTo
&& rr
->NR_AdditionalTo
->NR_AnswerTo
== (mDNSu8
*)~0)
6157 // Since additional records are an optimization anyway, we only ever send them on one interface at a time
6158 // If two clients on different interfaces do queries that invoke the same optional additional answer,
6159 // then the earlier client is out of luck
6160 rr
->ImmedAdditional
= InterfaceID
;
6161 // No need to set m->NextScheduledResponse here
6162 // We'll send these additional records when we send them, or not, as the case may be
6167 // *** 8. If we think other machines are likely to answer these questions, set our packet suppression timer
6169 if (delayresponse
&& (!m
->SuppressSending
|| (m
->SuppressSending
- m
->timenow
) < (delayresponse
+ 49) / 50))
6171 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
6172 mDNSs32 oldss
= m
->SuppressSending
;
6173 if (oldss
&& delayresponse
)
6174 LogMsg("Current SuppressSending delay%5ld; require%5ld", m
->SuppressSending
- m
->timenow
, (delayresponse
+ 49) / 50);
6176 // Pick a random delay:
6177 // We start with the base delay chosen above (typically either 1 second or 20 seconds),
6178 // and add a random value in the range 0-5 seconds (making 1-6 seconds or 20-25 seconds).
6179 // This is an integer value, with resolution determined by the platform clock rate.
6180 // We then divide that by 50 to get the delay value in ticks. We defer the division until last
6181 // to get better results on platforms with coarse clock granularity (e.g. ten ticks per second).
6182 // The +49 before dividing is to ensure we round up, not down, to ensure that even
6183 // on platforms where the native clock rate is less than fifty ticks per second,
6184 // we still guarantee that the final calculated delay is at least one platform tick.
6185 // We want to make sure we don't ever allow the delay to be zero ticks,
6186 // because if that happens we'll fail the Bonjour Conformance Test.
6187 // Our final computed delay is 20-120ms for normal delayed replies,
6188 // or 400-500ms in the case of multi-packet known-answer lists.
6189 m
->SuppressSending
= m
->timenow
+ (delayresponse
+ (mDNSs32
)mDNSRandom((mDNSu32
)mDNSPlatformOneSecond
*5) + 49) / 50;
6190 if (m
->SuppressSending
== 0) m
->SuppressSending
= 1;
6191 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
6192 if (oldss
&& delayresponse
)
6193 LogMsg("Set SuppressSending to %5ld", m
->SuppressSending
- m
->timenow
);
6198 // *** 9. If query is from a legacy client, or from a new client requesting a unicast reply, then generate a unicast response too
6200 if (SendLegacyResponse
)
6201 responseptr
= GenerateUnicastResponse(query
, end
, InterfaceID
, LegacyQuery
, response
, ResponseRecords
);
6204 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
6207 // *** 10. Finally, clear our link chains ready for use next time
6209 while (ResponseRecords
)
6211 rr
= ResponseRecords
;
6212 ResponseRecords
= rr
->NextResponse
;
6213 rr
->NextResponse
= mDNSNULL
;
6214 rr
->NR_AnswerTo
= mDNSNULL
;
6215 rr
->NR_AdditionalTo
= mDNSNULL
;
6218 while (ExpectedAnswers
)
6220 CacheRecord
*cr
= ExpectedAnswers
;
6221 ExpectedAnswers
= cr
->NextInKAList
;
6222 cr
->NextInKAList
= mDNSNULL
;
6224 // For non-truncated queries, we can definitively say that we should expect
6225 // to be seeing a response for any records still left in the ExpectedAnswers list
6226 if (!(query
->h
.flags
.b
[0] & kDNSFlag0_TC
))
6227 if (cr
->UnansweredQueries
== 0 || m
->timenow
- cr
->LastUnansweredTime
>= mDNSPlatformOneSecond
)
6229 cr
->UnansweredQueries
++;
6230 cr
->LastUnansweredTime
= m
->timenow
;
6231 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
6232 if (cr
->UnansweredQueries
> 1)
6233 debugf("ProcessQuery: (!TC) UAQ %lu MPQ %lu MPKA %lu %s",
6234 cr
->UnansweredQueries
, cr
->MPUnansweredQ
, cr
->MPUnansweredKA
, CRDisplayString(m
, cr
));
6236 SetNextCacheCheckTimeForRecord(m
, cr
);
6239 // If we've seen multiple unanswered queries for this record,
6240 // then mark it to expire in five seconds if we don't get a response by then.
6241 if (cr
->UnansweredQueries
>= MaxUnansweredQueries
)
6243 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
6244 // Only show debugging message if this record was not about to expire anyway
6245 if (RRExpireTime(cr
) - m
->timenow
> 4 * mDNSPlatformOneSecond
)
6246 debugf("ProcessQuery: (Max) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
6247 cr
->UnansweredQueries
, cr
->MPUnansweredQ
, cr
->MPUnansweredKA
, CRDisplayString(m
, cr
));
6249 mDNS_Reconfirm_internal(m
, cr
, kDefaultReconfirmTimeForNoAnswer
);
6251 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
6252 // Make a guess, based on the multi-packet query / known answer counts, whether we think we
6253 // should have seen an answer for this. (We multiply MPQ by 4 and MPKA by 5, to allow for
6254 // possible packet loss of up to 20% of the additional KA packets.)
6255 else if (cr
->MPUnansweredQ
* 4 > cr
->MPUnansweredKA
* 5 + 8)
6257 // We want to do this conservatively.
6258 // If there are so many machines on the network that they have to use multi-packet known-answer lists,
6259 // then we don't want them to all hit the network simultaneously with their final expiration queries.
6260 // By setting the record to expire in four minutes, we achieve two things:
6261 // (a) the 90-95% final expiration queries will be less bunched together
6262 // (b) we allow some time for us to witness enough other failed queries that we don't have to do our own
6263 mDNSu32 remain
= (mDNSu32
)(RRExpireTime(cr
) - m
->timenow
) / 4;
6264 if (remain
> 240 * (mDNSu32
)mDNSPlatformOneSecond
)
6265 remain
= 240 * (mDNSu32
)mDNSPlatformOneSecond
;
6267 // Only show debugging message if this record was not about to expire anyway
6268 if (RRExpireTime(cr
) - m
->timenow
> 4 * mDNSPlatformOneSecond
)
6269 debugf("ProcessQuery: (MPQ) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
6270 cr
->UnansweredQueries
, cr
->MPUnansweredQ
, cr
->MPUnansweredKA
, CRDisplayString(m
, cr
));
6272 if (remain
<= 60 * (mDNSu32
)mDNSPlatformOneSecond
)
6273 cr
->UnansweredQueries
++; // Treat this as equivalent to one definite unanswered query
6274 cr
->MPUnansweredQ
= 0; // Clear MPQ/MPKA statistics
6275 cr
->MPUnansweredKA
= 0;
6276 cr
->MPExpectingKA
= mDNSfalse
;
6278 if (remain
< kDefaultReconfirmTimeForNoAnswer
)
6279 remain
= kDefaultReconfirmTimeForNoAnswer
;
6280 mDNS_Reconfirm_internal(m
, cr
, remain
);
6285 while (DupQuestions
)
6287 DNSQuestion
*q
= DupQuestions
;
6288 DupQuestions
= q
->NextInDQList
;
6289 q
->NextInDQList
= mDNSNULL
;
6290 i
= RecordDupSuppressInfo(q
->DupSuppress
, m
->timenow
, InterfaceID
, srcaddr
->type
);
6291 debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s %d", q
->qname
.c
, DNSTypeName(q
->qtype
), InterfaceID
,
6292 srcaddr
->type
== mDNSAddrType_IPv4
? "v4" : "v6", i
);
6295 return(responseptr
);
6298 mDNSlocal
void mDNSCoreReceiveQuery(mDNS
*const m
, const DNSMessage
*const msg
, const mDNSu8
*const end
,
6299 const mDNSAddr
*srcaddr
, const mDNSIPPort srcport
, const mDNSAddr
*dstaddr
, mDNSIPPort dstport
,
6300 const mDNSInterfaceID InterfaceID
)
6302 mDNSu8
*responseend
= mDNSNULL
;
6303 mDNSBool QueryWasLocalUnicast
= srcaddr
&& dstaddr
&&
6304 !mDNSAddrIsDNSMulticast(dstaddr
) && mDNS_AddressIsLocalSubnet(m
, InterfaceID
, srcaddr
);
6306 if (!InterfaceID
&& dstaddr
&& mDNSAddrIsDNSMulticast(dstaddr
))
6308 LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
6309 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes (Multicast, but no InterfaceID)",
6310 srcaddr
, mDNSVal16(srcport
), dstaddr
, mDNSVal16(dstport
), InterfaceID
,
6311 msg
->h
.numQuestions
, msg
->h
.numQuestions
== 1 ? ", " : "s,",
6312 msg
->h
.numAnswers
, msg
->h
.numAnswers
== 1 ? ", " : "s,",
6313 msg
->h
.numAuthorities
, msg
->h
.numAuthorities
== 1 ? "y, " : "ies,",
6314 msg
->h
.numAdditionals
, msg
->h
.numAdditionals
== 1 ? " " : "s", end
- msg
->data
);
6318 verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
6319 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes",
6320 srcaddr
, mDNSVal16(srcport
), dstaddr
, mDNSVal16(dstport
), InterfaceID
,
6321 msg
->h
.numQuestions
, msg
->h
.numQuestions
== 1 ? ", " : "s,",
6322 msg
->h
.numAnswers
, msg
->h
.numAnswers
== 1 ? ", " : "s,",
6323 msg
->h
.numAuthorities
, msg
->h
.numAuthorities
== 1 ? "y, " : "ies,",
6324 msg
->h
.numAdditionals
, msg
->h
.numAdditionals
== 1 ? " " : "s", end
- msg
->data
);
6326 responseend
= ProcessQuery(m
, msg
, end
, srcaddr
, InterfaceID
,
6327 !mDNSSameIPPort(srcport
, MulticastDNSPort
), mDNSAddrIsDNSMulticast(dstaddr
), QueryWasLocalUnicast
, &m
->omsg
);
6329 if (responseend
) // If responseend is non-null, that means we built a unicast response packet
6331 debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
6332 m
->omsg
.h
.numQuestions
, m
->omsg
.h
.numQuestions
== 1 ? "" : "s",
6333 m
->omsg
.h
.numAnswers
, m
->omsg
.h
.numAnswers
== 1 ? "" : "s",
6334 m
->omsg
.h
.numAdditionals
, m
->omsg
.h
.numAdditionals
== 1 ? "" : "s",
6335 srcaddr
, mDNSVal16(srcport
), InterfaceID
, srcaddr
->type
);
6336 mDNSSendDNSMessage(m
, &m
->omsg
, responseend
, InterfaceID
, mDNSNULL
, srcaddr
, srcport
, mDNSNULL
, mDNSNULL
);
6341 mDNSlocal mDNSBool
TrustedSource(const mDNS
*const m
, const mDNSAddr
*const srcaddr
)
6345 (void)srcaddr
; // Unused
6346 for (s
= m
->DNSServers
; s
; s
= s
->next
)
6347 if (mDNSSameAddress(srcaddr
, &s
->addr
)) return(mDNStrue
);
6352 struct UDPSocket_struct
6354 mDNSIPPort port
; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port
6357 mDNSlocal DNSQuestion
*ExpectingUnicastResponseForQuestion(const mDNS
*const m
, const mDNSIPPort port
, const mDNSOpaque16 id
, const DNSQuestion
*const question
, mDNSBool tcp
)
6360 for (q
= m
->Questions
; q
; q
=q
->next
)
6362 if (!tcp
&& !q
->LocalSocket
) continue;
6363 if (mDNSSameIPPort(tcp
? q
->tcpSrcPort
: q
->LocalSocket
->port
, port
) &&
6364 mDNSSameOpaque16(q
->TargetQID
, id
) &&
6365 q
->qtype
== question
->qtype
&&
6366 q
->qclass
== question
->qclass
&&
6367 q
->qnamehash
== question
->qnamehash
&&
6368 SameDomainName(&q
->qname
, &question
->qname
))
6374 // This function is called when we receive a unicast response. This could be the case of a unicast response from the
6375 // DNS server or a response to the QU query. Hence, the cache record's InterfaceId can be both NULL or non-NULL (QU case)
6376 mDNSlocal DNSQuestion
*ExpectingUnicastResponseForRecord(mDNS
*const m
,
6377 const mDNSAddr
*const srcaddr
, const mDNSBool SrcLocal
, const mDNSIPPort port
, const mDNSOpaque16 id
, const CacheRecord
*const rr
, mDNSBool tcp
)
6383 for (q
= m
->Questions
; q
; q
=q
->next
)
6385 if (!q
->DuplicateOf
&& ResourceRecordAnswersUnicastResponse(&rr
->resrec
, q
))
6387 if (!mDNSOpaque16IsZero(q
->TargetQID
))
6389 debugf("ExpectingUnicastResponseForRecord msg->h.id %d q->TargetQID %d for %s", mDNSVal16(id
), mDNSVal16(q
->TargetQID
), CRDisplayString(m
, rr
));
6391 if (mDNSSameOpaque16(q
->TargetQID
, id
))
6396 srcp
= q
->LocalSocket
? q
->LocalSocket
->port
: zeroIPPort
;
6400 srcp
= q
->tcpSrcPort
;
6402 if (mDNSSameIPPort(srcp
, port
)) return(q
);
6404 // if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue);
6405 // if (q->LongLived && mDNSSameAddress(srcaddr, &q->servAddr)) return(mDNStrue); Shouldn't need this now that we have LLQType checking
6406 // if (TrustedSource(m, srcaddr)) return(mDNStrue);
6407 LogInfo("WARNING: Ignoring suspect uDNS response for %##s (%s) [q->Target %#a:%d] from %#a:%d %s",
6408 q
->qname
.c
, DNSTypeName(q
->qtype
), &q
->Target
, mDNSVal16(srcp
), srcaddr
, mDNSVal16(port
), CRDisplayString(m
, rr
));
6414 if (SrcLocal
&& q
->ExpectUnicastResp
&& (mDNSu32
)(m
->timenow
- q
->ExpectUnicastResp
) < (mDNSu32
)(mDNSPlatformOneSecond
*2))
6422 // Certain data types need more space for in-memory storage than their in-packet rdlength would imply
6423 // Currently this applies only to rdata types containing more than one domainname,
6424 // or types where the domainname is not the last item in the structure.
6425 // In addition, NSEC currently requires less space for in-memory storage than its in-packet representation.
6426 mDNSlocal mDNSu16
GetRDLengthMem(const ResourceRecord
*const rr
)
6430 case kDNSType_SOA
: return sizeof(rdataSOA
);
6431 case kDNSType_RP
: return sizeof(rdataRP
);
6432 case kDNSType_PX
: return sizeof(rdataPX
);
6433 case kDNSType_NSEC
:return sizeof(rdataNSEC
);
6434 default: return rr
->rdlength
;
6438 mDNSexport CacheRecord
*CreateNewCacheEntry(mDNS
*const m
, const mDNSu32 slot
, CacheGroup
*cg
, mDNSs32 delay
)
6440 CacheRecord
*rr
= mDNSNULL
;
6441 mDNSu16 RDLength
= GetRDLengthMem(&m
->rec
.r
.resrec
);
6443 if (!m
->rec
.r
.resrec
.InterfaceID
) debugf("CreateNewCacheEntry %s", CRDisplayString(m
, &m
->rec
.r
));
6445 //if (RDLength > InlineCacheRDSize)
6446 // LogInfo("Rdata len %4d > InlineCacheRDSize %d %s", RDLength, InlineCacheRDSize, CRDisplayString(m, &m->rec.r));
6448 if (!cg
) cg
= GetCacheGroup(m
, slot
, &m
->rec
.r
.resrec
); // If we don't have a CacheGroup for this name, make one now
6449 if (cg
) rr
= GetCacheRecord(m
, cg
, RDLength
); // Make a cache record, being careful not to recycle cg
6450 if (!rr
) NoCacheAnswer(m
, &m
->rec
.r
);
6453 RData
*saveptr
= rr
->resrec
.rdata
; // Save the rr->resrec.rdata pointer
6454 *rr
= m
->rec
.r
; // Block copy the CacheRecord object
6455 rr
->resrec
.rdata
= saveptr
; // Restore rr->resrec.rdata after the structure assignment
6456 rr
->resrec
.name
= cg
->name
; // And set rr->resrec.name to point into our CacheGroup header
6457 rr
->DelayDelivery
= delay
;
6459 // If this is an oversized record with external storage allocated, copy rdata to external storage
6460 if (rr
->resrec
.rdata
== (RData
*)&rr
->smallrdatastorage
&& RDLength
> InlineCacheRDSize
)
6461 LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s", m
->rec
.r
.resrec
.name
->c
);
6462 else if (rr
->resrec
.rdata
!= (RData
*)&rr
->smallrdatastorage
&& RDLength
<= InlineCacheRDSize
)
6463 LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s", m
->rec
.r
.resrec
.name
->c
);
6464 if (RDLength
> InlineCacheRDSize
)
6465 mDNSPlatformMemCopy(rr
->resrec
.rdata
, m
->rec
.r
.resrec
.rdata
, sizeofRDataHeader
+ RDLength
);
6467 rr
->next
= mDNSNULL
; // Clear 'next' pointer
6468 *(cg
->rrcache_tail
) = rr
; // Append this record to tail of cache slot list
6469 cg
->rrcache_tail
= &(rr
->next
); // Advance tail pointer
6471 CacheRecordAdd(m
, rr
); // CacheRecordAdd calls SetNextCacheCheckTimeForRecord(m, rr); for us
6476 mDNSlocal
void RefreshCacheRecord(mDNS
*const m
, CacheRecord
*rr
, mDNSu32 ttl
)
6478 rr
->TimeRcvd
= m
->timenow
;
6479 rr
->resrec
.rroriginalttl
= ttl
;
6480 rr
->UnansweredQueries
= 0;
6481 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
6482 rr
->MPUnansweredQ
= 0;
6483 rr
->MPUnansweredKA
= 0;
6484 rr
->MPExpectingKA
= mDNSfalse
;
6486 SetNextCacheCheckTimeForRecord(m
, rr
);
6489 mDNSexport
void GrantCacheExtensions(mDNS
*const m
, DNSQuestion
*q
, mDNSu32 lease
)
6492 const mDNSu32 slot
= HashSlot(&q
->qname
);
6493 CacheGroup
*cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
6494 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
6495 if (rr
->CRActiveQuestion
== q
)
6497 //LogInfo("GrantCacheExtensions: new lease %d / %s", lease, CRDisplayString(m, rr));
6498 RefreshCacheRecord(m
, rr
, lease
);
6502 mDNSlocal mDNSu32
GetEffectiveTTL(const uDNS_LLQType LLQType
, mDNSu32 ttl
) // TTL in seconds
6504 if (LLQType
== uDNS_LLQ_Entire
) ttl
= kLLQ_DefLease
;
6505 else if (LLQType
== uDNS_LLQ_Events
)
6507 // If the TTL is -1 for uDNS LLQ event packet, that means "remove"
6508 if (ttl
== 0xFFFFFFFF) ttl
= 0;
6509 else ttl
= kLLQ_DefLease
;
6511 else // else not LLQ (standard uDNS response)
6513 // The TTL is already capped to a maximum value in GetLargeResourceRecord, but just to be extra safe we
6514 // also do this check here to make sure we can't get overflow below when we add a quarter to the TTL
6515 if (ttl
> 0x60000000UL
/ mDNSPlatformOneSecond
) ttl
= 0x60000000UL
/ mDNSPlatformOneSecond
;
6517 // Adjustment factor to avoid race condition:
6518 // Suppose real record as TTL of 3600, and our local caching server has held it for 3500 seconds, so it returns an aged TTL of 100.
6519 // If we do our normal refresh at 80% of the TTL, our local caching server will return 20 seconds, so we'll do another
6520 // 80% refresh after 16 seconds, and then the server will return 4 seconds, and so on, in the fashion of Zeno's paradox.
6521 // To avoid this, we extend the record's effective TTL to give it a little extra grace period.
6522 // We adjust the 100 second TTL to 126. This means that when we do our 80% query at 101 seconds,
6523 // the cached copy at our local caching server will already have expired, so the server will be forced
6524 // to fetch a fresh copy from the authoritative server, and then return a fresh record with the full TTL of 3600 seconds.
6527 // For mDNS, TTL zero means "delete this record"
6528 // For uDNS, TTL zero means: this data is true at this moment, but don't cache it.
6529 // For the sake of network efficiency, we impose a minimum effective TTL of 15 seconds.
6530 // This means that we'll do our 80, 85, 90, 95% queries at 12.00, 12.75, 13.50, 14.25 seconds
6531 // respectively, and then if we get no response, delete the record from the cache at 15 seconds.
6532 // This gives the server up to three seconds to respond between when we send our 80% query at 12 seconds
6533 // and when we delete the record at 15 seconds. Allowing cache lifetimes less than 15 seconds would
6534 // (with the current code) result in the server having even less than three seconds to respond
6535 // before we deleted the record and reported a "remove" event to any active questions.
6536 // Furthermore, with the current code, if we were to allow a TTL of less than 2 seconds
6537 // then things really break (e.g. we end up making a negative cache entry).
6538 // In the future we may want to revisit this and consider properly supporting non-cached (TTL=0) uDNS answers.
6539 if (ttl
< 15) ttl
= 15;
6545 mDNSlocal mDNSBool
mDNSCoreRegisteredProxyRecord(mDNS
*const m
, AuthRecord
*rr
)
6547 NetworkInterfaceInfo
*intf
= m
->HostInterfaces
;
6548 AuthRecord
*rrPtr
= mDNSNULL
;
6552 rrPtr
= intf
->SPSRRSet
;
6555 if (SameResourceRecordSignature(rrPtr
, rr
))
6557 LogSPS("mDNSCoreRegisteredProxyRecord: Ignoring packet registered with sleep proxy : %s ", ARDisplayString(m
, rr
));
6560 rrPtr
= rrPtr
->next
;
6567 // Note: mDNSCoreReceiveResponse calls mDNS_Deregister_internal which can call a user callback, which may change
6568 // the record list and/or question list.
6569 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
6570 // InterfaceID non-NULL tells us the interface this multicast response was received on
6571 // InterfaceID NULL tells us this was a unicast response
6572 // dstaddr NULL tells us we received this over an outgoing TCP connection we made
6573 mDNSlocal
void mDNSCoreReceiveResponse(mDNS
*const m
,
6574 const DNSMessage
*const response
, const mDNSu8
*end
,
6575 const mDNSAddr
*srcaddr
, const mDNSIPPort srcport
, const mDNSAddr
*dstaddr
, mDNSIPPort dstport
,
6576 const mDNSInterfaceID InterfaceID
)
6579 mDNSBool ResponseMCast
= dstaddr
&& mDNSAddrIsDNSMulticast(dstaddr
);
6580 mDNSBool ResponseSrcLocal
= !srcaddr
|| mDNS_AddressIsLocalSubnet(m
, InterfaceID
, srcaddr
);
6581 DNSQuestion
*llqMatch
= mDNSNULL
;
6582 uDNS_LLQType LLQType
= uDNS_recvLLQResponse(m
, response
, end
, srcaddr
, srcport
, &llqMatch
);
6584 // "(CacheRecord*)1" is a special (non-zero) end-of-list marker
6585 // We use this non-zero marker so that records in our CacheFlushRecords list will always have NextInCFList
6586 // set non-zero, and that tells GetCacheEntity() that they're not, at this moment, eligible for recycling.
6587 CacheRecord
*CacheFlushRecords
= (CacheRecord
*)1;
6588 CacheRecord
**cfp
= &CacheFlushRecords
;
6590 // All records in a DNS response packet are treated as equally valid statements of truth. If we want
6591 // to guard against spoof responses, then the only credible protection against that is cryptographic
6592 // security, e.g. DNSSEC., not worring about which section in the spoof packet contained the record
6593 int firstauthority
= response
->h
.numAnswers
;
6594 int firstadditional
= firstauthority
+ response
->h
.numAuthorities
;
6595 int totalrecords
= firstadditional
+ response
->h
.numAdditionals
;
6596 const mDNSu8
*ptr
= response
->data
;
6597 DNSServer
*uDNSServer
= mDNSNULL
;
6599 debugf("Received Response from %#-15a addressed to %#-15a on %p with "
6600 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes LLQType %d",
6601 srcaddr
, dstaddr
, InterfaceID
,
6602 response
->h
.numQuestions
, response
->h
.numQuestions
== 1 ? ", " : "s,",
6603 response
->h
.numAnswers
, response
->h
.numAnswers
== 1 ? ", " : "s,",
6604 response
->h
.numAuthorities
, response
->h
.numAuthorities
== 1 ? "y, " : "ies,",
6605 response
->h
.numAdditionals
, response
->h
.numAdditionals
== 1 ? " " : "s", end
- response
->data
, LLQType
);
6607 // According to RFC 2181 <http://www.ietf.org/rfc/rfc2181.txt>
6608 // When a DNS client receives a reply with TC
6609 // set, it should ignore that response, and query again, using a
6610 // mechanism, such as a TCP connection, that will permit larger replies.
6611 // It feels wrong to be throwing away data after the network went to all the trouble of delivering it to us, but
6612 // delivering some records of the RRSet first and then the remainder a couple of milliseconds later was causing
6613 // failures in our Microsoft Active Directory client, which expects to get the entire set of answers at once.
6614 // <rdar://problem/6690034> Can't bind to Active Directory
6615 // In addition, if the client immediately canceled its query after getting the initial partial response, then we'll
6616 // abort our TCP connection, and not complete the operation, and end up with an incomplete RRSet in our cache.
6617 // Next time there's a query for this RRSet we'll see answers in our cache, and assume we have the whole RRSet already,
6618 // and not even do the TCP query.
6619 // Accordingly, if we get a uDNS reply with kDNSFlag0_TC set, we bail out and wait for the TCP response containing the entire RRSet.
6620 if (!InterfaceID
&& (response
->h
.flags
.b
[0] & kDNSFlag0_TC
)) return;
6622 if (LLQType
== uDNS_LLQ_Ignore
) return;
6624 // 1. We ignore questions (if any) in mDNS response packets
6625 // 2. If this is an LLQ response, we handle it much the same
6626 // 3. If we get a uDNS UDP response with the TC (truncated) bit set, then we can't treat this
6627 // answer as being the authoritative complete RRSet, and respond by deleting all other
6628 // matching cache records that don't appear in this packet.
6629 // Otherwise, this is a authoritative uDNS answer, so arrange for any stale records to be purged
6630 if (ResponseMCast
|| LLQType
== uDNS_LLQ_Events
|| (response
->h
.flags
.b
[0] & kDNSFlag0_TC
))
6631 ptr
= LocateAnswers(response
, end
);
6632 // Otherwise, for one-shot queries, any answers in our cache that are not also contained
6633 // in this response packet are immediately deemed to be invalid.
6636 mDNSu8 rcode
= (mDNSu8
)(response
->h
.flags
.b
[1] & kDNSFlag1_RC_Mask
);
6637 mDNSBool failure
= !(rcode
== kDNSFlag1_RC_NoErr
|| rcode
== kDNSFlag1_RC_NXDomain
|| rcode
== kDNSFlag1_RC_NotAuth
);
6638 mDNSBool returnEarly
= mDNSfalse
;
6639 // We could possibly combine this with the similar loop at the end of this function --
6640 // instead of tagging cache records here and then rescuing them if we find them in the answer section,
6641 // we could instead use the "m->PktNum" mechanism to tag each cache record with the packet number in
6642 // which it was received (or refreshed), and then at the end if we find any cache records which
6643 // answer questions in this packet's question section, but which aren't tagged with this packet's
6644 // packet number, then we deduce they are old and delete them
6645 for (i
= 0; i
< response
->h
.numQuestions
&& ptr
&& ptr
< end
; i
++)
6647 DNSQuestion q
, *qptr
= mDNSNULL
;
6648 ptr
= getQuestion(response
, ptr
, end
, InterfaceID
, &q
);
6649 if (ptr
&& (qptr
= ExpectingUnicastResponseForQuestion(m
, dstport
, response
->h
.id
, &q
, !dstaddr
)))
6654 const mDNSu32 slot
= HashSlot(&q
.qname
);
6655 CacheGroup
*cg
= CacheGroupForName(m
, slot
, q
.qnamehash
, &q
.qname
);
6656 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
6657 if (SameNameRecordAnswersQuestion(&rr
->resrec
, qptr
))
6659 debugf("uDNS marking %p %##s (%s) %p %s", q
.InterfaceID
, q
.qname
.c
, DNSTypeName(q
.qtype
),
6660 rr
->resrec
.InterfaceID
, CRDisplayString(m
, rr
));
6661 // Don't want to disturb rroriginalttl here, because code below might need it for the exponential backoff doubling algorithm
6662 rr
->TimeRcvd
= m
->timenow
- TicksTTL(rr
) - 1;
6663 rr
->UnansweredQueries
= MaxUnansweredQueries
;
6670 LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to query %##s (%s)", qptr
->qDNSServer
, rcode
, q
.qname
.c
, DNSTypeName(q
.qtype
));
6671 PenalizeDNSServer(m
, qptr
);
6673 returnEarly
= mDNStrue
;
6679 LogInfo("Ignoring %2d Answer%s %2d Authorit%s %2d Additional%s",
6680 response
->h
.numAnswers
, response
->h
.numAnswers
== 1 ? ", " : "s,",
6681 response
->h
.numAuthorities
, response
->h
.numAuthorities
== 1 ? "y, " : "ies,",
6682 response
->h
.numAdditionals
, response
->h
.numAdditionals
== 1 ? "" : "s");
6683 // not goto exit because we won't have any CacheFlushRecords and we do not want to
6684 // generate negative cache entries (we want to query the next server)
6689 for (i
= 0; i
< totalrecords
&& ptr
&& ptr
< end
; i
++)
6691 // All responses sent via LL multicast are acceptable for caching
6692 // All responses received over our outbound TCP connections are acceptable for caching
6693 mDNSBool AcceptableResponse
= ResponseMCast
|| !dstaddr
|| LLQType
;
6694 // (Note that just because we are willing to cache something, that doesn't necessarily make it a trustworthy answer
6695 // to any specific question -- any code reading records from the cache needs to make that determination for itself.)
6697 const mDNSu8 RecordType
=
6698 (i
< firstauthority
) ? (mDNSu8
)kDNSRecordTypePacketAns
:
6699 (i
< firstadditional
) ? (mDNSu8
)kDNSRecordTypePacketAuth
: (mDNSu8
)kDNSRecordTypePacketAdd
;
6700 ptr
= GetLargeResourceRecord(m
, response
, ptr
, end
, InterfaceID
, RecordType
, &m
->rec
);
6701 if (!ptr
) goto exit
; // Break out of the loop and clean up our CacheFlushRecords list before exiting
6702 if (m
->rec
.r
.resrec
.RecordType
== kDNSRecordTypePacketNegative
) { m
->rec
.r
.resrec
.RecordType
= 0; continue; }
6704 // Don't want to cache OPT or TSIG pseudo-RRs
6705 if (m
->rec
.r
.resrec
.rrtype
== kDNSType_TSIG
) { m
->rec
.r
.resrec
.RecordType
= 0; continue; }
6706 if (m
->rec
.r
.resrec
.rrtype
== kDNSType_OPT
)
6708 const rdataOPT
*opt
;
6709 const rdataOPT
*const e
= (const rdataOPT
*)&m
->rec
.r
.resrec
.rdata
->u
.data
[m
->rec
.r
.resrec
.rdlength
];
6710 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently
6711 // delete all our own AuthRecords (which are identified by having zero MAC tags on them).
6712 for (opt
= &m
->rec
.r
.resrec
.rdata
->u
.opt
[0]; opt
< e
; opt
++)
6713 if (opt
->opt
== kDNSOpt_Owner
&& opt
->u
.owner
.vers
== 0 && opt
->u
.owner
.HMAC
.l
[0])
6715 ClearProxyRecords(m
, &opt
->u
.owner
, m
->DuplicateRecords
);
6716 ClearProxyRecords(m
, &opt
->u
.owner
, m
->ResourceRecords
);
6718 m
->rec
.r
.resrec
.RecordType
= 0;
6722 // if a CNAME record points to itself, then don't add it to the cache
6723 if ((m
->rec
.r
.resrec
.rrtype
== kDNSType_CNAME
) && SameDomainName(m
->rec
.r
.resrec
.name
, &m
->rec
.r
.resrec
.rdata
->u
.name
))
6725 LogInfo("mDNSCoreReceiveResponse: CNAME loop domain name %##s", m
->rec
.r
.resrec
.name
->c
);
6726 m
->rec
.r
.resrec
.RecordType
= 0;
6730 // When we receive uDNS LLQ responses, we assume a long cache lifetime --
6731 // In the case of active LLQs, we'll get remove events when the records actually do go away
6732 // In the case of polling LLQs, we assume the record remains valid until the next poll
6733 if (!mDNSOpaque16IsZero(response
->h
.id
))
6734 m
->rec
.r
.resrec
.rroriginalttl
= GetEffectiveTTL(LLQType
, m
->rec
.r
.resrec
.rroriginalttl
);
6736 // If response was not sent via LL multicast,
6737 // then see if it answers a recent query of ours, which would also make it acceptable for caching.
6742 // For Long Lived queries that are both sent over UDP and Private TCP, LLQType is set.
6743 // Even though it is AcceptableResponse, we need a matching DNSServer pointer for the
6744 // queries to get ADD/RMV events. To lookup the question, we can't use
6745 // ExpectingUnicastResponseForRecord as the port numbers don't match. uDNS_recvLLQRespose
6746 // has already matched the question using the 64 bit Id in the packet and we use that here.
6748 if (llqMatch
!= mDNSNULL
) m
->rec
.r
.resrec
.rDNSServer
= uDNSServer
= llqMatch
->qDNSServer
;
6750 else if (!AcceptableResponse
|| !dstaddr
)
6752 // For responses that come over TCP (Responses that can't fit within UDP) or TLS (Private queries
6753 // that are not long lived e.g., AAAA lookup in a Private domain), it is indicated by !dstaddr.
6754 // Even though it is AcceptableResponse, we still need a DNSServer pointer for the resource records that
6757 DNSQuestion
*q
= ExpectingUnicastResponseForRecord(m
, srcaddr
, ResponseSrcLocal
, dstport
, response
->h
.id
, &m
->rec
.r
, !dstaddr
);
6759 // Intialize the DNS server on the resource record which will now filter what questions we answer with
6762 // We could potentially lookup the DNS server based on the source address, but that may not work always
6763 // and that's why ExpectingUnicastResponseForRecord does not try to verify whether the response came
6764 // from the DNS server that queried. We follow the same logic here. If we can find a matching quetion based
6765 // on the "id" and "source port", then this response answers the question and assume the response
6766 // came from the same DNS server that we sent the query to.
6770 AcceptableResponse
= mDNStrue
;
6773 debugf("mDNSCoreReceiveResponse: InterfaceID %p %##s (%s)", q
->InterfaceID
, q
->qname
.c
, DNSTypeName(q
->qtype
));
6774 m
->rec
.r
.resrec
.rDNSServer
= uDNSServer
= q
->qDNSServer
;
6779 // If we can't find a matching question, we need to see whether we have seen records earlier that matched
6780 // the question. The code below does that. So, make this record unacceptable for now
6783 debugf("mDNSCoreReceiveResponse: Can't find question for record name %##s", m
->rec
.r
.resrec
.name
->c
);
6784 AcceptableResponse
= mDNSfalse
;
6790 // 1. Check that this packet resource record does not conflict with any of ours
6791 if (mDNSOpaque16IsZero(response
->h
.id
) && m
->rec
.r
.resrec
.rrtype
!= kDNSType_NSEC
)
6793 if (m
->CurrentRecord
)
6794 LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
6795 m
->CurrentRecord
= m
->ResourceRecords
;
6796 while (m
->CurrentRecord
)
6798 AuthRecord
*rr
= m
->CurrentRecord
;
6799 m
->CurrentRecord
= rr
->next
;
6800 // We accept all multicast responses, and unicast responses resulting from queries we issued
6801 // For other unicast responses, this code accepts them only for responses with an
6802 // (apparently) local source address that pertain to a record of our own that's in probing state
6803 if (!AcceptableResponse
&& !(ResponseSrcLocal
&& rr
->resrec
.RecordType
== kDNSRecordTypeUnique
)) continue;
6805 if (PacketRRMatchesSignature(&m
->rec
.r
, rr
)) // If interface, name, type (if shared record) and class match...
6807 // ... check to see if type and rdata are identical
6808 if (IdenticalSameNameRecord(&m
->rec
.r
.resrec
, &rr
->resrec
))
6810 // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us
6811 if (m
->rec
.r
.resrec
.rroriginalttl
>= rr
->resrec
.rroriginalttl
/2 || m
->SleepState
)
6813 // If we were planning to send on this -- and only this -- interface, then we don't need to any more
6814 if (rr
->ImmedAnswer
== InterfaceID
) { rr
->ImmedAnswer
= mDNSNULL
; rr
->ImmedUnicast
= mDNSfalse
; }
6818 if (rr
->ImmedAnswer
== mDNSNULL
) { rr
->ImmedAnswer
= InterfaceID
; m
->NextScheduledResponse
= m
->timenow
; }
6819 else if (rr
->ImmedAnswer
!= InterfaceID
) { rr
->ImmedAnswer
= mDNSInterfaceMark
; m
->NextScheduledResponse
= m
->timenow
; }
6822 // else, the packet RR has different type or different rdata -- check to see if this is a conflict
6823 else if (m
->rec
.r
.resrec
.rroriginalttl
> 0 && PacketRRConflict(m
, rr
, &m
->rec
.r
))
6825 LogInfo("mDNSCoreReceiveResponse: Pkt Record: %08lX %s", m
->rec
.r
.resrec
.rdatahash
, CRDisplayString(m
, &m
->rec
.r
));
6826 LogInfo("mDNSCoreReceiveResponse: Our Record: %08lX %s", rr
-> resrec
.rdatahash
, ARDisplayString(m
, rr
));
6828 // If this record is marked DependentOn another record for conflict detection purposes,
6829 // then *that* record has to be bumped back to probing state to resolve the conflict
6830 if (rr
->DependentOn
)
6832 while (rr
->DependentOn
) rr
= rr
->DependentOn
;
6833 LogInfo("mDNSCoreReceiveResponse: Dep Record: %08lX %s", rr
-> resrec
.rdatahash
, ARDisplayString(m
, rr
));
6836 // If we've just whacked this record's ProbeCount, don't need to do it again
6837 if (rr
->ProbeCount
> DefaultProbeCountForTypeUnique
)
6838 LogInfo("mDNSCoreReceiveResponse: Already reset to Probing: %s", ARDisplayString(m
, rr
));
6839 else if (rr
->ProbeCount
== DefaultProbeCountForTypeUnique
)
6840 LogMsg("mDNSCoreReceiveResponse: Ignoring response received before we even began probing: %s", ARDisplayString(m
, rr
));
6843 LogMsg("mDNSCoreReceiveResponse: Received from %#a:%d %s", srcaddr
, mDNSVal16(srcport
), CRDisplayString(m
, &m
->rec
.r
));
6844 // If we'd previously verified this record, put it back to probing state and try again
6845 if (rr
->resrec
.RecordType
== kDNSRecordTypeVerified
)
6847 LogMsg("mDNSCoreReceiveResponse: Resetting to Probing: %s", ARDisplayString(m
, rr
));
6848 rr
->resrec
.RecordType
= kDNSRecordTypeUnique
;
6849 // We set ProbeCount to one more than the usual value so we know we've already touched this record.
6850 // This is because our single probe for "example-name.local" could yield a response with (say) two A records and
6851 // three AAAA records in it, and we don't want to call RecordProbeFailure() five times and count that as five conflicts.
6852 // This special value is recognised and reset to DefaultProbeCountForTypeUnique in SendQueries().
6853 rr
->ProbeCount
= DefaultProbeCountForTypeUnique
+ 1;
6854 rr
->AnnounceCount
= InitialAnnounceCount
;
6855 InitializeLastAPTime(m
, rr
);
6856 RecordProbeFailure(m
, rr
); // Repeated late conflicts also cause us to back off to the slower probing rate
6858 // If we're probing for this record, we just failed
6859 else if (rr
->resrec
.RecordType
== kDNSRecordTypeUnique
)
6861 // Before we call deregister, check if this is a packet we registered with the sleep proxy.
6862 if (!mDNSCoreRegisteredProxyRecord(m
, rr
))
6864 LogMsg("mDNSCoreReceiveResponse: ProbeCount %d; will deregister %s", rr
->ProbeCount
, ARDisplayString(m
, rr
));
6865 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_conflict
);
6868 // We assumed this record must be unique, but we were wrong. (e.g. There are two mDNSResponders on the
6869 // same machine giving different answers for the reverse mapping record, or there are two machines on the
6870 // network using the same IP address.) This is simply a misconfiguration, and there's nothing we can do
6871 // to fix it -- e.g. it's not our job to be trying to change the machine's IP address. We just discard our
6872 // record to avoid continued conflicts (as we do for a conflict on our Unique records) and get on with life.
6873 else if (rr
->resrec
.RecordType
== kDNSRecordTypeKnownUnique
)
6875 LogMsg("mDNSCoreReceiveResponse: Unexpected conflict discarding %s", ARDisplayString(m
, rr
));
6876 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_conflict
);
6879 LogMsg("mDNSCoreReceiveResponse: Unexpected record type %X %s", rr
->resrec
.RecordType
, ARDisplayString(m
, rr
));
6882 // Else, matching signature, different type or rdata, but not a considered a conflict.
6883 // If the packet record has the cache-flush bit set, then we check to see if we
6884 // have any record(s) of the same type that we should re-assert to rescue them
6885 // (see note about "multi-homing and bridged networks" at the end of this function).
6886 else if (m
->rec
.r
.resrec
.rrtype
== rr
->resrec
.rrtype
)
6887 if ((m
->rec
.r
.resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) && m
->timenow
- rr
->LastMCTime
> mDNSPlatformOneSecond
/2)
6888 { rr
->ImmedAnswer
= mDNSInterfaceMark
; m
->NextScheduledResponse
= m
->timenow
; }
6893 if (!AcceptableResponse
)
6895 const CacheRecord
*cr
;
6896 for (cr
= CacheFlushRecords
; cr
!= (CacheRecord
*)1; cr
= cr
->NextInCFList
)
6898 domainname
*target
= GetRRDomainNameTarget(&cr
->resrec
);
6899 // When we issue a query for A record, the response might contain both a CNAME and A records. Only the CNAME would
6900 // match the question and we already created a cache entry in the previous pass of this loop. Now when we process
6901 // the A record, it does not match the question because the record name here is the CNAME. Hence we try to
6902 // match with the previous records to make it an AcceptableResponse. We have to be careful about setting the
6903 // DNSServer value that we got in the previous pass. This can happen for other record types like SRV also.
6905 if (target
&& cr
->resrec
.rdatahash
== m
->rec
.r
.resrec
.namehash
&& SameDomainName(target
, m
->rec
.r
.resrec
.name
))
6907 debugf("mDNSCoreReceiveResponse: Found a matching entry for %##s in the CacheFlushRecords", m
->rec
.r
.resrec
.name
->c
);
6908 AcceptableResponse
= mDNStrue
;
6909 m
->rec
.r
.resrec
.rDNSServer
= uDNSServer
;
6915 // 2. See if we want to add this packet resource record to our cache
6916 // We only try to cache answers if we have a cache to put them in
6917 // Also, we ignore any apparent attempts at cache poisoning unicast to us that do not answer any outstanding active query
6918 if (!AcceptableResponse
) LogInfo("mDNSCoreReceiveResponse ignoring %s", CRDisplayString(m
, &m
->rec
.r
));
6919 if (m
->rrcache_size
&& AcceptableResponse
)
6921 const mDNSu32 slot
= HashSlot(m
->rec
.r
.resrec
.name
);
6922 CacheGroup
*cg
= CacheGroupForRecord(m
, slot
, &m
->rec
.r
.resrec
);
6925 // 2a. Check if this packet resource record is already in our cache
6926 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
6928 mDNSBool match
= !InterfaceID
? m
->rec
.r
.resrec
.rDNSServer
== rr
->resrec
.rDNSServer
: rr
->resrec
.InterfaceID
== InterfaceID
;
6929 // If we found this exact resource record, refresh its TTL
6930 if (match
&& IdenticalSameNameRecord(&m
->rec
.r
.resrec
, &rr
->resrec
))
6932 if (m
->rec
.r
.resrec
.rdlength
> InlineCacheRDSize
)
6933 verbosedebugf("Found record size %5d interface %p already in cache: %s",
6934 m
->rec
.r
.resrec
.rdlength
, InterfaceID
, CRDisplayString(m
, &m
->rec
.r
));
6936 if (m
->rec
.r
.resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
)
6938 // If this packet record has the kDNSClass_UniqueRRSet flag set, then add it to our cache flushing list
6939 if (rr
->NextInCFList
== mDNSNULL
&& cfp
!= &rr
->NextInCFList
&& LLQType
!= uDNS_LLQ_Events
)
6940 { *cfp
= rr
; cfp
= &rr
->NextInCFList
; *cfp
= (CacheRecord
*)1; }
6942 // If this packet record is marked unique, and our previous cached copy was not, then fix it
6943 if (!(rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
))
6946 for (q
= m
->Questions
; q
; q
=q
->next
) if (ResourceRecordAnswersQuestion(&rr
->resrec
, q
)) q
->UniqueAnswers
++;
6947 rr
->resrec
.RecordType
= m
->rec
.r
.resrec
.RecordType
;
6951 if (!SameRDataBody(&m
->rec
.r
.resrec
, &rr
->resrec
.rdata
->u
, SameDomainNameCS
))
6953 // If the rdata of the packet record differs in name capitalization from the record in our cache
6954 // then mDNSPlatformMemSame will detect this. In this case, throw the old record away, so that clients get
6955 // a 'remove' event for the record with the old capitalization, and then an 'add' event for the new one.
6956 // <rdar://problem/4015377> mDNS -F returns the same domain multiple times with different casing
6957 rr
->resrec
.rroriginalttl
= 0;
6958 rr
->TimeRcvd
= m
->timenow
;
6959 rr
->UnansweredQueries
= MaxUnansweredQueries
;
6960 SetNextCacheCheckTimeForRecord(m
, rr
);
6961 LogInfo("Discarding due to domainname case change old: %s", CRDisplayString(m
,rr
));
6962 LogInfo("Discarding due to domainname case change new: %s", CRDisplayString(m
,&m
->rec
.r
));
6963 LogInfo("Discarding due to domainname case change in %d slot %3d in %d %d",
6964 NextCacheCheckEvent(rr
) - m
->timenow
, slot
, m
->rrcache_nextcheck
[slot
] - m
->timenow
, m
->NextCacheCheck
- m
->timenow
);
6965 // DO NOT break out here -- we want to continue as if we never found it
6967 else if (m
->rec
.r
.resrec
.rroriginalttl
> 0)
6970 //if (rr->resrec.rroriginalttl == 0) LogMsg("uDNS rescuing %s", CRDisplayString(m, rr));
6971 RefreshCacheRecord(m
, rr
, m
->rec
.r
.resrec
.rroriginalttl
);
6973 // We have to reset the question interval to MaxQuestionInterval so that we don't keep
6974 // polling the network once we get a valid response back. For the first time when a new
6975 // cache entry is created, AnswerCurrentQuestionWithResourceRecord does that.
6976 // Subsequently, if we reissue questions from within the mDNSResponder e.g., DNS server
6977 // configuration changed, without flushing the cache, we reset the question interval here.
6978 // Currently, we do this for for both multicast and unicast questions as long as the record
6979 // type is unique. For unicast, resource record is always unique and for multicast it is
6980 // true for records like A etc. but not for PTR.
6981 if (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
)
6983 for (q
= m
->Questions
; q
; q
=q
->next
)
6985 if (!q
->DuplicateOf
&& !q
->LongLived
&&
6986 ActiveQuestion(q
) && ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
6988 q
->LastQTime
= m
->timenow
;
6989 q
->LastQTxTime
= m
->timenow
;
6990 q
->RecentAnswerPkts
= 0;
6991 q
->ThisQInterval
= MaxQuestionInterval
;
6992 q
->RequestUnicast
= mDNSfalse
;
6993 q
->unansweredQueries
= 0;
6994 debugf("mDNSCoreReceiveResponse: Set MaxQuestionInterval for %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
6995 break; // Why break here? Aren't there other questions we might want to look at?-- SC July 2010
7003 // If the packet TTL is zero, that means we're deleting this record.
7004 // To give other hosts on the network a chance to protest, we push the deletion
7005 // out one second into the future. Also, we set UnansweredQueries to MaxUnansweredQueries.
7006 // Otherwise, we'll do final queries for this record at 80% and 90% of its apparent
7007 // lifetime (800ms and 900ms from now) which is a pointless waste of network bandwidth.
7008 // If record's current expiry time is more than a second from now, we set it to expire in one second.
7009 // If the record is already going to expire in less than one second anyway, we leave it alone --
7010 // we don't want to let the goodbye packet *extend* the record's lifetime in our cache.
7011 debugf("DE for %s", CRDisplayString(m
, rr
));
7012 if (RRExpireTime(rr
) - m
->timenow
> mDNSPlatformOneSecond
)
7014 rr
->resrec
.rroriginalttl
= 1;
7015 rr
->TimeRcvd
= m
->timenow
;
7016 rr
->UnansweredQueries
= MaxUnansweredQueries
;
7017 SetNextCacheCheckTimeForRecord(m
, rr
);
7024 // If packet resource record not in our cache, add it now
7025 // (unless it is just a deletion of a record we never had, in which case we don't care)
7026 if (!rr
&& m
->rec
.r
.resrec
.rroriginalttl
> 0)
7028 const mDNSBool AddToCFList
= (m
->rec
.r
.resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) && (LLQType
!= uDNS_LLQ_Events
);
7029 const mDNSs32 delay
= AddToCFList
? NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
) :
7030 CheckForSoonToExpireRecords(m
, m
->rec
.r
.resrec
.name
, m
->rec
.r
.resrec
.namehash
, slot
);
7031 // If unique, assume we may have to delay delivery of this 'add' event.
7032 // Below, where we walk the CacheFlushRecords list, we either call CacheRecordDeferredAdd()
7033 // to immediately to generate answer callbacks, or we call ScheduleNextCacheCheckTime()
7034 // to schedule an mDNS_Execute task at the appropriate time.
7035 rr
= CreateNewCacheEntry(m
, slot
, cg
, delay
);
7038 if (AddToCFList
) { *cfp
= rr
; cfp
= &rr
->NextInCFList
; *cfp
= (CacheRecord
*)1; }
7039 else if (rr
->DelayDelivery
) ScheduleNextCacheCheckTime(m
, slot
, rr
->DelayDelivery
);
7043 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7047 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7049 // If we've just received one or more records with their cache flush bits set,
7050 // then scan that cache slot to see if there are any old stale records we need to flush
7051 while (CacheFlushRecords
!= (CacheRecord
*)1)
7053 CacheRecord
*r1
= CacheFlushRecords
, *r2
;
7054 const mDNSu32 slot
= HashSlot(r1
->resrec
.name
);
7055 const CacheGroup
*cg
= CacheGroupForRecord(m
, slot
, &r1
->resrec
);
7056 CacheFlushRecords
= CacheFlushRecords
->NextInCFList
;
7057 r1
->NextInCFList
= mDNSNULL
;
7059 // Look for records in the cache with the same signature as this new one with the cache flush
7060 // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL
7061 // (as required by DNS semantics) or (b) if they're old, mark them for deletion in one second.
7062 // We make these TTL adjustments *only* for records that still have *more* than one second
7063 // remaining to live. Otherwise, a record that we tagged for deletion half a second ago
7064 // (and now has half a second remaining) could inadvertently get its life extended, by either
7065 // (a) if we got an explicit goodbye packet half a second ago, the record would be considered
7066 // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet,
7067 // or (b) otherwise, the record would not be fully resurrected, but would be reset to expire
7068 // in one second, thereby inadvertently delaying its actual expiration, instead of hastening it.
7069 // If this were to happen repeatedly, the record's expiration could be deferred indefinitely.
7070 // To avoid this, we need to ensure that the cache flushing operation will only act to
7071 // *decrease* a record's remaining lifetime, never *increase* it.
7072 for (r2
= cg
? cg
->members
: mDNSNULL
; r2
; r2
=r2
->next
)
7073 // For Unicast (null InterfaceID) the DNSservers should also match
7074 if ((r1
->resrec
.InterfaceID
== r2
->resrec
.InterfaceID
) &&
7075 (r1
->resrec
.InterfaceID
|| (r1
->resrec
.rDNSServer
== r2
->resrec
.rDNSServer
)) &&
7076 r1
->resrec
.rrtype
== r2
->resrec
.rrtype
&&
7077 r1
->resrec
.rrclass
== r2
->resrec
.rrclass
)
7079 // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics)
7080 // else, if record is old, mark it to be flushed
7081 if (m
->timenow
- r2
->TimeRcvd
< mDNSPlatformOneSecond
&& RRExpireTime(r2
) - m
->timenow
> mDNSPlatformOneSecond
)
7083 // If we find mismatched TTLs in an RRSet, correct them.
7084 // We only do this for records with a TTL of 2 or higher. It's possible to have a
7085 // goodbye announcement with the cache flush bit set (or a case-change on record rdata,
7086 // which we treat as a goodbye followed by an addition) and in that case it would be
7087 // inappropriate to synchronize all the other records to a TTL of 0 (or 1).
7088 // We suppress the message for the specific case of correcting from 240 to 60 for type TXT,
7089 // because certain early Bonjour devices are known to have this specific mismatch, and
7090 // there's no point filling syslog with messages about something we already know about.
7091 // We also don't log this for uDNS responses, since a caching name server is obliged
7092 // to give us an aged TTL to correct for how long it has held the record,
7093 // so our received TTLs are expected to vary in that case
7094 if (r2
->resrec
.rroriginalttl
!= r1
->resrec
.rroriginalttl
&& r1
->resrec
.rroriginalttl
> 1)
7096 if (!(r2
->resrec
.rroriginalttl
== 240 && r1
->resrec
.rroriginalttl
== 60 && r2
->resrec
.rrtype
== kDNSType_TXT
) &&
7097 mDNSOpaque16IsZero(response
->h
.id
))
7098 LogInfo("Correcting TTL from %4d to %4d for %s",
7099 r2
->resrec
.rroriginalttl
, r1
->resrec
.rroriginalttl
, CRDisplayString(m
, r2
));
7100 r2
->resrec
.rroriginalttl
= r1
->resrec
.rroriginalttl
;
7102 r2
->TimeRcvd
= m
->timenow
;
7104 else // else, if record is old, mark it to be flushed
7106 verbosedebugf("Cache flush new %p age %d expire in %d %s", r1
, m
->timenow
- r1
->TimeRcvd
, RRExpireTime(r1
) - m
->timenow
, CRDisplayString(m
, r1
));
7107 verbosedebugf("Cache flush old %p age %d expire in %d %s", r2
, m
->timenow
- r2
->TimeRcvd
, RRExpireTime(r2
) - m
->timenow
, CRDisplayString(m
, r2
));
7108 // We set stale records to expire in one second.
7109 // This gives the owner a chance to rescue it if necessary.
7110 // This is important in the case of multi-homing and bridged networks:
7111 // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be
7112 // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit
7113 // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet
7114 // will promptly delete their cached copies of the (still valid) Ethernet IP address record.
7115 // By delaying the deletion by one second, we give X a change to notice that this bridging has
7116 // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches.
7118 // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary
7119 // final expiration queries for this record.
7121 // If a record is deleted twice, first with an explicit DE record, then a second time by virtue of the cache
7122 // flush bit on the new record replacing it, then we allow the record to be deleted immediately, without the usual
7123 // one-second grace period. This improves responsiveness for mDNS_Update(), as used for things like iChat status updates.
7124 // <rdar://problem/5636422> Updating TXT records is too slow
7125 // We check for "rroriginalttl == 1" because we want to include records tagged by the "packet TTL is zero" check above,
7126 // which sets rroriginalttl to 1, but not records tagged by the rdata case-change check, which sets rroriginalttl to 0.
7127 if (r2
->TimeRcvd
== m
->timenow
&& r2
->resrec
.rroriginalttl
== 1 && r2
->UnansweredQueries
== MaxUnansweredQueries
)
7129 LogInfo("Cache flush for DE record %s", CRDisplayString(m
, r2
));
7130 r2
->resrec
.rroriginalttl
= 0;
7132 else if (RRExpireTime(r2
) - m
->timenow
> mDNSPlatformOneSecond
)
7134 // We only set a record to expire in one second if it currently has *more* than a second to live
7135 // If it's already due to expire in a second or less, we just leave it alone
7136 r2
->resrec
.rroriginalttl
= 1;
7137 r2
->UnansweredQueries
= MaxUnansweredQueries
;
7138 r2
->TimeRcvd
= m
->timenow
- 1;
7139 // We use (m->timenow - 1) instead of m->timenow, because we use that to identify records
7140 // that we marked for deletion via an explicit DE record
7143 SetNextCacheCheckTimeForRecord(m
, r2
);
7146 if (r1
->DelayDelivery
) // If we were planning to delay delivery of this record, see if we still need to
7148 r1
->DelayDelivery
= CheckForSoonToExpireRecords(m
, r1
->resrec
.name
, r1
->resrec
.namehash
, slot
);
7149 // If no longer delaying, deliver answer now, else schedule delivery for the appropriate time
7150 if (!r1
->DelayDelivery
) CacheRecordDeferredAdd(m
, r1
);
7151 else ScheduleNextCacheCheckTime(m
, slot
, r1
->DelayDelivery
);
7155 // See if we need to generate negative cache entries for unanswered unicast questions
7156 ptr
= response
->data
;
7157 for (i
= 0; i
< response
->h
.numQuestions
&& ptr
&& ptr
< end
; i
++)
7160 DNSQuestion
*qptr
= mDNSNULL
;
7161 ptr
= getQuestion(response
, ptr
, end
, InterfaceID
, &q
);
7162 if (ptr
&& (qptr
= ExpectingUnicastResponseForQuestion(m
, dstport
, response
->h
.id
, &q
, !dstaddr
)))
7164 CacheRecord
*rr
, *neg
= mDNSNULL
;
7165 mDNSu32 slot
= HashSlot(&q
.qname
);
7166 CacheGroup
*cg
= CacheGroupForName(m
, slot
, q
.qnamehash
, &q
.qname
);
7167 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
7168 if (SameNameRecordAnswersQuestion(&rr
->resrec
, qptr
))
7170 // 1. If we got a fresh answer to this query, then don't need to generate a negative entry
7171 if (RRExpireTime(rr
) - m
->timenow
> 0) break;
7172 // 2. If we already had a negative entry, keep track of it so we can resurrect it instead of creating a new one
7173 if (rr
->resrec
.RecordType
== kDNSRecordTypePacketNegative
) neg
= rr
;
7175 // When we're doing parallel unicast and multicast queries for dot-local names (for supporting Microsoft
7176 // Active Directory sites) we don't want to waste memory making negative cache entries for all the unicast answers.
7177 // Otherwise we just fill up our cache with negative entries for just about every single multicast name we ever look up
7178 // (since the Microsoft Active Directory server is going to assert that pretty much every single multicast name doesn't exist).
7179 // This is not only a waste of memory, but there's also the problem of those negative entries confusing us later -- e.g. we
7180 // suppress sending our mDNS query packet because we think we already have a valid (negative) answer to that query in our cache.
7181 // The one exception is that we *DO* want to make a negative cache entry for "local. SOA", for the (common) case where we're
7182 // *not* on a Microsoft Active Directory network, and there is no authoritative server for "local". Note that this is not
7183 // in conflict with the mDNS spec, because that spec says, "Multicast DNS Zones have no SOA record," so it's okay to cache
7184 // negative answers for "local. SOA" from a uDNS server, because the mDNS spec already says that such records do not exist :-)
7186 // By suppressing negative responses, it might take longer to timeout a .local question as it might be expecting a
7187 // response e.g., we deliver a positive "A" response and suppress negative "AAAA" response and the upper layer may
7188 // be waiting longer to get the AAAA response before returning the "A" response to the application. To handle this
7189 // case without creating the negative cache entries, we generate a negative response and let the layer above us
7190 // do the appropriate thing. This negative response is also needed for appending new search domains.
7191 if (!InterfaceID
&& q
.qtype
!= kDNSType_SOA
&& IsLocalDomain(&q
.qname
))
7195 LogInfo("mDNSCoreReceiveResponse: Generate negative response for %##s (%s)", q
.qname
.c
, DNSTypeName(q
.qtype
));
7196 m
->CurrentQuestion
= qptr
;
7197 GenerateNegativeResponse(m
);
7198 m
->CurrentQuestion
= mDNSNULL
;
7200 else LogInfo("mDNSCoreReceiveResponse: Skipping check to see if we need to generate a negative cache entry for %##s (%s)", q
.qname
.c
, DNSTypeName(q
.qtype
));
7206 // We start off assuming a negative caching TTL of 60 seconds
7207 // but then look to see if we can find an SOA authority record to tell us a better value we should be using
7208 mDNSu32 negttl
= 60;
7210 const domainname
*name
= &q
.qname
;
7211 mDNSu32 hash
= q
.qnamehash
;
7213 // Special case for our special Microsoft Active Directory "local SOA" check.
7214 // Some cheap home gateways don't include an SOA record in the authority section when
7215 // they send negative responses, so we don't know how long to cache the negative result.
7216 // Because we don't want to keep hitting the root name servers with our query to find
7217 // if we're on a network using Microsoft Active Directory using "local" as a private
7218 // internal top-level domain, we make sure to cache the negative result for at least one day.
7219 if (q
.qtype
== kDNSType_SOA
&& SameDomainName(&q
.qname
, &localdomain
)) negttl
= 60 * 60 * 24;
7221 // If we're going to make (or update) a negative entry, then look for the appropriate TTL from the SOA record
7222 if (response
->h
.numAuthorities
&& (ptr
= LocateAuthorities(response
, end
)) != mDNSNULL
)
7224 ptr
= GetLargeResourceRecord(m
, response
, ptr
, end
, InterfaceID
, kDNSRecordTypePacketAuth
, &m
->rec
);
7225 if (ptr
&& m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
&& m
->rec
.r
.resrec
.rrtype
== kDNSType_SOA
)
7227 const rdataSOA
*const soa
= (const rdataSOA
*)m
->rec
.r
.resrec
.rdata
->u
.data
;
7228 mDNSu32 ttl_s
= soa
->min
;
7229 // We use the lesser of the SOA.MIN field and the SOA record's TTL, *except*
7230 // for the SOA record for ".", where the record is reported as non-cacheable
7231 // (TTL zero) for some reason, so in this case we just take the SOA record's TTL as-is
7232 if (ttl_s
> m
->rec
.r
.resrec
.rroriginalttl
&& m
->rec
.r
.resrec
.name
->c
[0])
7233 ttl_s
= m
->rec
.r
.resrec
.rroriginalttl
;
7234 if (negttl
< ttl_s
) negttl
= ttl_s
;
7236 // Special check for SOA queries: If we queried for a.b.c.d.com, and got no answer,
7237 // with an Authority Section SOA record for d.com, then this is a hint that the authority
7238 // is d.com, and consequently SOA records b.c.d.com and c.d.com don't exist either.
7239 // To do this we set the repeat count so the while loop below will make a series of negative cache entries for us
7240 if (q
.qtype
== kDNSType_SOA
)
7242 int qcount
= CountLabels(&q
.qname
);
7243 int scount
= CountLabels(m
->rec
.r
.resrec
.name
);
7244 if (qcount
- 1 > scount
)
7245 if (SameDomainName(SkipLeadingLabels(&q
.qname
, qcount
- scount
), m
->rec
.r
.resrec
.name
))
7246 repeat
= qcount
- 1 - scount
;
7249 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7252 // If we already had a negative entry in the cache, then we double our existing negative TTL. This is to avoid
7253 // the case where the record doesn't exist (e.g. particularly for things like our lb._dns-sd._udp.<domain> query),
7254 // and the server returns no SOA record (or an SOA record with a small MIN TTL) so we assume a TTL
7255 // of 60 seconds, and we end up polling the server every minute for a record that doesn't exist.
7256 // With this fix in place, when this happens, we double the effective TTL each time (up to one hour),
7257 // so that we back off our polling rate and don't keep hitting the server continually.
7260 if (negttl
< neg
->resrec
.rroriginalttl
* 2)
7261 negttl
= neg
->resrec
.rroriginalttl
* 2;
7266 negttl
= GetEffectiveTTL(LLQType
, negttl
); // Add 25% grace period if necessary
7268 // If we already had a negative cache entry just update it, else make one or more new negative cache entries
7271 debugf("Renewing negative TTL from %d to %d %s", neg
->resrec
.rroriginalttl
, negttl
, CRDisplayString(m
, neg
));
7272 RefreshCacheRecord(m
, neg
, negttl
);
7276 debugf("mDNSCoreReceiveResponse making negative cache entry TTL %d for %##s (%s)", negttl
, name
->c
, DNSTypeName(q
.qtype
));
7277 MakeNegativeCacheRecord(m
, &m
->rec
.r
, name
, hash
, q
.qtype
, q
.qclass
, negttl
, mDNSInterface_Any
, qptr
->qDNSServer
);
7278 CreateNewCacheEntry(m
, slot
, cg
, 0); // We never need any delivery delay for these generated negative cache records
7279 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7282 name
= (const domainname
*)(name
->c
+ 1 + name
->c
[0]);
7283 hash
= DomainNameHashValue(name
);
7284 slot
= HashSlot(name
);
7285 cg
= CacheGroupForName(m
, slot
, hash
, name
);
7293 // ScheduleWakeup causes all proxy records with WakeUp.HMAC matching mDNSEthAddr 'e' to be deregistered, causing
7294 // multiple wakeup magic packets to be sent if appropriate, and all records to be ultimately freed after a few seconds.
7295 // ScheduleWakeup is called on mDNS record conflicts, ARP conflicts, NDP conflicts, or reception of trigger traffic
7296 // that warrants waking the sleeping host.
7297 // ScheduleWakeup must be called with the lock held (ScheduleWakeupForList uses mDNS_Deregister_internal)
7299 mDNSlocal
void ScheduleWakeupForList(mDNS
*const m
, mDNSInterfaceID InterfaceID
, mDNSEthAddr
*e
, AuthRecord
*const thelist
)
7301 // We don't need to use the m->CurrentRecord mechanism here because the target HMAC is nonzero,
7302 // so all we're doing is marking the record to generate a few wakeup packets
7304 if (!e
->l
[0]) { LogMsg("ScheduleWakeupForList ERROR: Target HMAC is zero"); return; }
7305 for (rr
= thelist
; rr
; rr
= rr
->next
)
7306 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&& mDNSSameEthAddress(&rr
->WakeUp
.HMAC
, e
))
7308 LogInfo("ScheduleWakeupForList: Scheduling wakeup packets for %s", ARDisplayString(m
, rr
));
7309 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
7313 mDNSlocal
void ScheduleWakeup(mDNS
*const m
, mDNSInterfaceID InterfaceID
, mDNSEthAddr
*e
)
7315 if (!e
->l
[0]) { LogMsg("ScheduleWakeup ERROR: Target HMAC is zero"); return; }
7316 ScheduleWakeupForList(m
, InterfaceID
, e
, m
->DuplicateRecords
);
7317 ScheduleWakeupForList(m
, InterfaceID
, e
, m
->ResourceRecords
);
7320 mDNSlocal
void SPSRecordCallback(mDNS
*const m
, AuthRecord
*const ar
, mStatus result
)
7322 if (result
&& result
!= mStatus_MemFree
)
7323 LogInfo("SPS Callback %d %s", result
, ARDisplayString(m
, ar
));
7325 if (result
== mStatus_NameConflict
)
7328 LogMsg("%-7s Conflicting mDNS -- waking %.6a %s", InterfaceNameForID(m
, ar
->resrec
.InterfaceID
), &ar
->WakeUp
.HMAC
, ARDisplayString(m
, ar
));
7329 if (ar
->WakeUp
.HMAC
.l
[0])
7331 SendWakeup(m
, ar
->resrec
.InterfaceID
, &ar
->WakeUp
.IMAC
, &ar
->WakeUp
.password
); // Send one wakeup magic packet
7332 ScheduleWakeup(m
, ar
->resrec
.InterfaceID
, &ar
->WakeUp
.HMAC
); // Schedule all other records with the same owner to be woken
7337 if (result
== mStatus_NameConflict
|| result
== mStatus_MemFree
)
7340 mDNSPlatformMemFree(ar
);
7341 mDNS_UpdateAllowSleep(m
);
7345 mDNSlocal
void mDNSCoreReceiveUpdate(mDNS
*const m
,
7346 const DNSMessage
*const msg
, const mDNSu8
*end
,
7347 const mDNSAddr
*srcaddr
, const mDNSIPPort srcport
, const mDNSAddr
*dstaddr
, mDNSIPPort dstport
,
7348 const mDNSInterfaceID InterfaceID
)
7352 mDNSu8
*p
= m
->omsg
.data
;
7353 OwnerOptData owner
= zeroOwner
; // Need to zero this, so we'll know if this Update packet was missing its Owner option
7354 mDNSu32 updatelease
= 0;
7357 LogSPS("Received Update from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
7358 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes",
7359 srcaddr
, mDNSVal16(srcport
), dstaddr
, mDNSVal16(dstport
), InterfaceID
,
7360 msg
->h
.numQuestions
, msg
->h
.numQuestions
== 1 ? ", " : "s,",
7361 msg
->h
.numAnswers
, msg
->h
.numAnswers
== 1 ? ", " : "s,",
7362 msg
->h
.numAuthorities
, msg
->h
.numAuthorities
== 1 ? "y, " : "ies,",
7363 msg
->h
.numAdditionals
, msg
->h
.numAdditionals
== 1 ? " " : "s", end
- msg
->data
);
7365 if (!InterfaceID
|| !m
->SPSSocket
|| !mDNSSameIPPort(dstport
, m
->SPSSocket
->port
)) return;
7367 if (mDNS_PacketLoggingEnabled
)
7368 DumpPacket(m
, mStatus_NoError
, mDNSfalse
, "UDP", srcaddr
, srcport
, dstaddr
, dstport
, msg
, end
);
7370 ptr
= LocateOptRR(msg
, end
, DNSOpt_LeaseData_Space
+ DNSOpt_OwnerData_ID_Space
);
7373 ptr
= GetLargeResourceRecord(m
, msg
, ptr
, end
, 0, kDNSRecordTypePacketAdd
, &m
->rec
);
7374 if (ptr
&& m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
&& m
->rec
.r
.resrec
.rrtype
== kDNSType_OPT
)
7377 const rdataOPT
*const e
= (const rdataOPT
*)&m
->rec
.r
.resrec
.rdata
->u
.data
[m
->rec
.r
.resrec
.rdlength
];
7378 for (o
= &m
->rec
.r
.resrec
.rdata
->u
.opt
[0]; o
< e
; o
++)
7380 if (o
->opt
== kDNSOpt_Lease
) updatelease
= o
->u
.updatelease
;
7381 else if (o
->opt
== kDNSOpt_Owner
&& o
->u
.owner
.vers
== 0) owner
= o
->u
.owner
;
7384 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7387 InitializeDNSMessage(&m
->omsg
.h
, msg
->h
.id
, UpdateRespFlags
);
7389 if (!updatelease
|| !owner
.HMAC
.l
[0])
7391 static int msgs
= 0;
7395 LogMsg("Refusing sleep proxy registration from %#a:%d:%s%s", srcaddr
, mDNSVal16(srcport
),
7396 !updatelease
? " No lease" : "", !owner
.HMAC
.l
[0] ? " No owner" : "");
7398 m
->omsg
.h
.flags
.b
[1] |= kDNSFlag1_RC_FormErr
;
7400 else if (m
->ProxyRecords
+ msg
->h
.mDNS_numUpdates
> MAX_PROXY_RECORDS
)
7402 static int msgs
= 0;
7406 LogMsg("Refusing sleep proxy registration from %#a:%d: Too many records %d + %d = %d > %d", srcaddr
, mDNSVal16(srcport
),
7407 m
->ProxyRecords
, msg
->h
.mDNS_numUpdates
, m
->ProxyRecords
+ msg
->h
.mDNS_numUpdates
, MAX_PROXY_RECORDS
);
7409 m
->omsg
.h
.flags
.b
[1] |= kDNSFlag1_RC_Refused
;
7413 LogSPS("Received Update for H-MAC %.6a I-MAC %.6a Password %.6a seq %d", &owner
.HMAC
, &owner
.IMAC
, &owner
.password
, owner
.seq
);
7415 if (updatelease
> 24 * 60 * 60)
7416 updatelease
= 24 * 60 * 60;
7418 if (updatelease
> 0x40000000UL
/ mDNSPlatformOneSecond
)
7419 updatelease
= 0x40000000UL
/ mDNSPlatformOneSecond
;
7421 ptr
= LocateAuthorities(msg
, end
);
7422 for (i
= 0; i
< msg
->h
.mDNS_numUpdates
&& ptr
&& ptr
< end
; i
++)
7424 ptr
= GetLargeResourceRecord(m
, msg
, ptr
, end
, InterfaceID
, kDNSRecordTypePacketAuth
, &m
->rec
);
7425 if (ptr
&& m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
)
7427 mDNSu16 RDLengthMem
= GetRDLengthMem(&m
->rec
.r
.resrec
);
7428 AuthRecord
*ar
= mDNSPlatformMemAllocate(sizeof(AuthRecord
) - sizeof(RDataBody
) + RDLengthMem
);
7429 if (!ar
) { m
->omsg
.h
.flags
.b
[1] |= kDNSFlag1_RC_Refused
; break; }
7432 mDNSu8 RecordType
= m
->rec
.r
.resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
? kDNSRecordTypeUnique
: kDNSRecordTypeShared
;
7433 m
->rec
.r
.resrec
.rrclass
&= ~kDNSClass_UniqueRRSet
;
7434 ClearIdenticalProxyRecords(m
, &owner
, m
->DuplicateRecords
); // Make sure we don't have any old stale duplicates of this record
7435 ClearIdenticalProxyRecords(m
, &owner
, m
->ResourceRecords
);
7436 mDNS_SetupResourceRecord(ar
, mDNSNULL
, InterfaceID
, m
->rec
.r
.resrec
.rrtype
, m
->rec
.r
.resrec
.rroriginalttl
, RecordType
, AuthRecordAny
, SPSRecordCallback
, ar
);
7437 AssignDomainName(&ar
->namestorage
, m
->rec
.r
.resrec
.name
);
7438 ar
->resrec
.rdlength
= GetRDLength(&m
->rec
.r
.resrec
, mDNSfalse
);
7439 ar
->resrec
.rdata
->MaxRDLength
= RDLengthMem
;
7440 mDNSPlatformMemCopy(ar
->resrec
.rdata
->u
.data
, m
->rec
.r
.resrec
.rdata
->u
.data
, RDLengthMem
);
7441 ar
->ForceMCast
= mDNStrue
;
7443 if (m
->rec
.r
.resrec
.rrtype
== kDNSType_PTR
)
7445 mDNSs32 t
= ReverseMapDomainType(m
->rec
.r
.resrec
.name
);
7446 if (t
== mDNSAddrType_IPv4
) GetIPv4FromName(&ar
->AddressProxy
, m
->rec
.r
.resrec
.name
);
7447 else if (t
== mDNSAddrType_IPv6
) GetIPv6FromName(&ar
->AddressProxy
, m
->rec
.r
.resrec
.name
);
7448 debugf("mDNSCoreReceiveUpdate: PTR %d %d %#a %s", t
, ar
->AddressProxy
.type
, &ar
->AddressProxy
, ARDisplayString(m
, ar
));
7449 if (ar
->AddressProxy
.type
) SetSPSProxyListChanged(InterfaceID
);
7451 ar
->TimeRcvd
= m
->timenow
;
7452 ar
->TimeExpire
= m
->timenow
+ updatelease
* mDNSPlatformOneSecond
;
7453 if (m
->NextScheduledSPS
- ar
->TimeExpire
> 0)
7454 m
->NextScheduledSPS
= ar
->TimeExpire
;
7455 mDNS_Register_internal(m
, ar
);
7456 // Unsolicited Neighbor Advertisements (RFC 2461 Section 7.2.6) give us fast address cache updating,
7457 // but some older IPv6 clients get confused by them, so for now we don't send them. Without Unsolicited
7458 // Neighbor Advertisements we have to rely on Neighbor Unreachability Detection instead, which is slower.
7459 // Given this, we'll do our best to wake for existing IPv6 connections, but we don't want to encourage
7460 // new ones for sleeping clients, so we'll we send deletions for our SPS clients' AAAA records.
7461 if (m
->KnownBugs
& mDNS_KnownBug_LimitedIPv6
)
7462 if (ar
->resrec
.rrtype
== kDNSType_AAAA
) ar
->resrec
.rroriginalttl
= 0;
7464 mDNS_UpdateAllowSleep(m
);
7465 LogSPS("SPS Registered %4d %X %s", m
->ProxyRecords
, RecordType
, ARDisplayString(m
,ar
));
7468 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7471 if (m
->omsg
.h
.flags
.b
[1] & kDNSFlag1_RC_Mask
)
7473 LogMsg("Refusing sleep proxy registration from %#a:%d: Out of memory", srcaddr
, mDNSVal16(srcport
));
7474 ClearProxyRecords(m
, &owner
, m
->DuplicateRecords
);
7475 ClearProxyRecords(m
, &owner
, m
->ResourceRecords
);
7479 mDNS_SetupResourceRecord(&opt
, mDNSNULL
, mDNSInterface_Any
, kDNSType_OPT
, kStandardTTL
, kDNSRecordTypeKnownUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
7480 opt
.resrec
.rrclass
= NormalMaxDNSMessageData
;
7481 opt
.resrec
.rdlength
= sizeof(rdataOPT
); // One option in this OPT record
7482 opt
.resrec
.rdestimate
= sizeof(rdataOPT
);
7483 opt
.resrec
.rdata
->u
.opt
[0].opt
= kDNSOpt_Lease
;
7484 opt
.resrec
.rdata
->u
.opt
[0].u
.updatelease
= updatelease
;
7485 p
= PutResourceRecordTTLWithLimit(&m
->omsg
, p
, &m
->omsg
.h
.numAdditionals
, &opt
.resrec
, opt
.resrec
.rroriginalttl
, m
->omsg
.data
+ AbsoluteMaxDNSMessageData
);
7489 if (p
) mDNSSendDNSMessage(m
, &m
->omsg
, p
, InterfaceID
, m
->SPSSocket
, srcaddr
, srcport
, mDNSNULL
, mDNSNULL
);
7492 mDNSlocal
void mDNSCoreReceiveUpdateR(mDNS
*const m
, const DNSMessage
*const msg
, const mDNSu8
*end
, const mDNSInterfaceID InterfaceID
)
7496 mDNSu32 updatelease
= 60 * 60; // If SPS fails to indicate lease time, assume one hour
7497 const mDNSu8
*ptr
= LocateOptRR(msg
, end
, DNSOpt_LeaseData_Space
);
7500 ptr
= GetLargeResourceRecord(m
, msg
, ptr
, end
, 0, kDNSRecordTypePacketAdd
, &m
->rec
);
7501 if (ptr
&& m
->rec
.r
.resrec
.RecordType
!= kDNSRecordTypePacketNegative
&& m
->rec
.r
.resrec
.rrtype
== kDNSType_OPT
)
7504 const rdataOPT
*const e
= (const rdataOPT
*)&m
->rec
.r
.resrec
.rdata
->u
.data
[m
->rec
.r
.resrec
.rdlength
];
7505 for (o
= &m
->rec
.r
.resrec
.rdata
->u
.opt
[0]; o
< e
; o
++)
7506 if (o
->opt
== kDNSOpt_Lease
)
7508 updatelease
= o
->u
.updatelease
;
7509 LogSPS("Sleep Proxy granted lease time %4d seconds", updatelease
);
7512 m
->rec
.r
.resrec
.RecordType
= 0; // Clear RecordType to show we're not still using it
7515 if (m
->CurrentRecord
)
7516 LogMsg("mDNSCoreReceiveUpdateR ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
7517 m
->CurrentRecord
= m
->ResourceRecords
;
7518 while (m
->CurrentRecord
)
7520 AuthRecord
*const rr
= m
->CurrentRecord
;
7521 if (rr
->resrec
.InterfaceID
== InterfaceID
|| (!rr
->resrec
.InterfaceID
&& (rr
->ForceMCast
|| IsLocalDomain(rr
->resrec
.name
))))
7522 if (mDNSSameOpaque16(rr
->updateid
, msg
->h
.id
))
7524 rr
->updateid
= zeroID
;
7525 rr
->expire
= NonZeroTime(m
->timenow
+ updatelease
* mDNSPlatformOneSecond
);
7526 LogSPS("Sleep Proxy %s record %5d %s", rr
->WakeUp
.HMAC
.l
[0] ? "transferred" : "registered", updatelease
, ARDisplayString(m
,rr
));
7527 if (rr
->WakeUp
.HMAC
.l
[0])
7529 rr
->WakeUp
.HMAC
= zeroEthAddr
; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host
7530 rr
->RequireGoodbye
= mDNSfalse
; // and we don't want to send goodbye for it
7531 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
7534 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
7535 // new records could have been added to the end of the list as a result of that call.
7536 if (m
->CurrentRecord
== rr
) // If m->CurrentRecord was not advanced for us, do it now
7537 m
->CurrentRecord
= rr
->next
;
7540 // If we were waiting to go to sleep, then this SPS registration or wide-area record deletion
7541 // may have been the thing we were waiting for, so schedule another check to see if we can sleep now.
7542 if (m
->SleepLimit
) m
->NextScheduledSPRetry
= m
->timenow
;
7545 mDNSexport
void MakeNegativeCacheRecord(mDNS
*const m
, CacheRecord
*const cr
,
7546 const domainname
*const name
, const mDNSu32 namehash
, const mDNSu16 rrtype
, const mDNSu16 rrclass
, mDNSu32 ttl_seconds
, mDNSInterfaceID InterfaceID
, DNSServer
*dnsserver
)
7548 if (cr
== &m
->rec
.r
&& m
->rec
.r
.resrec
.RecordType
)
7550 LogMsg("MakeNegativeCacheRecord: m->rec appears to be already in use for %s", CRDisplayString(m
, &m
->rec
.r
));
7556 // Create empty resource record
7557 cr
->resrec
.RecordType
= kDNSRecordTypePacketNegative
;
7558 cr
->resrec
.InterfaceID
= InterfaceID
;
7559 cr
->resrec
.rDNSServer
= dnsserver
;
7560 cr
->resrec
.name
= name
; // Will be updated to point to cg->name when we call CreateNewCacheEntry
7561 cr
->resrec
.rrtype
= rrtype
;
7562 cr
->resrec
.rrclass
= rrclass
;
7563 cr
->resrec
.rroriginalttl
= ttl_seconds
;
7564 cr
->resrec
.rdlength
= 0;
7565 cr
->resrec
.rdestimate
= 0;
7566 cr
->resrec
.namehash
= namehash
;
7567 cr
->resrec
.rdatahash
= 0;
7568 cr
->resrec
.rdata
= (RData
*)&cr
->smallrdatastorage
;
7569 cr
->resrec
.rdata
->MaxRDLength
= 0;
7571 cr
->NextInKAList
= mDNSNULL
;
7572 cr
->TimeRcvd
= m
->timenow
;
7573 cr
->DelayDelivery
= 0;
7574 cr
->NextRequiredQuery
= m
->timenow
;
7575 cr
->LastUsed
= m
->timenow
;
7576 cr
->CRActiveQuestion
= mDNSNULL
;
7577 cr
->UnansweredQueries
= 0;
7578 cr
->LastUnansweredTime
= 0;
7579 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING
7580 cr
->MPUnansweredQ
= 0;
7581 cr
->MPLastUnansweredQT
= 0;
7582 cr
->MPUnansweredKA
= 0;
7583 cr
->MPExpectingKA
= mDNSfalse
;
7585 cr
->NextInCFList
= mDNSNULL
;
7588 mDNSexport
void mDNSCoreReceive(mDNS
*const m
, void *const pkt
, const mDNSu8
*const end
,
7589 const mDNSAddr
*const srcaddr
, const mDNSIPPort srcport
, const mDNSAddr
*dstaddr
, const mDNSIPPort dstport
,
7590 const mDNSInterfaceID InterfaceID
)
7592 mDNSInterfaceID ifid
= InterfaceID
;
7593 DNSMessage
*msg
= (DNSMessage
*)pkt
;
7594 const mDNSu8 StdQ
= kDNSFlag0_QR_Query
| kDNSFlag0_OP_StdQuery
;
7595 const mDNSu8 StdR
= kDNSFlag0_QR_Response
| kDNSFlag0_OP_StdQuery
;
7596 const mDNSu8 UpdQ
= kDNSFlag0_QR_Query
| kDNSFlag0_OP_Update
;
7597 const mDNSu8 UpdR
= kDNSFlag0_QR_Response
| kDNSFlag0_OP_Update
;
7599 mDNSu8
*ptr
= mDNSNULL
;
7600 mDNSBool TLS
= (dstaddr
== (mDNSAddr
*)1); // For debug logs: dstaddr = 0 means TCP; dstaddr = 1 means TLS
7601 if (TLS
) dstaddr
= mDNSNULL
;
7603 #ifndef UNICAST_DISABLED
7604 if (mDNSSameAddress(srcaddr
, &m
->Router
))
7606 #ifdef _LEGACY_NAT_TRAVERSAL_
7607 if (mDNSSameIPPort(srcport
, SSDPPort
) || (m
->SSDPSocket
&& mDNSSameIPPort(dstport
, m
->SSDPSocket
->port
)))
7610 LNT_ConfigureRouterInfo(m
, InterfaceID
, pkt
, (mDNSu16
)(end
- (mDNSu8
*)pkt
));
7615 if (mDNSSameIPPort(srcport
, NATPMPPort
))
7618 uDNS_ReceiveNATPMPPacket(m
, InterfaceID
, pkt
, (mDNSu16
)(end
- (mDNSu8
*)pkt
));
7623 #ifdef _LEGACY_NAT_TRAVERSAL_
7624 else if (m
->SSDPSocket
&& mDNSSameIPPort(dstport
, m
->SSDPSocket
->port
)) { debugf("Ignoring SSDP response from %#a:%d", srcaddr
, mDNSVal16(srcport
)); return; }
7628 if ((unsigned)(end
- (mDNSu8
*)pkt
) < sizeof(DNSMessageHeader
))
7630 LogMsg("DNS Message from %#a:%d to %#a:%d length %d too short", srcaddr
, mDNSVal16(srcport
), dstaddr
, mDNSVal16(dstport
), end
- (mDNSu8
*)pkt
);
7633 QR_OP
= (mDNSu8
)(msg
->h
.flags
.b
[0] & kDNSFlag0_QROP_Mask
);
7634 // Read the integer parts which are in IETF byte-order (MSB first, LSB second)
7635 ptr
= (mDNSu8
*)&msg
->h
.numQuestions
;
7636 msg
->h
.numQuestions
= (mDNSu16
)((mDNSu16
)ptr
[0] << 8 | ptr
[1]);
7637 msg
->h
.numAnswers
= (mDNSu16
)((mDNSu16
)ptr
[2] << 8 | ptr
[3]);
7638 msg
->h
.numAuthorities
= (mDNSu16
)((mDNSu16
)ptr
[4] << 8 | ptr
[5]);
7639 msg
->h
.numAdditionals
= (mDNSu16
)((mDNSu16
)ptr
[6] << 8 | ptr
[7]);
7641 if (!m
) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; }
7643 // We use zero addresses and all-ones addresses at various places in the code to indicate special values like "no address"
7644 // If we accept and try to process a packet with zero or all-ones source address, that could really mess things up
7645 if (srcaddr
&& !mDNSAddressIsValid(srcaddr
)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr
); return; }
7649 #ifndef UNICAST_DISABLED
7650 if (!dstaddr
|| (!mDNSAddressIsAllDNSLinkGroup(dstaddr
) && (QR_OP
== StdR
|| QR_OP
== UpdR
)))
7651 if (!mDNSOpaque16IsZero(msg
->h
.id
)) // uDNS_ReceiveMsg only needs to get real uDNS responses, not "QU" mDNS responses
7653 ifid
= mDNSInterface_Any
;
7654 if (mDNS_PacketLoggingEnabled
)
7655 DumpPacket(m
, mStatus_NoError
, mDNSfalse
, TLS
? "TLS" : !dstaddr
? "TCP" : "UDP", srcaddr
, srcport
, dstaddr
, dstport
, msg
, end
);
7656 uDNS_ReceiveMsg(m
, msg
, end
, srcaddr
, srcport
);
7657 // Note: mDNSCore also needs to get access to received unicast responses
7660 if (QR_OP
== StdQ
) mDNSCoreReceiveQuery (m
, msg
, end
, srcaddr
, srcport
, dstaddr
, dstport
, ifid
);
7661 else if (QR_OP
== StdR
) mDNSCoreReceiveResponse(m
, msg
, end
, srcaddr
, srcport
, dstaddr
, dstport
, ifid
);
7662 else if (QR_OP
== UpdQ
) mDNSCoreReceiveUpdate (m
, msg
, end
, srcaddr
, srcport
, dstaddr
, dstport
, InterfaceID
);
7663 else if (QR_OP
== UpdR
) mDNSCoreReceiveUpdateR (m
, msg
, end
, InterfaceID
);
7666 LogMsg("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d length %d on %p (ignored)",
7667 msg
->h
.flags
.b
[0], msg
->h
.flags
.b
[1], srcaddr
, mDNSVal16(srcport
), dstaddr
, mDNSVal16(dstport
), end
- (mDNSu8
*)pkt
, InterfaceID
);
7668 if (mDNS_LoggingEnabled
)
7671 while (i
<end
- (mDNSu8
*)pkt
)
7674 char *p
= buffer
+ mDNS_snprintf(buffer
, sizeof(buffer
), "%04X", i
);
7675 do if (i
<end
- (mDNSu8
*)pkt
) p
+= mDNS_snprintf(p
, sizeof(buffer
), " %02X", ((mDNSu8
*)pkt
)[i
]); while (++i
& 15);
7676 LogInfo("%s", buffer
);
7680 // Packet reception often causes a change to the task list:
7681 // 1. Inbound queries can cause us to need to send responses
7682 // 2. Conflicing response packets received from other hosts can cause us to need to send defensive responses
7683 // 3. Other hosts announcing deletion of shared records can cause us to need to re-assert those records
7684 // 4. Response packets that answer questions may cause our client to issue new questions
7688 // ***************************************************************************
7689 #if COMPILER_LIKES_PRAGMA_MARK
7691 #pragma mark - Searcher Functions
7694 // Targets are considered the same if both queries are untargeted, or
7695 // if both are targeted to the same address+port
7696 // (If Target address is zero, TargetPort is undefined)
7697 #define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \
7698 (mDNSSameAddress(&(A)->Target, &(B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort)))
7700 // Note: We explicitly disallow making a public query be a duplicate of a private one. This is to avoid the
7701 // circular deadlock where a client does a query for something like "dns-sd -Q _dns-query-tls._tcp.company.com SRV"
7702 // and we have a key for company.com, so we try to locate the private query server for company.com, which necessarily entails
7703 // doing a standard DNS query for the _dns-query-tls._tcp SRV record for company.com. If we make the latter (public) query
7704 // a duplicate of the former (private) query, then it will block forever waiting for an answer that will never come.
7706 // We keep SuppressUnusable questions separate so that we can return a quick response to them and not get blocked behind
7707 // the queries that are not marked SuppressUnusable. But if the query is not suppressed, they are treated the same as
7708 // non-SuppressUnusable questions. This should be fine as the goal of SuppressUnusable is to return quickly only if it
7709 // is suppressed. If it is not suppressed, we do try all the DNS servers for valid answers like any other question.
7710 // The main reason for this design is that cache entries point to a *single* question and that question is responsible
7711 // for keeping the cache fresh as long as it is active. Having multiple active question for a single cache entry
7712 // breaks this design principle.
7714 // If IsLLQ(Q) is true, it means the question is both:
7715 // (a) long-lived and
7716 // (b) being performed by a unicast DNS long-lived query (either full LLQ, or polling)
7717 // for multicast questions, we don't want to treat LongLived as anything special
7718 #define IsLLQ(Q) ((Q)->LongLived && !mDNSOpaque16IsZero((Q)->TargetQID))
7720 mDNSlocal DNSQuestion
*FindDuplicateQuestion(const mDNS
*const m
, const DNSQuestion
*const question
)
7723 // Note: A question can only be marked as a duplicate of one that occurs *earlier* in the list.
7724 // This prevents circular references, where two questions are each marked as a duplicate of the other.
7725 // Accordingly, we break out of the loop when we get to 'question', because there's no point searching
7726 // further in the list.
7727 for (q
= m
->Questions
; q
&& q
!= question
; q
=q
->next
) // Scan our list for another question
7728 if (q
->InterfaceID
== question
->InterfaceID
&& // with the same InterfaceID,
7729 SameQTarget(q
, question
) && // and same unicast/multicast target settings
7730 q
->qtype
== question
->qtype
&& // type,
7731 q
->qclass
== question
->qclass
&& // class,
7732 IsLLQ(q
) == IsLLQ(question
) && // and long-lived status matches
7733 (!q
->AuthInfo
|| question
->AuthInfo
) && // to avoid deadlock, don't make public query dup of a private one
7734 (q
->SuppressQuery
== question
->SuppressQuery
) && // Questions that are suppressed/not suppressed
7735 q
->qnamehash
== question
->qnamehash
&&
7736 SameDomainName(&q
->qname
, &question
->qname
)) // and name
7741 // This is called after a question is deleted, in case other identical questions were being suppressed as duplicates
7742 mDNSlocal
void UpdateQuestionDuplicates(mDNS
*const m
, DNSQuestion
*const question
)
7745 DNSQuestion
*first
= mDNSNULL
;
7747 // This is referring to some other question as duplicate. No other question can refer to this
7748 // question as a duplicate.
7749 if (question
->DuplicateOf
)
7751 LogInfo("UpdateQuestionDuplicates: question %p %##s (%s) duplicate of %p %##s (%s)",
7752 question
, question
->qname
.c
, DNSTypeName(question
->qtype
),
7753 question
->DuplicateOf
, question
->DuplicateOf
->qname
.c
, DNSTypeName(question
->DuplicateOf
->qtype
));
7757 for (q
= m
->Questions
; q
; q
=q
->next
) // Scan our list of questions
7758 if (q
->DuplicateOf
== question
) // To see if any questions were referencing this as their duplicate
7760 q
->DuplicateOf
= first
;
7764 // If q used to be a duplicate, but now is not,
7765 // then inherit the state from the question that's going away
7766 q
->LastQTime
= question
->LastQTime
;
7767 q
->ThisQInterval
= question
->ThisQInterval
;
7768 q
->ExpectUnicastResp
= question
->ExpectUnicastResp
;
7769 q
->LastAnswerPktNum
= question
->LastAnswerPktNum
;
7770 q
->RecentAnswerPkts
= question
->RecentAnswerPkts
;
7771 q
->RequestUnicast
= question
->RequestUnicast
;
7772 q
->LastQTxTime
= question
->LastQTxTime
;
7773 q
->CNAMEReferrals
= question
->CNAMEReferrals
;
7774 q
->nta
= question
->nta
;
7775 q
->servAddr
= question
->servAddr
;
7776 q
->servPort
= question
->servPort
;
7777 q
->qDNSServer
= question
->qDNSServer
;
7778 q
->validDNSServers
= question
->validDNSServers
;
7779 q
->unansweredQueries
= question
->unansweredQueries
;
7780 q
->noServerResponse
= question
->noServerResponse
;
7781 q
->triedAllServersOnce
= question
->triedAllServersOnce
;
7783 q
->TargetQID
= question
->TargetQID
;
7784 q
->LocalSocket
= question
->LocalSocket
;
7786 q
->state
= question
->state
;
7787 // q->tcp = question->tcp;
7788 q
->ReqLease
= question
->ReqLease
;
7789 q
->expire
= question
->expire
;
7790 q
->ntries
= question
->ntries
;
7791 q
->id
= question
->id
;
7793 question
->LocalSocket
= mDNSNULL
;
7794 question
->nta
= mDNSNULL
; // If we've got a GetZoneData in progress, transfer it to the newly active question
7795 // question->tcp = mDNSNULL;
7798 debugf("UpdateQuestionDuplicates transferred LocalSocket pointer for %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
7802 LogInfo("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
7803 q
->nta
->ZoneDataContext
= q
;
7806 // Need to work out how to safely transfer this state too -- appropriate context pointers need to be updated or the code will crash
7807 if (question
->tcp
) LogInfo("UpdateQuestionDuplicates did not transfer tcp pointer");
7809 if (question
->state
== LLQ_Established
)
7811 LogInfo("UpdateQuestionDuplicates transferred LLQ state for %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
7812 question
->state
= 0; // Must zero question->state, or mDNS_StopQuery_internal will clean up and cancel our LLQ from the server
7815 SetNextQueryTime(m
,q
);
7820 mDNSexport McastResolver
*mDNS_AddMcastResolver(mDNS
*const m
, const domainname
*d
, const mDNSInterfaceID interface
, mDNSu32 timeout
)
7822 McastResolver
**p
= &m
->McastResolvers
;
7823 McastResolver
*tmp
= mDNSNULL
;
7825 if (!d
) d
= (const domainname
*)"";
7827 LogInfo("mDNS_AddMcastResolver: Adding %##s, InterfaceID %p, timeout %u", d
->c
, interface
, timeout
);
7829 if (m
->mDNS_busy
!= m
->mDNS_reentrancy
+1)
7830 LogMsg("mDNS_AddMcastResolver: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m
->mDNS_busy
, m
->mDNS_reentrancy
);
7832 while (*p
) // Check if we already have this {interface, domain} tuple registered
7834 if ((*p
)->interface
== interface
&& SameDomainName(&(*p
)->domain
, d
))
7836 if (!((*p
)->flags
& DNSServer_FlagDelete
)) LogMsg("Note: Mcast Resolver domain %##s (%p) registered more than once", d
->c
, interface
);
7837 (*p
)->flags
&= ~DNSServer_FlagDelete
;
7840 tmp
->next
= mDNSNULL
;
7846 if (tmp
) *p
= tmp
; // move to end of list, to ensure ordering from platform layer
7849 // allocate, add to list
7850 *p
= mDNSPlatformMemAllocate(sizeof(**p
));
7851 if (!*p
) LogMsg("mDNS_AddMcastResolver: ERROR!! - malloc");
7854 (*p
)->interface
= interface
;
7855 (*p
)->flags
= DNSServer_FlagNew
;
7856 (*p
)->timeout
= timeout
;
7857 AssignDomainName(&(*p
)->domain
, d
);
7858 (*p
)->next
= mDNSNULL
;
7864 mDNSinline mDNSs32
PenaltyTimeForServer(mDNS
*m
, DNSServer
*server
)
7867 if (server
->penaltyTime
!= 0)
7869 ptime
= server
->penaltyTime
- m
->timenow
;
7872 // This should always be a positive value between 0 and DNSSERVER_PENALTY_TIME
7873 // If it does not get reset in ResetDNSServerPenalties for some reason, we do it
7875 LogMsg("PenaltyTimeForServer: PenaltyTime negative %d, (server penaltyTime %d, timenow %d) resetting the penalty",
7876 ptime
, server
->penaltyTime
, m
->timenow
);
7877 server
->penaltyTime
= 0;
7884 //Checks to see whether the newname is a better match for the name, given the best one we have
7885 //seen so far (given in bestcount).
7886 //Returns -1 if the newname is not a better match
7887 //Returns 0 if the newname is the same as the old match
7888 //Returns 1 if the newname is a better match
7889 mDNSlocal
int BetterMatchForName(const domainname
*name
, int namecount
, const domainname
*newname
, int newcount
,
7892 // If the name contains fewer labels than the new server's domain or the new name
7893 // contains fewer labels than the current best, then it can't possibly be a better match
7894 if (namecount
< newcount
|| newcount
< bestcount
) return -1;
7896 // If there is no match, return -1 and the caller will skip this newname for
7899 // If we find a match and the number of labels is the same as bestcount, then
7900 // we return 0 so that the caller can do additional logic to pick one of
7901 // the best based on some other factors e.g., penaltyTime
7903 // If we find a match and the number of labels is more than bestcount, then we
7904 // return 1 so that the caller can pick this over the old one.
7906 // Note: newcount can either be equal or greater than bestcount beause of the
7909 if (SameDomainName(SkipLeadingLabels(name
, namecount
- newcount
), newname
))
7910 return bestcount
== newcount
? 0 : 1;
7915 // Normally, we have McastResolvers for .local, in-addr.arpa and ip6.arpa. But there
7916 // can be queries that can forced to multicast (ForceMCast) even though they don't end in these
7917 // names. In that case, we give a default timeout of 5 seconds
7918 #define DEFAULT_MCAST_TIMEOUT 5
7919 mDNSlocal mDNSu32
GetTimeoutForMcastQuestion(mDNS
*m
, DNSQuestion
*question
)
7921 McastResolver
*curmatch
= mDNSNULL
;
7922 int bestmatchlen
= -1, namecount
= CountLabels(&question
->qname
);
7923 McastResolver
*curr
;
7924 int bettermatch
, currcount
;
7925 for (curr
= m
->McastResolvers
; curr
; curr
= curr
->next
)
7927 currcount
= CountLabels(&curr
->domain
);
7928 bettermatch
= BetterMatchForName(&question
->qname
, namecount
, &curr
->domain
, currcount
, bestmatchlen
);
7929 // Take the first best match. If there are multiple equally good matches (bettermatch = 0), we take
7930 // the timeout value from the first one
7931 if (bettermatch
== 1)
7934 bestmatchlen
= currcount
;
7937 LogInfo("GetTimeoutForMcastQuestion: question %##s curmatch %p, Timeout %d", question
->qname
.c
, curmatch
,
7938 curmatch
? curmatch
->timeout
: DEFAULT_MCAST_TIMEOUT
);
7939 return ( curmatch
? curmatch
->timeout
: DEFAULT_MCAST_TIMEOUT
);
7942 // Sets all the Valid DNS servers for a question
7943 mDNSexport mDNSu32
SetValidDNSServers(mDNS
*m
, DNSQuestion
*question
)
7945 DNSServer
*curmatch
= mDNSNULL
;
7946 int bestmatchlen
= -1, namecount
= CountLabels(&question
->qname
);
7948 int bettermatch
, currcount
;
7950 mDNSu32 timeout
= 0;
7952 question
->validDNSServers
= zeroOpaque64
;
7953 for (curr
= m
->DNSServers
; curr
; curr
= curr
->next
)
7955 debugf("SetValidDNSServers: Parsing DNS server Address %#a (Domain %##s), Scope: %d", &curr
->addr
, curr
->domain
.c
, curr
->scoped
);
7956 // skip servers that will soon be deleted
7957 if (curr
->flags
& DNSServer_FlagDelete
)
7958 { debugf("SetValidDNSServers: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index
, &curr
->addr
, curr
->domain
.c
, curr
->scoped
); continue; }
7960 // This happens normally when you unplug the interface where we reset the interfaceID to mDNSInterface_Any for all
7961 // the DNS servers whose scope match the interfaceID. Few seconds later, we also receive the updated DNS configuration.
7962 // But any questions that has mDNSInterface_Any scope that are started/restarted before we receive the update
7963 // (e.g., CheckSuppressUnusableQuestions is called when interfaces are deregistered with the core) should not
7964 // match the scoped entries by mistake.
7966 // Note: DNS configuration change will help pick the new dns servers but currently it does not affect the timeout
7968 if (curr
->scoped
&& curr
->interface
== mDNSInterface_Any
)
7969 { debugf("SetValidDNSServers: Scoped DNS server %#a (Domain %##s) with Interface Any", &curr
->addr
, curr
->domain
.c
); continue; }
7971 currcount
= CountLabels(&curr
->domain
);
7972 if ((!curr
->scoped
&& (!question
->InterfaceID
|| (question
->InterfaceID
== mDNSInterface_Unicast
))) || (curr
->interface
== question
->InterfaceID
))
7974 bettermatch
= BetterMatchForName(&question
->qname
, namecount
, &curr
->domain
, currcount
, bestmatchlen
);
7976 // If we found a better match (bettermatch == 1) then clear all the bits
7977 // corresponding to the old DNSServers that we have may set before and start fresh.
7978 // If we find an equal match, then include that DNSServer also by setting the corresponding
7980 if ((bettermatch
== 1) || (bettermatch
== 0))
7983 bestmatchlen
= currcount
;
7984 if (bettermatch
) { debugf("SetValidDNSServers: Resetting all the bits"); question
->validDNSServers
= zeroOpaque64
; timeout
= 0; }
7985 debugf("SetValidDNSServers: question %##s Setting the bit for DNS server Address %#a (Domain %##s), Scoped:%d index %d,"
7986 " Timeout %d, interface %p", question
->qname
.c
, &curr
->addr
, curr
->domain
.c
, curr
->scoped
, index
, curr
->timeout
,
7988 timeout
+= curr
->timeout
;
7989 bit_set_opaque64(question
->validDNSServers
, index
);
7994 question
->noServerResponse
= 0;
7996 debugf("SetValidDNSServers: ValidDNSServer bits 0x%x%x for question %p %##s (%s)",
7997 question
->validDNSServers
.l
[1], question
->validDNSServers
.l
[0], question
, question
->qname
.c
, DNSTypeName(question
->qtype
));
7998 // If there are no matching resolvers, then use the default value to timeout
7999 return (timeout
? timeout
: DEFAULT_UDNS_TIMEOUT
);
8002 // Get the Best server that matches a name. If you find penalized servers, look for the one
8003 // that will come out of the penalty box soon
8004 mDNSlocal DNSServer
*GetBestServer(mDNS
*m
, const domainname
*name
, mDNSInterfaceID InterfaceID
, mDNSOpaque64 validBits
, int *selected
, mDNSBool nameMatch
)
8006 DNSServer
*curmatch
= mDNSNULL
;
8007 int bestmatchlen
= -1, namecount
= name
? CountLabels(name
) : 0;
8009 mDNSs32 bestPenaltyTime
, currPenaltyTime
;
8010 int bettermatch
, currcount
;
8014 debugf("GetBestServer: ValidDNSServer bits 0x%x%x", validBits
.l
[1], validBits
.l
[0]);
8015 bestPenaltyTime
= DNSSERVER_PENALTY_TIME
+ 1;
8016 for (curr
= m
->DNSServers
; curr
; curr
= curr
->next
)
8018 // skip servers that will soon be deleted
8019 if (curr
->flags
& DNSServer_FlagDelete
)
8020 { debugf("GetBestServer: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index
, &curr
->addr
, curr
->domain
.c
, curr
->scoped
); continue; }
8022 // Check if this is a valid DNSServer
8023 if (!bit_get_opaque64(validBits
, index
)) { debugf("GetBestServer: continuing for index %d", index
); index
++; continue; }
8025 currcount
= CountLabels(&curr
->domain
);
8026 currPenaltyTime
= PenaltyTimeForServer(m
, curr
);
8028 debugf("GetBestServer: Address %#a (Domain %##s), PenaltyTime(abs) %d, PenaltyTime(rel) %d",
8029 &curr
->addr
, curr
->domain
.c
, curr
->penaltyTime
, currPenaltyTime
);
8031 // If there are multiple best servers for a given question, we will pick the first one
8032 // if none of them are penalized. If some of them are penalized in that list, we pick
8033 // the least penalized one. BetterMatchForName walks through all best matches and
8034 // "currPenaltyTime < bestPenaltyTime" check lets us either pick the first best server
8035 // in the list when there are no penalized servers and least one among them
8036 // when there are some penalized servers
8038 // Notes on InterfaceID matching:
8040 // 1) A DNSServer entry may have an InterfaceID but the scoped flag may not be set. This
8041 // is the old way of specifying an InterfaceID option for DNSServer. We recoginize these
8042 // entries by "scoped" being false. These are like any other unscoped entries except that
8043 // if it is picked e.g., domain match, when the packet is sent out later, the packet will
8044 // be sent out on that interface. Theese entries can be matched by either specifying a
8045 // zero InterfaceID or non-zero InterfaceID on the question. Specifying an InterfaceID on
8046 // the question will cause an extra check on matching the InterfaceID on the question
8047 // against the DNSServer.
8049 // 2) A DNSServer may also have both scoped set and InterfaceID non-NULL. This
8050 // is the new way of specifying an InterfaceID option for DNSServer. These will be considered
8051 // only when the question has non-zero interfaceID.
8053 if ((!curr
->scoped
&& !InterfaceID
) || (curr
->interface
== InterfaceID
))
8056 // If we know that all the names are already equally good matches, then skip calling BetterMatchForName.
8057 // This happens when we initially walk all the DNS servers and set the validity bit on the question.
8058 // Actually we just need PenaltyTime match, but for the sake of readability we just skip the expensive
8059 // part and still do some redundant steps e.g., InterfaceID match
8061 if (nameMatch
) bettermatch
= BetterMatchForName(name
, namecount
, &curr
->domain
, currcount
, bestmatchlen
);
8062 else bettermatch
= 0;
8064 // If we found a better match (bettermatch == 1) then we don't need to
8065 // compare penalty times. But if we found an equal match, then we compare
8066 // the penalty times to pick a better match
8068 if ((bettermatch
== 1) || ((bettermatch
== 0) && currPenaltyTime
< bestPenaltyTime
))
8069 { currindex
= index
; curmatch
= curr
; bestmatchlen
= currcount
; bestPenaltyTime
= currPenaltyTime
; }
8073 if (selected
) *selected
= currindex
;
8077 // Look up a DNS Server, matching by name and InterfaceID
8078 mDNSexport DNSServer
*GetServerForName(mDNS
*m
, const domainname
*name
, mDNSInterfaceID InterfaceID
)
8080 DNSServer
*curmatch
= mDNSNULL
;
8081 char *ifname
= mDNSNULL
; // for logging purposes only
8082 mDNSOpaque64 allValid
;
8084 if ((InterfaceID
== mDNSInterface_Unicast
) || (InterfaceID
== mDNSInterface_LocalOnly
))
8085 InterfaceID
= mDNSNULL
;
8087 if (InterfaceID
) ifname
= InterfaceNameForID(m
, InterfaceID
);
8089 // By passing in all ones, we make sure that every DNS server is considered
8090 allValid
.l
[0] = allValid
.l
[1] = 0xFFFFFFFF;
8092 curmatch
= GetBestServer(m
, name
, InterfaceID
, allValid
, mDNSNULL
, mDNStrue
);
8094 if (curmatch
!= mDNSNULL
)
8095 LogInfo("GetServerForName: DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s", &curmatch
->addr
,
8096 mDNSVal16(curmatch
->port
), (curmatch
->penaltyTime
? (curmatch
->penaltyTime
- m
->timenow
) : 0), ifname
? ifname
: "None",
8099 LogInfo("GetServerForName: no DNS server (Scope %s:%p) found for name %##s", ifname
? ifname
: "None", InterfaceID
, name
);
8104 // Look up a DNS Server for a question within its valid DNSServer bits
8105 mDNSexport DNSServer
*GetServerForQuestion(mDNS
*m
, DNSQuestion
*question
)
8107 DNSServer
*curmatch
= mDNSNULL
;
8108 char *ifname
= mDNSNULL
; // for logging purposes only
8109 mDNSInterfaceID InterfaceID
= question
->InterfaceID
;
8110 const domainname
*name
= &question
->qname
;
8113 if ((InterfaceID
== mDNSInterface_Unicast
) || (InterfaceID
== mDNSInterface_LocalOnly
))
8114 InterfaceID
= mDNSNULL
;
8116 if (InterfaceID
) ifname
= InterfaceNameForID(m
, InterfaceID
);
8118 if (!mDNSOpaque64IsZero(&question
->validDNSServers
))
8120 curmatch
= GetBestServer(m
, name
, InterfaceID
, question
->validDNSServers
, &currindex
, mDNSfalse
);
8121 if (currindex
!= -1) bit_clr_opaque64(question
->validDNSServers
, currindex
);
8124 if (curmatch
!= mDNSNULL
)
8125 LogInfo("GetServerForQuestion: %p DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s (%s)", question
, &curmatch
->addr
,
8126 mDNSVal16(curmatch
->port
), (curmatch
->penaltyTime
? (curmatch
->penaltyTime
- m
->timenow
) : 0), ifname
? ifname
: "None",
8127 InterfaceID
, name
, DNSTypeName(question
->qtype
));
8129 LogInfo("GetServerForQuestion: %p no DNS server (Scope %s:%p) found for name %##s (%s)", question
, ifname
? ifname
: "None", InterfaceID
, name
, DNSTypeName(question
->qtype
));
8135 #define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \
8136 (mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort)))
8138 // Called in normal client context (lock not held)
8139 mDNSlocal
void LLQNATCallback(mDNS
*m
, NATTraversalInfo
*n
)
8144 LogInfo("LLQNATCallback external address:port %.4a:%u, NAT result %d", &n
->ExternalAddress
, mDNSVal16(n
->ExternalPort
), n
->Result
);
8145 for (q
= m
->Questions
; q
; q
=q
->next
)
8146 if (ActiveQuestion(q
) && !mDNSOpaque16IsZero(q
->TargetQID
) && q
->LongLived
)
8147 startLLQHandshake(m
, q
); // If ExternalPort is zero, will do StartLLQPolling instead
8148 #if APPLE_OSX_mDNSResponder
8149 UpdateAutoTunnelDomainStatuses(m
);
8154 mDNSlocal mDNSBool
ShouldSuppressQuery(mDNS
*const m
, domainname
*qname
, mDNSu16 qtype
, mDNSInterfaceID InterfaceID
)
8156 NetworkInterfaceInfo
*i
;
8158 DomainAuthInfo
*AuthInfo
;
8160 if (qtype
== kDNSType_A
) iptype
= mDNSAddrType_IPv4
;
8161 else if (qtype
== kDNSType_AAAA
) iptype
= mDNSAddrType_IPv6
;
8162 else { LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type", qname
, DNSTypeName(qtype
)); return mDNSfalse
; }
8164 // We still want the ability to be able to listen to the local services and hence
8165 // don't fail .local requests. We always have a loopback interface which we don't
8167 if (InterfaceID
!= mDNSInterface_Unicast
&& IsLocalDomain(qname
)) { LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local question", qname
, DNSTypeName(qtype
)); return mDNSfalse
; }
8169 // Skip Private domains as we have special addresses to get the hosts in the Private domain
8170 AuthInfo
= GetAuthInfoForName_internal(m
, qname
);
8171 if (AuthInfo
&& !AuthInfo
->deltime
&& AuthInfo
->AutoTunnel
)
8172 { LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Private Domain", qname
, DNSTypeName(qtype
)); return mDNSfalse
; }
8174 // Match on Type, Address and InterfaceID
8176 // Check whether we are looking for a name that ends in .local, then presence of a link-local
8177 // address on the interface is sufficient.
8178 for (i
= m
->HostInterfaces
; i
; i
= i
->next
)
8180 if (i
->ip
.type
!= iptype
) continue;
8182 if (!InterfaceID
|| (InterfaceID
== mDNSInterface_LocalOnly
) || (InterfaceID
== mDNSInterface_P2P
) ||
8183 (InterfaceID
== mDNSInterface_Unicast
) || (i
->InterfaceID
== InterfaceID
))
8185 if (iptype
== mDNSAddrType_IPv4
&& !mDNSv4AddressIsLoopback(&i
->ip
.ip
.v4
) && !mDNSv4AddressIsLinkLocal(&i
->ip
.ip
.v4
))
8187 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local Address %.4a found", qname
, DNSTypeName(qtype
),
8189 if (m
->SleepState
== SleepState_Sleeping
)
8190 LogInfo("ShouldSuppressQuery: Would have returned true earlier");
8193 else if (iptype
== mDNSAddrType_IPv6
&&
8194 !mDNSv6AddressIsLoopback(&i
->ip
.ip
.v6
) &&
8195 !mDNSv6AddressIsLinkLocal(&i
->ip
.ip
.v6
) &&
8196 !mDNSSameIPv6Address(i
->ip
.ip
.v6
, m
->AutoTunnelHostAddr
) &&
8197 !mDNSSameIPv6Address(i
->ip
.ip
.v6
, m
->AutoTunnelRelayAddrOut
))
8199 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local Address %.16a found", qname
, DNSTypeName(qtype
),
8201 if (m
->SleepState
== SleepState_Sleeping
)
8202 LogInfo("ShouldSuppressQuery: Would have returned true earlier");
8207 LogInfo("ShouldSuppressQuery: Query suppressed for %##s, qtype %s, because no matching interface found", qname
, DNSTypeName(qtype
));
8211 mDNSlocal
void CacheRecordRmvEventsForCurrentQuestion(mDNS
*const m
, DNSQuestion
*q
)
8217 slot
= HashSlot(&q
->qname
);
8218 cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
8219 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
8221 // Don't deliver RMV events for negative records
8222 if (rr
->resrec
.RecordType
== kDNSRecordTypePacketNegative
)
8224 LogInfo("CacheRecordRmvEventsForCurrentQuestion: CacheRecord %s Suppressing RMV events for question %p %##s (%s), CRActiveQuestion %p, CurrentAnswers %d",
8225 CRDisplayString(m
, rr
), q
, q
->qname
.c
, DNSTypeName(q
->qtype
), rr
->CRActiveQuestion
, q
->CurrentAnswers
);
8229 if (SameNameRecordAnswersQuestion(&rr
->resrec
, q
))
8231 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Calling AnswerCurrentQuestionWithResourceRecord (RMV) for question %##s using resource record %s LocalAnswers %d",
8232 q
->qname
.c
, CRDisplayString(m
, rr
), q
->LOAddressAnswers
);
8234 q
->CurrentAnswers
--;
8235 if (rr
->resrec
.rdlength
> SmallRecordLimit
) q
->LargeAnswers
--;
8236 if (rr
->resrec
.RecordType
& kDNSRecordTypePacketUniqueMask
) q
->UniqueAnswers
--;
8238 if (rr
->CRActiveQuestion
== q
)
8241 // If this was the active question for this cache entry, it was the one that was
8242 // responsible for keeping the cache entry fresh when the cache entry was reaching
8243 // its expiry. We need to handover the responsibility to someone else. Otherwise,
8244 // when the cache entry is about to expire, we won't find an active question
8245 // (pointed by CRActiveQuestion) to refresh the cache.
8246 for (qptr
= m
->Questions
; qptr
; qptr
=qptr
->next
)
8247 if (qptr
!= q
&& ActiveQuestion(qptr
) && ResourceRecordAnswersQuestion(&rr
->resrec
, qptr
))
8251 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Updating CRActiveQuestion to %p for cache record %s, "
8252 "Original question CurrentAnswers %d, new question CurrentAnswers %d, SuppressUnusable %d, SuppressQuery %d",
8253 qptr
, CRDisplayString(m
,rr
), q
->CurrentAnswers
, qptr
->CurrentAnswers
, qptr
->SuppressUnusable
, qptr
->SuppressQuery
);
8255 rr
->CRActiveQuestion
= qptr
; // Question used to be active; new value may or may not be null
8256 if (!qptr
) m
->rrcache_active
--; // If no longer active, decrement rrcache_active count
8258 AnswerCurrentQuestionWithResourceRecord(m
, rr
, QC_rmv
);
8259 if (m
->CurrentQuestion
!= q
) break; // If callback deleted q, then we're finished here
8264 mDNSlocal mDNSBool
IsQuestionNew(mDNS
*const m
, DNSQuestion
*question
)
8267 for (q
= m
->NewQuestions
; q
; q
= q
->next
)
8268 if (q
== question
) return mDNStrue
;
8272 mDNSlocal mDNSBool
LocalRecordRmvEventsForQuestion(mDNS
*const m
, DNSQuestion
*q
)
8278 if (m
->CurrentQuestion
)
8279 LogMsg("LocalRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)",
8280 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
8282 if (IsQuestionNew(m
, q
))
8284 LogInfo("LocalRecordRmvEventsForQuestion: New Question %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
8287 m
->CurrentQuestion
= q
;
8288 slot
= AuthHashSlot(&q
->qname
);
8289 ag
= AuthGroupForName(&m
->rrauth
, slot
, q
->qnamehash
, &q
->qname
);
8292 for (rr
= ag
->members
; rr
; rr
=rr
->next
)
8293 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME
8294 if (LORecordAnswersAddressType(rr
) && LocalOnlyRecordAnswersQuestion(rr
, q
))
8296 LogInfo("LocalRecordRmvEventsForQuestion: Delivering possible Rmv events with record %s",
8297 ARDisplayString(m
, rr
));
8298 if (q
->CurrentAnswers
<= 0 || q
->LOAddressAnswers
<= 0)
8300 LogMsg("LocalRecordRmvEventsForQuestion: ERROR!! CurrentAnswers or LOAddressAnswers is zero %p %##s"
8301 " (%s) CurrentAnswers %d, LOAddressAnswers %d", q
, q
->qname
.c
, DNSTypeName(q
->qtype
),
8302 q
->CurrentAnswers
, q
->LOAddressAnswers
);
8305 AnswerLocalQuestionWithLocalAuthRecord(m
, rr
, QC_rmv
); // MUST NOT dereference q again
8306 if (m
->CurrentQuestion
!= q
) { m
->CurrentQuestion
= mDNSNULL
; return mDNSfalse
; }
8309 m
->CurrentQuestion
= mDNSNULL
;
8313 // Returns false if the question got deleted while delivering the RMV events
8314 // The caller should handle the case
8315 mDNSlocal mDNSBool
CacheRecordRmvEventsForQuestion(mDNS
*const m
, DNSQuestion
*q
)
8317 if (m
->CurrentQuestion
)
8318 LogMsg("CacheRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)",
8319 m
->CurrentQuestion
->qname
.c
, DNSTypeName(m
->CurrentQuestion
->qtype
));
8321 // If it is a new question, we have not delivered any ADD events yet. So, don't deliver RMV events.
8322 // If this question was answered using local auth records, then you can't deliver RMVs using cache
8323 if (!IsQuestionNew(m
, q
) && !q
->LOAddressAnswers
)
8325 m
->CurrentQuestion
= q
;
8326 CacheRecordRmvEventsForCurrentQuestion(m
, q
);
8327 if (m
->CurrentQuestion
!= q
) { m
->CurrentQuestion
= mDNSNULL
; return mDNSfalse
; }
8328 m
->CurrentQuestion
= mDNSNULL
;
8330 else { LogInfo("CacheRecordRmvEventsForQuestion: Question %p %##s (%s) is a new question", q
, q
->qname
.c
, DNSTypeName(q
->qtype
)); }
8334 // The caller should hold the lock
8335 mDNSexport
void CheckSuppressUnusableQuestions(mDNS
*const m
)
8338 DNSQuestion
*restart
= mDNSNULL
;
8340 // We look through all questions including new questions. During network change events,
8341 // we potentially restart questions here in this function that ends up as new questions,
8342 // which may be suppressed at this instance. Before it is handled we get another network
8343 // event that changes the status e.g., address becomes available. If we did not process
8344 // new questions, we would never change its SuppressQuery status.
8346 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the
8347 // application callback can potentially stop the current question (detected by CurrentQuestion) or
8348 // *any* other question which could be the next one that we may process here. RestartQuestion
8349 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal
8350 // if the "next" question is stopped while the CurrentQuestion is stopped
8351 if (m
->RestartQuestion
)
8352 LogMsg("CheckSuppressUnusableQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)",
8353 m
->RestartQuestion
->qname
.c
, DNSTypeName(m
->RestartQuestion
->qtype
));
8354 m
->RestartQuestion
= m
->Questions
;
8355 while (m
->RestartQuestion
)
8357 q
= m
->RestartQuestion
;
8358 m
->RestartQuestion
= q
->next
;
8359 if (!mDNSOpaque16IsZero(q
->TargetQID
) && q
->SuppressUnusable
)
8361 mDNSBool old
= q
->SuppressQuery
;
8362 q
->SuppressQuery
= ShouldSuppressQuery(m
, &q
->qname
, q
->qtype
, q
->InterfaceID
);
8363 if (q
->SuppressQuery
!= old
)
8365 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero
8366 // LOddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before
8367 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers)
8369 if (q
->SuppressQuery
)
8371 // Previously it was not suppressed, Generate RMV events for the ADDs that we might have delivered before
8372 // followed by a negative cache response. Temporarily turn off suppression so that
8373 // AnswerCurrentQuestionWithResourceRecord can answer the question
8374 q
->SuppressQuery
= mDNSfalse
;
8375 if (!CacheRecordRmvEventsForQuestion(m
, q
)) { LogInfo("CheckSuppressUnusableQuestions: Question deleted while delivering RMV events"); continue; }
8376 q
->SuppressQuery
= mDNStrue
;
8379 // SuppressUnusable does not affect questions that are answered from the local records (/etc/hosts)
8380 // and SuppressQuery status does not mean anything for these questions. As we are going to stop the
8381 // question below, we need to deliver the RMV events so that the ADDs that will be delivered during
8382 // the restart will not be a duplicate ADD
8383 if (!LocalRecordRmvEventsForQuestion(m
, q
)) { LogInfo("CheckSuppressUnusableQuestions: Question deleted while delivering RMV events"); continue; }
8385 // There are two cases here.
8387 // 1. Previously it was suppressed and now it is not suppressed, restart the question so
8388 // that it will start as a new question. Note that we can't just call ActivateUnicastQuery
8389 // because when we get the response, if we had entries in the cache already, it will not answer
8390 // this question if the cache entry did not change. Hence, we need to restart
8391 // the query so that it can be answered from the cache.
8393 // 2. Previously it was not suppressed and now it is suppressed. We need to restart the questions
8394 // so that we redo the duplicate checks in mDNS_StartQuery_internal. A SuppressUnusable question
8395 // is a duplicate of non-SuppressUnusable question if it is not suppressed (SuppressQuery is false).
8396 // A SuppressUnusable question is not a duplicate of non-SuppressUnusable question if it is suppressed
8397 // (SuppressQuery is true). The reason for this is that when a question is suppressed, we want an
8398 // immediate response and not want to be blocked behind a question that is querying DNS servers. When
8399 // the question is not suppressed, we don't want two active questions sending packets on the wire.
8400 // This affects both efficiency and also the current design where there is only one active question
8401 // pointed to from a cache entry.
8403 // We restart queries in a two step process by first calling stop and build a temporary list which we
8404 // will restart at the end. The main reason for the two step process is to handle duplicate questions.
8405 // If there are duplicate questions, calling stop inherits the values from another question on the list (which
8406 // will soon become the real question) including q->ThisQInterval which might be zero if it was
8407 // suppressed before. At the end when we have restarted all questions, none of them is active as each
8408 // inherits from one another and we need to reactivate one of the questions here which is a little hacky.
8410 // It is much cleaner and less error prone to build a list of questions and restart at the end.
8412 LogInfo("CheckSuppressUnusableQuestions: Stop question %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
8413 mDNS_StopQuery_internal(m
, q
);
8422 restart
= restart
->next
;
8424 LogInfo("CheckSuppressUnusableQuestions: Start question %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
8425 mDNS_StartQuery_internal(m
, q
);
8429 mDNSexport mStatus
mDNS_StartQuery_internal(mDNS
*const m
, DNSQuestion
*const question
)
8431 if (question
->Target
.type
&& !ValidQuestionTarget(question
))
8433 LogMsg("mDNS_StartQuery_internal: Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery? for question %##s)",
8434 question
->Target
.type
, mDNSVal16(question
->TargetPort
), question
->qname
.c
);
8435 question
->Target
.type
= mDNSAddrType_None
;
8438 if (!question
->Target
.type
) question
->TargetPort
= zeroIPPort
; // If no question->Target specified clear TargetPort
8440 question
->TargetQID
=
8441 #ifndef UNICAST_DISABLED
8442 (question
->Target
.type
|| Question_uDNS(question
)) ? mDNS_NewMessageID(m
) :
8443 #endif // UNICAST_DISABLED
8446 debugf("mDNS_StartQuery: %##s (%s)", question
->qname
.c
, DNSTypeName(question
->qtype
));
8448 if (m
->rrcache_size
== 0) // Can't do queries if we have no cache space allocated
8449 return(mStatus_NoCache
);
8455 if (!ValidateDomainName(&question
->qname
))
8457 LogMsg("Attempt to start query with invalid qname %##s (%s)", question
->qname
.c
, DNSTypeName(question
->qtype
));
8458 return(mStatus_Invalid
);
8461 // Note: It important that new questions are appended at the *end* of the list, not prepended at the start
8463 if (question
->InterfaceID
== mDNSInterface_LocalOnly
|| question
->InterfaceID
== mDNSInterface_P2P
) q
= &m
->LocalOnlyQuestions
;
8464 while (*q
&& *q
!= question
) q
=&(*q
)->next
;
8468 LogMsg("Error! Tried to add a question %##s (%s) %p that's already in the active list",
8469 question
->qname
.c
, DNSTypeName(question
->qtype
), question
);
8470 return(mStatus_AlreadyRegistered
);
8475 // If this question is referencing a specific interface, verify it exists
8476 if (question
->InterfaceID
&& question
->InterfaceID
!= mDNSInterface_LocalOnly
&& question
->InterfaceID
!= mDNSInterface_Unicast
&& question
->InterfaceID
!= mDNSInterface_P2P
)
8478 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, question
->InterfaceID
);
8480 LogMsg("Note: InterfaceID %p for question %##s (%s) not currently found in active interface list",
8481 question
->InterfaceID
, question
->qname
.c
, DNSTypeName(question
->qtype
));
8484 // Note: In the case where we already have the answer to this question in our cache, that may be all the client
8485 // wanted, and they may immediately cancel their question. In this case, sending an actual query on the wire would
8486 // be a waste. For that reason, we schedule our first query to go out in half a second (InitialQuestionInterval).
8487 // If AnswerNewQuestion() finds that we have *no* relevant answers currently in our cache, then it will accelerate
8488 // that to go out immediately.
8489 question
->next
= mDNSNULL
;
8490 question
->qnamehash
= DomainNameHashValue(&question
->qname
); // MUST do this before FindDuplicateQuestion()
8491 question
->DelayAnswering
= CheckForSoonToExpireRecords(m
, &question
->qname
, question
->qnamehash
, HashSlot(&question
->qname
));
8492 question
->LastQTime
= m
->timenow
;
8493 question
->ThisQInterval
= InitialQuestionInterval
; // MUST be > zero for an active question
8494 question
->ExpectUnicastResp
= 0;
8495 question
->LastAnswerPktNum
= m
->PktNum
;
8496 question
->RecentAnswerPkts
= 0;
8497 question
->CurrentAnswers
= 0;
8498 question
->LargeAnswers
= 0;
8499 question
->UniqueAnswers
= 0;
8500 question
->LOAddressAnswers
= 0;
8501 question
->FlappingInterface1
= mDNSNULL
;
8502 question
->FlappingInterface2
= mDNSNULL
;
8503 // Must do AuthInfo and SuppressQuery before calling FindDuplicateQuestion()
8504 question
->AuthInfo
= GetAuthInfoForQuestion(m
, question
);
8505 if (question
->SuppressUnusable
)
8506 question
->SuppressQuery
= ShouldSuppressQuery(m
, &question
->qname
, question
->qtype
, question
->InterfaceID
);
8508 question
->SuppressQuery
= 0;
8509 question
->DuplicateOf
= FindDuplicateQuestion(m
, question
);
8510 question
->NextInDQList
= mDNSNULL
;
8511 question
->SendQNow
= mDNSNULL
;
8512 question
->SendOnAll
= mDNSfalse
;
8513 question
->RequestUnicast
= 0;
8514 question
->LastQTxTime
= m
->timenow
;
8515 question
->CNAMEReferrals
= 0;
8517 // We'll create our question->LocalSocket on demand, if needed.
8518 // We won't need one for duplicate questions, or from questions answered immediately out of the cache.
8519 // We also don't need one for LLQs because (when we're using NAT) we want them all to share a single
8520 // NAT mapping for receiving inbound add/remove events.
8521 question
->LocalSocket
= mDNSNULL
;
8522 question
->deliverAddEvents
= mDNSfalse
;
8523 question
->qDNSServer
= mDNSNULL
;
8524 question
->unansweredQueries
= 0;
8525 question
->nta
= mDNSNULL
;
8526 question
->servAddr
= zeroAddr
;
8527 question
->servPort
= zeroIPPort
;
8528 question
->tcp
= mDNSNULL
;
8529 question
->NoAnswer
= NoAnswer_Normal
;
8531 question
->state
= LLQ_InitialRequest
;
8532 question
->ReqLease
= 0;
8533 question
->expire
= 0;
8534 question
->ntries
= 0;
8535 question
->id
= zeroOpaque64
;
8536 question
->validDNSServers
= zeroOpaque64
;
8537 question
->triedAllServersOnce
= 0;
8538 question
->noServerResponse
= 0;
8539 question
->StopTime
= 0;
8540 if (question
->WakeOnResolve
)
8542 question
->WakeOnResolveCount
= InitialWakeOnResolveCount
;
8543 mDNS_PurgeBeforeResolve(m
, question
);
8546 question
->WakeOnResolveCount
= 0;
8548 if (question
->DuplicateOf
) question
->AuthInfo
= question
->DuplicateOf
->AuthInfo
;
8550 for (i
=0; i
<DupSuppressInfoSize
; i
++)
8551 question
->DupSuppress
[i
].InterfaceID
= mDNSNULL
;
8553 debugf("mDNS_StartQuery: Question %##s (%s) Interface %p Now %d Send in %d Answer in %d (%p) %s (%p)",
8554 question
->qname
.c
, DNSTypeName(question
->qtype
), question
->InterfaceID
, m
->timenow
,
8555 NextQSendTime(question
) - m
->timenow
,
8556 question
->DelayAnswering
? question
->DelayAnswering
- m
->timenow
: 0,
8557 question
, question
->DuplicateOf
? "duplicate of" : "not duplicate", question
->DuplicateOf
);
8559 if (question
->DelayAnswering
)
8560 LogInfo("mDNS_StartQuery_internal: Delaying answering for %d ticks while cache stabilizes for %##s (%s)",
8561 question
->DelayAnswering
- m
->timenow
, question
->qname
.c
, DNSTypeName(question
->qtype
));
8563 if (question
->InterfaceID
== mDNSInterface_LocalOnly
|| question
->InterfaceID
== mDNSInterface_P2P
)
8565 if (!m
->NewLocalOnlyQuestions
) m
->NewLocalOnlyQuestions
= question
;
8569 if (!m
->NewQuestions
) m
->NewQuestions
= question
;
8571 // If the question's id is non-zero, then it's Wide Area
8572 // MUST NOT do this Wide Area setup until near the end of
8573 // mDNS_StartQuery_internal -- this code may itself issue queries (e.g. SOA,
8574 // NS, etc.) and if we haven't finished setting up our own question and setting
8575 // m->NewQuestions if necessary then we could end up recursively re-entering
8576 // this routine with the question list data structures in an inconsistent state.
8577 if (!mDNSOpaque16IsZero(question
->TargetQID
))
8579 // Duplicate questions should have the same DNSServers so that when we find
8580 // a matching resource record, all of them get the answers. Calling GetServerForQuestion
8581 // for the duplicate question may get a different DNS server from the original question
8582 mDNSu32 timeout
= SetValidDNSServers(m
, question
);
8583 // We set the timeout whenever mDNS_StartQuery_internal is called. This means if we have
8584 // a networking change/search domain change that calls this function again we keep
8585 // reinitializing the timeout value which means it may never timeout. If this becomes
8586 // a common case in the future, we can easily fix this by adding extra state that
8587 // indicates that we have already set the StopTime.
8588 if (question
->TimeoutQuestion
)
8589 question
->StopTime
= NonZeroTime(m
->timenow
+ timeout
* mDNSPlatformOneSecond
);
8590 if (question
->DuplicateOf
)
8592 question
->validDNSServers
= question
->DuplicateOf
->validDNSServers
;
8593 question
->qDNSServer
= question
->DuplicateOf
->qDNSServer
;
8594 LogInfo("mDNS_StartQuery_internal: Duplicate question %p (%p) %##s (%s), Timeout %d, DNS Server %#a:%d",
8595 question
, question
->DuplicateOf
, question
->qname
.c
, DNSTypeName(question
->qtype
), timeout
,
8596 question
->qDNSServer
? &question
->qDNSServer
->addr
: mDNSNULL
,
8597 mDNSVal16(question
->qDNSServer
? question
->qDNSServer
->port
: zeroIPPort
));
8601 question
->qDNSServer
= GetServerForQuestion(m
, question
);
8602 LogInfo("mDNS_StartQuery_internal: question %p %##s (%s) Timeout %d, DNS Server %#a:%d",
8603 question
, question
->qname
.c
, DNSTypeName(question
->qtype
), timeout
,
8604 question
->qDNSServer
? &question
->qDNSServer
->addr
: mDNSNULL
,
8605 mDNSVal16(question
->qDNSServer
? question
->qDNSServer
->port
: zeroIPPort
));
8607 ActivateUnicastQuery(m
, question
, mDNSfalse
);
8609 // If long-lived query, and we don't have our NAT mapping active, start it now
8610 if (question
->LongLived
&& !m
->LLQNAT
.clientContext
)
8612 m
->LLQNAT
.Protocol
= NATOp_MapUDP
;
8613 m
->LLQNAT
.IntPort
= m
->UnicastPort4
;
8614 m
->LLQNAT
.RequestedPort
= m
->UnicastPort4
;
8615 m
->LLQNAT
.clientCallback
= LLQNATCallback
;
8616 m
->LLQNAT
.clientContext
= (void*)1; // Means LLQ NAT Traversal is active
8617 mDNS_StartNATOperation_internal(m
, &m
->LLQNAT
);
8620 #if APPLE_OSX_mDNSResponder
8621 if (question
->LongLived
)
8622 UpdateAutoTunnelDomainStatuses(m
);
8628 if (question
->TimeoutQuestion
)
8629 question
->StopTime
= NonZeroTime(m
->timenow
+ GetTimeoutForMcastQuestion(m
, question
) * mDNSPlatformOneSecond
);
8631 if (question
->StopTime
) SetNextQueryStopTime(m
, question
);
8632 SetNextQueryTime(m
,question
);
8635 return(mStatus_NoError
);
8639 // CancelGetZoneData is an internal routine (i.e. must be called with the lock already held)
8640 mDNSexport
void CancelGetZoneData(mDNS
*const m
, ZoneData
*nta
)
8642 debugf("CancelGetZoneData %##s (%s)", nta
->question
.qname
.c
, DNSTypeName(nta
->question
.qtype
));
8643 // This function may be called anytime to free the zone information.The question may or may not have stopped.
8644 // If it was already stopped, mDNS_StopQuery_internal would have set q->ThisQInterval to -1 and should not
8646 if (nta
->question
.ThisQInterval
!= -1)
8648 mDNS_StopQuery_internal(m
, &nta
->question
);
8649 if (nta
->question
.ThisQInterval
!= -1)
8650 LogMsg("CancelGetZoneData: Question %##s (%s) ThisQInterval %d not -1", nta
->question
.qname
.c
, DNSTypeName(nta
->question
.qtype
), nta
->question
.ThisQInterval
);
8652 mDNSPlatformMemFree(nta
);
8655 mDNSexport mStatus
mDNS_StopQuery_internal(mDNS
*const m
, DNSQuestion
*const question
)
8657 const mDNSu32 slot
= HashSlot(&question
->qname
);
8658 CacheGroup
*cg
= CacheGroupForName(m
, slot
, question
->qnamehash
, &question
->qname
);
8660 DNSQuestion
**qp
= &m
->Questions
;
8662 //LogInfo("mDNS_StopQuery_internal %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
8664 if (question
->InterfaceID
== mDNSInterface_LocalOnly
|| question
->InterfaceID
== mDNSInterface_P2P
) qp
= &m
->LocalOnlyQuestions
;
8665 while (*qp
&& *qp
!= question
) qp
=&(*qp
)->next
;
8666 if (*qp
) *qp
= (*qp
)->next
;
8670 if (question
->ThisQInterval
>= 0) // Only log error message if the query was supposed to be active
8672 LogMsg("mDNS_StopQuery_internal: Question %##s (%s) not found in active list",
8673 question
->qname
.c
, DNSTypeName(question
->qtype
));
8677 return(mStatus_BadReferenceErr
);
8680 // Take care to cut question from list *before* calling UpdateQuestionDuplicates
8681 UpdateQuestionDuplicates(m
, question
);
8682 // But don't trash ThisQInterval until afterwards.
8683 question
->ThisQInterval
= -1;
8685 // If there are any cache records referencing this as their active question, then see if there is any
8686 // other question that is also referencing them, else their CRActiveQuestion needs to get set to NULL.
8687 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
8689 if (rr
->CRActiveQuestion
== question
)
8692 // Checking for ActiveQuestion filters questions that are suppressed also
8693 // as suppressed questions are not active
8694 for (q
= m
->Questions
; q
; q
=q
->next
) // Scan our list of questions
8695 if (ActiveQuestion(q
) && ResourceRecordAnswersQuestion(&rr
->resrec
, q
))
8698 debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s, Original question CurrentAnswers %d, new question "
8699 "CurrentAnswers %d, SuppressQuery %d", q
, CRDisplayString(m
,rr
), question
->CurrentAnswers
, q
->CurrentAnswers
, q
->SuppressQuery
);
8700 rr
->CRActiveQuestion
= q
; // Question used to be active; new value may or may not be null
8701 if (!q
) m
->rrcache_active
--; // If no longer active, decrement rrcache_active count
8705 // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv() is about to look at,
8706 // bump its pointer forward one question.
8707 if (m
->CurrentQuestion
== question
)
8709 debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)",
8710 question
->qname
.c
, DNSTypeName(question
->qtype
));
8711 m
->CurrentQuestion
= question
->next
;
8714 if (m
->NewQuestions
== question
)
8716 debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)",
8717 question
->qname
.c
, DNSTypeName(question
->qtype
));
8718 m
->NewQuestions
= question
->next
;
8721 if (m
->NewLocalOnlyQuestions
== question
) m
->NewLocalOnlyQuestions
= question
->next
;
8723 if (m
->RestartQuestion
== question
)
8725 LogMsg("mDNS_StopQuery_internal: Just deleted the current restart question: %##s (%s)",
8726 question
->qname
.c
, DNSTypeName(question
->qtype
));
8727 m
->RestartQuestion
= question
->next
;
8730 // Take care not to trash question->next until *after* we've updated m->CurrentQuestion and m->NewQuestions
8731 question
->next
= mDNSNULL
;
8733 // LogMsg("mDNS_StopQuery_internal: Question %##s (%s) removed", question->qname.c, DNSTypeName(question->qtype));
8735 // And finally, cancel any associated GetZoneData operation that's still running.
8736 // Must not do this until last, because there's a good chance the GetZoneData question is the next in the list,
8737 // so if we delete it earlier in this routine, we could find that our "question->next" pointer above is already
8738 // invalid before we even use it. By making sure that we update m->CurrentQuestion and m->NewQuestions if necessary
8739 // *first*, then they're all ready to be updated a second time if necessary when we cancel our GetZoneData query.
8740 if (question
->tcp
) { DisposeTCPConn(question
->tcp
); question
->tcp
= mDNSNULL
; }
8741 if (question
->LocalSocket
) { mDNSPlatformUDPClose(question
->LocalSocket
); question
->LocalSocket
= mDNSNULL
; }
8742 if (!mDNSOpaque16IsZero(question
->TargetQID
) && question
->LongLived
)
8744 // Scan our list to see if any more wide-area LLQs remain. If not, stop our NAT Traversal.
8746 for (q
= m
->Questions
; q
; q
=q
->next
)
8747 if (!mDNSOpaque16IsZero(q
->TargetQID
) && q
->LongLived
) break;
8750 if (!m
->LLQNAT
.clientContext
) // Should never happen, but just in case...
8751 LogMsg("mDNS_StopQuery ERROR LLQNAT.clientContext NULL");
8754 LogInfo("Stopping LLQNAT");
8755 mDNS_StopNATOperation_internal(m
, &m
->LLQNAT
);
8756 m
->LLQNAT
.clientContext
= mDNSNULL
; // Means LLQ NAT Traversal not running
8760 // If necessary, tell server it can delete this LLQ state
8761 if (question
->state
== LLQ_Established
)
8763 question
->ReqLease
= 0;
8764 sendLLQRefresh(m
, question
);
8765 // If we need need to make a TCP connection to cancel the LLQ, that's going to take a little while.
8766 // We clear the tcp->question backpointer so that when the TCP connection completes, it doesn't
8767 // crash trying to access our cancelled question, but we don't cancel the TCP operation itself --
8768 // we let that run out its natural course and complete asynchronously.
8771 question
->tcp
->question
= mDNSNULL
;
8772 question
->tcp
= mDNSNULL
;
8775 #if APPLE_OSX_mDNSResponder
8776 UpdateAutoTunnelDomainStatuses(m
);
8779 // wait until we send the refresh above which needs the nta
8780 if (question
->nta
) { CancelGetZoneData(m
, question
->nta
); question
->nta
= mDNSNULL
; }
8782 return(mStatus_NoError
);
8785 mDNSexport mStatus
mDNS_StartQuery(mDNS
*const m
, DNSQuestion
*const question
)
8789 status
= mDNS_StartQuery_internal(m
, question
);
8794 mDNSexport mStatus
mDNS_StopQuery(mDNS
*const m
, DNSQuestion
*const question
)
8798 status
= mDNS_StopQuery_internal(m
, question
);
8803 // Note that mDNS_StopQueryWithRemoves() does not currently implement the full generality of the other APIs
8804 // Specifically, question callbacks invoked as a result of this call cannot themselves make API calls.
8805 // We invoke the callback without using mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback
8806 // specifically to catch and report if the client callback does try to make API calls
8807 mDNSexport mStatus
mDNS_StopQueryWithRemoves(mDNS
*const m
, DNSQuestion
*const question
)
8813 // Check if question is new -- don't want to give remove events for a question we haven't even answered yet
8814 for (qq
= m
->NewQuestions
; qq
; qq
=qq
->next
) if (qq
== question
) break;
8816 status
= mDNS_StopQuery_internal(m
, question
);
8817 if (status
== mStatus_NoError
&& !qq
)
8819 const CacheRecord
*rr
;
8820 const mDNSu32 slot
= HashSlot(&question
->qname
);
8821 CacheGroup
*const cg
= CacheGroupForName(m
, slot
, question
->qnamehash
, &question
->qname
);
8822 LogInfo("Generating terminal removes for %##s (%s)", question
->qname
.c
, DNSTypeName(question
->qtype
));
8823 for (rr
= cg
? cg
->members
: mDNSNULL
; rr
; rr
=rr
->next
)
8824 if (rr
->resrec
.RecordType
!= kDNSRecordTypePacketNegative
&& SameNameRecordAnswersQuestion(&rr
->resrec
, question
))
8826 // Don't use mDNS_DropLockBeforeCallback() here, since we don't allow API calls
8827 if (question
->QuestionCallback
)
8828 question
->QuestionCallback(m
, question
, &rr
->resrec
, mDNSfalse
);
8835 mDNSexport mStatus
mDNS_Reconfirm(mDNS
*const m
, CacheRecord
*const cr
)
8839 status
= mDNS_Reconfirm_internal(m
, cr
, kDefaultReconfirmTimeForNoAnswer
);
8840 if (status
== mStatus_NoError
) ReconfirmAntecedents(m
, cr
->resrec
.name
, cr
->resrec
.namehash
, 0);
8845 mDNSexport mStatus
mDNS_ReconfirmByValue(mDNS
*const m
, ResourceRecord
*const rr
)
8847 mStatus status
= mStatus_BadReferenceErr
;
8850 cr
= FindIdenticalRecordInCache(m
, rr
);
8851 debugf("mDNS_ReconfirmByValue: %p %s", cr
, RRDisplayString(m
, rr
));
8852 if (cr
) status
= mDNS_Reconfirm_internal(m
, cr
, kDefaultReconfirmTimeForNoAnswer
);
8853 if (status
== mStatus_NoError
) ReconfirmAntecedents(m
, cr
->resrec
.name
, cr
->resrec
.namehash
, 0);
8858 mDNSlocal mStatus
mDNS_StartBrowse_internal(mDNS
*const m
, DNSQuestion
*const question
,
8859 const domainname
*const srv
, const domainname
*const domain
,
8860 const mDNSInterfaceID InterfaceID
, mDNSBool ForceMCast
, mDNSQuestionCallback
*Callback
, void *Context
)
8862 question
->InterfaceID
= InterfaceID
;
8863 question
->Target
= zeroAddr
;
8864 question
->qtype
= kDNSType_PTR
;
8865 question
->qclass
= kDNSClass_IN
;
8866 question
->LongLived
= mDNStrue
;
8867 question
->ExpectUnique
= mDNSfalse
;
8868 question
->ForceMCast
= ForceMCast
;
8869 question
->ReturnIntermed
= mDNSfalse
;
8870 question
->SuppressUnusable
= mDNSfalse
;
8871 question
->SearchListIndex
= 0;
8872 question
->AppendSearchDomains
= 0;
8873 question
->RetryWithSearchDomains
= mDNSfalse
;
8874 question
->TimeoutQuestion
= 0;
8875 question
->WakeOnResolve
= 0;
8876 question
->qnameOrig
= mDNSNULL
;
8877 question
->QuestionCallback
= Callback
;
8878 question
->QuestionContext
= Context
;
8879 if (!ConstructServiceName(&question
->qname
, mDNSNULL
, srv
, domain
)) return(mStatus_BadParamErr
);
8881 return(mDNS_StartQuery_internal(m
, question
));
8884 mDNSexport mStatus
mDNS_StartBrowse(mDNS
*const m
, DNSQuestion
*const question
,
8885 const domainname
*const srv
, const domainname
*const domain
,
8886 const mDNSInterfaceID InterfaceID
, mDNSBool ForceMCast
, mDNSQuestionCallback
*Callback
, void *Context
)
8890 status
= mDNS_StartBrowse_internal(m
, question
, srv
, domain
, InterfaceID
, ForceMCast
, Callback
, Context
);
8895 mDNSlocal mDNSBool
MachineHasActiveIPv6(mDNS
*const m
)
8897 NetworkInterfaceInfo
*intf
;
8898 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
8899 if (intf
->ip
.type
== mDNSAddrType_IPv6
) return(mDNStrue
);
8903 mDNSlocal
void FoundServiceInfoSRV(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
, QC_result AddRecord
)
8905 ServiceInfoQuery
*query
= (ServiceInfoQuery
*)question
->QuestionContext
;
8906 mDNSBool PortChanged
= !mDNSSameIPPort(query
->info
->port
, answer
->rdata
->u
.srv
.port
);
8907 if (!AddRecord
) return;
8908 if (answer
->rrtype
!= kDNSType_SRV
) return;
8910 query
->info
->port
= answer
->rdata
->u
.srv
.port
;
8912 // If this is our first answer, then set the GotSRV flag and start the address query
8915 query
->GotSRV
= mDNStrue
;
8916 query
->qAv4
.InterfaceID
= answer
->InterfaceID
;
8917 AssignDomainName(&query
->qAv4
.qname
, &answer
->rdata
->u
.srv
.target
);
8918 query
->qAv6
.InterfaceID
= answer
->InterfaceID
;
8919 AssignDomainName(&query
->qAv6
.qname
, &answer
->rdata
->u
.srv
.target
);
8920 mDNS_StartQuery(m
, &query
->qAv4
);
8921 // Only do the AAAA query if this machine actually has IPv6 active
8922 if (MachineHasActiveIPv6(m
)) mDNS_StartQuery(m
, &query
->qAv6
);
8924 // If this is not our first answer, only re-issue the address query if the target host name has changed
8925 else if ((query
->qAv4
.InterfaceID
!= query
->qSRV
.InterfaceID
&& query
->qAv4
.InterfaceID
!= answer
->InterfaceID
) ||
8926 !SameDomainName(&query
->qAv4
.qname
, &answer
->rdata
->u
.srv
.target
))
8928 mDNS_StopQuery(m
, &query
->qAv4
);
8929 if (query
->qAv6
.ThisQInterval
>= 0) mDNS_StopQuery(m
, &query
->qAv6
);
8930 if (SameDomainName(&query
->qAv4
.qname
, &answer
->rdata
->u
.srv
.target
) && !PortChanged
)
8932 // If we get here, it means:
8933 // 1. This is not our first SRV answer
8934 // 2. The interface ID is different, but the target host and port are the same
8935 // This implies that we're seeing the exact same SRV record on more than one interface, so we should
8936 // make our address queries at least as broad as the original SRV query so that we catch all the answers.
8937 query
->qAv4
.InterfaceID
= query
->qSRV
.InterfaceID
; // Will be mDNSInterface_Any, or a specific interface
8938 query
->qAv6
.InterfaceID
= query
->qSRV
.InterfaceID
;
8942 query
->qAv4
.InterfaceID
= answer
->InterfaceID
;
8943 AssignDomainName(&query
->qAv4
.qname
, &answer
->rdata
->u
.srv
.target
);
8944 query
->qAv6
.InterfaceID
= answer
->InterfaceID
;
8945 AssignDomainName(&query
->qAv6
.qname
, &answer
->rdata
->u
.srv
.target
);
8947 debugf("FoundServiceInfoSRV: Restarting address queries for %##s (%s)", query
->qAv4
.qname
.c
, DNSTypeName(query
->qAv4
.qtype
));
8948 mDNS_StartQuery(m
, &query
->qAv4
);
8949 // Only do the AAAA query if this machine actually has IPv6 active
8950 if (MachineHasActiveIPv6(m
)) mDNS_StartQuery(m
, &query
->qAv6
);
8952 else if (query
->ServiceInfoQueryCallback
&& query
->GotADD
&& query
->GotTXT
&& PortChanged
)
8954 if (++query
->Answers
>= 100)
8955 debugf("**** WARNING **** Have given %lu answers for %##s (SRV) %##s %u",
8956 query
->Answers
, query
->qSRV
.qname
.c
, answer
->rdata
->u
.srv
.target
.c
,
8957 mDNSVal16(answer
->rdata
->u
.srv
.port
));
8958 query
->ServiceInfoQueryCallback(m
, query
);
8960 // CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's
8961 // callback function is allowed to do anything, including deleting this query and freeing its memory.
8964 mDNSlocal
void FoundServiceInfoTXT(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
, QC_result AddRecord
)
8966 ServiceInfoQuery
*query
= (ServiceInfoQuery
*)question
->QuestionContext
;
8967 if (!AddRecord
) return;
8968 if (answer
->rrtype
!= kDNSType_TXT
) return;
8969 if (answer
->rdlength
> sizeof(query
->info
->TXTinfo
)) return;
8971 query
->GotTXT
= mDNStrue
;
8972 query
->info
->TXTlen
= answer
->rdlength
;
8973 query
->info
->TXTinfo
[0] = 0; // In case answer->rdlength is zero
8974 mDNSPlatformMemCopy(query
->info
->TXTinfo
, answer
->rdata
->u
.txt
.c
, answer
->rdlength
);
8976 verbosedebugf("FoundServiceInfoTXT: %##s GotADD=%d", query
->info
->name
.c
, query
->GotADD
);
8978 // CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's
8979 // callback function is allowed to do anything, including deleting this query and freeing its memory.
8980 if (query
->ServiceInfoQueryCallback
&& query
->GotADD
)
8982 if (++query
->Answers
>= 100)
8983 debugf("**** WARNING **** have given %lu answers for %##s (TXT) %#s...",
8984 query
->Answers
, query
->qSRV
.qname
.c
, answer
->rdata
->u
.txt
.c
);
8985 query
->ServiceInfoQueryCallback(m
, query
);
8989 mDNSlocal
void FoundServiceInfo(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
, QC_result AddRecord
)
8991 ServiceInfoQuery
*query
= (ServiceInfoQuery
*)question
->QuestionContext
;
8992 //LogInfo("FoundServiceInfo %d %s", AddRecord, RRDisplayString(m, answer));
8993 if (!AddRecord
) return;
8995 if (answer
->rrtype
== kDNSType_A
)
8997 query
->info
->ip
.type
= mDNSAddrType_IPv4
;
8998 query
->info
->ip
.ip
.v4
= answer
->rdata
->u
.ipv4
;
9000 else if (answer
->rrtype
== kDNSType_AAAA
)
9002 query
->info
->ip
.type
= mDNSAddrType_IPv6
;
9003 query
->info
->ip
.ip
.v6
= answer
->rdata
->u
.ipv6
;
9007 debugf("FoundServiceInfo: answer %##s type %d (%s) unexpected", answer
->name
->c
, answer
->rrtype
, DNSTypeName(answer
->rrtype
));
9011 query
->GotADD
= mDNStrue
;
9012 query
->info
->InterfaceID
= answer
->InterfaceID
;
9014 verbosedebugf("FoundServiceInfo v%ld: %##s GotTXT=%d", query
->info
->ip
.type
, query
->info
->name
.c
, query
->GotTXT
);
9016 // CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's
9017 // callback function is allowed to do anything, including deleting this query and freeing its memory.
9018 if (query
->ServiceInfoQueryCallback
&& query
->GotTXT
)
9020 if (++query
->Answers
>= 100)
9021 debugf(answer
->rrtype
== kDNSType_A
?
9022 "**** WARNING **** have given %lu answers for %##s (A) %.4a" :
9023 "**** WARNING **** have given %lu answers for %##s (AAAA) %.16a",
9024 query
->Answers
, query
->qSRV
.qname
.c
, &answer
->rdata
->u
.data
);
9025 query
->ServiceInfoQueryCallback(m
, query
);
9029 // On entry, the client must have set the name and InterfaceID fields of the ServiceInfo structure
9030 // If the query is not interface-specific, then InterfaceID may be zero
9031 // Each time the Callback is invoked, the remainder of the fields will have been filled in
9032 // In addition, InterfaceID will be updated to give the interface identifier corresponding to that response
9033 mDNSexport mStatus
mDNS_StartResolveService(mDNS
*const m
,
9034 ServiceInfoQuery
*query
, ServiceInfo
*info
, mDNSServiceInfoQueryCallback
*Callback
, void *Context
)
9039 query
->qSRV
.ThisQInterval
= -1; // So that mDNS_StopResolveService() knows whether to cancel this question
9040 query
->qSRV
.InterfaceID
= info
->InterfaceID
;
9041 query
->qSRV
.Target
= zeroAddr
;
9042 AssignDomainName(&query
->qSRV
.qname
, &info
->name
);
9043 query
->qSRV
.qtype
= kDNSType_SRV
;
9044 query
->qSRV
.qclass
= kDNSClass_IN
;
9045 query
->qSRV
.LongLived
= mDNSfalse
;
9046 query
->qSRV
.ExpectUnique
= mDNStrue
;
9047 query
->qSRV
.ForceMCast
= mDNSfalse
;
9048 query
->qSRV
.ReturnIntermed
= mDNSfalse
;
9049 query
->qSRV
.SuppressUnusable
= mDNSfalse
;
9050 query
->qSRV
.SearchListIndex
= 0;
9051 query
->qSRV
.AppendSearchDomains
= 0;
9052 query
->qSRV
.RetryWithSearchDomains
= mDNSfalse
;
9053 query
->qSRV
.TimeoutQuestion
= 0;
9054 query
->qSRV
.WakeOnResolve
= 0;
9055 query
->qSRV
.qnameOrig
= mDNSNULL
;
9056 query
->qSRV
.QuestionCallback
= FoundServiceInfoSRV
;
9057 query
->qSRV
.QuestionContext
= query
;
9059 query
->qTXT
.ThisQInterval
= -1; // So that mDNS_StopResolveService() knows whether to cancel this question
9060 query
->qTXT
.InterfaceID
= info
->InterfaceID
;
9061 query
->qTXT
.Target
= zeroAddr
;
9062 AssignDomainName(&query
->qTXT
.qname
, &info
->name
);
9063 query
->qTXT
.qtype
= kDNSType_TXT
;
9064 query
->qTXT
.qclass
= kDNSClass_IN
;
9065 query
->qTXT
.LongLived
= mDNSfalse
;
9066 query
->qTXT
.ExpectUnique
= mDNStrue
;
9067 query
->qTXT
.ForceMCast
= mDNSfalse
;
9068 query
->qTXT
.ReturnIntermed
= mDNSfalse
;
9069 query
->qTXT
.SuppressUnusable
= mDNSfalse
;
9070 query
->qTXT
.SearchListIndex
= 0;
9071 query
->qTXT
.AppendSearchDomains
= 0;
9072 query
->qTXT
.RetryWithSearchDomains
= mDNSfalse
;
9073 query
->qTXT
.TimeoutQuestion
= 0;
9074 query
->qTXT
.WakeOnResolve
= 0;
9075 query
->qTXT
.qnameOrig
= mDNSNULL
;
9076 query
->qTXT
.QuestionCallback
= FoundServiceInfoTXT
;
9077 query
->qTXT
.QuestionContext
= query
;
9079 query
->qAv4
.ThisQInterval
= -1; // So that mDNS_StopResolveService() knows whether to cancel this question
9080 query
->qAv4
.InterfaceID
= info
->InterfaceID
;
9081 query
->qAv4
.Target
= zeroAddr
;
9082 query
->qAv4
.qname
.c
[0] = 0;
9083 query
->qAv4
.qtype
= kDNSType_A
;
9084 query
->qAv4
.qclass
= kDNSClass_IN
;
9085 query
->qAv4
.LongLived
= mDNSfalse
;
9086 query
->qAv4
.ExpectUnique
= mDNStrue
;
9087 query
->qAv4
.ForceMCast
= mDNSfalse
;
9088 query
->qAv4
.ReturnIntermed
= mDNSfalse
;
9089 query
->qAv4
.SuppressUnusable
= mDNSfalse
;
9090 query
->qAv4
.SearchListIndex
= 0;
9091 query
->qAv4
.AppendSearchDomains
= 0;
9092 query
->qAv4
.RetryWithSearchDomains
= mDNSfalse
;
9093 query
->qAv4
.TimeoutQuestion
= 0;
9094 query
->qAv4
.WakeOnResolve
= 0;
9095 query
->qAv4
.qnameOrig
= mDNSNULL
;
9096 query
->qAv4
.QuestionCallback
= FoundServiceInfo
;
9097 query
->qAv4
.QuestionContext
= query
;
9099 query
->qAv6
.ThisQInterval
= -1; // So that mDNS_StopResolveService() knows whether to cancel this question
9100 query
->qAv6
.InterfaceID
= info
->InterfaceID
;
9101 query
->qAv6
.Target
= zeroAddr
;
9102 query
->qAv6
.qname
.c
[0] = 0;
9103 query
->qAv6
.qtype
= kDNSType_AAAA
;
9104 query
->qAv6
.qclass
= kDNSClass_IN
;
9105 query
->qAv6
.LongLived
= mDNSfalse
;
9106 query
->qAv6
.ExpectUnique
= mDNStrue
;
9107 query
->qAv6
.ForceMCast
= mDNSfalse
;
9108 query
->qAv6
.ReturnIntermed
= mDNSfalse
;
9109 query
->qAv6
.SuppressUnusable
= mDNSfalse
;
9110 query
->qAv6
.SearchListIndex
= 0;
9111 query
->qAv6
.AppendSearchDomains
= 0;
9112 query
->qAv6
.RetryWithSearchDomains
= mDNSfalse
;
9113 query
->qAv6
.TimeoutQuestion
= 0;
9114 query
->qAv6
.WakeOnResolve
= 0;
9115 query
->qAv6
.qnameOrig
= mDNSNULL
;
9116 query
->qAv6
.QuestionCallback
= FoundServiceInfo
;
9117 query
->qAv6
.QuestionContext
= query
;
9119 query
->GotSRV
= mDNSfalse
;
9120 query
->GotTXT
= mDNSfalse
;
9121 query
->GotADD
= mDNSfalse
;
9125 query
->ServiceInfoQueryCallback
= Callback
;
9126 query
->ServiceInfoQueryContext
= Context
;
9128 // info->name = Must already be set up by client
9129 // info->interface = Must already be set up by client
9130 info
->ip
= zeroAddr
;
9131 info
->port
= zeroIPPort
;
9134 // We use mDNS_StartQuery_internal here because we're already holding the lock
9135 status
= mDNS_StartQuery_internal(m
, &query
->qSRV
);
9136 if (status
== mStatus_NoError
) status
= mDNS_StartQuery_internal(m
, &query
->qTXT
);
9137 if (status
!= mStatus_NoError
) mDNS_StopResolveService(m
, query
);
9143 mDNSexport
void mDNS_StopResolveService (mDNS
*const m
, ServiceInfoQuery
*q
)
9146 // We use mDNS_StopQuery_internal here because we're already holding the lock
9147 if (q
->qSRV
.ThisQInterval
>= 0) mDNS_StopQuery_internal(m
, &q
->qSRV
);
9148 if (q
->qTXT
.ThisQInterval
>= 0) mDNS_StopQuery_internal(m
, &q
->qTXT
);
9149 if (q
->qAv4
.ThisQInterval
>= 0) mDNS_StopQuery_internal(m
, &q
->qAv4
);
9150 if (q
->qAv6
.ThisQInterval
>= 0) mDNS_StopQuery_internal(m
, &q
->qAv6
);
9154 mDNSexport mStatus
mDNS_GetDomains(mDNS
*const m
, DNSQuestion
*const question
, mDNS_DomainType DomainType
, const domainname
*dom
,
9155 const mDNSInterfaceID InterfaceID
, mDNSQuestionCallback
*Callback
, void *Context
)
9157 question
->InterfaceID
= InterfaceID
;
9158 question
->Target
= zeroAddr
;
9159 question
->qtype
= kDNSType_PTR
;
9160 question
->qclass
= kDNSClass_IN
;
9161 question
->LongLived
= mDNSfalse
;
9162 question
->ExpectUnique
= mDNSfalse
;
9163 question
->ForceMCast
= mDNSfalse
;
9164 question
->ReturnIntermed
= mDNSfalse
;
9165 question
->SuppressUnusable
= mDNSfalse
;
9166 question
->SearchListIndex
= 0;
9167 question
->AppendSearchDomains
= 0;
9168 question
->RetryWithSearchDomains
= mDNSfalse
;
9169 question
->TimeoutQuestion
= 0;
9170 question
->WakeOnResolve
= 0;
9171 question
->qnameOrig
= mDNSNULL
;
9172 question
->QuestionCallback
= Callback
;
9173 question
->QuestionContext
= Context
;
9174 if (DomainType
> mDNS_DomainTypeMax
) return(mStatus_BadParamErr
);
9175 if (!MakeDomainNameFromDNSNameString(&question
->qname
, mDNS_DomainTypeNames
[DomainType
])) return(mStatus_BadParamErr
);
9176 if (!dom
) dom
= &localdomain
;
9177 if (!AppendDomainName(&question
->qname
, dom
)) return(mStatus_BadParamErr
);
9178 return(mDNS_StartQuery(m
, question
));
9181 // ***************************************************************************
9182 #if COMPILER_LIKES_PRAGMA_MARK
9184 #pragma mark - Responder Functions
9187 mDNSexport mStatus
mDNS_Register(mDNS
*const m
, AuthRecord
*const rr
)
9191 status
= mDNS_Register_internal(m
, rr
);
9196 mDNSexport mStatus
mDNS_Update(mDNS
*const m
, AuthRecord
*const rr
, mDNSu32 newttl
,
9197 const mDNSu16 newrdlength
, RData
*const newrdata
, mDNSRecordUpdateCallback
*Callback
)
9199 if (!ValidateRData(rr
->resrec
.rrtype
, newrdlength
, newrdata
))
9201 LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(&rr
->resrec
, &newrdata
->u
, m
->MsgBuffer
));
9202 return(mStatus_Invalid
);
9207 // If TTL is unspecified, leave TTL unchanged
9208 if (newttl
== 0) newttl
= rr
->resrec
.rroriginalttl
;
9210 // If we already have an update queued up which has not gone through yet, give the client a chance to free that memory
9213 RData
*n
= rr
->NewRData
;
9214 rr
->NewRData
= mDNSNULL
; // Clear the NewRData pointer ...
9215 if (rr
->UpdateCallback
)
9216 rr
->UpdateCallback(m
, rr
, n
, rr
->newrdlength
); // ...and let the client free this memory, if necessary
9219 rr
->NewRData
= newrdata
;
9220 rr
->newrdlength
= newrdlength
;
9221 rr
->UpdateCallback
= Callback
;
9223 #ifndef UNICAST_DISABLED
9224 if (rr
->ARType
!= AuthRecordLocalOnly
&& rr
->ARType
!= AuthRecordP2P
&& !IsLocalDomain(rr
->resrec
.name
))
9226 mStatus status
= uDNS_UpdateRecord(m
, rr
);
9227 // The caller frees the memory on error, don't retain stale pointers
9228 if (status
!= mStatus_NoError
) { rr
->NewRData
= mDNSNULL
; rr
->newrdlength
= 0; }
9234 if (RRLocalOnly(rr
) || (rr
->resrec
.rroriginalttl
== newttl
&&
9235 rr
->resrec
.rdlength
== newrdlength
&& mDNSPlatformMemSame(rr
->resrec
.rdata
->u
.data
, newrdata
->u
.data
, newrdlength
)))
9236 CompleteRDataUpdate(m
, rr
);
9239 rr
->AnnounceCount
= InitialAnnounceCount
;
9240 InitializeLastAPTime(m
, rr
);
9241 while (rr
->NextUpdateCredit
&& m
->timenow
- rr
->NextUpdateCredit
>= 0) GrantUpdateCredit(rr
);
9242 if (!rr
->UpdateBlocked
&& rr
->UpdateCredits
) rr
->UpdateCredits
--;
9243 if (!rr
->NextUpdateCredit
) rr
->NextUpdateCredit
= NonZeroTime(m
->timenow
+ kUpdateCreditRefreshInterval
);
9244 if (rr
->AnnounceCount
> rr
->UpdateCredits
+ 1) rr
->AnnounceCount
= (mDNSu8
)(rr
->UpdateCredits
+ 1);
9245 if (rr
->UpdateCredits
<= 5)
9247 mDNSu32 delay
= 6 - rr
->UpdateCredits
; // Delay 1 second, then 2, then 3, etc. up to 6 seconds maximum
9248 if (!rr
->UpdateBlocked
) rr
->UpdateBlocked
= NonZeroTime(m
->timenow
+ (mDNSs32
)delay
* mDNSPlatformOneSecond
);
9249 rr
->ThisAPInterval
*= 4;
9250 rr
->LastAPTime
= rr
->UpdateBlocked
- rr
->ThisAPInterval
;
9251 LogMsg("Excessive update rate for %##s; delaying announcement by %ld second%s",
9252 rr
->resrec
.name
->c
, delay
, delay
> 1 ? "s" : "");
9254 rr
->resrec
.rroriginalttl
= newttl
;
9258 return(mStatus_NoError
);
9261 // Note: mDNS_Deregister calls mDNS_Deregister_internal which can call a user callback, which may change
9262 // the record list and/or question list.
9263 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
9264 mDNSexport mStatus
mDNS_Deregister(mDNS
*const m
, AuthRecord
*const rr
)
9268 status
= mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
9273 // Circular reference: AdvertiseInterface references mDNS_HostNameCallback, which calls mDNS_SetFQDN, which call AdvertiseInterface
9274 mDNSlocal
void mDNS_HostNameCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
);
9276 mDNSlocal NetworkInterfaceInfo
*FindFirstAdvertisedInterface(mDNS
*const m
)
9278 NetworkInterfaceInfo
*intf
;
9279 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9280 if (intf
->Advertise
) break;
9284 mDNSlocal
void AdvertiseInterface(mDNS
*const m
, NetworkInterfaceInfo
*set
)
9286 char buffer
[MAX_REVERSE_MAPPING_NAME
];
9287 NetworkInterfaceInfo
*primary
= FindFirstAdvertisedInterface(m
);
9288 if (!primary
) primary
= set
; // If no existing advertised interface, this new NetworkInterfaceInfo becomes our new primary
9290 // Send dynamic update for non-linklocal IPv4 Addresses
9291 mDNS_SetupResourceRecord(&set
->RR_A
, mDNSNULL
, set
->InterfaceID
, kDNSType_A
, kHostNameTTL
, kDNSRecordTypeUnique
, AuthRecordAny
, mDNS_HostNameCallback
, set
);
9292 mDNS_SetupResourceRecord(&set
->RR_PTR
, mDNSNULL
, set
->InterfaceID
, kDNSType_PTR
, kHostNameTTL
, kDNSRecordTypeKnownUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
9293 mDNS_SetupResourceRecord(&set
->RR_HINFO
, mDNSNULL
, set
->InterfaceID
, kDNSType_HINFO
, kHostNameTTL
, kDNSRecordTypeUnique
, AuthRecordAny
, mDNSNULL
, mDNSNULL
);
9295 #if ANSWER_REMOTE_HOSTNAME_QUERIES
9296 set
->RR_A
.AllowRemoteQuery
= mDNStrue
;
9297 set
->RR_PTR
.AllowRemoteQuery
= mDNStrue
;
9298 set
->RR_HINFO
.AllowRemoteQuery
= mDNStrue
;
9300 // 1. Set up Address record to map from host name ("foo.local.") to IP address
9301 // 2. Set up reverse-lookup PTR record to map from our address back to our host name
9302 AssignDomainName(&set
->RR_A
.namestorage
, &m
->MulticastHostname
);
9303 if (set
->ip
.type
== mDNSAddrType_IPv4
)
9305 set
->RR_A
.resrec
.rrtype
= kDNSType_A
;
9306 set
->RR_A
.resrec
.rdata
->u
.ipv4
= set
->ip
.ip
.v4
;
9307 // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code
9308 mDNS_snprintf(buffer
, sizeof(buffer
), "%d.%d.%d.%d.in-addr.arpa.",
9309 set
->ip
.ip
.v4
.b
[3], set
->ip
.ip
.v4
.b
[2], set
->ip
.ip
.v4
.b
[1], set
->ip
.ip
.v4
.b
[0]);
9311 else if (set
->ip
.type
== mDNSAddrType_IPv6
)
9314 set
->RR_A
.resrec
.rrtype
= kDNSType_AAAA
;
9315 set
->RR_A
.resrec
.rdata
->u
.ipv6
= set
->ip
.ip
.v6
;
9316 for (i
= 0; i
< 16; i
++)
9318 static const char hexValues
[] = "0123456789ABCDEF";
9319 buffer
[i
* 4 ] = hexValues
[set
->ip
.ip
.v6
.b
[15 - i
] & 0x0F];
9320 buffer
[i
* 4 + 1] = '.';
9321 buffer
[i
* 4 + 2] = hexValues
[set
->ip
.ip
.v6
.b
[15 - i
] >> 4];
9322 buffer
[i
* 4 + 3] = '.';
9324 mDNS_snprintf(&buffer
[64], sizeof(buffer
)-64, "ip6.arpa.");
9327 MakeDomainNameFromDNSNameString(&set
->RR_PTR
.namestorage
, buffer
);
9328 set
->RR_PTR
.AutoTarget
= Target_AutoHost
; // Tell mDNS that the target of this PTR is to be kept in sync with our host name
9329 set
->RR_PTR
.ForceMCast
= mDNStrue
; // This PTR points to our dot-local name, so don't ever try to write it into a uDNS server
9331 set
->RR_A
.RRSet
= &primary
->RR_A
; // May refer to self
9333 mDNS_Register_internal(m
, &set
->RR_A
);
9334 mDNS_Register_internal(m
, &set
->RR_PTR
);
9336 if (!NO_HINFO
&& m
->HIHardware
.c
[0] > 0 && m
->HISoftware
.c
[0] > 0 && m
->HIHardware
.c
[0] + m
->HISoftware
.c
[0] <= 254)
9338 mDNSu8
*p
= set
->RR_HINFO
.resrec
.rdata
->u
.data
;
9339 AssignDomainName(&set
->RR_HINFO
.namestorage
, &m
->MulticastHostname
);
9340 set
->RR_HINFO
.DependentOn
= &set
->RR_A
;
9341 mDNSPlatformMemCopy(p
, &m
->HIHardware
, 1 + (mDNSu32
)m
->HIHardware
.c
[0]);
9343 mDNSPlatformMemCopy(p
, &m
->HISoftware
, 1 + (mDNSu32
)m
->HISoftware
.c
[0]);
9344 mDNS_Register_internal(m
, &set
->RR_HINFO
);
9348 debugf("Not creating HINFO record: platform support layer provided no information");
9349 set
->RR_HINFO
.resrec
.RecordType
= kDNSRecordTypeUnregistered
;
9353 mDNSlocal
void DeadvertiseInterface(mDNS
*const m
, NetworkInterfaceInfo
*set
)
9355 NetworkInterfaceInfo
*intf
;
9357 // If we still have address records referring to this one, update them
9358 NetworkInterfaceInfo
*primary
= FindFirstAdvertisedInterface(m
);
9359 AuthRecord
*A
= primary
? &primary
->RR_A
: mDNSNULL
;
9360 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9361 if (intf
->RR_A
.RRSet
== &set
->RR_A
)
9362 intf
->RR_A
.RRSet
= A
;
9364 // Unregister these records.
9365 // When doing the mDNS_Exit processing, we first call DeadvertiseInterface for each interface, so by the time the platform
9366 // support layer gets to call mDNS_DeregisterInterface, the address and PTR records have already been deregistered for it.
9367 // Also, in the event of a name conflict, one or more of our records will have been forcibly deregistered.
9368 // To avoid unnecessary and misleading warning messages, we check the RecordType before calling mDNS_Deregister_internal().
9369 if (set
->RR_A
. resrec
.RecordType
) mDNS_Deregister_internal(m
, &set
->RR_A
, mDNS_Dereg_normal
);
9370 if (set
->RR_PTR
. resrec
.RecordType
) mDNS_Deregister_internal(m
, &set
->RR_PTR
, mDNS_Dereg_normal
);
9371 if (set
->RR_HINFO
.resrec
.RecordType
) mDNS_Deregister_internal(m
, &set
->RR_HINFO
, mDNS_Dereg_normal
);
9374 mDNSexport
void mDNS_SetFQDN(mDNS
*const m
)
9376 domainname newmname
;
9377 NetworkInterfaceInfo
*intf
;
9381 if (!AppendDomainLabel(&newmname
, &m
->hostlabel
)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
9382 if (!AppendLiteralLabelString(&newmname
, "local")) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
9386 if (SameDomainNameCS(&m
->MulticastHostname
, &newmname
)) debugf("mDNS_SetFQDN - hostname unchanged");
9389 AssignDomainName(&m
->MulticastHostname
, &newmname
);
9391 // 1. Stop advertising our address records on all interfaces
9392 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9393 if (intf
->Advertise
) DeadvertiseInterface(m
, intf
);
9395 // 2. Start advertising our address records using the new name
9396 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9397 if (intf
->Advertise
) AdvertiseInterface(m
, intf
);
9400 // 3. Make sure that any AutoTarget SRV records (and the like) get updated
9401 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
) if (rr
->AutoTarget
) SetTargetToHostName(m
, rr
);
9402 for (rr
= m
->DuplicateRecords
; rr
; rr
=rr
->next
) if (rr
->AutoTarget
) SetTargetToHostName(m
, rr
);
9407 mDNSlocal
void mDNS_HostNameCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
9409 (void)rr
; // Unused parameter
9413 char *msg
= "Unknown result";
9414 if (result
== mStatus_NoError
) msg
= "Name registered";
9415 else if (result
== mStatus_NameConflict
) msg
= "Name conflict";
9416 debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)", rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
), msg
, result
);
9420 if (result
== mStatus_NoError
)
9422 // Notify the client that the host name is successfully registered
9423 if (m
->MainCallback
)
9424 m
->MainCallback(m
, mStatus_NoError
);
9426 else if (result
== mStatus_NameConflict
)
9428 domainlabel oldlabel
= m
->hostlabel
;
9430 // 1. First give the client callback a chance to pick a new name
9431 if (m
->MainCallback
)
9432 m
->MainCallback(m
, mStatus_NameConflict
);
9434 // 2. If the client callback didn't do it, add (or increment) an index ourselves
9435 // This needs to be case-INSENSITIVE compare, because we need to know that the name has been changed so as to
9436 // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again.
9437 if (SameDomainLabel(m
->hostlabel
.c
, oldlabel
.c
))
9438 IncrementLabelSuffix(&m
->hostlabel
, mDNSfalse
);
9440 // 3. Generate the FQDNs from the hostlabel,
9441 // and make sure all SRV records, etc., are updated to reference our new hostname
9443 LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead", oldlabel
.c
, m
->hostlabel
.c
);
9445 else if (result
== mStatus_MemFree
)
9447 // .local hostnames do not require goodbyes - we ignore the MemFree (which is sent directly by
9448 // mDNS_Deregister_internal), and allow the caller to deallocate immediately following mDNS_DeadvertiseInterface
9449 debugf("mDNS_HostNameCallback: MemFree (ignored)");
9452 LogMsg("mDNS_HostNameCallback: Unknown error %d for registration of record %s", result
, rr
->resrec
.name
->c
);
9455 mDNSlocal
void UpdateInterfaceProtocols(mDNS
*const m
, NetworkInterfaceInfo
*active
)
9457 NetworkInterfaceInfo
*intf
;
9458 active
->IPv4Available
= mDNSfalse
;
9459 active
->IPv6Available
= mDNSfalse
;
9460 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9461 if (intf
->InterfaceID
== active
->InterfaceID
)
9463 if (intf
->ip
.type
== mDNSAddrType_IPv4
&& intf
->McastTxRx
) active
->IPv4Available
= mDNStrue
;
9464 if (intf
->ip
.type
== mDNSAddrType_IPv6
&& intf
->McastTxRx
) active
->IPv6Available
= mDNStrue
;
9468 mDNSlocal
void RestartRecordGetZoneData(mDNS
* const m
)
9471 LogInfo("RestartRecordGetZoneData: ResourceRecords");
9472 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
9473 if (AuthRecord_uDNS(rr
) && rr
->state
!= regState_NoTarget
)
9475 debugf("RestartRecordGetZoneData: StartGetZoneData for %##s", rr
->resrec
.name
->c
);
9476 // Zero out the updateid so that if we have a pending response from the server, it won't
9477 // be accepted as a valid response. If we accept the response, we might free the new "nta"
9478 if (rr
->nta
) { rr
->updateid
= zeroID
; CancelGetZoneData(m
, rr
->nta
); }
9479 rr
->nta
= StartGetZoneData(m
, rr
->resrec
.name
, ZoneServiceUpdate
, RecordRegistrationGotZoneData
, rr
);
9483 mDNSlocal
void InitializeNetWakeState(mDNS
*const m
, NetworkInterfaceInfo
*set
)
9486 set
->NetWakeBrowse
.ThisQInterval
= -1;
9489 set
->NetWakeResolve
[i
].ThisQInterval
= -1;
9490 set
->SPSAddr
[i
].type
= mDNSAddrType_None
;
9492 set
->NextSPSAttempt
= -1;
9493 set
->NextSPSAttemptTime
= m
->timenow
;
9496 mDNSexport
void mDNS_ActivateNetWake_internal(mDNS
*const m
, NetworkInterfaceInfo
*set
)
9498 NetworkInterfaceInfo
*p
= m
->HostInterfaces
;
9499 while (p
&& p
!= set
) p
=p
->next
;
9500 if (!p
) { LogMsg("mDNS_ActivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set
); return; }
9502 if (set
->InterfaceActive
)
9504 LogSPS("ActivateNetWake for %s (%#a)", set
->ifname
, &set
->ip
);
9505 mDNS_StartBrowse_internal(m
, &set
->NetWakeBrowse
, &SleepProxyServiceType
, &localdomain
, set
->InterfaceID
, mDNSfalse
, m
->SPSBrowseCallback
, set
);
9509 mDNSexport
void mDNS_DeactivateNetWake_internal(mDNS
*const m
, NetworkInterfaceInfo
*set
)
9511 NetworkInterfaceInfo
*p
= m
->HostInterfaces
;
9512 while (p
&& p
!= set
) p
=p
->next
;
9513 if (!p
) { LogMsg("mDNS_DeactivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set
); return; }
9515 if (set
->NetWakeBrowse
.ThisQInterval
>= 0)
9518 LogSPS("DeactivateNetWake for %s (%#a)", set
->ifname
, &set
->ip
);
9520 // Stop our browse and resolve operations
9521 mDNS_StopQuery_internal(m
, &set
->NetWakeBrowse
);
9522 for (i
=0; i
<3; i
++) if (set
->NetWakeResolve
[i
].ThisQInterval
>= 0) mDNS_StopQuery_internal(m
, &set
->NetWakeResolve
[i
]);
9524 // Make special call to the browse callback to let it know it can to remove all records for this interface
9525 if (m
->SPSBrowseCallback
)
9527 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
9528 m
->SPSBrowseCallback(m
, &set
->NetWakeBrowse
, mDNSNULL
, mDNSfalse
);
9529 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
9532 // Reset our variables back to initial state, so we're ready for when NetWake is turned back on
9533 // (includes resetting NetWakeBrowse.ThisQInterval back to -1)
9534 InitializeNetWakeState(m
, set
);
9538 mDNSexport mStatus
mDNS_RegisterInterface(mDNS
*const m
, NetworkInterfaceInfo
*set
, mDNSBool flapping
)
9541 mDNSBool FirstOfType
= mDNStrue
;
9542 NetworkInterfaceInfo
**p
= &m
->HostInterfaces
;
9544 if (!set
->InterfaceID
)
9545 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID", &set
->ip
); return(mStatus_Invalid
); }
9547 if (!mDNSAddressIsValidNonZero(&set
->mask
))
9548 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a", &set
->ip
, &set
->mask
); return(mStatus_Invalid
); }
9552 // Assume this interface will be active now, unless we find a duplicate already in the list
9553 set
->InterfaceActive
= mDNStrue
;
9554 set
->IPv4Available
= (mDNSu8
)(set
->ip
.type
== mDNSAddrType_IPv4
&& set
->McastTxRx
);
9555 set
->IPv6Available
= (mDNSu8
)(set
->ip
.type
== mDNSAddrType_IPv6
&& set
->McastTxRx
);
9557 InitializeNetWakeState(m
, set
);
9559 // Scan list to see if this InterfaceID is already represented
9564 LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo that's already in the list");
9566 return(mStatus_AlreadyRegistered
);
9569 if ((*p
)->InterfaceID
== set
->InterfaceID
)
9571 // This InterfaceID already represented by a different interface in the list, so mark this instance inactive for now
9572 set
->InterfaceActive
= mDNSfalse
;
9573 if (set
->ip
.type
== (*p
)->ip
.type
) FirstOfType
= mDNSfalse
;
9574 if (set
->ip
.type
== mDNSAddrType_IPv4
&& set
->McastTxRx
) (*p
)->IPv4Available
= mDNStrue
;
9575 if (set
->ip
.type
== mDNSAddrType_IPv6
&& set
->McastTxRx
) (*p
)->IPv6Available
= mDNStrue
;
9581 set
->next
= mDNSNULL
;
9585 AdvertiseInterface(m
, set
);
9587 LogInfo("mDNS_RegisterInterface: InterfaceID %p %s (%#a) %s", set
->InterfaceID
, set
->ifname
, &set
->ip
,
9588 set
->InterfaceActive
?
9589 "not represented in list; marking active and retriggering queries" :
9590 "already represented in list; marking inactive for now");
9592 if (set
->NetWake
) mDNS_ActivateNetWake_internal(m
, set
);
9594 // In early versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
9595 // giving the false impression that there's an active representative of this interface when there really isn't.
9596 // Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records,
9597 // even if we believe that we previously had an active representative of this interface.
9598 if (set
->McastTxRx
&& (FirstOfType
|| set
->InterfaceActive
))
9601 // Normally, after an interface comes up, we pause half a second before beginning probing.
9602 // This is to guard against cases where there's rapid interface changes, where we could be confused by
9603 // seeing packets we ourselves sent just moments ago (perhaps when this interface had a different address)
9604 // which are then echoed back after a short delay by some Ethernet switches and some 802.11 base stations.
9605 // We don't want to do a probe, and then see a stale echo of an announcement we ourselves sent,
9606 // and think it's a conflicting answer to our probe.
9607 // In the case of a flapping interface, we pause for five seconds, and reduce the announcement count to one packet.
9608 const mDNSs32 probedelay
= flapping
? mDNSPlatformOneSecond
* 5 : mDNSPlatformOneSecond
/ 2;
9609 const mDNSu8 numannounce
= flapping
? (mDNSu8
)1 : InitialAnnounceCount
;
9611 // Use a small amount of randomness:
9612 // In the case of a network administrator turning on an Ethernet hub so that all the
9613 // connected machines establish link at exactly the same time, we don't want them all
9614 // to go and hit the network with identical queries at exactly the same moment.
9615 // We set a random delay of up to InitialQuestionInterval (1/3 second).
9616 // We must *never* set m->SuppressSending to more than that (or set it repeatedly in a way
9617 // that causes mDNSResponder to remain in a prolonged state of SuppressSending, because
9618 // suppressing packet sending for more than about 1/3 second can cause protocol correctness
9619 // to start to break down (e.g. we don't answer probes fast enough, and get name conflicts).
9620 // See <rdar://problem/4073853> mDNS: m->SuppressSending set too enthusiastically
9621 if (!m
->SuppressSending
) m
->SuppressSending
= m
->timenow
+ (mDNSs32
)mDNSRandom((mDNSu32
)InitialQuestionInterval
);
9623 if (flapping
) LogMsg("mDNS_RegisterInterface: Frequent transitions for interface %s (%#a)", set
->ifname
, &set
->ip
);
9625 LogInfo("mDNS_RegisterInterface: %s (%#a) probedelay %d", set
->ifname
, &set
->ip
, probedelay
);
9626 if (m
->SuppressProbes
== 0 ||
9627 m
->SuppressProbes
- NonZeroTime(m
->timenow
+ probedelay
) < 0)
9628 m
->SuppressProbes
= NonZeroTime(m
->timenow
+ probedelay
);
9630 // Include OWNER option in packets for 60 seconds after connecting to the network. Setting
9631 // it here also handles the wake up case as the network link comes UP after waking causing
9632 // us to reconnect to the network. If we do this as part of the wake up code, it is possible
9633 // that the network link comes UP after 60 seconds and we never set the OWNER option
9634 m
->AnnounceOwner
= NonZeroTime(m
->timenow
+ 60 * mDNSPlatformOneSecond
);
9635 LogInfo("mDNS_RegisterInterface: Setting AnnounceOwner");
9637 for (q
= m
->Questions
; q
; q
=q
->next
) // Scan our list of questions
9638 if (mDNSOpaque16IsZero(q
->TargetQID
))
9639 if (!q
->InterfaceID
|| q
->InterfaceID
== set
->InterfaceID
) // If non-specific Q, or Q on this specific interface,
9640 { // then reactivate this question
9641 // If flapping, delay between first and second queries is nine seconds instead of one second
9642 mDNSBool dodelay
= flapping
&& (q
->FlappingInterface1
== set
->InterfaceID
|| q
->FlappingInterface2
== set
->InterfaceID
);
9643 mDNSs32 initial
= dodelay
? InitialQuestionInterval
* QuestionIntervalStep2
: InitialQuestionInterval
;
9644 mDNSs32 qdelay
= dodelay
? mDNSPlatformOneSecond
* 5 : 0;
9645 if (dodelay
) LogInfo("No cache records expired for %##s (%s); okay to delay questions a little", q
->qname
.c
, DNSTypeName(q
->qtype
));
9647 if (!q
->ThisQInterval
|| q
->ThisQInterval
> initial
)
9649 q
->ThisQInterval
= initial
;
9650 q
->RequestUnicast
= 2; // Set to 2 because is decremented once *before* we check it
9652 q
->LastQTime
= m
->timenow
- q
->ThisQInterval
+ qdelay
;
9653 q
->RecentAnswerPkts
= 0;
9654 SetNextQueryTime(m
,q
);
9657 // For all our non-specific authoritative resource records (and any dormant records specific to this interface)
9658 // we now need them to re-probe if necessary, and then re-announce.
9659 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
9660 if (!AuthRecord_uDNS(rr
))
9661 if (!rr
->resrec
.InterfaceID
|| rr
->resrec
.InterfaceID
== set
->InterfaceID
)
9663 if (rr
->resrec
.RecordType
== kDNSRecordTypeVerified
&& !rr
->DependentOn
) rr
->resrec
.RecordType
= kDNSRecordTypeUnique
;
9664 rr
->ProbeCount
= DefaultProbeCountForRecordType(rr
->resrec
.RecordType
);
9665 if (rr
->AnnounceCount
< numannounce
) rr
->AnnounceCount
= numannounce
;
9666 rr
->SendNSECNow
= mDNSNULL
;
9667 InitializeLastAPTime(m
, rr
);
9671 RestartRecordGetZoneData(m
);
9673 CheckSuppressUnusableQuestions(m
);
9675 mDNS_UpdateAllowSleep(m
);
9678 return(mStatus_NoError
);
9681 // Note: mDNS_DeregisterInterface calls mDNS_Deregister_internal which can call a user callback, which may change
9682 // the record list and/or question list.
9683 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
9684 mDNSexport
void mDNS_DeregisterInterface(mDNS
*const m
, NetworkInterfaceInfo
*set
, mDNSBool flapping
)
9686 NetworkInterfaceInfo
**p
= &m
->HostInterfaces
;
9687 mDNSBool revalidate
= mDNSfalse
;
9691 // Find this record in our list
9692 while (*p
&& *p
!= set
) p
=&(*p
)->next
;
9693 if (!*p
) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list"); mDNS_Unlock(m
); return; }
9695 mDNS_DeactivateNetWake_internal(m
, set
);
9697 // Unlink this record from our list
9699 set
->next
= mDNSNULL
;
9701 if (!set
->InterfaceActive
)
9703 // If this interface not the active member of its set, update the v4/v6Available flags for the active member
9704 NetworkInterfaceInfo
*intf
;
9705 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9706 if (intf
->InterfaceActive
&& intf
->InterfaceID
== set
->InterfaceID
)
9707 UpdateInterfaceProtocols(m
, intf
);
9711 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, set
->InterfaceID
);
9714 LogInfo("mDNS_DeregisterInterface: Another representative of InterfaceID %p %s (%#a) exists;"
9715 " making it active", set
->InterfaceID
, set
->ifname
, &set
->ip
);
9716 if (intf
->InterfaceActive
)
9717 LogMsg("mDNS_DeregisterInterface: ERROR intf->InterfaceActive already set for %s (%#a)", set
->ifname
, &set
->ip
);
9718 intf
->InterfaceActive
= mDNStrue
;
9719 UpdateInterfaceProtocols(m
, intf
);
9721 if (intf
->NetWake
) mDNS_ActivateNetWake_internal(m
, intf
);
9723 // See if another representative *of the same type* exists. If not, we mave have gone from
9724 // dual-stack to v6-only (or v4-only) so we need to reconfirm which records are still valid.
9725 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
9726 if (intf
->InterfaceID
== set
->InterfaceID
&& intf
->ip
.type
== set
->ip
.type
)
9728 if (!intf
) revalidate
= mDNStrue
;
9738 LogInfo("mDNS_DeregisterInterface: Last representative of InterfaceID %p %s (%#a) deregistered;"
9739 " marking questions etc. dormant", set
->InterfaceID
, set
->ifname
, &set
->ip
);
9741 if (set
->McastTxRx
&& flapping
)
9742 LogMsg("DeregisterInterface: Frequent transitions for interface %s (%#a)", set
->ifname
, &set
->ip
);
9744 // 1. Deactivate any questions specific to this interface, and tag appropriate questions
9745 // so that mDNS_RegisterInterface() knows how swiftly it needs to reactivate them
9746 for (q
= m
->Questions
; q
; q
=q
->next
)
9748 if (q
->InterfaceID
== set
->InterfaceID
) q
->ThisQInterval
= 0;
9749 if (!q
->InterfaceID
|| q
->InterfaceID
== set
->InterfaceID
)
9751 q
->FlappingInterface2
= q
->FlappingInterface1
;
9752 q
->FlappingInterface1
= set
->InterfaceID
; // Keep history of the last two interfaces to go away
9756 // 2. Flush any cache records received on this interface
9757 revalidate
= mDNSfalse
; // Don't revalidate if we're flushing the records
9758 FORALL_CACHERECORDS(slot
, cg
, rr
)
9759 if (rr
->resrec
.InterfaceID
== set
->InterfaceID
)
9761 // If this interface is deemed flapping,
9762 // postpone deleting the cache records in case the interface comes back again
9763 if (set
->McastTxRx
&& flapping
)
9765 // For a flapping interface we want these record to go away after 30 seconds
9766 mDNS_Reconfirm_internal(m
, rr
, kDefaultReconfirmTimeForFlappingInterface
);
9767 // We set UnansweredQueries = MaxUnansweredQueries so we don't waste time doing any queries for them --
9768 // if the interface does come back, any relevant questions will be reactivated anyway
9769 rr
->UnansweredQueries
= MaxUnansweredQueries
;
9772 mDNS_PurgeCacheResourceRecord(m
, rr
);
9775 // 3. Any DNS servers specific to this interface are now unusable
9776 for (s
= m
->DNSServers
; s
; s
= s
->next
)
9777 if (s
->interface
== set
->InterfaceID
)
9779 s
->interface
= mDNSInterface_Any
;
9780 s
->teststate
= DNSServer_Disabled
;
9785 // If we were advertising on this interface, deregister those address and reverse-lookup records now
9786 if (set
->Advertise
) DeadvertiseInterface(m
, set
);
9788 // If we have any cache records received on this interface that went away, then re-verify them.
9789 // In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
9790 // giving the false impression that there's an active representative of this interface when there really isn't.
9791 // Don't need to do this when shutting down, because *all* interfaces are about to go away
9792 if (revalidate
&& !m
->ShutdownTime
)
9797 FORALL_CACHERECORDS(slot
, cg
, rr
)
9798 if (rr
->resrec
.InterfaceID
== set
->InterfaceID
)
9799 mDNS_Reconfirm_internal(m
, rr
, kDefaultReconfirmTimeForFlappingInterface
);
9802 CheckSuppressUnusableQuestions(m
);
9804 mDNS_UpdateAllowSleep(m
);
9809 mDNSlocal
void ServiceCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
9811 ServiceRecordSet
*sr
= (ServiceRecordSet
*)rr
->RecordContext
;
9812 (void)m
; // Unused parameter
9816 char *msg
= "Unknown result";
9817 if (result
== mStatus_NoError
) msg
= "Name Registered";
9818 else if (result
== mStatus_NameConflict
) msg
= "Name Conflict";
9819 else if (result
== mStatus_MemFree
) msg
= "Memory Free";
9820 debugf("ServiceCallback: %##s (%s) %s (%d)", rr
->resrec
.name
->c
, DNSTypeName(rr
->resrec
.rrtype
), msg
, result
);
9824 // Only pass on the NoError acknowledgement for the SRV record (when it finishes probing)
9825 if (result
== mStatus_NoError
&& rr
!= &sr
->RR_SRV
) return;
9827 // If we got a name conflict on either SRV or TXT, forcibly deregister this service, and record that we did that
9828 if (result
== mStatus_NameConflict
)
9830 sr
->Conflict
= mDNStrue
; // Record that this service set had a conflict
9831 mDNS_DeregisterService(m
, sr
); // Unlink the records from our list
9835 if (result
== mStatus_MemFree
)
9837 // If the SRV/TXT/PTR records, or the _services._dns-sd._udp record, or any of the subtype PTR records,
9838 // are still in the process of deregistering, don't pass on the NameConflict/MemFree message until
9839 // every record is finished cleaning up.
9841 ExtraResourceRecord
*e
= sr
->Extras
;
9843 if (sr
->RR_SRV
.resrec
.RecordType
!= kDNSRecordTypeUnregistered
) return;
9844 if (sr
->RR_TXT
.resrec
.RecordType
!= kDNSRecordTypeUnregistered
) return;
9845 if (sr
->RR_PTR
.resrec
.RecordType
!= kDNSRecordTypeUnregistered
) return;
9846 if (sr
->RR_ADV
.resrec
.RecordType
!= kDNSRecordTypeUnregistered
) return;
9847 for (i
=0; i
<sr
->NumSubTypes
; i
++) if (sr
->SubTypes
[i
].resrec
.RecordType
!= kDNSRecordTypeUnregistered
) return;
9851 if (e
->r
.resrec
.RecordType
!= kDNSRecordTypeUnregistered
) return;
9855 // If this ServiceRecordSet was forcibly deregistered, and now its memory is ready for reuse,
9856 // then we can now report the NameConflict to the client
9857 if (sr
->Conflict
) result
= mStatus_NameConflict
;
9861 LogInfo("ServiceCallback: All records %s for %##s", (result
== mStatus_MemFree
? "Unregistered": "Registered"), sr
->RR_PTR
.resrec
.name
->c
);
9862 // CAUTION: MUST NOT do anything more with sr after calling sr->Callback(), because the client's callback
9863 // function is allowed to do anything, including deregistering this service and freeing its memory.
9864 if (sr
->ServiceCallback
)
9865 sr
->ServiceCallback(m
, sr
, result
);
9868 mDNSlocal
void NSSCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
9870 ServiceRecordSet
*sr
= (ServiceRecordSet
*)rr
->RecordContext
;
9871 if (sr
->ServiceCallback
)
9872 sr
->ServiceCallback(m
, sr
, result
);
9876 // Name is first label of domain name (any dots in the name are actual dots, not label separators)
9877 // Type is service type (e.g. "_ipp._tcp.")
9878 // Domain is fully qualified domain name (i.e. ending with a null label)
9879 // We always register a TXT, even if it is empty (so that clients are not
9880 // left waiting forever looking for a nonexistent record.)
9881 // If the host parameter is mDNSNULL or the root domain (ASCII NUL),
9882 // then the default host name (m->MulticastHostname) is automatically used
9883 // If the optional target host parameter is set, then the storage it points to must remain valid for the lifetime of the service registration
9884 mDNSexport mStatus
mDNS_RegisterService(mDNS
*const m
, ServiceRecordSet
*sr
,
9885 const domainlabel
*const name
, const domainname
*const type
, const domainname
*const domain
,
9886 const domainname
*const host
, mDNSIPPort port
, const mDNSu8 txtinfo
[], mDNSu16 txtlen
,
9887 AuthRecord
*SubTypes
, mDNSu32 NumSubTypes
,
9888 mDNSInterfaceID InterfaceID
, mDNSServiceCallback Callback
, void *Context
, mDNSu32 flags
)
9894 mDNSu8 recordType
= (flags
& regFlagKnownUnique
) ? kDNSRecordTypeKnownUnique
: kDNSRecordTypeUnique
;
9896 sr
->ServiceCallback
= Callback
;
9897 sr
->ServiceContext
= Context
;
9898 sr
->Conflict
= mDNSfalse
;
9900 sr
->Extras
= mDNSNULL
;
9901 sr
->NumSubTypes
= NumSubTypes
;
9902 sr
->SubTypes
= SubTypes
;
9904 if (InterfaceID
== mDNSInterface_LocalOnly
)
9905 artype
= AuthRecordLocalOnly
;
9906 else if (InterfaceID
== mDNSInterface_P2P
)
9907 artype
= AuthRecordP2P
;
9908 else if ((InterfaceID
== mDNSInterface_Any
) && (flags
& regFlagIncludeP2P
))
9909 artype
= AuthRecordAnyIncludeP2P
;
9911 artype
= AuthRecordAny
;
9913 // Initialize the AuthRecord objects to sane values
9914 // Need to initialize everything correctly *before* making the decision whether to do a RegisterNoSuchService and bail out
9915 mDNS_SetupResourceRecord(&sr
->RR_ADV
, mDNSNULL
, InterfaceID
, kDNSType_PTR
, kStandardTTL
, kDNSRecordTypeAdvisory
, artype
, ServiceCallback
, sr
);
9916 mDNS_SetupResourceRecord(&sr
->RR_PTR
, mDNSNULL
, InterfaceID
, kDNSType_PTR
, kStandardTTL
, kDNSRecordTypeShared
, artype
, ServiceCallback
, sr
);
9918 if (SameDomainName(type
, (const domainname
*) "\x4" "_ubd" "\x4" "_tcp"))
9919 hostTTL
= kHostNameSmallTTL
;
9921 hostTTL
= kHostNameTTL
;
9923 mDNS_SetupResourceRecord(&sr
->RR_SRV
, mDNSNULL
, InterfaceID
, kDNSType_SRV
, hostTTL
, recordType
, artype
, ServiceCallback
, sr
);
9924 mDNS_SetupResourceRecord(&sr
->RR_TXT
, mDNSNULL
, InterfaceID
, kDNSType_TXT
, kStandardTTL
, kDNSRecordTypeUnique
, artype
, ServiceCallback
, sr
);
9926 // If port number is zero, that means the client is really trying to do a RegisterNoSuchService
9927 if (mDNSIPPortIsZero(port
))
9928 return(mDNS_RegisterNoSuchService(m
, &sr
->RR_SRV
, name
, type
, domain
, mDNSNULL
, InterfaceID
, NSSCallback
, sr
, (flags
& regFlagIncludeP2P
)));
9930 // If the client is registering an oversized TXT record,
9931 // it is the client's responsibility to alloate a ServiceRecordSet structure that is large enough for it
9932 if (sr
->RR_TXT
.resrec
.rdata
->MaxRDLength
< txtlen
)
9933 sr
->RR_TXT
.resrec
.rdata
->MaxRDLength
= txtlen
;
9935 // Set up the record names
9936 // For now we only create an advisory record for the main type, not for subtypes
9937 // We need to gain some operational experience before we decide if there's a need to create them for subtypes too
9938 if (ConstructServiceName(&sr
->RR_ADV
.namestorage
, (const domainlabel
*)"\x09_services", (const domainname
*)"\x07_dns-sd\x04_udp", domain
) == mDNSNULL
)
9939 return(mStatus_BadParamErr
);
9940 if (ConstructServiceName(&sr
->RR_PTR
.namestorage
, mDNSNULL
, type
, domain
) == mDNSNULL
) return(mStatus_BadParamErr
);
9941 if (ConstructServiceName(&sr
->RR_SRV
.namestorage
, name
, type
, domain
) == mDNSNULL
) return(mStatus_BadParamErr
);
9942 AssignDomainName(&sr
->RR_TXT
.namestorage
, sr
->RR_SRV
.resrec
.name
);
9944 // 1. Set up the ADV record rdata to advertise our service type
9945 AssignDomainName(&sr
->RR_ADV
.resrec
.rdata
->u
.name
, sr
->RR_PTR
.resrec
.name
);
9947 // 2. Set up the PTR record rdata to point to our service name
9948 // We set up two additionals, so when a client asks for this PTR we automatically send the SRV and the TXT too
9949 // Note: uDNS registration code assumes that Additional1 points to the SRV record
9950 AssignDomainName(&sr
->RR_PTR
.resrec
.rdata
->u
.name
, sr
->RR_SRV
.resrec
.name
);
9951 sr
->RR_PTR
.Additional1
= &sr
->RR_SRV
;
9952 sr
->RR_PTR
.Additional2
= &sr
->RR_TXT
;
9954 // 2a. Set up any subtype PTRs to point to our service name
9955 // If the client is using subtypes, it is the client's responsibility to have
9956 // already set the first label of the record name to the subtype being registered
9957 for (i
=0; i
<NumSubTypes
; i
++)
9960 AssignDomainName(&st
, sr
->SubTypes
[i
].resrec
.name
);
9961 st
.c
[1+st
.c
[0]] = 0; // Only want the first label, not the whole FQDN (particularly for mDNS_RenameAndReregisterService())
9962 AppendDomainName(&st
, type
);
9963 mDNS_SetupResourceRecord(&sr
->SubTypes
[i
], mDNSNULL
, InterfaceID
, kDNSType_PTR
, kStandardTTL
, kDNSRecordTypeShared
, artype
, ServiceCallback
, sr
);
9964 if (ConstructServiceName(&sr
->SubTypes
[i
].namestorage
, mDNSNULL
, &st
, domain
) == mDNSNULL
) return(mStatus_BadParamErr
);
9965 AssignDomainName(&sr
->SubTypes
[i
].resrec
.rdata
->u
.name
, &sr
->RR_SRV
.namestorage
);
9966 sr
->SubTypes
[i
].Additional1
= &sr
->RR_SRV
;
9967 sr
->SubTypes
[i
].Additional2
= &sr
->RR_TXT
;
9970 // 3. Set up the SRV record rdata.
9971 sr
->RR_SRV
.resrec
.rdata
->u
.srv
.priority
= 0;
9972 sr
->RR_SRV
.resrec
.rdata
->u
.srv
.weight
= 0;
9973 sr
->RR_SRV
.resrec
.rdata
->u
.srv
.port
= port
;
9975 // Setting AutoTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name
9976 if (host
&& host
->c
[0]) AssignDomainName(&sr
->RR_SRV
.resrec
.rdata
->u
.srv
.target
, host
);
9977 else { sr
->RR_SRV
.AutoTarget
= Target_AutoHost
; sr
->RR_SRV
.resrec
.rdata
->u
.srv
.target
.c
[0] = '\0'; }
9979 // 4. Set up the TXT record rdata,
9980 // and set DependentOn because we're depending on the SRV record to find and resolve conflicts for us
9981 // Note: uDNS registration code assumes that DependentOn points to the SRV record
9982 if (txtinfo
== mDNSNULL
) sr
->RR_TXT
.resrec
.rdlength
= 0;
9983 else if (txtinfo
!= sr
->RR_TXT
.resrec
.rdata
->u
.txt
.c
)
9985 sr
->RR_TXT
.resrec
.rdlength
= txtlen
;
9986 if (sr
->RR_TXT
.resrec
.rdlength
> sr
->RR_TXT
.resrec
.rdata
->MaxRDLength
) return(mStatus_BadParamErr
);
9987 mDNSPlatformMemCopy(sr
->RR_TXT
.resrec
.rdata
->u
.txt
.c
, txtinfo
, txtlen
);
9989 sr
->RR_TXT
.DependentOn
= &sr
->RR_SRV
;
9992 // It is important that we register SRV first. uDNS assumes that SRV is registered first so
9993 // that if the SRV cannot find a target, rest of the records that belong to this service
9994 // will not be activated.
9995 err
= mDNS_Register_internal(m
, &sr
->RR_SRV
);
9996 // If we can't register the SRV record due to errors, bail out. It has not been inserted in
9997 // any list and hence no need to deregister. We could probably do similar checks for other
9998 // records below and bail out. For now, this seems to be sufficient to address rdar://9304275
10004 if (!err
) err
= mDNS_Register_internal(m
, &sr
->RR_TXT
);
10005 // We register the RR_PTR last, because we want to be sure that in the event of a forced call to
10006 // mDNS_StartExit, the RR_PTR will be the last one to be forcibly deregistered, since that is what triggers
10007 // the mStatus_MemFree callback to ServiceCallback, which in turn passes on the mStatus_MemFree back to
10008 // the client callback, which is then at liberty to free the ServiceRecordSet memory at will. We need to
10009 // make sure we've deregistered all our records and done any other necessary cleanup before that happens.
10010 if (!err
) err
= mDNS_Register_internal(m
, &sr
->RR_ADV
);
10011 for (i
=0; i
<NumSubTypes
; i
++) if (!err
) err
= mDNS_Register_internal(m
, &sr
->SubTypes
[i
]);
10012 if (!err
) err
= mDNS_Register_internal(m
, &sr
->RR_PTR
);
10016 if (err
) mDNS_DeregisterService(m
, sr
);
10020 mDNSexport mStatus
mDNS_AddRecordToService(mDNS
*const m
, ServiceRecordSet
*sr
,
10021 ExtraResourceRecord
*extra
, RData
*rdata
, mDNSu32 ttl
, mDNSu32 includeP2P
)
10023 ExtraResourceRecord
**e
;
10025 AuthRecType artype
;
10026 mDNSInterfaceID InterfaceID
= sr
->RR_PTR
.resrec
.InterfaceID
;
10028 if (InterfaceID
== mDNSInterface_LocalOnly
)
10029 artype
= AuthRecordLocalOnly
;
10030 if (InterfaceID
== mDNSInterface_P2P
)
10031 artype
= AuthRecordP2P
;
10032 else if ((InterfaceID
== mDNSInterface_Any
) && includeP2P
)
10033 artype
= AuthRecordAnyIncludeP2P
;
10035 artype
= AuthRecordAny
;
10037 extra
->next
= mDNSNULL
;
10038 mDNS_SetupResourceRecord(&extra
->r
, rdata
, sr
->RR_PTR
.resrec
.InterfaceID
,
10039 extra
->r
.resrec
.rrtype
, ttl
, kDNSRecordTypeUnique
, artype
, ServiceCallback
, sr
);
10040 AssignDomainName(&extra
->r
.namestorage
, sr
->RR_SRV
.resrec
.name
);
10044 while (*e
) e
= &(*e
)->next
;
10046 if (ttl
== 0) ttl
= kStandardTTL
;
10048 extra
->r
.DependentOn
= &sr
->RR_SRV
;
10050 debugf("mDNS_AddRecordToService adding record to %##s %s %d",
10051 extra
->r
.resrec
.name
->c
, DNSTypeName(extra
->r
.resrec
.rrtype
), extra
->r
.resrec
.rdlength
);
10053 status
= mDNS_Register_internal(m
, &extra
->r
);
10054 if (status
== mStatus_NoError
) *e
= extra
;
10060 mDNSexport mStatus
mDNS_RemoveRecordFromService(mDNS
*const m
, ServiceRecordSet
*sr
, ExtraResourceRecord
*extra
,
10061 mDNSRecordCallback MemFreeCallback
, void *Context
)
10063 ExtraResourceRecord
**e
;
10068 while (*e
&& *e
!= extra
) e
= &(*e
)->next
;
10071 debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra
->r
.resrec
.name
->c
);
10072 status
= mStatus_BadReferenceErr
;
10076 debugf("mDNS_RemoveRecordFromService removing record from %##s", extra
->r
.resrec
.name
->c
);
10077 extra
->r
.RecordCallback
= MemFreeCallback
;
10078 extra
->r
.RecordContext
= Context
;
10080 status
= mDNS_Deregister_internal(m
, &extra
->r
, mDNS_Dereg_normal
);
10086 mDNSexport mStatus
mDNS_RenameAndReregisterService(mDNS
*const m
, ServiceRecordSet
*const sr
, const domainlabel
*newname
)
10088 // Note: Don't need to use mDNS_Lock(m) here, because this code is just using public routines
10089 // mDNS_RegisterService() and mDNS_AddRecordToService(), which do the right locking internally.
10090 domainlabel name1
, name2
;
10091 domainname type
, domain
;
10092 const domainname
*host
= sr
->RR_SRV
.AutoTarget
? mDNSNULL
: &sr
->RR_SRV
.resrec
.rdata
->u
.srv
.target
;
10093 ExtraResourceRecord
*extras
= sr
->Extras
;
10096 DeconstructServiceName(sr
->RR_SRV
.resrec
.name
, &name1
, &type
, &domain
);
10100 IncrementLabelSuffix(&name2
, mDNStrue
);
10104 if (SameDomainName(&domain
, &localdomain
))
10105 debugf("%##s service renamed from \"%#s\" to \"%#s\"", type
.c
, name1
.c
, newname
->c
);
10106 else debugf("%##s service (domain %##s) renamed from \"%#s\" to \"%#s\"",type
.c
, domain
.c
, name1
.c
, newname
->c
);
10108 err
= mDNS_RegisterService(m
, sr
, newname
, &type
, &domain
,
10109 host
, sr
->RR_SRV
.resrec
.rdata
->u
.srv
.port
, sr
->RR_TXT
.resrec
.rdata
->u
.txt
.c
, sr
->RR_TXT
.resrec
.rdlength
,
10110 sr
->SubTypes
, sr
->NumSubTypes
,
10111 sr
->RR_PTR
.resrec
.InterfaceID
, sr
->ServiceCallback
, sr
->ServiceContext
, 0);
10113 // mDNS_RegisterService() just reset sr->Extras to NULL.
10114 // Fortunately we already grabbed ourselves a copy of this pointer (above), so we can now run
10115 // through the old list of extra records, and re-add them to our freshly created service registration
10116 while (!err
&& extras
)
10118 ExtraResourceRecord
*e
= extras
;
10119 extras
= extras
->next
;
10120 err
= mDNS_AddRecordToService(m
, sr
, e
, e
->r
.resrec
.rdata
, e
->r
.resrec
.rroriginalttl
, 0);
10126 // Note: mDNS_DeregisterService calls mDNS_Deregister_internal which can call a user callback,
10127 // which may change the record list and/or question list.
10128 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
10129 mDNSexport mStatus
mDNS_DeregisterService_drt(mDNS
*const m
, ServiceRecordSet
*sr
, mDNS_Dereg_type drt
)
10131 // If port number is zero, that means this was actually registered using mDNS_RegisterNoSuchService()
10132 if (mDNSIPPortIsZero(sr
->RR_SRV
.resrec
.rdata
->u
.srv
.port
)) return(mDNS_DeregisterNoSuchService(m
, &sr
->RR_SRV
));
10134 if (sr
->RR_PTR
.resrec
.RecordType
== kDNSRecordTypeUnregistered
)
10136 debugf("Service set for %##s already deregistered", sr
->RR_SRV
.resrec
.name
->c
);
10137 return(mStatus_BadReferenceErr
);
10139 else if (sr
->RR_PTR
.resrec
.RecordType
== kDNSRecordTypeDeregistering
)
10141 LogInfo("Service set for %##s already in the process of deregistering", sr
->RR_SRV
.resrec
.name
->c
);
10142 // Avoid race condition:
10143 // If a service gets a conflict, then we set the Conflict flag to tell us to generate
10144 // an mStatus_NameConflict message when we get the mStatus_MemFree for our PTR record.
10145 // If the client happens to deregister the service in the middle of that process, then
10146 // we clear the flag back to the normal state, so that we deliver a plain mStatus_MemFree
10147 // instead of incorrectly promoting it to mStatus_NameConflict.
10148 // This race condition is exposed particularly when the conformance test generates
10149 // a whole batch of simultaneous conflicts across a range of services all advertised
10150 // using the same system default name, and if we don't take this precaution then
10151 // we end up incrementing m->nicelabel multiple times instead of just once.
10152 // <rdar://problem/4060169> Bug when auto-renaming Computer Name after name collision
10153 sr
->Conflict
= mDNSfalse
;
10154 return(mStatus_NoError
);
10160 ExtraResourceRecord
*e
;
10164 // We use mDNS_Dereg_repeat because, in the event of a collision, some or all of the
10165 // SRV, TXT, or Extra records could have already been automatically deregistered, and that's okay
10166 mDNS_Deregister_internal(m
, &sr
->RR_SRV
, mDNS_Dereg_repeat
);
10167 mDNS_Deregister_internal(m
, &sr
->RR_TXT
, mDNS_Dereg_repeat
);
10169 mDNS_Deregister_internal(m
, &sr
->RR_ADV
, drt
);
10171 // We deregister all of the extra records, but we leave the sr->Extras list intact
10172 // in case the client wants to do a RenameAndReregister and reinstate the registration
10175 mDNS_Deregister_internal(m
, &e
->r
, mDNS_Dereg_repeat
);
10179 for (i
=0; i
<sr
->NumSubTypes
; i
++)
10180 mDNS_Deregister_internal(m
, &sr
->SubTypes
[i
], drt
);
10182 status
= mDNS_Deregister_internal(m
, &sr
->RR_PTR
, drt
);
10188 // Create a registration that asserts that no such service exists with this name.
10189 // This can be useful where there is a given function is available through several protocols.
10190 // For example, a printer called "Stuart's Printer" may implement printing via the "pdl-datastream" and "IPP"
10191 // protocols, but not via "LPR". In this case it would be prudent for the printer to assert the non-existence of an
10192 // "LPR" service called "Stuart's Printer". Without this precaution, another printer than offers only "LPR" printing
10193 // could inadvertently advertise its service under the same name "Stuart's Printer", which might be confusing for users.
10194 mDNSexport mStatus
mDNS_RegisterNoSuchService(mDNS
*const m
, AuthRecord
*const rr
,
10195 const domainlabel
*const name
, const domainname
*const type
, const domainname
*const domain
,
10196 const domainname
*const host
,
10197 const mDNSInterfaceID InterfaceID
, mDNSRecordCallback Callback
, void *Context
, mDNSBool includeP2P
)
10199 AuthRecType artype
;
10201 if (InterfaceID
== mDNSInterface_LocalOnly
)
10202 artype
= AuthRecordLocalOnly
;
10203 else if (InterfaceID
== mDNSInterface_P2P
)
10204 artype
= AuthRecordP2P
;
10205 else if ((InterfaceID
== mDNSInterface_Any
) && includeP2P
)
10206 artype
= AuthRecordAnyIncludeP2P
;
10208 artype
= AuthRecordAny
;
10210 mDNS_SetupResourceRecord(rr
, mDNSNULL
, InterfaceID
, kDNSType_SRV
, kHostNameTTL
, kDNSRecordTypeUnique
, artype
, Callback
, Context
);
10211 if (ConstructServiceName(&rr
->namestorage
, name
, type
, domain
) == mDNSNULL
) return(mStatus_BadParamErr
);
10212 rr
->resrec
.rdata
->u
.srv
.priority
= 0;
10213 rr
->resrec
.rdata
->u
.srv
.weight
= 0;
10214 rr
->resrec
.rdata
->u
.srv
.port
= zeroIPPort
;
10215 if (host
&& host
->c
[0]) AssignDomainName(&rr
->resrec
.rdata
->u
.srv
.target
, host
);
10216 else rr
->AutoTarget
= Target_AutoHost
;
10217 return(mDNS_Register(m
, rr
));
10220 mDNSexport mStatus
mDNS_AdvertiseDomains(mDNS
*const m
, AuthRecord
*rr
,
10221 mDNS_DomainType DomainType
, const mDNSInterfaceID InterfaceID
, char *domname
)
10223 AuthRecType artype
;
10225 if (InterfaceID
== mDNSInterface_LocalOnly
)
10226 artype
= AuthRecordLocalOnly
;
10227 else if (InterfaceID
== mDNSInterface_P2P
)
10228 artype
= AuthRecordP2P
;
10230 artype
= AuthRecordAny
;
10231 mDNS_SetupResourceRecord(rr
, mDNSNULL
, InterfaceID
, kDNSType_PTR
, kStandardTTL
, kDNSRecordTypeShared
, artype
, mDNSNULL
, mDNSNULL
);
10232 if (!MakeDomainNameFromDNSNameString(&rr
->namestorage
, mDNS_DomainTypeNames
[DomainType
])) return(mStatus_BadParamErr
);
10233 if (!MakeDomainNameFromDNSNameString(&rr
->resrec
.rdata
->u
.name
, domname
)) return(mStatus_BadParamErr
);
10234 return(mDNS_Register(m
, rr
));
10237 mDNSlocal mDNSBool
mDNS_IdUsedInResourceRecordsList(mDNS
* const m
, mDNSOpaque16 id
)
10240 for (r
= m
->ResourceRecords
; r
; r
=r
->next
) if (mDNSSameOpaque16(id
, r
->updateid
)) return mDNStrue
;
10244 mDNSlocal mDNSBool
mDNS_IdUsedInQuestionsList(mDNS
* const m
, mDNSOpaque16 id
)
10247 for (q
= m
->Questions
; q
; q
=q
->next
) if (mDNSSameOpaque16(id
, q
->TargetQID
)) return mDNStrue
;
10251 mDNSexport mDNSOpaque16
mDNS_NewMessageID(mDNS
* const m
)
10256 for (i
=0; i
<10; i
++)
10258 id
= mDNSOpaque16fromIntVal(1 + (mDNSu16
)mDNSRandom(0xFFFE));
10259 if (!mDNS_IdUsedInResourceRecordsList(m
, id
) && !mDNS_IdUsedInQuestionsList(m
, id
)) break;
10262 debugf("mDNS_NewMessageID: %5d", mDNSVal16(id
));
10267 // ***************************************************************************
10268 #if COMPILER_LIKES_PRAGMA_MARK
10270 #pragma mark - Sleep Proxy Server
10273 mDNSlocal
void RestartARPProbing(mDNS
*const m
, AuthRecord
*const rr
)
10275 // If we see an ARP from a machine we think is sleeping, then either
10276 // (i) the machine has woken, or
10277 // (ii) it's just a stray old packet from before the machine slept
10278 // To handle the second case, we reset ProbeCount, so we'll suppress our own answers for a while, to avoid
10279 // generating ARP conflicts with a waking machine, and set rr->LastAPTime so we'll start probing again in 10 seconds.
10280 // If the machine has just woken then we'll discard our records when we see the first new mDNS probe from that machine.
10281 // If it was a stray old packet, then after 10 seconds we'll probe again and then start answering ARPs again. In this case we *do*
10282 // need to send new ARP Announcements, because the owner's ARP broadcasts will have updated neighboring ARP caches, so we need to
10283 // re-assert our (temporary) ownership of that IP address in order to receive subsequent packets addressed to that IPv4 address.
10285 rr
->resrec
.RecordType
= kDNSRecordTypeUnique
;
10286 rr
->ProbeCount
= DefaultProbeCountForTypeUnique
;
10288 // If we haven't started announcing yet (and we're not already in ten-second-delay mode) the machine is probably
10289 // still going to sleep, so we just reset rr->ProbeCount so we'll continue probing until it stops responding.
10290 // If we *have* started announcing, the machine is probably in the process of waking back up, so in that case
10291 // we're more cautious and we wait ten seconds before probing it again. We do this because while waking from
10292 // sleep, some network interfaces tend to lose or delay inbound packets, and without this delay, if the waking machine
10293 // didn't answer our three probes within three seconds then we'd announce and cause it an unnecessary address conflict.
10294 if (rr
->AnnounceCount
== InitialAnnounceCount
&& m
->timenow
- rr
->LastAPTime
>= 0)
10295 InitializeLastAPTime(m
, rr
);
10298 rr
->AnnounceCount
= InitialAnnounceCount
;
10299 rr
->ThisAPInterval
= mDNSPlatformOneSecond
;
10300 rr
->LastAPTime
= m
->timenow
+ mDNSPlatformOneSecond
* 9; // Send first packet at rr->LastAPTime + rr->ThisAPInterval, i.e. 10 seconds from now
10301 SetNextAnnounceProbeTime(m
, rr
);
10305 mDNSlocal
void mDNSCoreReceiveRawARP(mDNS
*const m
, const ARP_EthIP
*const arp
, const mDNSInterfaceID InterfaceID
)
10307 static const mDNSOpaque16 ARP_op_request
= { { 0, 1 } };
10309 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, InterfaceID
);
10315 // Process ARP Requests and Probes (but not Announcements), and generate an ARP Reply if necessary.
10316 // We also process ARPs from our own kernel (and 'answer' them by injecting a local ARP table entry)
10317 // We ignore ARP Announcements here -- Announcements are not questions, they're assertions, so we don't need to answer them.
10318 // The times we might need to react to an ARP Announcement are:
10319 // (i) as an indication that the host in question has not gone to sleep yet (so we should delay beginning to proxy for it) or
10320 // (ii) if it's a conflicting Announcement from another host
10321 // -- and we check for these in Pass 2 below.
10322 if (mDNSSameOpaque16(arp
->op
, ARP_op_request
) && !mDNSSameIPv4Address(arp
->spa
, arp
->tpa
))
10324 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
10325 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
10326 rr
->AddressProxy
.type
== mDNSAddrType_IPv4
&& mDNSSameIPv4Address(rr
->AddressProxy
.ip
.v4
, arp
->tpa
))
10328 static const char msg1
[] = "ARP Req from owner -- re-probing";
10329 static const char msg2
[] = "Ignoring ARP Request from ";
10330 static const char msg3
[] = "Creating Local ARP Cache entry ";
10331 static const char msg4
[] = "Answering ARP Request from ";
10332 const char *const msg
= mDNSSameEthAddress(&arp
->sha
, &rr
->WakeUp
.IMAC
) ? msg1
:
10333 (rr
->AnnounceCount
== InitialAnnounceCount
) ? msg2
:
10334 mDNSSameEthAddress(&arp
->sha
, &intf
->MAC
) ? msg3
: msg4
;
10335 LogSPS("%-7s %s %.6a %.4a for %.4a -- H-MAC %.6a I-MAC %.6a %s",
10336 intf
->ifname
, msg
, &arp
->sha
, &arp
->spa
, &arp
->tpa
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
, rr
));
10337 if (msg
== msg1
) RestartARPProbing(m
, rr
);
10338 else if (msg
== msg3
) mDNSPlatformSetLocalAddressCacheEntry(m
, &rr
->AddressProxy
, &rr
->WakeUp
.IMAC
, InterfaceID
);
10339 else if (msg
== msg4
) SendARP(m
, 2, rr
, &arp
->tpa
, &arp
->sha
, &arp
->spa
, &arp
->sha
);
10344 // For all types of ARP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding.
10345 // (Strictly speaking we're only checking Announcement/Request/Reply packets, since ARP Probes have zero Sender IP address,
10346 // so by definition (and by design) they can never conflict with any real (i.e. non-zero) IP address).
10347 // We ignore ARPs we sent ourselves (Sender MAC address is our MAC address) because our own proxy ARPs do not constitute a conflict that we need to handle.
10348 // If we see an apparently conflicting ARP, we check the sender hardware address:
10349 // If the sender hardware address is the original owner this is benign, so we just suppress our own proxy answering for a while longer.
10350 // If the sender hardware address is *not* the original owner, then this is a conflict, and we need to wake the sleeping machine to handle it.
10351 if (mDNSSameEthAddress(&arp
->sha
, &intf
->MAC
))
10352 debugf("ARP from self for %.4a", &arp
->tpa
);
10355 if (!mDNSSameIPv4Address(arp
->spa
, zerov4Addr
))
10356 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
10357 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
10358 rr
->AddressProxy
.type
== mDNSAddrType_IPv4
&& mDNSSameIPv4Address(rr
->AddressProxy
.ip
.v4
, arp
->spa
))
10360 RestartARPProbing(m
, rr
);
10361 if (mDNSSameEthAddress(&arp
->sha
, &rr
->WakeUp
.IMAC
))
10362 LogSPS("%-7s ARP %s from owner %.6a %.4a for %-15.4a -- re-starting probing for %s", intf
->ifname
,
10363 mDNSSameIPv4Address(arp
->spa
, arp
->tpa
) ? "Announcement " : mDNSSameOpaque16(arp
->op
, ARP_op_request
) ? "Request " : "Response ",
10364 &arp
->sha
, &arp
->spa
, &arp
->tpa
, ARDisplayString(m
, rr
));
10367 LogMsg("%-7s Conflicting ARP from %.6a %.4a for %.4a -- waking H-MAC %.6a I-MAC %.6a %s", intf
->ifname
,
10368 &arp
->sha
, &arp
->spa
, &arp
->tpa
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
, rr
));
10369 ScheduleWakeup(m
, rr
->resrec
.InterfaceID
, &rr
->WakeUp
.HMAC
);
10378 // Option 1 is Source Link Layer Address Option
10379 // Option 2 is Target Link Layer Address Option
10380 mDNSlocal const mDNSEthAddr *GetLinkLayerAddressOption(const IPv6NDP *const ndp, const mDNSu8 *const end, mDNSu8 op)
10382 const mDNSu8 *options = (mDNSu8 *)(ndp+1);
10383 while (options < end)
10385 debugf("NDP Option %02X len %2d %d", options[0], options[1], end - options);
10386 if (options[0] == op && options[1] == 1) return (const mDNSEthAddr*)(options+2);
10387 options += options[1] * 8;
10393 mDNSlocal
void mDNSCoreReceiveRawND(mDNS
*const m
, const mDNSEthAddr
*const sha
, const mDNSv6Addr
*spa
,
10394 const IPv6NDP
*const ndp
, const mDNSu8
*const end
, const mDNSInterfaceID InterfaceID
)
10397 NetworkInterfaceInfo
*intf
= FirstInterfaceForID(m
, InterfaceID
);
10402 // Pass 1: Process Neighbor Solicitations, and generate a Neighbor Advertisement if necessary.
10403 if (ndp
->type
== NDP_Sol
)
10405 //const mDNSEthAddr *const sha = GetLinkLayerAddressOption(ndp, end, NDP_SrcLL);
10407 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
10408 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
10409 rr
->AddressProxy
.type
== mDNSAddrType_IPv6
&& mDNSSameIPv6Address(rr
->AddressProxy
.ip
.v6
, ndp
->target
))
10411 static const char msg1
[] = "NDP Req from owner -- re-probing";
10412 static const char msg2
[] = "Ignoring NDP Request from ";
10413 static const char msg3
[] = "Creating Local NDP Cache entry ";
10414 static const char msg4
[] = "Answering NDP Request from ";
10415 static const char msg5
[] = "Answering NDP Probe from ";
10416 const char *const msg
= sha
&& mDNSSameEthAddress(sha
, &rr
->WakeUp
.IMAC
) ? msg1
:
10417 (rr
->AnnounceCount
== InitialAnnounceCount
) ? msg2
:
10418 sha
&& mDNSSameEthAddress(sha
, &intf
->MAC
) ? msg3
:
10419 spa
&& mDNSIPv6AddressIsZero(*spa
) ? msg4
: msg5
;
10420 LogSPS("%-7s %s %.6a %.16a for %.16a -- H-MAC %.6a I-MAC %.6a %s",
10421 intf
->ifname
, msg
, sha
, spa
, &ndp
->target
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
, rr
));
10422 if (msg
== msg1
) RestartARPProbing(m
, rr
);
10423 else if (msg
== msg3
)
10425 if (!(m
->KnownBugs
& mDNS_KnownBug_LimitedIPv6
))
10426 mDNSPlatformSetLocalAddressCacheEntry(m
, &rr
->AddressProxy
, &rr
->WakeUp
.IMAC
, InterfaceID
);
10428 else if (msg
== msg4
) SendNDP(m
, NDP_Adv
, NDP_Solicited
, rr
, &ndp
->target
, mDNSNULL
, spa
, sha
);
10429 else if (msg
== msg5
) SendNDP(m
, NDP_Adv
, 0, rr
, &ndp
->target
, mDNSNULL
, &AllHosts_v6
, &AllHosts_v6_Eth
);
10433 // Pass 2: For all types of NDP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding.
10434 if (mDNSSameEthAddress(sha
, &intf
->MAC
))
10435 debugf("NDP from self for %.16a", &ndp
->target
);
10438 // For Neighbor Advertisements we check the Target address field, not the actual IPv6 source address.
10439 // When a machine has both link-local and routable IPv6 addresses, it may send NDP packets making assertions
10440 // about its routable IPv6 address, using its link-local address as the source address for all NDP packets.
10441 // Hence it is the NDP target address we care about, not the actual packet source address.
10442 if (ndp
->type
== NDP_Adv
) spa
= &ndp
->target
;
10443 if (!mDNSSameIPv6Address(*spa
, zerov6Addr
))
10444 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
10445 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
10446 rr
->AddressProxy
.type
== mDNSAddrType_IPv6
&& mDNSSameIPv6Address(rr
->AddressProxy
.ip
.v6
, *spa
))
10448 RestartARPProbing(m
, rr
);
10449 if (mDNSSameEthAddress(sha
, &rr
->WakeUp
.IMAC
))
10450 LogSPS("%-7s NDP %s from owner %.6a %.16a for %.16a -- re-starting probing for %s", intf
->ifname
,
10451 ndp
->type
== NDP_Sol
? "Solicitation " : "Advertisement", sha
, spa
, &ndp
->target
, ARDisplayString(m
, rr
));
10454 LogMsg("%-7s Conflicting NDP from %.6a %.16a for %.16a -- waking H-MAC %.6a I-MAC %.6a %s", intf
->ifname
,
10455 sha
, spa
, &ndp
->target
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
, rr
));
10456 ScheduleWakeup(m
, rr
->resrec
.InterfaceID
, &rr
->WakeUp
.HMAC
);
10464 mDNSlocal
void mDNSCoreReceiveRawTransportPacket(mDNS
*const m
, const mDNSEthAddr
*const sha
, const mDNSAddr
*const src
, const mDNSAddr
*const dst
, const mDNSu8 protocol
,
10465 const mDNSu8
*const p
, const TransportLayerPacket
*const t
, const mDNSu8
*const end
, const mDNSInterfaceID InterfaceID
, const mDNSu16 len
)
10467 const mDNSIPPort port
= (protocol
== 0x06) ? t
->tcp
.dst
: (protocol
== 0x11) ? t
->udp
.dst
: zeroIPPort
;
10468 mDNSBool wake
= mDNSfalse
;
10472 #define XX wake ? "Received" : "Ignoring", end-p
10473 case 0x01: LogSPS("Ignoring %d-byte ICMP from %#a to %#a", end
-p
, src
, dst
);
10477 #define SSH_AsNumber 22
10478 static const mDNSIPPort SSH
= { { SSH_AsNumber
>> 8, SSH_AsNumber
& 0xFF } };
10481 // (a) RST is not set, AND
10482 // (b) packet is SYN, SYN+FIN, or plain data packet (no SYN or FIN). We won't wake for FIN alone.
10483 wake
= (!(t
->tcp
.flags
& 4) && (t
->tcp
.flags
& 3) != 1);
10485 // For now, to reduce spurious wakeups, we wake only for TCP SYN,
10486 // except for ssh connections, where we'll wake for plain data packets too
10487 if (!mDNSSameIPPort(port
, SSH
) && !(t
->tcp
.flags
& 2)) wake
= mDNSfalse
;
10489 LogSPS("%s %d-byte TCP from %#a:%d to %#a:%d%s%s%s", XX
,
10490 src
, mDNSVal16(t
->tcp
.src
), dst
, mDNSVal16(port
),
10491 (t
->tcp
.flags
& 2) ? " SYN" : "",
10492 (t
->tcp
.flags
& 1) ? " FIN" : "",
10493 (t
->tcp
.flags
& 4) ? " RST" : "");
10498 #define ARD_AsNumber 3283
10499 static const mDNSIPPort ARD
= { { ARD_AsNumber
>> 8, ARD_AsNumber
& 0xFF } };
10500 const mDNSu16 udplen
= (mDNSu16
)((mDNSu16
)t
->bytes
[4] << 8 | t
->bytes
[5]); // Length *including* 8-byte UDP header
10501 if (udplen
>= sizeof(UDPHeader
))
10503 const mDNSu16 datalen
= udplen
- sizeof(UDPHeader
);
10506 // For Back to My Mac UDP port 4500 (IPSEC) packets, we do some special handling
10507 if (mDNSSameIPPort(port
, IPSECPort
))
10509 // Specifically ignore NAT keepalive packets
10510 if (datalen
== 1 && end
>= &t
->bytes
[9] && t
->bytes
[8] == 0xFF) wake
= mDNSfalse
;
10513 // Skip over the Non-ESP Marker if present
10514 const mDNSBool NonESP
= (end
>= &t
->bytes
[12] && t
->bytes
[8] == 0 && t
->bytes
[9] == 0 && t
->bytes
[10] == 0 && t
->bytes
[11] == 0);
10515 const IKEHeader
*const ike
= (IKEHeader
*)(t
+ (NonESP
? 12 : 8));
10516 const mDNSu16 ikelen
= datalen
- (NonESP
? 4 : 0);
10517 if (ikelen
>= sizeof(IKEHeader
) && end
>= ((mDNSu8
*)ike
) + sizeof(IKEHeader
))
10518 if ((ike
->Version
& 0x10) == 0x10)
10520 // ExchangeType == 5 means 'Informational' <http://www.ietf.org/rfc/rfc2408.txt>
10521 // ExchangeType == 34 means 'IKE_SA_INIT' <http://www.iana.org/assignments/ikev2-parameters>
10522 if (ike
->ExchangeType
== 5 || ike
->ExchangeType
== 34) wake
= mDNSfalse
;
10523 LogSPS("%s %d-byte IKE ExchangeType %d", XX
, ike
->ExchangeType
);
10528 // For now, because we haven't yet worked out a clean elegant way to do this, we just special-case the
10529 // Apple Remote Desktop port number -- we ignore all packets to UDP 3283 (the "Net Assistant" port),
10530 // except for Apple Remote Desktop's explicit manual wakeup packet, which looks like this:
10531 // UDP header (8 bytes)
10532 // Payload: 13 88 00 6a 41 4e 41 20 (8 bytes) ffffffffffff (6 bytes) 16xMAC (96 bytes) = 110 bytes total
10533 if (mDNSSameIPPort(port
, ARD
)) wake
= (datalen
>= 110 && end
>= &t
->bytes
[10] && t
->bytes
[8] == 0x13 && t
->bytes
[9] == 0x88);
10535 LogSPS("%s %d-byte UDP from %#a:%d to %#a:%d", XX
, src
, mDNSVal16(t
->udp
.src
), dst
, mDNSVal16(port
));
10540 case 0x3A: if (&t
->bytes
[len
] <= end
)
10542 mDNSu16 checksum
= IPv6CheckSum(&src
->ip
.v6
, &dst
->ip
.v6
, protocol
, t
->bytes
, len
);
10543 if (!checksum
) mDNSCoreReceiveRawND(m
, sha
, &src
->ip
.v6
, &t
->ndp
, &t
->bytes
[len
], InterfaceID
);
10544 else LogInfo("IPv6CheckSum bad %04X %02X%02X from %#a to %#a", checksum
, t
->bytes
[2], t
->bytes
[3], src
, dst
);
10548 default: LogSPS("Ignoring %d-byte IP packet unknown protocol %d from %#a to %#a", end
-p
, protocol
, src
, dst
);
10554 AuthRecord
*rr
, *r2
;
10557 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
10558 if (rr
->resrec
.InterfaceID
== InterfaceID
&&
10559 rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
10560 rr
->AddressProxy
.type
&& mDNSSameAddress(&rr
->AddressProxy
, dst
))
10562 const mDNSu8
*const tp
= (protocol
== 6) ? (const mDNSu8
*)"\x4_tcp" : (const mDNSu8
*)"\x4_udp";
10563 for (r2
= m
->ResourceRecords
; r2
; r2
=r2
->next
)
10564 if (r2
->resrec
.InterfaceID
== InterfaceID
&& mDNSSameEthAddress(&r2
->WakeUp
.HMAC
, &rr
->WakeUp
.HMAC
) &&
10565 r2
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
&&
10566 r2
->resrec
.rrtype
== kDNSType_SRV
&& mDNSSameIPPort(r2
->resrec
.rdata
->u
.srv
.port
, port
) &&
10567 SameDomainLabel(ThirdLabel(r2
->resrec
.name
)->c
, tp
))
10569 if (!r2
&& mDNSSameIPPort(port
, IPSECPort
)) r2
= rr
; // So that we wake for BTMM IPSEC packets, even without a matching SRV record
10572 LogMsg("Waking host at %s %#a H-MAC %.6a I-MAC %.6a for %s",
10573 InterfaceNameForID(m
, rr
->resrec
.InterfaceID
), dst
, &rr
->WakeUp
.HMAC
, &rr
->WakeUp
.IMAC
, ARDisplayString(m
, r2
));
10574 ScheduleWakeup(m
, rr
->resrec
.InterfaceID
, &rr
->WakeUp
.HMAC
);
10577 LogSPS("Sleeping host at %s %#a %.6a has no service on %#s %d",
10578 InterfaceNameForID(m
, rr
->resrec
.InterfaceID
), dst
, &rr
->WakeUp
.HMAC
, tp
, mDNSVal16(port
));
10584 mDNSexport
void mDNSCoreReceiveRawPacket(mDNS
*const m
, const mDNSu8
*const p
, const mDNSu8
*const end
, const mDNSInterfaceID InterfaceID
)
10586 static const mDNSOpaque16 Ethertype_ARP
= { { 0x08, 0x06 } }; // Ethertype 0x0806 = ARP
10587 static const mDNSOpaque16 Ethertype_IPv4
= { { 0x08, 0x00 } }; // Ethertype 0x0800 = IPv4
10588 static const mDNSOpaque16 Ethertype_IPv6
= { { 0x86, 0xDD } }; // Ethertype 0x86DD = IPv6
10589 static const mDNSOpaque16 ARP_hrd_eth
= { { 0x00, 0x01 } }; // Hardware address space (Ethernet = 1)
10590 static const mDNSOpaque16 ARP_pro_ip
= { { 0x08, 0x00 } }; // Protocol address space (IP = 0x0800)
10592 // Note: BPF guarantees that the NETWORK LAYER header will be word aligned, not the link-layer header.
10593 // In other words, we can safely assume that pkt below (ARP, IPv4 or IPv6) is properly word aligned,
10594 // but if pkt is 4-byte aligned, that necessarily means that eth CANNOT also be 4-byte aligned
10595 // since it points to a an address 14 bytes before pkt.
10596 const EthernetHeader
*const eth
= (const EthernetHeader
*)p
;
10597 const NetworkLayerPacket
*const pkt
= (const NetworkLayerPacket
*)(eth
+1);
10599 #define RequiredCapLen(P) ((P)==0x01 ? 4 : (P)==0x06 ? 20 : (P)==0x11 ? 8 : (P)==0x3A ? 24 : 0)
10601 // Is ARP? Length must be at least 14 + 28 = 42 bytes
10602 if (end
>= p
+42 && mDNSSameOpaque16(eth
->ethertype
, Ethertype_ARP
) && mDNSSameOpaque16(pkt
->arp
.hrd
, ARP_hrd_eth
) && mDNSSameOpaque16(pkt
->arp
.pro
, ARP_pro_ip
))
10603 mDNSCoreReceiveRawARP(m
, &pkt
->arp
, InterfaceID
);
10604 // Is IPv4 with zero fragmentation offset? Length must be at least 14 + 20 = 34 bytes
10605 else if (end
>= p
+34 && mDNSSameOpaque16(eth
->ethertype
, Ethertype_IPv4
) && (pkt
->v4
.flagsfrags
.b
[0] & 0x1F) == 0 && pkt
->v4
.flagsfrags
.b
[1] == 0)
10607 const mDNSu8
*const trans
= p
+ 14 + (pkt
->v4
.vlen
& 0xF) * 4;
10608 debugf("Got IPv4 %02X from %.4a to %.4a", pkt
->v4
.protocol
, &pkt
->v4
.src
, &pkt
->v4
.dst
);
10609 src
.type
= mDNSAddrType_IPv4
; src
.ip
.v4
= pkt
->v4
.src
;
10610 dst
.type
= mDNSAddrType_IPv4
; dst
.ip
.v4
= pkt
->v4
.dst
;
10611 if (end
>= trans
+ RequiredCapLen(pkt
->v4
.protocol
))
10612 mDNSCoreReceiveRawTransportPacket(m
, ð
->src
, &src
, &dst
, pkt
->v4
.protocol
, p
, (TransportLayerPacket
*)trans
, end
, InterfaceID
, 0);
10614 // Is IPv6? Length must be at least 14 + 28 = 42 bytes
10615 else if (end
>= p
+54 && mDNSSameOpaque16(eth
->ethertype
, Ethertype_IPv6
))
10617 const mDNSu8
*const trans
= p
+ 54;
10618 debugf("Got IPv6 %02X from %.16a to %.16a", pkt
->v6
.pro
, &pkt
->v6
.src
, &pkt
->v6
.dst
);
10619 src
.type
= mDNSAddrType_IPv6
; src
.ip
.v6
= pkt
->v6
.src
;
10620 dst
.type
= mDNSAddrType_IPv6
; dst
.ip
.v6
= pkt
->v6
.dst
;
10621 if (end
>= trans
+ RequiredCapLen(pkt
->v6
.pro
))
10622 mDNSCoreReceiveRawTransportPacket(m
, ð
->src
, &src
, &dst
, pkt
->v6
.pro
, p
, (TransportLayerPacket
*)trans
, end
, InterfaceID
,
10623 (mDNSu16
)pkt
->bytes
[4] << 8 | pkt
->bytes
[5]);
10627 mDNSlocal
void ConstructSleepProxyServerName(mDNS
*const m
, domainlabel
*name
)
10629 name
->c
[0] = (mDNSu8
)mDNS_snprintf((char*)name
->c
+1, 62, "%d-%d-%d-%d %#s",
10630 m
->SPSType
, m
->SPSPortability
, m
->SPSMarginalPower
, m
->SPSTotalPower
, &m
->nicelabel
);
10633 mDNSlocal
void SleepProxyServerCallback(mDNS
*const m
, ServiceRecordSet
*const srs
, mStatus result
)
10635 if (result
== mStatus_NameConflict
)
10636 mDNS_RenameAndReregisterService(m
, srs
, mDNSNULL
);
10637 else if (result
== mStatus_MemFree
)
10643 m
->SPSState
= (mDNSu8
)(m
->SPSSocket
!= mDNSNULL
);
10647 ConstructSleepProxyServerName(m
, &name
);
10648 mDNS_RegisterService(m
, srs
,
10649 &name
, &SleepProxyServiceType
, &localdomain
,
10650 mDNSNULL
, m
->SPSSocket
->port
, // Host, port
10651 (mDNSu8
*)"", 1, // TXT data, length
10652 mDNSNULL
, 0, // Subtypes (none)
10653 mDNSInterface_Any
, // Interface ID
10654 SleepProxyServerCallback
, mDNSNULL
, 0); // Callback, context, flags
10656 LogSPS("Sleep Proxy Server %#s %s", srs
->RR_SRV
.resrec
.name
->c
, m
->SPSState
? "started" : "stopped");
10661 // Called with lock held
10662 mDNSexport
void mDNSCoreBeSleepProxyServer_internal(mDNS
*const m
, mDNSu8 sps
, mDNSu8 port
, mDNSu8 marginalpower
, mDNSu8 totpower
)
10664 // This routine uses mDNS_DeregisterService and calls SleepProxyServerCallback, so we execute in user callback context
10665 mDNS_DropLockBeforeCallback();
10667 // If turning off SPS, close our socket
10668 // (Do this first, BEFORE calling mDNS_DeregisterService below)
10669 if (!sps
&& m
->SPSSocket
) { mDNSPlatformUDPClose(m
->SPSSocket
); m
->SPSSocket
= mDNSNULL
; }
10671 // If turning off, or changing type, deregister old name
10672 if (m
->SPSState
== 1 && sps
!= m
->SPSType
)
10673 { m
->SPSState
= 2; mDNS_DeregisterService_drt(m
, &m
->SPSRecords
, sps
? mDNS_Dereg_rapid
: mDNS_Dereg_normal
); }
10675 // Record our new SPS parameters
10677 m
->SPSPortability
= port
;
10678 m
->SPSMarginalPower
= marginalpower
;
10679 m
->SPSTotalPower
= totpower
;
10681 // If turning on, open socket and advertise service
10686 m
->SPSSocket
= mDNSPlatformUDPSocket(m
, zeroIPPort
);
10687 if (!m
->SPSSocket
) { LogMsg("mDNSCoreBeSleepProxyServer: Failed to allocate SPSSocket"); goto fail
; }
10689 if (m
->SPSState
== 0) SleepProxyServerCallback(m
, &m
->SPSRecords
, mStatus_MemFree
);
10691 else if (m
->SPSState
)
10693 LogSPS("mDNSCoreBeSleepProxyServer turning off from state %d; will wake clients", m
->SPSState
);
10694 m
->NextScheduledSPS
= m
->timenow
;
10697 mDNS_ReclaimLockAfterCallback();
10700 // ***************************************************************************
10701 #if COMPILER_LIKES_PRAGMA_MARK
10703 #pragma mark - Startup and Shutdown
10706 mDNSlocal
void mDNS_GrowCache_internal(mDNS
*const m
, CacheEntity
*storage
, mDNSu32 numrecords
)
10708 if (storage
&& numrecords
)
10711 debugf("Adding cache storage for %d more records (%d bytes)", numrecords
, numrecords
*sizeof(CacheEntity
));
10712 for (i
=0; i
<numrecords
; i
++) storage
[i
].next
= &storage
[i
+1];
10713 storage
[numrecords
-1].next
= m
->rrcache_free
;
10714 m
->rrcache_free
= storage
;
10715 m
->rrcache_size
+= numrecords
;
10719 mDNSexport
void mDNS_GrowCache(mDNS
*const m
, CacheEntity
*storage
, mDNSu32 numrecords
)
10722 mDNS_GrowCache_internal(m
, storage
, numrecords
);
10726 mDNSexport mStatus
mDNS_Init(mDNS
*const m
, mDNS_PlatformSupport
*const p
,
10727 CacheEntity
*rrcachestorage
, mDNSu32 rrcachesize
,
10728 mDNSBool AdvertiseLocalAddresses
, mDNSCallback
*Callback
, void *Context
)
10734 if (!rrcachestorage
) rrcachesize
= 0;
10738 m
->CanReceiveUnicastOn5353
= mDNSfalse
; // Assume we can't receive unicasts on 5353, unless platform layer tells us otherwise
10739 m
->AdvertiseLocalAddresses
= AdvertiseLocalAddresses
;
10740 m
->DivertMulticastAdvertisements
= mDNSfalse
;
10741 m
->mDNSPlatformStatus
= mStatus_Waiting
;
10742 m
->UnicastPort4
= zeroIPPort
;
10743 m
->UnicastPort6
= zeroIPPort
;
10744 m
->PrimaryMAC
= zeroEthAddr
;
10745 m
->MainCallback
= Callback
;
10746 m
->MainContext
= Context
;
10747 m
->rec
.r
.resrec
.RecordType
= 0;
10749 // For debugging: To catch and report locking failures
10751 m
->mDNS_reentrancy
= 0;
10752 m
->ShutdownTime
= 0;
10753 m
->lock_rrcache
= 0;
10754 m
->lock_Questions
= 0;
10755 m
->lock_Records
= 0;
10757 // Task Scheduling variables
10758 result
= mDNSPlatformTimeInit();
10759 if (result
!= mStatus_NoError
) return(result
);
10760 m
->timenow_adjust
= (mDNSs32
)mDNSRandom(0xFFFFFFFF);
10761 timenow
= mDNS_TimeNow_NoLock(m
);
10763 m
->timenow
= 0; // MUST only be set within mDNS_Lock/mDNS_Unlock section
10764 m
->timenow_last
= timenow
;
10765 m
->NextScheduledEvent
= timenow
;
10766 m
->SuppressSending
= timenow
;
10767 m
->NextCacheCheck
= timenow
+ 0x78000000;
10768 m
->NextScheduledQuery
= timenow
+ 0x78000000;
10769 m
->NextScheduledProbe
= timenow
+ 0x78000000;
10770 m
->NextScheduledResponse
= timenow
+ 0x78000000;
10771 m
->NextScheduledNATOp
= timenow
+ 0x78000000;
10772 m
->NextScheduledSPS
= timenow
+ 0x78000000;
10773 m
->NextScheduledStopTime
= timenow
+ 0x78000000;
10774 m
->RandomQueryDelay
= 0;
10775 m
->RandomReconfirmDelay
= 0;
10777 m
->LocalRemoveEvents
= mDNSfalse
;
10778 m
->SleepState
= SleepState_Awake
;
10779 m
->SleepSeqNum
= 0;
10780 m
->SystemWakeOnLANEnabled
= mDNSfalse
;
10781 m
->AnnounceOwner
= NonZeroTime(timenow
+ 60 * mDNSPlatformOneSecond
);
10785 // These fields only required for mDNS Searcher...
10786 m
->Questions
= mDNSNULL
;
10787 m
->NewQuestions
= mDNSNULL
;
10788 m
->CurrentQuestion
= mDNSNULL
;
10789 m
->LocalOnlyQuestions
= mDNSNULL
;
10790 m
->NewLocalOnlyQuestions
= mDNSNULL
;
10791 m
->RestartQuestion
= mDNSNULL
;
10792 m
->rrcache_size
= 0;
10793 m
->rrcache_totalused
= 0;
10794 m
->rrcache_active
= 0;
10795 m
->rrcache_report
= 10;
10796 m
->rrcache_free
= mDNSNULL
;
10798 for (slot
= 0; slot
< CACHE_HASH_SLOTS
; slot
++)
10800 m
->rrcache_hash
[slot
] = mDNSNULL
;
10801 m
->rrcache_nextcheck
[slot
] = timenow
+ 0x78000000;;
10804 mDNS_GrowCache_internal(m
, rrcachestorage
, rrcachesize
);
10805 m
->rrauth
.rrauth_free
= mDNSNULL
;
10807 for (slot
= 0; slot
< AUTH_HASH_SLOTS
; slot
++)
10808 m
->rrauth
.rrauth_hash
[slot
] = mDNSNULL
;
10810 // Fields below only required for mDNS Responder...
10811 m
->hostlabel
.c
[0] = 0;
10812 m
->nicelabel
.c
[0] = 0;
10813 m
->MulticastHostname
.c
[0] = 0;
10814 m
->HIHardware
.c
[0] = 0;
10815 m
->HISoftware
.c
[0] = 0;
10816 m
->ResourceRecords
= mDNSNULL
;
10817 m
->DuplicateRecords
= mDNSNULL
;
10818 m
->NewLocalRecords
= mDNSNULL
;
10819 m
->NewLocalOnlyRecords
= mDNSfalse
;
10820 m
->CurrentRecord
= mDNSNULL
;
10821 m
->HostInterfaces
= mDNSNULL
;
10822 m
->ProbeFailTime
= 0;
10823 m
->NumFailedProbes
= 0;
10824 m
->SuppressProbes
= 0;
10826 #ifndef UNICAST_DISABLED
10827 m
->NextuDNSEvent
= timenow
+ 0x78000000;
10828 m
->NextSRVUpdate
= timenow
+ 0x78000000;
10830 m
->DNSServers
= mDNSNULL
;
10832 m
->Router
= zeroAddr
;
10833 m
->AdvertisedV4
= zeroAddr
;
10834 m
->AdvertisedV6
= zeroAddr
;
10836 m
->AuthInfoList
= mDNSNULL
;
10838 m
->ReverseMap
.ThisQInterval
= -1;
10839 m
->StaticHostname
.c
[0] = 0;
10841 m
->Hostnames
= mDNSNULL
;
10842 m
->AutoTunnelHostAddr
.b
[0] = 0;
10843 m
->AutoTunnelHostAddrActive
= mDNSfalse
;
10844 m
->AutoTunnelLabel
.c
[0] = 0;
10846 m
->StartWABQueries
= mDNSfalse
;
10847 m
->RegisterAutoTunnel6
= mDNStrue
;
10849 // NAT traversal fields
10850 m
->NATTraversals
= mDNSNULL
;
10851 m
->CurrentNATTraversal
= mDNSNULL
;
10852 m
->retryIntervalGetAddr
= 0; // delta between time sent and retry
10853 m
->retryGetAddr
= timenow
+ 0x78000000; // absolute time when we retry
10854 m
->ExternalAddress
= zerov4Addr
;
10856 m
->NATMcastRecvskt
= mDNSNULL
;
10857 m
->LastNATupseconds
= 0;
10858 m
->LastNATReplyLocalTime
= timenow
;
10859 m
->LastNATMapResultCode
= NATErr_None
;
10861 m
->UPnPInterfaceID
= 0;
10862 m
->SSDPSocket
= mDNSNULL
;
10863 m
->SSDPWANPPPConnection
= mDNSfalse
;
10864 m
->UPnPRouterPort
= zeroIPPort
;
10865 m
->UPnPSOAPPort
= zeroIPPort
;
10866 m
->UPnPRouterURL
= mDNSNULL
;
10867 m
->UPnPWANPPPConnection
= mDNSfalse
;
10868 m
->UPnPSOAPURL
= mDNSNULL
;
10869 m
->UPnPRouterAddressString
= mDNSNULL
;
10870 m
->UPnPSOAPAddressString
= mDNSNULL
;
10872 m
->SPSPortability
= 0;
10873 m
->SPSMarginalPower
= 0;
10874 m
->SPSTotalPower
= 0;
10876 m
->SPSProxyListChanged
= mDNSNULL
;
10877 m
->SPSSocket
= mDNSNULL
;
10878 m
->SPSBrowseCallback
= mDNSNULL
;
10879 m
->ProxyRecords
= 0;
10883 #if APPLE_OSX_mDNSResponder
10884 m
->TunnelClients
= mDNSNULL
;
10887 CHECK_WCF_FUNCTION(WCFConnectionNew
)
10889 m
->WCF
= WCFConnectionNew();
10890 if (!m
->WCF
) { LogMsg("WCFConnectionNew failed"); return -1; }
10896 result
= mDNSPlatformInit(m
);
10898 #ifndef UNICAST_DISABLED
10899 // It's better to do this *after* the platform layer has set up the
10900 // interface list and security credentials
10901 uDNS_SetupDNSConfig(m
); // Get initial DNS configuration
10907 mDNSexport
void mDNS_ConfigChanged(mDNS
*const m
)
10909 if (m
->SPSState
== 1)
10911 domainlabel name
, newname
;
10912 domainname type
, domain
;
10913 DeconstructServiceName(m
->SPSRecords
.RR_SRV
.resrec
.name
, &name
, &type
, &domain
);
10914 ConstructSleepProxyServerName(m
, &newname
);
10915 if (!SameDomainLabelCS(name
.c
, newname
.c
))
10917 LogSPS("Renaming SPS from “%#s” to “%#s”", name
.c
, newname
.c
);
10918 // When SleepProxyServerCallback gets the mStatus_MemFree message,
10919 // it will reregister the service under the new name
10921 mDNS_DeregisterService_drt(m
, &m
->SPSRecords
, mDNS_Dereg_rapid
);
10925 if (m
->MainCallback
)
10926 m
->MainCallback(m
, mStatus_ConfigChanged
);
10929 mDNSlocal
void DynDNSHostNameCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
10932 debugf("NameStatusCallback: result %d for registration of name %##s", result
, rr
->resrec
.name
->c
);
10933 mDNSPlatformDynDNSHostNameStatusChanged(rr
->resrec
.name
, result
);
10936 mDNSlocal
void PurgeOrReconfirmCacheRecord(mDNS
*const m
, CacheRecord
*cr
, const DNSServer
* const ptr
, mDNSBool lameduck
)
10938 mDNSBool purge
= cr
->resrec
.RecordType
== kDNSRecordTypePacketNegative
||
10939 cr
->resrec
.rrtype
== kDNSType_A
||
10940 cr
->resrec
.rrtype
== kDNSType_AAAA
||
10941 cr
->resrec
.rrtype
== kDNSType_SRV
;
10945 debugf("PurgeOrReconfirmCacheRecord: %s cache record due to %s server %p %#a:%d (%##s): %s",
10946 purge
? "purging" : "reconfirming",
10947 lameduck
? "lame duck" : "new",
10948 ptr
, &ptr
->addr
, mDNSVal16(ptr
->port
), ptr
->domain
.c
, CRDisplayString(m
, cr
));
10952 LogInfo("PurgeorReconfirmCacheRecord: Purging Resourcerecord %s, RecordType %x", CRDisplayString(m
, cr
), cr
->resrec
.RecordType
);
10953 mDNS_PurgeCacheResourceRecord(m
, cr
);
10957 LogInfo("PurgeorReconfirmCacheRecord: Reconfirming Resourcerecord %s, RecordType %x", CRDisplayString(m
, cr
), cr
->resrec
.RecordType
);
10958 mDNS_Reconfirm_internal(m
, cr
, kDefaultReconfirmTimeForNoAnswer
);
10962 mDNSlocal
void mDNS_PurgeBeforeResolve(mDNS
*const m
, DNSQuestion
*q
)
10964 const mDNSu32 slot
= HashSlot(&q
->qname
);
10965 CacheGroup
*const cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
10968 for (rp
= cg
? cg
->members
: mDNSNULL
; rp
; rp
= rp
->next
)
10970 if (SameNameRecordAnswersQuestion(&rp
->resrec
, q
))
10972 LogInfo("mDNS_PurgeBeforeResolve: Flushing %s", CRDisplayString(m
, rp
));
10973 mDNS_PurgeCacheResourceRecord(m
, rp
);
10978 // Check for a positive unicast response to the question but with qtype
10979 mDNSexport mDNSBool
mDNS_CheckForCacheRecord(mDNS
*const m
, DNSQuestion
*q
, mDNSu16 qtype
)
10981 DNSQuestion question
;
10982 const mDNSu32 slot
= HashSlot(&q
->qname
);
10983 CacheGroup
*const cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
10986 // Create an identical question but with qtype
10987 mDNS_SetupQuestion(&question
, q
->InterfaceID
, &q
->qname
, qtype
, mDNSNULL
, mDNSNULL
);
10988 question
.qDNSServer
= q
->qDNSServer
;
10990 for (rp
= cg
? cg
->members
: mDNSNULL
; rp
; rp
= rp
->next
)
10992 if (!rp
->resrec
.InterfaceID
&& rp
->resrec
.RecordType
!= kDNSRecordTypePacketNegative
&&
10993 SameNameRecordAnswersQuestion(&rp
->resrec
, &question
))
10995 LogInfo("mDNS_CheckForCacheRecord: Found %s", CRDisplayString(m
, rp
));
11002 mDNSlocal
void CacheRecordResetDNSServer(mDNS
*const m
, DNSQuestion
*q
, DNSServer
*new)
11004 const mDNSu32 slot
= HashSlot(&q
->qname
);
11005 CacheGroup
*const cg
= CacheGroupForName(m
, slot
, q
->qnamehash
, &q
->qname
);
11007 mDNSBool found
= mDNSfalse
;
11008 mDNSBool foundNew
= mDNSfalse
;
11009 DNSServer
*old
= q
->qDNSServer
;
11010 mDNSBool newQuestion
= IsQuestionNew(m
, q
);
11013 // This function is called when the DNSServer is updated to the new question. There may already be
11014 // some cache entries matching the old DNSServer and/or new DNSServer. There are four cases. In the
11015 // following table, "Yes" denotes that a cache entry was found for old/new DNSServer.
11017 // old DNSServer new DNSServer
11024 // Case 1: There are cache entries for both old and new DNSServer. We handle this case by simply
11025 // expiring the old Cache entries, deliver a RMV event (if an ADD event was delivered before)
11026 // followed by the ADD event of the cache entries corresponding to the new server. This
11027 // case happens when we pick a DNSServer, issue a query and get a valid response and create
11028 // cache entries after which it stops responding. Another query (non-duplicate) picks a different
11029 // DNSServer and creates identical cache entries (perhaps through records in Additional records).
11030 // Now if the first one expires and tries to pick the new DNSServer (the original DNSServer
11031 // is not responding) we will find cache entries corresponding to both DNSServers.
11033 // Case 2: There are no cache entries for the old DNSServer but there are some for the new DNSServer.
11034 // This means we should deliver an ADD event. Normally ADD events are delivered by
11035 // AnswerNewQuestion if it is a new question. So, we check to see if it is a new question
11036 // and if so, leave it to AnswerNewQuestion to deliver it. Otherwise, we use
11037 // AnswerQuestionsForDNSServerChanges to deliver the ADD event. This case happens when a
11038 // question picks a DNS server for which AnswerNewQuestion could not deliver an answer even
11039 // though there were potential cache entries but DNSServer did not match. Now when we
11040 // pick a new DNSServer, those cache entries may answer this question.
11042 // Case 3: There are the cache entries for the old DNSServer but none for the new. We just move
11043 // the old cache entries to point to the new DNSServer and the caller is expected to
11044 // do a purge or reconfirm to delete or validate the RDATA. We don't need to do anything
11045 // special for delivering ADD events, as it should have been done/will be done by
11046 // AnswerNewQuestion. This case happens when we picked a DNSServer, sent the query and
11047 // got a response and the cache is expired now and we are reissuing the question but the
11048 // original DNSServer does not respond.
11050 // Case 4: There are no cache entries either for the old or for the new DNSServer. There is nothing
11051 // much we can do here.
11053 // Case 2 and 3 are the most common while case 4 is possible when no DNSServers are working. Case 1
11054 // is relatively less likely to happen in practice
11056 // Temporarily set the DNSServer to look for the matching records for the new DNSServer.
11057 q
->qDNSServer
= new;
11058 for (rp
= cg
? cg
->members
: mDNSNULL
; rp
; rp
= rp
->next
)
11060 if (SameNameRecordAnswersQuestion(&rp
->resrec
, q
))
11062 LogInfo("CacheRecordResetDNSServer: Found cache record %##s for new DNSServer address: %#a", rp
->resrec
.name
->c
,
11063 (rp
->resrec
.rDNSServer
!= mDNSNULL
? &rp
->resrec
.rDNSServer
->addr
: mDNSNULL
));
11064 foundNew
= mDNStrue
;
11068 q
->qDNSServer
= old
;
11070 for (rp
= cg
? cg
->members
: mDNSNULL
; rp
; rp
= rp
->next
)
11072 if (SameNameRecordAnswersQuestion(&rp
->resrec
, q
))
11078 LogInfo("CacheRecordResetDNSServer: Flushing Resourcerecord %##s, before:%#a, after:%#a", rp
->resrec
.name
->c
,
11079 (rp
->resrec
.rDNSServer
!= mDNSNULL
? &rp
->resrec
.rDNSServer
->addr
: mDNSNULL
),
11080 (new != mDNSNULL
? &new->addr
: mDNSNULL
));
11081 mDNS_PurgeCacheResourceRecord(m
, rp
);
11084 // "q" is not a duplicate question. If it is a newQuestion, then the CRActiveQuestion can't be
11085 // possibly set as it is set only when we deliver the ADD event to the question.
11086 if (rp
->CRActiveQuestion
!= mDNSNULL
)
11088 LogMsg("CacheRecordResetDNSServer: ERROR!!: CRActiveQuestion %p set, current question %p, name %##s", rp
->CRActiveQuestion
, q
, q
->qname
.c
);
11089 rp
->CRActiveQuestion
= mDNSNULL
;
11091 // if this is a new question, then we never delivered an ADD yet, so don't deliver the RMV.
11095 LogInfo("CacheRecordResetDNSServer: resetting cache record %##s DNSServer address before:%#a,"
11096 " after:%#a, CRActiveQuestion %p", rp
->resrec
.name
->c
, (rp
->resrec
.rDNSServer
!= mDNSNULL
?
11097 &rp
->resrec
.rDNSServer
->addr
: mDNSNULL
), (new != mDNSNULL
? &new->addr
: mDNSNULL
),
11098 rp
->CRActiveQuestion
);
11099 // Though we set it to the new DNS server, the caller is *assumed* to do either a purge
11100 // or reconfirm or send out questions to the "new" server to verify whether the cached
11102 rp
->resrec
.rDNSServer
= new;
11106 // Case 1 and Case 2
11107 if ((found
&& foundNew
) || (!found
&& foundNew
))
11110 LogInfo("CacheRecordResetDNSServer: deliverAddEvents not set for question %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
11111 else if (QuerySuppressed(q
))
11112 LogInfo("CacheRecordResetDNSServer: deliverAddEvents not set for suppressed question %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
11115 LogInfo("CacheRecordResetDNSServer: deliverAddEvents set for %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
11116 q
->deliverAddEvents
= mDNStrue
;
11117 for (qptr
= q
->next
; qptr
; qptr
= qptr
->next
)
11118 if (qptr
->DuplicateOf
== q
) qptr
->deliverAddEvents
= mDNStrue
;
11123 // Case 3 and Case 4
11127 mDNSexport
void DNSServerChangeForQuestion(mDNS
*const m
, DNSQuestion
*q
, DNSServer
*new)
11131 // 1. Whenever we change the DNS server, we change the message identifier also so that response
11132 // from the old server is not accepted as a response from the new server but only messages
11133 // from the new server are accepted as valid responses. We do it irrespective of whether "new"
11134 // is NULL or not. It is possible that we send two queries, no responses, pick a new DNS server
11135 // which is NULL and now the response comes back and will try to penalize the DNS server which
11136 // is NULL. By setting the messageID here, we will not accept that as a valid response.
11138 q
->TargetQID
= mDNS_NewMessageID(m
);
11140 // 2. Move the old cache records to point them at the new DNSServer so that we can deliver the ADD/RMV events
11141 // appropriately. At any point in time, we want all the cache records point only to one DNSServer for a given
11142 // question. "DNSServer" here is the DNSServer object and not the DNS server itself. It is possible to
11143 // have the same DNS server address in two objects, one scoped and another not scoped. But, the cache is per
11144 // DNSServer object. By maintaining the question and the cache entries point to the same DNSServer
11145 // always, the cache maintenance and delivery of ADD/RMV events becomes simpler.
11147 // CacheRecordResetDNSServer should be called only once for the non-duplicate question as once the cache
11148 // entries are moved to point to the new DNSServer, we don't need to call it for the duplicate question
11149 // and it is wrong to call for the duplicate question as it's decision to mark deliverAddevents will be
11152 if (q
->DuplicateOf
)
11153 LogMsg("DNSServerChangeForQuestion: ERROR: Called for duplicate question %##s", q
->qname
.c
);
11155 CacheRecordResetDNSServer(m
, q
, new);
11157 // 3. Make sure all the duplicate questions point to the same DNSServer so that delivery
11158 // of events for all of them are consistent. Duplicates for a question are always inserted
11159 // after in the list.
11160 q
->qDNSServer
= new;
11161 for (qptr
= q
->next
; qptr
; qptr
= qptr
->next
)
11163 if (qptr
->DuplicateOf
== q
) { qptr
->validDNSServers
= q
->validDNSServers
; qptr
->qDNSServer
= new; }
11167 mDNSexport mStatus
uDNS_SetupDNSConfig(mDNS
*const m
)
11173 mDNSAddr v4
, v6
, r
;
11175 DNSServer
*ptr
, **p
= &m
->DNSServers
;
11176 const DNSServer
*oldServers
= m
->DNSServers
;
11178 McastResolver
*mr
, **mres
= &m
->McastResolvers
;
11180 debugf("uDNS_SetupDNSConfig: entry");
11182 // Let the platform layer get the current DNS information
11183 // The m->StartWABQueries is set when we get the first domain enumeration query (no need to hit the network
11184 // with domain enumeration queries until we actually need that information). Even if it is not set, we still
11185 // need to setup the search domains so that we can append them to queries that need them.
11187 uDNS_SetupSearchDomains(m
, m
->StartWABQueries
? UDNS_START_WAB_QUERY
: 0);
11191 for (ptr
= m
->DNSServers
; ptr
; ptr
= ptr
->next
)
11193 ptr
->penaltyTime
= 0;
11194 ptr
->flags
|= DNSServer_FlagDelete
;
11197 // We handle the mcast resolvers here itself as mDNSPlatformSetDNSConfig looks at
11198 // mcast resolvers. Today we get both mcast and ucast configuration using the same
11200 for (mr
= m
->McastResolvers
; mr
; mr
= mr
->next
)
11201 mr
->flags
|= McastResolver_FlagDelete
;
11203 mDNSPlatformSetDNSConfig(m
, mDNStrue
, mDNSfalse
, &fqdn
, mDNSNULL
, mDNSNULL
);
11205 // For now, we just delete the mcast resolvers. We don't deal with cache or
11206 // questions here. Neither question nor cache point to mcast resolvers. Questions
11207 // do inherit the timeout values from mcast resolvers. But we don't bother
11208 // affecting them as they never change.
11211 if (((*mres
)->flags
& DNSServer_FlagDelete
) != 0)
11214 *mres
= (*mres
)->next
;
11215 debugf("uDNS_SetupDNSConfig: Deleting mcast resolver %##s", mr
, mr
->domain
.c
);
11216 mDNSPlatformMemFree(mr
);
11220 (*mres
)->flags
&= ~McastResolver_FlagNew
;
11221 mres
= &(*mres
)->next
;
11225 // Mark the records to be flushed that match a new resolver. We need to do this before
11226 // we walk the questions below where we change the DNSServer pointer of the cache
11228 FORALL_CACHERECORDS(slot
, cg
, cr
)
11230 if (cr
->resrec
.InterfaceID
) continue;
11232 // We just mark them for purge or reconfirm. We can't affect the DNSServer pointer
11233 // here as the code below that calls CacheRecordResetDNSServer relies on this
11235 // The new DNSServer may be a scoped or non-scoped one. We use the active question's
11236 // InterfaceID for looking up the right DNS server
11237 ptr
= GetServerForName(m
, cr
->resrec
.name
, cr
->CRActiveQuestion
? cr
->CRActiveQuestion
->InterfaceID
: mDNSNULL
);
11239 // Purge or Reconfirm if this cache entry would use the new DNS server
11240 if (ptr
&& (ptr
!= cr
->resrec
.rDNSServer
))
11242 // As the DNSServers for this cache record is not the same anymore, we don't
11243 // want any new questions to pick this old value
11244 if (cr
->CRActiveQuestion
== mDNSNULL
)
11246 LogInfo("uDNS_SetupDNSConfig: Purging Resourcerecord %s", CRDisplayString(m
, cr
));
11247 mDNS_PurgeCacheResourceRecord(m
, cr
);
11251 LogInfo("uDNS_SetupDNSConfig: Purging/Reconfirming Resourcerecord %s", CRDisplayString(m
, cr
));
11252 PurgeOrReconfirmCacheRecord(m
, cr
, ptr
, mDNSfalse
);
11256 // Update our qDNSServer pointers before we go and free the DNSServer object memory
11257 for (q
= m
->Questions
; q
; q
=q
->next
)
11258 if (!mDNSOpaque16IsZero(q
->TargetQID
))
11262 if (q
->DuplicateOf
) continue;
11263 SetValidDNSServers(m
, q
);
11264 q
->triedAllServersOnce
= 0;
11265 s
= GetServerForQuestion(m
, q
);
11269 // If DNS Server for this question has changed, reactivate it
11270 debugf("uDNS_SetupDNSConfig: Updating DNS Server from %p %#a:%d (%##s) to %p %#a:%d (%##s) for %##s (%s)",
11271 t
, t
? &t
->addr
: mDNSNULL
, mDNSVal16(t
? t
->port
: zeroIPPort
), t
? t
->domain
.c
: (mDNSu8
*)"",
11272 s
, s
? &s
->addr
: mDNSNULL
, mDNSVal16(s
? s
->port
: zeroIPPort
), s
? s
->domain
.c
: (mDNSu8
*)"",
11273 q
->qname
.c
, DNSTypeName(q
->qtype
));
11275 // After we reset the DNSServer pointer on the cache records here, three things could happen:
11277 // 1) The query gets sent out and when the actual response comes back later it is possible
11278 // that the response has the same RDATA, in which case we update our cache entry.
11279 // If the response is different, then the entry will expire and a new entry gets added.
11280 // For the latter case to generate a RMV followed by ADD events, we need to reset the DNS
11281 // server here to match the question and the cache record.
11283 // 2) We might have marked the cache entries for purge above and for us to be able to generate the RMV
11284 // events for the questions, the DNSServer on the question should match the Cache Record
11286 // 3) We might have marked the cache entries for reconfirm above, for which we send the query out which is
11287 // the same as the first case above.
11289 DNSServerChangeForQuestion(m
, q
, s
);
11290 q
->unansweredQueries
= 0;
11291 // We still need to pick a new DNSServer for the questions that have been
11292 // suppressed, but it is wrong to activate the query as DNS server change
11293 // could not possibly change the status of SuppressUnusable questions
11294 if (!QuerySuppressed(q
))
11296 debugf("uDNS_SetupDNSConfig: Activating query %p %##s (%s)", q
, q
->qname
.c
, DNSTypeName(q
->qtype
));
11297 ActivateUnicastQuery(m
, q
, mDNStrue
);
11298 // ActivateUnicastQuery is called for duplicate questions also as it does something
11299 // special for AutoTunnel questions
11300 for (qptr
= q
->next
; qptr
; qptr
= qptr
->next
)
11302 if (qptr
->DuplicateOf
== q
) ActivateUnicastQuery(m
, qptr
, mDNStrue
);
11308 debugf("uDNS_SetupDNSConfig: Not Updating DNS server question %p %##s (%s) DNS server %#a:%d %p %d",
11309 q
, q
->qname
.c
, DNSTypeName(q
->qtype
), t
? &t
->addr
: mDNSNULL
, mDNSVal16(t
? t
->port
: zeroIPPort
), q
->DuplicateOf
, q
->SuppressUnusable
);
11310 for (qptr
= q
->next
; qptr
; qptr
= qptr
->next
)
11311 if (qptr
->DuplicateOf
== q
) { qptr
->validDNSServers
= q
->validDNSServers
; qptr
->qDNSServer
= q
->qDNSServer
; }
11317 if (((*p
)->flags
& DNSServer_FlagDelete
) != 0)
11319 // Scan our cache, looking for uDNS records that we would have queried this server for.
11320 // We reconfirm any records that match, because in this world of split DNS, firewalls, etc.
11321 // different DNS servers can give different answers to the same question.
11323 FORALL_CACHERECORDS(slot
, cg
, cr
)
11325 if (cr
->resrec
.InterfaceID
) continue;
11326 if (cr
->resrec
.rDNSServer
== ptr
)
11328 // If we don't have an active question for this cache record, neither Purge can
11329 // generate RMV events nor Reconfirm can send queries out. Just set the DNSServer
11330 // pointer on the record NULL so that we don't point to freed memory (We might dereference
11331 // DNSServer pointers from resource record for logging purposes).
11333 // If there is an active question, point to its DNSServer as long as it does not point to the
11334 // freed one. We already went through the questions above and made them point at either the
11335 // new server or NULL if there is no server and also affected the cache entries that match
11336 // this question. Hence, whenever we hit a resource record with a DNSServer that is just
11337 // about to be deleted, we should never have an active question. The code below just tries to
11338 // be careful logging messages if we ever hit this case.
11340 if (cr
->CRActiveQuestion
)
11342 DNSQuestion
*qptr
= cr
->CRActiveQuestion
;
11343 if (qptr
->qDNSServer
== mDNSNULL
)
11344 LogMsg("uDNS_SetupDNSConfig: Cache Record %s match: Active question %##s (%s) with DNSServer Address NULL, Server to be deleted %#a",
11345 CRDisplayString(m
, cr
), qptr
->qname
.c
, DNSTypeName(qptr
->qtype
), &ptr
->addr
);
11347 LogMsg("uDNS_SetupDNSConfig: Cache Record %s match: Active question %##s (%s) DNSServer Address %#a, Server to be deleted %#a",
11348 CRDisplayString(m
, cr
), qptr
->qname
.c
, DNSTypeName(qptr
->qtype
), &qptr
->qDNSServer
->addr
, &ptr
->addr
);
11350 if (qptr
->qDNSServer
== ptr
)
11352 qptr
->validDNSServers
= zeroOpaque64
;
11353 qptr
->qDNSServer
= mDNSNULL
;
11354 cr
->resrec
.rDNSServer
= mDNSNULL
;
11358 cr
->resrec
.rDNSServer
= qptr
->qDNSServer
;
11363 LogInfo("uDNS_SetupDNSConfig: Cache Record %##s has no Active question, Record's DNSServer Address %#a, Server to be deleted %#a",
11364 cr
->resrec
.name
, &cr
->resrec
.rDNSServer
->addr
, &ptr
->addr
);
11365 cr
->resrec
.rDNSServer
= mDNSNULL
;
11368 PurgeOrReconfirmCacheRecord(m
, cr
, ptr
, mDNStrue
);
11372 debugf("uDNS_SetupDNSConfig: Deleting server %p %#a:%d (%##s)", ptr
, &ptr
->addr
, mDNSVal16(ptr
->port
), ptr
->domain
.c
);
11373 mDNSPlatformMemFree(ptr
);
11374 NumUnicastDNSServers
--;
11378 (*p
)->flags
&= ~DNSServer_FlagNew
;
11383 // If we now have no DNS servers at all and we used to have some, then immediately purge all unicast cache records (including for LLQs).
11384 // This is important for giving prompt remove events when the user disconnects the Ethernet cable or turns off wireless.
11385 // Otherwise, stale data lingers for 5-10 seconds, which is not the user-experience people expect from Bonjour.
11386 // Similarly, if we now have some DNS servers and we used to have none, we want to purge any fake negative results we may have generated.
11387 if ((m
->DNSServers
!= mDNSNULL
) != (oldServers
!= mDNSNULL
))
11390 FORALL_CACHERECORDS(slot
, cg
, cr
) if (!cr
->resrec
.InterfaceID
) { mDNS_PurgeCacheResourceRecord(m
, cr
); count
++; }
11391 LogInfo("uDNS_SetupDNSConfig: %s available; purged %d unicast DNS records from cache",
11392 m
->DNSServers
? "DNS server became" : "No DNS servers", count
);
11394 // Force anything that needs to get zone data to get that information again
11395 RestartRecordGetZoneData(m
);
11398 // Did our FQDN change?
11399 if (!SameDomainName(&fqdn
, &m
->FQDN
))
11401 if (m
->FQDN
.c
[0]) mDNS_RemoveDynDNSHostName(m
, &m
->FQDN
);
11403 AssignDomainName(&m
->FQDN
, &fqdn
);
11407 mDNSPlatformDynDNSHostNameStatusChanged(&m
->FQDN
, 1);
11408 mDNS_AddDynDNSHostName(m
, &m
->FQDN
, DynDNSHostNameCallback
, mDNSNULL
);
11414 // handle router and primary interface changes
11415 v4
= v6
= r
= zeroAddr
;
11416 v4
.type
= r
.type
= mDNSAddrType_IPv4
;
11418 if (mDNSPlatformGetPrimaryInterface(m
, &v4
, &v6
, &r
) == mStatus_NoError
&& !mDNSv4AddressIsLinkLocal(&v4
.ip
.v4
))
11420 mDNS_SetPrimaryInterfaceInfo(m
,
11421 !mDNSIPv4AddressIsZero(v4
.ip
.v4
) ? &v4
: mDNSNULL
,
11422 !mDNSIPv6AddressIsZero(v6
.ip
.v6
) ? &v6
: mDNSNULL
,
11423 !mDNSIPv4AddressIsZero(r
.ip
.v4
) ? &r
: mDNSNULL
);
11427 mDNS_SetPrimaryInterfaceInfo(m
, mDNSNULL
, mDNSNULL
, mDNSNULL
);
11428 if (m
->FQDN
.c
[0]) mDNSPlatformDynDNSHostNameStatusChanged(&m
->FQDN
, 1); // Set status to 1 to indicate temporary failure
11431 debugf("uDNS_SetupDNSConfig: number of unicast DNS servers %d", NumUnicastDNSServers
);
11432 return mStatus_NoError
;
11435 mDNSexport
void mDNSCoreInitComplete(mDNS
*const m
, mStatus result
)
11437 m
->mDNSPlatformStatus
= result
;
11438 if (m
->MainCallback
)
11441 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
11442 m
->MainCallback(m
, mStatus_NoError
);
11443 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
11448 mDNSlocal
void DeregLoop(mDNS
*const m
, AuthRecord
*const start
)
11450 m
->CurrentRecord
= start
;
11451 while (m
->CurrentRecord
)
11453 AuthRecord
*rr
= m
->CurrentRecord
;
11454 LogInfo("DeregLoop: %s deregistration for %p %02X %s",
11455 (rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
) ? "Initiating " : "Accelerating",
11456 rr
, rr
->resrec
.RecordType
, ARDisplayString(m
, rr
));
11457 if (rr
->resrec
.RecordType
!= kDNSRecordTypeDeregistering
)
11458 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_rapid
);
11459 else if (rr
->AnnounceCount
> 1)
11461 rr
->AnnounceCount
= 1;
11462 rr
->LastAPTime
= m
->timenow
- rr
->ThisAPInterval
;
11464 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because
11465 // new records could have been added to the end of the list as a result of that call.
11466 if (m
->CurrentRecord
== rr
) // If m->CurrentRecord was not advanced for us, do it now
11467 m
->CurrentRecord
= rr
->next
;
11471 mDNSexport
void mDNS_StartExit(mDNS
*const m
)
11473 NetworkInterfaceInfo
*intf
;
11478 LogInfo("mDNS_StartExit");
11479 m
->ShutdownTime
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
* 5);
11481 mDNSCoreBeSleepProxyServer_internal(m
, 0, 0, 0, 0);
11483 #if APPLE_OSX_mDNSResponder
11485 CHECK_WCF_FUNCTION(WCFConnectionDealloc
)
11487 if (m
->WCF
) WCFConnectionDealloc((WCFConnection
*)m
->WCF
);
11492 #ifndef UNICAST_DISABLED
11496 // Don't need to do SleepRecordRegistrations() here
11497 // because we deregister all records and services later in this routine
11498 while (m
->Hostnames
) mDNS_RemoveDynDNSHostName(m
, &m
->Hostnames
->fqdn
);
11500 // For each member of our SearchList, deregister any records it may have created, and cut them from the list.
11501 // Otherwise they'll be forcibly deregistered for us (without being cut them from the appropriate list)
11502 // and we may crash because the list still contains dangling pointers.
11503 for (s
= SearchList
; s
; s
= s
->next
)
11504 while (s
->AuthRecs
)
11506 ARListElem
*dereg
= s
->AuthRecs
;
11507 s
->AuthRecs
= s
->AuthRecs
->next
;
11508 mDNS_Deregister_internal(m
, &dereg
->ar
, mDNS_Dereg_normal
); // Memory will be freed in the FreeARElemCallback
11513 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
11514 if (intf
->Advertise
)
11515 DeadvertiseInterface(m
, intf
);
11517 // Shut down all our active NAT Traversals
11518 while (m
->NATTraversals
)
11520 NATTraversalInfo
*t
= m
->NATTraversals
;
11521 mDNS_StopNATOperation_internal(m
, t
); // This will cut 't' from the list, thereby advancing m->NATTraversals in the process
11523 // After stopping the NAT Traversal, we zero out the fields.
11524 // This has particularly important implications for our AutoTunnel records --
11525 // when we deregister our AutoTunnel records below, we don't want their mStatus_MemFree
11526 // handlers to just turn around and attempt to re-register those same records.
11527 // Clearing t->ExternalPort/t->RequestedPort will cause the mStatus_MemFree callback handlers
11529 t
->ExternalAddress
= zerov4Addr
;
11530 t
->ExternalPort
= zeroIPPort
;
11531 t
->RequestedPort
= zeroIPPort
;
11533 t
->Result
= mStatus_NoError
;
11536 // Make sure there are nothing but deregistering records remaining in the list
11537 if (m
->CurrentRecord
)
11538 LogMsg("mDNS_StartExit: ERROR m->CurrentRecord already set %s", ARDisplayString(m
, m
->CurrentRecord
));
11540 // We're in the process of shutting down, so queries, etc. are no longer available.
11541 // Consequently, determining certain information, e.g. the uDNS update server's IP
11542 // address, will not be possible. The records on the main list are more likely to
11543 // already contain such information, so we deregister the duplicate records first.
11544 LogInfo("mDNS_StartExit: Deregistering duplicate resource records");
11545 DeregLoop(m
, m
->DuplicateRecords
);
11546 LogInfo("mDNS_StartExit: Deregistering resource records");
11547 DeregLoop(m
, m
->ResourceRecords
);
11549 // If we scheduled a response to send goodbye packets, we set NextScheduledResponse to now. Normally when deregistering records,
11550 // we allow up to 100ms delay (to help improve record grouping) but when shutting down we don't want any such delay.
11551 if (m
->NextScheduledResponse
- m
->timenow
< mDNSPlatformOneSecond
)
11553 m
->NextScheduledResponse
= m
->timenow
;
11554 m
->SuppressSending
= 0;
11557 if (m
->ResourceRecords
) LogInfo("mDNS_StartExit: Sending final record deregistrations");
11558 else LogInfo("mDNS_StartExit: No deregistering records remain");
11560 for (rr
= m
->DuplicateRecords
; rr
; rr
= rr
->next
)
11561 LogMsg("mDNS_StartExit: Should not still have Duplicate Records remaining: %02X %s", rr
->resrec
.RecordType
, ARDisplayString(m
, rr
));
11563 // If any deregistering records remain, send their deregistration announcements before we exit
11564 if (m
->mDNSPlatformStatus
!= mStatus_NoError
) DiscardDeregistrations(m
);
11568 LogInfo("mDNS_StartExit: done");
11571 mDNSexport
void mDNS_FinalExit(mDNS
*const m
)
11573 mDNSu32 rrcache_active
= 0;
11574 mDNSu32 rrcache_totalused
= 0;
11578 LogInfo("mDNS_FinalExit: mDNSPlatformClose");
11579 mDNSPlatformClose(m
);
11581 rrcache_totalused
= m
->rrcache_totalused
;
11582 for (slot
= 0; slot
< CACHE_HASH_SLOTS
; slot
++)
11584 while (m
->rrcache_hash
[slot
])
11586 CacheGroup
*cg
= m
->rrcache_hash
[slot
];
11587 while (cg
->members
)
11589 CacheRecord
*cr
= cg
->members
;
11590 cg
->members
= cg
->members
->next
;
11591 if (cr
->CRActiveQuestion
) rrcache_active
++;
11592 ReleaseCacheRecord(m
, cr
);
11594 cg
->rrcache_tail
= &cg
->members
;
11595 ReleaseCacheGroup(m
, &m
->rrcache_hash
[slot
]);
11598 debugf("mDNS_FinalExit: RR Cache was using %ld records, %lu active", rrcache_totalused
, rrcache_active
);
11599 if (rrcache_active
!= m
->rrcache_active
)
11600 LogMsg("*** ERROR *** rrcache_active %lu != m->rrcache_active %lu", rrcache_active
, m
->rrcache_active
);
11602 for (rr
= m
->ResourceRecords
; rr
; rr
= rr
->next
)
11603 LogMsg("mDNS_FinalExit failed to send goodbye for: %p %02X %s", rr
, rr
->resrec
.RecordType
, ARDisplayString(m
, rr
));
11605 LogInfo("mDNS_FinalExit: done");