1 /* -*- Mode: C; tab-width: 4 -*- 2 * 3 * Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved. 4 * 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 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 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. 16 * 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. 19 * 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). 24 25 * Formatting notes: 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.) 37 */ 38 39 #include "DNSCommon.h" // Defines general DNS untility routines 40 #include "uDNS.h" // Defines entry points into unicast-specific routines 41 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) 48 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) 55 #endif 56 57 #if APPLE_OSX_mDNSResponder 58 59 #include <WebFilterDNS/WebFilterDNS.h> 60 61 #if ! NO_WCF 62 WCFConnection *WCFConnectionNew(void) __attribute__((weak_import)); 63 void WCFConnectionDealloc(WCFConnection* c) __attribute__((weak_import)); 64 65 // Do we really need to define a macro for "if"? 66 #define CHECK_WCF_FUNCTION(X) if (X) 67 #endif // ! NO_WCF 68 69 #else 70 71 #define NO_WCF 1 72 #endif // APPLE_OSX_mDNSResponder 73 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); 81 82 // *************************************************************************** 83 #if COMPILER_LIKES_PRAGMA_MARK 84 #pragma mark - Program Constants 85 #endif 86 87 #define NO_HINFO 1 88 89 90 // Any records bigger than this are considered 'large' records 91 #define SmallRecordLimit 1024 92 93 #define kMaxUpdateCredits 10 94 #define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6) 95 96 mDNSexport const char *const mDNS_DomainTypeNames[] = 97 { 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 103 }; 104 105 #ifdef UNICAST_DISABLED 106 #define uDNS_IsActiveQuery(q, u) mDNSfalse 107 #endif 108 109 // *************************************************************************** 110 #if COMPILER_LIKES_PRAGMA_MARK 111 #pragma mark - 112 #pragma mark - General Utility Functions 113 #endif 114 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)) 121 122 #define FollowCNAME(q, rr, AddRecord) (AddRecord && (q)->qtype != kDNSType_CNAME && \ 123 (rr)->RecordType != kDNSRecordTypePacketNegative && \ 124 (rr)->rrtype == kDNSType_CNAME) 125 126 mDNSlocal void SetNextQueryStopTime(mDNS *const m, const DNSQuestion *const q) 127 { 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); 130 131 #if ForceAlerts 132 if (m->mDNS_busy != m->mDNS_reentrancy+1) *(long*)0 = 0; 133 #endif 134 135 if (m->NextScheduledStopTime - q->StopTime > 0) 136 m->NextScheduledStopTime = q->StopTime; 137 } 138 139 mDNSexport void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q) 140 { 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); 143 144 #if ForceAlerts 145 if (m->mDNS_busy != m->mDNS_reentrancy+1) *(long*)0 = 0; 146 #endif 147 148 if (ActiveQuestion(q)) 149 { 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); 156 } 157 } 158 159 mDNSlocal void ReleaseAuthEntity(AuthHash *r, AuthEntity *e) 160 { 161 #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1 162 unsigned int i; 163 for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF; 164 #endif 165 e->next = r->rrauth_free; 166 r->rrauth_free = e; 167 r->rrauth_totalused--; 168 } 169 170 mDNSlocal void ReleaseAuthGroup(AuthHash *r, AuthGroup **cp) 171 { 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); 180 } 181 182 mDNSlocal AuthEntity *GetAuthEntity(AuthHash *r, const AuthGroup *const PreserveAG) 183 { 184 AuthEntity *e = mDNSNULL; 185 186 if (r->rrauth_lock) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); } 187 r->rrauth_lock = 1; 188 189 if (!r->rrauth_free) 190 { 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; 198 } 199 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. 202 if (!r->rrauth_free) 203 { 204 mDNSu32 oldtotalused = r->rrauth_totalused; 205 mDNSu32 slot; 206 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 207 { 208 AuthGroup **cp = &r->rrauth_hash[slot]; 209 while (*cp) 210 { 211 if ((*cp)->members || (*cp)==PreserveAG) cp=&(*cp)->next; 212 else ReleaseAuthGroup(r, cp); 213 } 214 } 215 LogInfo("GetAuthEntity: Recycled %d records to reduce auth cache from %d to %d", 216 oldtotalused - r->rrauth_totalused, oldtotalused, r->rrauth_totalused); 217 } 218 219 if (r->rrauth_free) // If there are records in the free list, take one 220 { 221 e = r->rrauth_free; 222 r->rrauth_free = e->next; 223 if (++r->rrauth_totalused >= r->rrauth_report) 224 { 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; 229 } 230 mDNSPlatformMemZero(e, sizeof(*e)); 231 } 232 233 r->rrauth_lock = 0; 234 235 return(e); 236 } 237 238 mDNSexport AuthGroup *AuthGroupForName(AuthHash *r, const mDNSu32 slot, const mDNSu32 namehash, const domainname *const name) 239 { 240 AuthGroup *ag; 241 for (ag = r->rrauth_hash[slot]; ag; ag=ag->next) 242 if (ag->namehash == namehash && SameDomainName(ag->name, name)) 243 break; 244 return(ag); 245 } 246 247 mDNSexport AuthGroup *AuthGroupForRecord(AuthHash *r, const mDNSu32 slot, const ResourceRecord *const rr) 248 { 249 return(AuthGroupForName(r, slot, rr->namehash, rr->name)); 250 } 251 252 mDNSlocal AuthGroup *GetAuthGroup(AuthHash *r, const mDNSu32 slot, const ResourceRecord *const rr) 253 { 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); 264 if (!ag->name) 265 { 266 LogMsg("GetAuthGroup: Failed to allocate name storage for %##s", rr->name->c); 267 ReleaseAuthEntity(r, (AuthEntity*)ag); 268 return(mDNSNULL); 269 } 270 AssignDomainName(ag->name, rr->name); 271 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); 275 276 return(ag); 277 } 278 279 // Returns the AuthGroup in which the AuthRecord was inserted 280 mDNSexport AuthGroup *InsertAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr) 281 { 282 AuthGroup *ag; 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 286 if (ag) 287 { 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 291 } 292 return ag; 293 } 294 295 mDNSexport AuthGroup *RemoveAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr) 296 { 297 AuthGroup *a; 298 AuthGroup **ag = &a; 299 AuthRecord **rp; 300 const mDNSu32 slot = AuthHashSlot(rr->resrec.name); 301 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; 305 while (*rp) 306 { 307 if (*rp != rr) 308 rp=&(*rp)->next; 309 else 310 { 311 // We don't break here, so that we can set the tail below without tracking "prev" pointers 312 313 LogInfo("RemoveAuthRecord: removing auth record %s from table", ARDisplayString(m, rr)); 314 *rp = (*rp)->next; // Cut record from list 315 } 316 } 317 // TBD: If there are no more members, release authgroup ? 318 (*ag)->rrauth_tail = rp; 319 return a; 320 } 321 322 mDNSexport CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 slot, const mDNSu32 namehash, const domainname *const name) 323 { 324 CacheGroup *cg; 325 for (cg = m->rrcache_hash[slot]; cg; cg=cg->next) 326 if (cg->namehash == namehash && SameDomainName(cg->name, name)) 327 break; 328 return(cg); 329 } 330 331 mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr) 332 { 333 return(CacheGroupForName(m, slot, rr->namehash, rr->name)); 334 } 335 336 mDNSexport mDNSBool mDNS_AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr) 337 { 338 NetworkInterfaceInfo *intf; 339 340 if (addr->type == mDNSAddrType_IPv4) 341 { 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) 347 return(mDNStrue); 348 } 349 350 if (addr->type == mDNSAddrType_IPv6) 351 { 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)) 359 return(mDNStrue); 360 } 361 362 return(mDNSfalse); 363 } 364 365 mDNSlocal NetworkInterfaceInfo *FirstInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID) 366 { 367 NetworkInterfaceInfo *intf = m->HostInterfaces; 368 while (intf && intf->InterfaceID != InterfaceID) intf = intf->next; 369 return(intf); 370 } 371 372 mDNSexport char *InterfaceNameForID(mDNS *const m, const mDNSInterfaceID InterfaceID) 373 { 374 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 375 return(intf ? intf->ifname : mDNSNULL); 376 } 377 378 // Caller should hold the lock 379 mDNSlocal void GenerateNegativeResponse(mDNS *const m) 380 { 381 DNSQuestion *q; 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)); 385 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 391 } 392 393 mDNSlocal void AnswerQuestionByFollowingCNAME(mDNS *const m, DNSQuestion *q, ResourceRecord *rr) 394 { 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)); 399 else 400 { 401 const mDNSu32 c = q->CNAMEReferrals + 1; // Stash a copy of the new q->CNAMEReferrals value 402 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. 412 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. 417 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)); 420 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)) 428 { 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; 432 } 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; 437 } 438 } 439 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) 443 { 444 DNSQuestion *q = m->CurrentQuestion; 445 mDNSBool followcname; 446 447 if (!q) 448 { 449 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: ERROR!! CurrentQuestion NULL while answering with %s", ARDisplayString(m, rr)); 450 return; 451 } 452 453 followcname = FollowCNAME(q, &rr->resrec, AddRecord); 454 455 // We should not be delivering results for record types Unregistered, Deregistering, and (unverified) Unique 456 if (!(rr->resrec.RecordType & kDNSRecordTypeActiveMask)) 457 { 458 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: *NOT* delivering %s event for local record type %X %s", 459 AddRecord ? "Add" : "Rmv", rr->resrec.RecordType, ARDisplayString(m, rr)); 460 return; 461 } 462 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) 467 { 468 q->CurrentAnswers += AddRecord ? 1 : -1; 469 if (LORecordAnswersAddressType(rr)) 470 { 471 if (!followcname || q->ReturnIntermed) 472 { 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); 477 } 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); 483 return; 484 } 485 else 486 q->QuestionCallback(m, q, &rr->resrec, AddRecord); 487 } 488 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 489 } 490 491 mDNSlocal void AnswerInterfaceAnyQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) 492 { 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) 498 { 499 mDNSBool answered; 500 DNSQuestion *q = m->CurrentQuestion; 501 if (RRAny(rr)) 502 answered = ResourceRecordAnswersQuestion(&rr->resrec, q); 503 else 504 answered = LocalOnlyRecordAnswersQuestion(rr, q); 505 if (answered) 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; 509 } 510 m->CurrentQuestion = mDNSNULL; 511 } 512 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(). 520 // 521 // AnswerAllLocalQuestionsWithLocalAuthRecord is used by the m->NewLocalRecords loop in mDNS_Execute(), 522 // and by mDNS_Deregister_internal() 523 524 mDNSlocal void AnswerAllLocalQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) 525 { 526 if (m->CurrentQuestion) 527 LogMsg("AnswerAllLocalQuestionsWithLocalAuthRecord ERROR m->CurrentQuestion already set: %##s (%s)", 528 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 529 530 m->CurrentQuestion = m->LocalOnlyQuestions; 531 while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions) 532 { 533 mDNSBool answered; 534 DNSQuestion *q = m->CurrentQuestion; 535 // We are called with both LocalOnly/P2P record or a regular AuthRecord 536 if (RRAny(rr)) 537 answered = ResourceRecordAnswersQuestion(&rr->resrec, q); 538 else 539 answered = LocalOnlyRecordAnswersQuestion(rr, q); 540 if (answered) 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; 544 } 545 546 m->CurrentQuestion = mDNSNULL; 547 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); 551 552 } 553 554 // *************************************************************************** 555 #if COMPILER_LIKES_PRAGMA_MARK 556 #pragma mark - 557 #pragma mark - Resource Record Utility Functions 558 #endif 559 560 #define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA) 561 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)) ) 566 567 #define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \ 568 (ResourceRecordIsValidAnswer(RR) && \ 569 ((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID))) 570 571 #define DefaultProbeCountForTypeUnique ((mDNSu8)3) 572 #define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0) 573 574 #define InitialAnnounceCount ((mDNSu8)8) 575 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) 581 582 // Number of wakeups we send if WakeOnResolve is set in the question 583 #define InitialWakeOnResolveCount ((mDNSu8)3) 584 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) 592 593 #define DefaultAPIntervalForRecordType(X) ((X) & kDNSRecordTypeActiveSharedMask ? DefaultAnnounceIntervalForTypeShared : \ 594 (X) & kDNSRecordTypeUnique ? DefaultProbeIntervalForTypeUnique : \ 595 (X) & kDNSRecordTypeActiveUniqueMask ? DefaultAnnounceIntervalForTypeUnique : 0) 596 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)) 601 602 #define MaxUnansweredQueries 4 603 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 610 611 // SameResourceRecordNameClassInterface is functionally the same as SameResourceRecordSignature, except rrtype does not have to match 612 613 #define SameResourceRecordSignature(A,B) (A)->resrec.rrtype == (B)->resrec.rrtype && SameResourceRecordNameClassInterface((A),(B)) 614 615 mDNSlocal mDNSBool SameResourceRecordNameClassInterface(const AuthRecord *const r1, const AuthRecord *const r2) 616 { 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); 622 return(mDNSBool)( 623 r1->resrec.rrclass == r2->resrec.rrclass && 624 r1->resrec.namehash == r2->resrec.namehash && 625 SameDomainName(r1->resrec.name, r2->resrec.name)); 626 } 627 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. 633 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) 637 { 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); 645 return(mDNSBool)( 646 pktrr->resrec.rrclass == authrr->resrec.rrclass && 647 pktrr->resrec.namehash == authrr->resrec.namehash && 648 SameDomainName(pktrr->resrec.name, authrr->resrec.name)); 649 } 650 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) 659 { 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); 662 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); 673 } 674 675 mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr) 676 { 677 if (rr->resrec.RecordType == kDNSRecordTypeUnique) 678 { 679 if ((rr->LastAPTime + rr->ThisAPInterval) - m->timenow > mDNSPlatformOneSecond * 10) 680 { 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); 683 } 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; 692 } 693 else if (rr->AnnounceCount && (ResourceRecordIsValidAnswer(rr) || rr->resrec.RecordType == kDNSRecordTypeDeregistering)) 694 { 695 if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 696 m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval); 697 } 698 } 699 700 mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr) 701 { 702 // For reverse-mapping Sleep Proxy PTR records, probe interval is one second 703 rr->ThisAPInterval = rr->AddressProxy.type ? mDNSPlatformOneSecond : DefaultAPIntervalForRecordType(rr->resrec.RecordType); 704 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. 715 716 if (rr->ProbeCount) 717 { 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) 720 { 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)); 728 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; 734 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; 740 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); 744 745 if (m->SuppressProbes - m->timenow > mDNSPlatformOneSecond * 8) 746 { 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, 751 m->SuppressSending, 752 m->SuppressSending - m->timenow); 753 m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2)); 754 } 755 } 756 rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval; 757 } 758 else if (m->SuppressProbes && m->SuppressProbes - m->timenow >= 0) 759 rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval + DefaultProbeIntervalForTypeUnique * DefaultProbeCountForTypeUnique + rr->ThisAPInterval / 2; 760 else 761 rr->LastAPTime = m->timenow - rr->ThisAPInterval; 762 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; 770 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; 779 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; 784 785 SetNextAnnounceProbeTime(m, rr); 786 } 787 788 mDNSlocal const domainname *SetUnicastTargetToHostName(mDNS *const m, AuthRecord *rr) 789 { 790 const domainname *target; 791 if (rr->AutoTarget) 792 { 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; 798 } 799 800 target = GetServiceTarget(m, rr); 801 if (!target || target->c[0] == 0) 802 { 803 // defer registration until we've got a target 804 LogInfo("SetUnicastTargetToHostName No target for %s", ARDisplayString(m, rr)); 805 rr->state = regState_NoTarget; 806 return mDNSNULL; 807 } 808 else 809 { 810 LogInfo("SetUnicastTargetToHostName target %##s for resource record %s", target->c, ARDisplayString(m,rr)); 811 return target; 812 } 813 } 814 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) 818 { 819 domainname *const target = GetRRDomainNameTarget(&rr->resrec); 820 const domainname *newname = &m->MulticastHostname; 821 822 if (!target) LogInfo("SetTargetToHostName: Don't know how to set the target of rrtype %s", DNSTypeName(rr->resrec.rrtype)); 823 824 if (!(rr->ForceMCast || rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P || IsLocalDomain(&rr->namestorage))) 825 { 826 const domainname *const n = SetUnicastTargetToHostName(m, rr); 827 if (n) newname = n; 828 else { target->c[0] = 0; SetNewRData(&rr->resrec, mDNSNULL, 0); return; } 829 } 830 831 if (target && SameDomainName(target, newname)) 832 debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name->c, target->c); 833 834 if (target && !SameDomainName(target, newname)) 835 { 836 AssignDomainName(target, newname); 837 SetNewRData(&rr->resrec, mDNSNULL, 0); // Update rdlength, rdestimate, rdatahash 838 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); 843 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)); 850 851 rr->AnnounceCount = InitialAnnounceCount; 852 rr->RequireGoodbye = mDNSfalse; 853 InitializeLastAPTime(m, rr); 854 } 855 } 856 857 mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr) 858 { 859 if (rr->RecordCallback) 860 { 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 867 } 868 } 869 870 mDNSexport void ActivateUnicastRegistration(mDNS *const m, AuthRecord *const rr) 871 { 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) 877 { 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; 883 if (srvRR) 884 { 885 if (srvRR->resrec.rrtype != kDNSType_SRV) 886 { 887 LogMsg("ActivateUnicastRegistration: ERROR!! Resource record %s wrong, expecting SRV type", ARDisplayString(m, srvRR)); 888 } 889 else 890 { 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; 894 } 895 } 896 } 897 898 if (rr->state == regState_NoTarget) 899 { 900 LogInfo("ActivateUnicastRegistration record %s in regState_NoTarget, not activating", ARDisplayString(m, rr)); 901 return; 902 } 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) 909 { 910 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to DeregPending", ARDisplayString(m, rr), rr->state); 911 rr->state = regState_DeregPending; 912 } 913 else 914 { 915 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to Pending", ARDisplayString(m, rr), rr->state); 916 rr->state = regState_Pending; 917 } 918 rr->ProbeCount = 0; 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) 930 { 931 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 932 rr->NATinfo.clientContext = mDNSNULL; 933 } 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); 938 } 939 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)) 947 948 #define RecordIsLocalDuplicate(A,B) \ 949 ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(&(A)->resrec, &(B)->resrec)) 950 951 mDNSlocal AuthRecord *CheckAuthIdenticalRecord(AuthHash *r, AuthRecord *rr) 952 { 953 AuthGroup *a; 954 AuthGroup **ag = &a; 955 AuthRecord **rp; 956 const mDNSu32 slot = AuthHashSlot(rr->resrec.name); 957 958 a = AuthGroupForRecord(r, slot, &rr->resrec); 959 if (!a) return mDNSNULL; 960 rp = &(*ag)->members; 961 while (*rp) 962 { 963 if (!RecordIsLocalDuplicate(*rp, rr)) 964 rp=&(*rp)->next; 965 else 966 { 967 if ((*rp)->resrec.RecordType == kDNSRecordTypeDeregistering) 968 { 969 (*rp)->AnnounceCount = 0; 970 rp=&(*rp)->next; 971 } 972 else return *rp; 973 } 974 } 975 return (mDNSNULL); 976 } 977 978 mDNSlocal mDNSBool CheckAuthRecordConflict(AuthHash *r, AuthRecord *rr) 979 { 980 AuthGroup *a; 981 AuthGroup **ag = &a; 982 AuthRecord **rp; 983 const mDNSu32 slot = AuthHashSlot(rr->resrec.name); 984 985 a = AuthGroupForRecord(r, slot, &rr->resrec); 986 if (!a) return mDNSfalse; 987 rp = &(*ag)->members; 988 while (*rp) 989 { 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)) 993 return mDNStrue; 994 else 995 rp=&(*rp)->next; 996 } 997 return (mDNSfalse); 998 } 999 1000 // checks to see if "rr" is already present 1001 mDNSlocal AuthRecord *CheckAuthSameRecord(AuthHash *r, AuthRecord *rr) 1002 { 1003 AuthGroup *a; 1004 AuthGroup **ag = &a; 1005 AuthRecord **rp; 1006 const mDNSu32 slot = AuthHashSlot(rr->resrec.name); 1007 1008 a = AuthGroupForRecord(r, slot, &rr->resrec); 1009 if (!a) return mDNSNULL; 1010 rp = &(*ag)->members; 1011 while (*rp) 1012 { 1013 if (*rp != rr) 1014 rp=&(*rp)->next; 1015 else 1016 { 1017 return *rp; 1018 } 1019 } 1020 return (mDNSNULL); 1021 } 1022 1023 // Exported so uDNS.c can call this 1024 mDNSexport mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr) 1025 { 1026 domainname *target = GetRRDomainNameTarget(&rr->resrec); 1027 AuthRecord *r; 1028 AuthRecord **p = &m->ResourceRecords; 1029 AuthRecord **d = &m->DuplicateRecords; 1030 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); } 1033 1034 if (!rr->resrec.RecordType) 1035 { LogMsg("mDNS_Register_internal: RecordType must be non-zero %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); } 1036 1037 if (m->ShutdownTime) 1038 { LogMsg("mDNS_Register_internal: Shutting down, can't register %s", ARDisplayString(m, rr)); return(mStatus_ServiceNotRunning); } 1039 1040 if (m->DivertMulticastAdvertisements && !AuthRecord_uDNS(rr)) 1041 { 1042 mDNSInterfaceID previousID = rr->resrec.InterfaceID; 1043 if (rr->resrec.InterfaceID == mDNSInterface_Any || rr->resrec.InterfaceID == mDNSInterface_P2P) 1044 { 1045 rr->resrec.InterfaceID = mDNSInterface_LocalOnly; 1046 rr->ARType = AuthRecordLocalOnly; 1047 } 1048 if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly) 1049 { 1050 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); 1051 if (intf && !intf->Advertise){ rr->resrec.InterfaceID = mDNSInterface_LocalOnly; rr->ARType = AuthRecordLocalOnly; } 1052 } 1053 if (rr->resrec.InterfaceID != previousID) 1054 LogInfo("mDNS_Register_internal: Diverting record to local-only %s", ARDisplayString(m, rr)); 1055 } 1056 1057 if (RRLocalOnly(rr)) 1058 { 1059 if (CheckAuthSameRecord(&m->rrauth, rr)) 1060 { 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); 1064 } 1065 } 1066 else 1067 { 1068 while (*p && *p != rr) p=&(*p)->next; 1069 if (*p) 1070 { 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); 1074 } 1075 } 1076 1077 while (*d && *d != rr) d=&(*d)->next; 1078 if (*d) 1079 { 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); 1083 } 1084 1085 if (rr->DependentOn) 1086 { 1087 if (rr->resrec.RecordType == kDNSRecordTypeUnique) 1088 rr->resrec.RecordType = kDNSRecordTypeVerified; 1089 else 1090 { 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); 1094 } 1095 if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique))) 1096 { 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); 1100 } 1101 } 1102 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) 1107 { 1108 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); 1109 if (!intf) 1110 { 1111 debugf("mDNS_Register_internal: Bogus InterfaceID %p in resource record", rr->resrec.InterfaceID); 1112 return(mStatus_BadReferenceErr); 1113 } 1114 } 1115 1116 rr->next = mDNSNULL; 1117 1118 // Field Group 1: The actual information pertaining to this resource record 1119 // Set up by client prior to call 1120 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; 1133 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; 1161 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; 1164 1165 // Field Group 4: Transient uDNS state for Authoritative Records 1166 rr->state = regState_Zero; 1167 rr->uselease = 0; 1168 rr->expire = 0; 1169 rr->Private = 0; 1170 rr->updateid = zeroID; 1171 rr->zone = rr->resrec.name; 1172 rr->nta = mDNSNULL; 1173 rr->tcp = mDNSNULL; 1174 rr->OrigRData = 0; 1175 rr->OrigRDLen = 0; 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; 1185 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 1192 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; } 1197 1198 if (rr->AutoTarget) 1199 { 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) 1205 { 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)); 1210 } 1211 #endif 1212 } 1213 else 1214 { 1215 rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse); 1216 rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue); 1217 } 1218 1219 if (!ValidateDomainName(rr->resrec.name)) 1220 { LogMsg("Attempt to register record with invalid name: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); } 1221 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); } 1225 1226 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name); 1227 rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(&rr->resrec); 1228 1229 if (RRLocalOnly(rr)) 1230 { 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) 1237 { 1238 if (CheckAuthRecordConflict(&m->rrauth, rr)) 1239 { 1240 LogInfo("mDNS_Register_internal: Name conflict %s (%p), InterfaceID %p", ARDisplayString(m, rr), rr, rr->resrec.InterfaceID); 1241 return mStatus_NameConflict; 1242 } 1243 } 1244 } 1245 1246 // For uDNS records, we don't support duplicate checks at this time. 1247 #ifndef UNICAST_DISABLED 1248 if (AuthRecord_uDNS(rr)) 1249 { 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; 1255 *p = rr; 1256 if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified; 1257 rr->ProbeCount = 0; 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 1261 } 1262 #endif 1263 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)) 1266 { 1267 rr->ProbeCount = 0; 1268 rr->AnnounceCount = 0; 1269 r = CheckAuthIdenticalRecord(&m->rrauth, rr); 1270 } 1271 else 1272 { 1273 for (r = m->ResourceRecords; r; r=r->next) 1274 if (RecordIsLocalDuplicate(r, rr)) 1275 { 1276 if (r->resrec.RecordType == kDNSRecordTypeDeregistering) r->AnnounceCount = 0; 1277 else break; 1278 } 1279 } 1280 1281 if (r) 1282 { 1283 debugf("mDNS_Register_internal:Adding to duplicate list %s", ARDisplayString(m,rr)); 1284 *d = 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) 1290 rr->ProbeCount = 0; 1291 } 1292 else 1293 { 1294 debugf("mDNS_Register_internal: Adding to active record list %s", ARDisplayString(m,rr)); 1295 if (RRLocalOnly(rr)) 1296 { 1297 AuthGroup *ag; 1298 ag = InsertAuthRecord(m, &m->rrauth, rr); 1299 if (ag && !ag->NewLocalOnlyRecords) { 1300 m->NewLocalOnlyRecords = mDNStrue; 1301 ag->NewLocalOnlyRecords = rr; 1302 } 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); 1307 } 1308 else 1309 { 1310 if (!m->NewLocalRecords) m->NewLocalRecords = rr; 1311 *p = rr; 1312 } 1313 } 1314 1315 if (!AuthRecord_uDNS(rr)) // This check is superfluous, given that for unicast records we (currently) bail out above 1316 { 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); 1320 1321 // Adding a record may affect whether or not we should sleep 1322 mDNS_UpdateAllowSleep(m); 1323 } 1324 1325 return(mStatus_NoError); 1326 } 1327 1328 mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr) 1329 { 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) 1340 { 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)); 1344 } 1345 } 1346 1347 mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr) 1348 { 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 1355 } 1356 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) 1361 { 1362 AuthRecord *r2; 1363 mDNSu8 RecordType = rr->resrec.RecordType; 1364 AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records 1365 mDNSBool dupList = mDNSfalse; 1366 1367 if (RRLocalOnly(rr)) 1368 { 1369 AuthGroup *a; 1370 AuthGroup **ag = &a; 1371 AuthRecord **rp; 1372 const mDNSu32 slot = AuthHashSlot(rr->resrec.name); 1373 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; 1378 p = rp; 1379 } 1380 else 1381 { 1382 while (*p && *p != rr) p=&(*p)->next; 1383 } 1384 1385 if (*p) 1386 { 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 1389 { 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; 1393 } 1394 else 1395 { 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; 1400 if (*d) 1401 { 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)) 1407 { 1408 dup->next = mDNSNULL; 1409 if (!InsertAuthRecord(m, &m->rrauth, dup)) LogMsg("mDNS_Deregister_internal: ERROR!! cannot insert %s", ARDisplayString(m, dup)); 1410 } 1411 else 1412 { 1413 dup->next = rr->next; // And then... 1414 rr->next = dup; // ... splice it in right after the record we're about to delete 1415 } 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; 1434 } 1435 } 1436 } 1437 else 1438 { 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)); 1446 } 1447 1448 if (!*p) 1449 { 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); 1454 } 1455 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 1458 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. 1469 1470 #ifndef UNICAST_DISABLED 1471 if (AuthRecord_uDNS(rr)) 1472 { 1473 if (rr->RequireGoodbye) 1474 { 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); 1484 } 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; 1489 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) 1498 { 1499 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 1500 rr->NATinfo.clientContext = mDNSNULL; 1501 } 1502 if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; } 1503 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 1504 } 1505 #endif // UNICAST_DISABLED 1506 1507 if (RecordType == kDNSRecordTypeUnregistered) 1508 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered", ARDisplayString(m, rr)); 1509 else if (RecordType == kDNSRecordTypeDeregistering) 1510 { 1511 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering", ARDisplayString(m, rr)); 1512 return(mStatus_BadReferenceErr); 1513 } 1514 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))) 1523 { 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); 1533 } 1534 else 1535 { 1536 if (!dupList && RRLocalOnly(rr)) 1537 { 1538 AuthGroup *ag = RemoveAuthRecord(m, &m->rrauth, rr); 1539 if (ag->NewLocalOnlyRecords == rr) ag->NewLocalOnlyRecords = rr->next; 1540 } 1541 else 1542 { 1543 *p = rr->next; // Cut this record from the list 1544 if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next; 1545 } 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; 1549 1550 // Should we generate local remove events here? 1551 // i.e. something like: 1552 // if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; } 1553 1554 verbosedebugf("mDNS_Deregister_internal: Deleting record for %s", ARDisplayString(m, rr)); 1555 rr->resrec.RecordType = kDNSRecordTypeUnregistered; 1556 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)); 1560 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 1563 1564 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) 1570 { 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 1576 } 1577 else 1578 { 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; 1588 while (r2) 1589 { 1590 if (r2->ProbeCount != 0xFF) r2 = r2->next; 1591 else { mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict); r2 = m->DuplicateRecords; } 1592 } 1593 } 1594 } 1595 mDNS_UpdateAllowSleep(m); 1596 return(mStatus_NoError); 1597 } 1598 1599 // *************************************************************************** 1600 #if COMPILER_LIKES_PRAGMA_MARK 1601 #pragma mark - 1602 #pragma mark - Packet Sending Functions 1603 #endif 1604 1605 mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add) 1606 { 1607 if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse) 1608 { 1609 **nrpp = rr; 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; 1616 } 1617 debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1618 } 1619 1620 mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID) 1621 { 1622 AuthRecord *rr, *rr2; 1623 for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put 1624 { 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); 1629 1630 if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID)) 1631 AddRecordToResponseList(nrpp, rr->Additional2, rr); 1632 1633 // For SRV records, automatically add the Address record(s) for the target host 1634 if (rr->resrec.rrtype == kDNSType_SRV) 1635 { 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); 1642 } 1643 else if (RRTypeIsAddressType(rr->resrec.rrtype)) // For A or AAAA, put counterpart as additional 1644 { 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); 1651 } 1652 else if (rr->resrec.rrtype == kDNSType_PTR) // For service PTR, see if we want to add DeviceInfo record 1653 { 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); 1657 } 1658 } 1659 } 1660 1661 mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID) 1662 { 1663 AuthRecord *rr; 1664 AuthRecord *ResponseRecords = mDNSNULL; 1665 AuthRecord **nrp = &ResponseRecords; 1666 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 1667 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) 1670 { 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; 1676 1677 if (rr->ImmedUnicast && rr->ImmedAnswer == InterfaceID) 1678 { 1679 if ((dest->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->v4Requester, dest->ip.v4)) || 1680 (dest->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->v6Requester, dest->ip.v6))) 1681 { 1682 rr->ImmedAnswer = mDNSNULL; // Clear the state fields 1683 rr->ImmedUnicast = mDNSfalse; 1684 rr->v4Requester = zerov4Addr; 1685 rr->v6Requester = zerov6Addr; 1686 1687 // Only sent records registered for P2P over P2P interfaces 1688 if (intf && !mDNSPlatformValidRecordForInterface(rr, intf)) 1689 { 1690 LogInfo("SendDelayedUnicastResponse: Not sending %s, on %s", ARDisplayString(m, rr), InterfaceNameForID(m, InterfaceID)); 1691 continue; 1692 } 1693 1694 if (rr->NextResponse == mDNSNULL && nrp != &rr->NextResponse) // rr->NR_AnswerTo 1695 { rr->NR_AnswerTo = (mDNSu8*)~0; *nrp = rr; nrp = &rr->NextResponse; } 1696 } 1697 } 1698 } 1699 1700 AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID); 1701 1702 while (ResponseRecords) 1703 { 1704 mDNSu8 *responseptr = m->omsg.data; 1705 mDNSu8 *newptr; 1706 InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags); 1707 1708 // Put answers in the packet 1709 while (ResponseRecords && ResponseRecords->NR_AnswerTo) 1710 { 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; 1723 } 1724 1725 // Add additionals, if there's space 1726 while (ResponseRecords && !ResponseRecords->NR_AnswerTo) 1727 { 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 1733 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; 1741 } 1742 1743 if (m->omsg.h.numAnswers) 1744 mDNSSendDNSMessage(m, &m->omsg, responseptr, InterfaceID, mDNSNULL, dest, MulticastDNSPort, mDNSNULL, mDNSNULL); 1745 } 1746 } 1747 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) 1751 { 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 1760 } 1761 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) 1768 { 1769 if (m->CurrentRecord) 1770 LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 1771 m->CurrentRecord = m->ResourceRecords; 1772 1773 while (m->CurrentRecord) 1774 { 1775 AuthRecord *rr = m->CurrentRecord; 1776 if (!AuthRecord_uDNS(rr) && rr->resrec.RecordType == kDNSRecordTypeDeregistering) 1777 CompleteDeregistration(m, rr); // Don't touch rr after this 1778 else 1779 m->CurrentRecord = rr->next; 1780 } 1781 } 1782 1783 mDNSlocal mStatus GetLabelDecimalValue(const mDNSu8 *const src, mDNSu8 *dst) 1784 { 1785 int i, val = 0; 1786 if (src[0] < 1 || src[0] > 3) return(mStatus_Invalid); 1787 for (i=1; i<=src[0]; i++) 1788 { 1789 if (src[i] < '0' || src[i] > '9') return(mStatus_Invalid); 1790 val = val * 10 + src[i] - '0'; 1791 } 1792 if (val > 255) return(mStatus_Invalid); 1793 *dst = (mDNSu8)val; 1794 return(mStatus_NoError); 1795 } 1796 1797 mDNSlocal mStatus GetIPv4FromName(mDNSAddr *const a, const domainname *const name) 1798 { 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); 1807 } 1808 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) 1812 1813 mDNSlocal mStatus GetIPv6FromName(mDNSAddr *const a, const domainname *const name) 1814 { 1815 int i, h, l; 1816 const domainname *n; 1817 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; } 1820 1821 n = SkipLeadingLabels(name, skip); 1822 for (i=0; i<16; i++) 1823 { 1824 if (n->c[0] != 1) return mStatus_Invalid; 1825 l = HexVal(n->c[1]); 1826 n = (const domainname *)(n->c + 2); 1827 1828 if (n->c[0] != 1) return mStatus_Invalid; 1829 h = HexVal(n->c[1]); 1830 n = (const domainname *)(n->c + 2); 1831 1832 if (l<0 || h<0) return mStatus_Invalid; 1833 a->ip.v6.b[15-i] = (mDNSu8)((h << 4) | l); 1834 } 1835 1836 a->type = mDNSAddrType_IPv6; 1837 return(mStatus_NoError); 1838 } 1839 1840 mDNSlocal mDNSs32 ReverseMapDomainType(const domainname *const name) 1841 { 1842 int skip = CountLabels(name) - 2; 1843 if (skip >= 0) 1844 { 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; 1848 } 1849 return(mDNSAddrType_None); 1850 } 1851 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) 1854 { 1855 int i; 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; } 1859 1860 // 0x00 Destination address 1861 for (i=0; i<6; i++) *ptr++ = dst->b[i]; 1862 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]; 1865 1866 // 0x0C ARP Ethertype (0x0806) 1867 *ptr++ = 0x08; *ptr++ = 0x06; 1868 1869 // 0x0E ARP header 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 1875 1876 // 0x16 Sender hardware address (our MAC address) 1877 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[i]; 1878 1879 // 0x1C Sender protocol address 1880 for (i=0; i<4; i++) *ptr++ = spa->b[i]; 1881 1882 // 0x20 Target hardware address 1883 for (i=0; i<6; i++) *ptr++ = tha->b[i]; 1884 1885 // 0x26 Target protocol address 1886 for (i=0; i<4; i++) *ptr++ = tpa->b[i]; 1887 1888 // 0x2A Total ARP Packet length 42 bytes 1889 mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID); 1890 } 1891 1892 mDNSlocal mDNSu16 CheckSum(const void *const data, mDNSs32 length, mDNSu32 sum) 1893 { 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); 1899 } 1900 1901 mDNSlocal mDNSu16 IPv6CheckSum(const mDNSv6Addr *const src, const mDNSv6Addr *const dst, const mDNSu8 protocol, const void *const data, const mDNSu32 length) 1902 { 1903 IPv6PseudoHeader ph; 1904 ph.src = *src; 1905 ph.dst = *dst; 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; 1910 ph.pro.b[0] = 0; 1911 ph.pro.b[1] = 0; 1912 ph.pro.b[2] = 0; 1913 ph.pro.b[3] = protocol; 1914 return CheckSum(&ph, sizeof(ph), CheckSum(data, length, 0)); 1915 } 1916 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) 1919 { 1920 int i; 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; } 1930 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: 1938 // *ptr++ = 0x33; 1939 // *ptr++ = 0x33; 1940 // *ptr++ = 0xFF; 1941 // *ptr++ = tpa->b[0xD]; 1942 // *ptr++ = tpa->b[0xE]; 1943 // *ptr++ = tpa->b[0xF]; 1944 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]; 1947 1948 // 0x0C IPv6 Ethertype (0x86DD) 1949 *ptr++ = 0x86; *ptr++ = 0xDD; 1950 1951 // 0x0E IPv6 header 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 1956 1957 // 0x16 Sender IPv6 address 1958 for (i=0; i<16; i++) *ptr++ = spa->b[i]; 1959 1960 // 0x26 Destination IPv6 address 1961 for (i=0; i<16; i++) *ptr++ = v6dst->b[i]; 1962 1963 // 0x36 NDP header 1964 *ptr++ = op; // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement 1965 *ptr++ = 0x00; // Code 1966 *ptr++ = 0x00; *ptr++ = 0x00; // Checksum placeholder (0x38, 0x39) 1967 *ptr++ = flags; 1968 *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00; 1969 1970 if (op == NDP_Sol) // Neighbor Solicitation. The NDP "target" is the address we seek. 1971 { 1972 // 0x3E NDP target. 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)) 1980 { 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]; 1984 } 1985 } 1986 else // Neighbor Advertisement. The NDP "target" is the address we're giving information about. 1987 { 1988 // 0x3E NDP target. 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]; 1994 } 1995 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]; 2001 2002 mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID); 2003 } 2004 2005 mDNSlocal void SetupOwnerOpt(const mDNS *const m, const NetworkInterfaceInfo *const intf, rdataOPT *const owner) 2006 { 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; 2012 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; 2017 } 2018 2019 mDNSlocal void GrantUpdateCredit(AuthRecord *rr) 2020 { 2021 if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0; 2022 else rr->NextUpdateCredit = NonZeroTime(rr->NextUpdateCredit + kUpdateCreditRefreshInterval); 2023 } 2024 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. 2037 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) 2042 { 2043 int pktcount = 0; 2044 AuthRecord *rr, *r2; 2045 mDNSs32 maxExistingAnnounceInterval = 0; 2046 const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces); 2047 2048 m->NextScheduledResponse = m->timenow + 0x78000000; 2049 2050 if (m->SleepState == SleepState_Transferring) RetrySPSRegistrations(m); 2051 2052 for (rr = m->ResourceRecords; rr; rr=rr->next) 2053 if (rr->ImmedUnicast) 2054 { 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) 2062 { 2063 LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s", ARDisplayString(m, rr)); 2064 rr->ImmedUnicast = mDNSfalse; 2065 } 2066 } 2067 2068 // *** 2069 // *** 1. Setup: Set the SendRNow and ImmedAnswer fields to indicate which interface(s) the records need to be sent on 2070 // *** 2071 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) 2074 { 2075 while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr); 2076 if (TimeToAnnounceThisRecord(rr, m->timenow)) 2077 { 2078 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) 2079 { 2080 if (!rr->WakeUp.HMAC.l[0]) 2081 { 2082 if (rr->AnnounceCount) rr->ImmedAnswer = mDNSInterfaceMark; // Send goodbye packet on all interfaces 2083 } 2084 else 2085 { 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)) 2090 { 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) 2094 { 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); 2098 } 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; 2102 } 2103 } 2104 } 2105 else if (ResourceRecordIsValidAnswer(rr)) 2106 { 2107 if (rr->AddressProxy.type) 2108 { 2109 rr->AnnounceCount--; 2110 rr->ThisAPInterval *= 2; 2111 rr->LastAPTime = m->timenow; 2112 if (rr->AddressProxy.type == mDNSAddrType_IPv4) 2113 { 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); 2117 } 2118 else if (rr->AddressProxy.type == mDNSAddrType_IPv6) 2119 { 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); 2123 } 2124 } 2125 else 2126 { 2127 rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces 2128 if (maxExistingAnnounceInterval < rr->ThisAPInterval) 2129 maxExistingAnnounceInterval = rr->ThisAPInterval; 2130 if (rr->UpdateBlocked) rr->UpdateBlocked = 0; 2131 } 2132 } 2133 } 2134 } 2135 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 2145 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) 2151 { 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)) 2166 { 2167 if (!m->DeviceInfo.ImmedAnswer) m->DeviceInfo.ImmedAnswer = rr->ImmedAnswer; 2168 else m->DeviceInfo.ImmedAnswer = mDNSInterfaceMark; 2169 } 2170 } 2171 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) 2180 { 2181 if (rr->ImmedAnswer) // If we're sending this as answer, see that its whole RRSet is similarly marked 2182 { 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; 2188 } 2189 else if (rr->ImmedAdditional) // If we're sending this as additional, see that its whole RRSet is similarly marked 2190 { 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; 2195 } 2196 } 2197 2198 // Now set SendRNow state appropriately 2199 for (rr = m->ResourceRecords; rr; rr=rr->next) 2200 { 2201 if (rr->ImmedAnswer == mDNSInterfaceMark) // Sending this record on all appropriate interfaces 2202 { 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)) 2209 { 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); 2215 } 2216 } 2217 else if (rr->ImmedAnswer) // Else, just respond to a single query on single interface: 2218 { 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; 2223 } 2224 SetNextAnnounceProbeTime(m, rr); 2225 //if (rr->SendRNow) LogMsg("%-15.4a %s", &rr->v4Requester, ARDisplayString(m, rr)); 2226 } 2227 2228 // *** 2229 // *** 2. Loop through interface list, sending records as appropriate 2230 // *** 2231 2232 while (intf) 2233 { 2234 const int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0; 2235 int numDereg = 0; 2236 int numAnnounce = 0; 2237 int numAnswer = 0; 2238 mDNSu8 *responseptr = m->omsg.data; 2239 mDNSu8 *newptr; 2240 InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags); 2241 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) 2247 { 2248 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))) 2253 { 2254 LogInfo("SendResponses: Not sending %s, on %s", ARDisplayString(m, rr), InterfaceNameForID(m, rr->SendRNow)); 2255 rr->SendRNow = GetNextActiveInterfaceID(intf); 2256 } 2257 else if (rr->SendRNow == intf->InterfaceID) 2258 { 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)); 2264 newptr = mDNSNULL; 2265 if (rr->NewRData && active) 2266 { 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) 2269 { 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 2273 } 2274 SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); 2275 } 2276 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 2281 if (newptr) 2282 { 2283 responseptr = newptr; 2284 rr->RequireGoodbye = active; 2285 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) numDereg++; 2286 else if (rr->LastAPTime == m->timenow) numAnnounce++; else numAnswer++; 2287 } 2288 2289 if (rr->NewRData && active) 2290 SetNewRData(&rr->resrec, OldRData, oldrdlength); 2291 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; 2296 2297 if (newptr) // If succeeded in sending, advance to next interface 2298 { 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); 2302 else 2303 rr->SendRNow = mDNSNULL; 2304 } 2305 } 2306 } 2307 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)) 2313 { 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); 2316 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)) 2321 { 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; } 2327 } 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 2331 { 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; 2336 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 2341 if (newptr) 2342 { 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; 2352 } 2353 } 2354 } 2355 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) 2362 { 2363 AuthRecord nsec; 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)) 2370 { 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); 2373 } 2374 newptr = responseptr; 2375 if (!r2) // If we successfully built our NSEC record, add it to the packet now 2376 { 2377 newptr = PutRR_OS(responseptr, &m->omsg.h.numAdditionals, &nsec.resrec); 2378 if (newptr) responseptr = newptr; 2379 } 2380 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) 2384 { 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; 2391 } 2392 } 2393 2394 if (m->omsg.h.numAnswers || m->omsg.h.numAdditionals) 2395 { 2396 // If we have data to send, add OWNER option if necessary, then send packet 2397 2398 if (OwnerRecordSpace) 2399 { 2400 AuthRecord opt; 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)); 2411 else 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)); 2414 } 2415 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); 2421 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. 2427 } 2428 else // Nothing more to send on this interface; go to next 2429 { 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); 2434 #endif 2435 intf = next; 2436 pktcount = 0; // When we move to a new interface, reset packet count back to zero -- NSEC generation logic uses it 2437 } 2438 } 2439 2440 // *** 2441 // *** 3. Cleanup: Now that everything is sent, call client callback functions, and reset state variables 2442 // *** 2443 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) 2448 { 2449 rr = m->CurrentRecord; 2450 m->CurrentRecord = rr->next; 2451 2452 if (rr->SendRNow) 2453 { 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; 2457 } 2458 2459 if (rr->ImmedAnswer || rr->resrec.RecordType == kDNSRecordTypeDeregistering) 2460 { 2461 if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client 2462 2463 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering && rr->AnnounceCount == 0) 2464 { 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 2467 } 2468 else 2469 { 2470 rr->ImmedAnswer = mDNSNULL; 2471 rr->ImmedUnicast = mDNSfalse; 2472 rr->v4Requester = zerov4Addr; 2473 rr->v6Requester = zerov6Addr; 2474 } 2475 } 2476 } 2477 verbosedebugf("SendResponses: Next in %ld ticks", m->NextScheduledResponse - m->timenow); 2478 } 2479 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) 2497 2498 #define NextCacheCheckEvent(RR) ((RR)->NextRequiredQuery + CacheCheckGracePeriod(RR)) 2499 2500 mDNSexport void ScheduleNextCacheCheckTime(mDNS *const m, const mDNSu32 slot, const mDNSs32 event) 2501 { 2502 if (m->rrcache_nextcheck[slot] - event > 0) 2503 m->rrcache_nextcheck[slot] = event; 2504 if (m->NextCacheCheck - event > 0) 2505 m->NextCacheCheck = event; 2506 } 2507 2508 // Note: MUST call SetNextCacheCheckTimeForRecord any time we change: 2509 // rr->TimeRcvd 2510 // rr->resrec.rroriginalttl 2511 // rr->UnansweredQueries 2512 // rr->CRActiveQuestion 2513 mDNSlocal void SetNextCacheCheckTimeForRecord(mDNS *const m, CacheRecord *const rr) 2514 { 2515 rr->NextRequiredQuery = RRExpireTime(rr); 2516 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) 2520 { 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)); 2525 } 2526 2527 ScheduleNextCacheCheckTime(m, HashSlot(rr->resrec.name), NextCacheCheckEvent(rr)); 2528 } 2529 2530 #define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5) 2531 #define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5) 2532 #define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5) 2533 #define kDefaultReconfirmTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 30) 2534 2535 mDNSlocal mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval) 2536 { 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; 2541 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)) 2544 { 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); 2553 } 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); 2557 } 2558 2559 #define MaxQuestionInterval (3600 * mDNSPlatformOneSecond) 2560 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) 2566 { 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)); 2571 if (!newptr) 2572 { 2573 debugf("BuildQuestion: No more space in this packet for question %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 2574 return(mDNSfalse); 2575 } 2576 else 2577 { 2578 mDNSu32 forecast = *answerforecast; 2579 const mDNSu32 slot = HashSlot(&q->qname); 2580 const CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname); 2581 CacheRecord *rr; 2582 CacheRecord **ka = *kalistptrptr; // Make a working copy of the pointer we're going to update 2583 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) 2592 { 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. 2598 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) 2606 { 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 2613 } 2614 } 2615 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); 2621 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 2626 { 2627 rr->UnansweredQueries++; // indicate that we're expecting a response 2628 rr->LastUnansweredTime = m->timenow; 2629 SetNextCacheCheckTimeForRecord(m, rr); 2630 } 2631 2632 return(mDNStrue); 2633 } 2634 } 2635 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) 2649 { 2650 mDNSu32 slot; 2651 CacheGroup *cg; 2652 CacheRecord *cr; 2653 debugf("ReconfirmAntecedents (depth=%d) for %##s", depth, name->c); 2654 FORALL_CACHERECORDS(slot, cg, cr) 2655 { 2656 domainname *crtarget = GetRRDomainNameTarget(&cr->resrec); 2657 if (crtarget && cr->resrec.rdatahash == namehash && SameDomainName(crtarget, name)) 2658 { 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); 2662 } 2663 } 2664 } 2665 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) 2671 { 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; 2675 return(cr); 2676 } 2677 2678 mDNSlocal const CacheRecord *FindSPSInCache1(mDNS *const m, const DNSQuestion *const q, const CacheRecord *const c0, const CacheRecord *const c1) 2679 { 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... 2688 { 2689 mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c); 2690 if (bestmetric > metric) { bestmetric = metric; bestcr = cr; } 2691 } 2692 return(bestcr); 2693 } 2694 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]) 2697 { 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]); 2701 } 2702 2703 // Only DupSuppressInfos newer than the specified 'time' are allowed to remain active 2704 mDNSlocal void ExpireDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time) 2705 { 2706 int i; 2707 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL; 2708 } 2709 2710 mDNSlocal void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time, mDNSInterfaceID InterfaceID) 2711 { 2712 int i; 2713 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL; 2714 } 2715 2716 mDNSlocal mDNSBool SuppressOnThisInterface(const DupSuppressInfo ds[DupSuppressInfoSize], const NetworkInterfaceInfo * const intf) 2717 { 2718 int i; 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) 2723 { 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); 2727 } 2728 return(mDNSfalse); 2729 } 2730 2731 mDNSlocal int RecordDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 Time, mDNSInterfaceID InterfaceID, mDNSs32 Type) 2732 { 2733 int i, j; 2734 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; 2737 2738 // If not, find a slot we can re-use 2739 if (i >= DupSuppressInfoSize) 2740 { 2741 i = 0; 2742 for (j=1; j<DupSuppressInfoSize && ds[i].InterfaceID; j++) 2743 if (!ds[j].InterfaceID || ds[j].Time - ds[i].Time < 0) 2744 i = j; 2745 } 2746 2747 // Record the info about this query we saw 2748 ds[i].Time = Time; 2749 ds[i].InterfaceID = InterfaceID; 2750 ds[i].Type = Type; 2751 2752 return(i); 2753 } 2754 2755 mDNSlocal void mDNSSendWakeOnResolve(mDNS *const m, DNSQuestion *q) 2756 { 2757 int len, i, cnt; 2758 mDNSInterfaceID InterfaceID = q->InterfaceID; 2759 domainname *d = &q->qname; 2760 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) 2763 { 2764 LogMsg("mDNSSendWakeOnResolve: ERROR!! Invalid InterfaceID %p for question %##s", InterfaceID, q->qname.c); 2765 return; 2766 } 2767 2768 // Split MAC@IPAddress and pass them separately 2769 len = d->c[0]; 2770 i = 1; 2771 cnt = 0; 2772 for (i = 1; i < len; i++) 2773 { 2774 if (d->c[i] == '@') 2775 { 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 2778 if (cnt != 5) 2779 { 2780 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, cnt %d", q->qname.c, cnt); 2781 return; 2782 } 2783 if ((i - 1) > (int) (sizeof(EthAddr) - 1)) 2784 { 2785 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, length %d", q->qname.c, i - 1); 2786 return; 2787 } 2788 if ((len - i) > (int)(sizeof(IPAddr) - 1)) 2789 { 2790 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed IP address %##s, length %d", q->qname.c, len - i); 2791 return; 2792 } 2793 mDNSPlatformMemCopy(EthAddr, &d->c[1], i - 1); 2794 EthAddr[i - 1] = 0; 2795 mDNSPlatformMemCopy(IPAddr, &d->c[i + 1], len - i); 2796 IPAddr[len - i] = 0; 2797 mDNSPlatformSendWakeupPacket(m, InterfaceID, EthAddr, IPAddr, InitialWakeOnResolveCount - q->WakeOnResolveCount); 2798 return; 2799 } 2800 else if (d->c[i] == ':') 2801 cnt++; 2802 } 2803 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed WakeOnResolve name %##s", q->qname.c); 2804 } 2805 2806 2807 mDNSlocal mDNSBool AccelerateThisQuery(mDNS *const m, DNSQuestion *q) 2808 { 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)) 2811 return(mDNStrue); 2812 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)) 2815 { 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 2826 { 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 2830 } 2831 return(mDNStrue); 2832 } 2833 2834 return(mDNSfalse); 2835 } 2836 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 2840 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. 2848 2849 mDNSlocal void SendQueries(mDNS *const m) 2850 { 2851 mDNSu32 slot; 2852 CacheGroup *cg; 2853 CacheRecord *cr; 2854 AuthRecord *ar; 2855 int pktcount = 0; 2856 DNSQuestion *q; 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; 2861 2862 // 1. If time for a query, work out what we need to do 2863 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) 2869 { 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; 2879 } 2880 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) 2889 { 2890 q = m->CurrentQuestion; 2891 if (q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow))) 2892 { 2893 mDNSu8 *qptr = m->omsg.data; 2894 const mDNSu8 *const limit = m->omsg.data + sizeof(m->omsg.data); 2895 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); 2898 if (q->LocalSocket) 2899 { 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; 2904 } 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); 2912 } 2913 else if (mDNSOpaque16IsZero(q->TargetQID) && !q->Target.type && TimeToSendThisQuestion(q, m->timenow)) 2914 { 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; 2919 } 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; 2924 } 2925 while (m->CurrentQuestion) 2926 { 2927 LogInfo("SendQueries question loop 1: Skipping NewQuestion %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 2928 m->CurrentQuestion = m->CurrentQuestion->next; 2929 } 2930 m->CurrentQuestion = mDNSNULL; 2931 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) 2940 { 2941 if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow || 2942 (!q->Target.type && ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q)))) 2943 { 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) 2948 { 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))) 2958 { 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); 2968 } 2969 } 2970 2971 // Mark for sending. (If no active interfaces, then don't even try.) 2972 q->SendOnAll = (q->SendQNow == mDNSInterfaceMark); 2973 if (q->SendOnAll) 2974 { 2975 q->SendQNow = !intf ? mDNSNULL : (q->InterfaceID) ? q->InterfaceID : intf->InterfaceID; 2976 q->LastQTime = m->timenow; 2977 } 2978 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); 2982 2983 q->LastQTxTime = m->timenow; 2984 q->RecentAnswerPkts = 0; 2985 if (q->RequestUnicast) q->RequestUnicast--; 2986 } 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); 2990 } 2991 2992 // 2. Scan our authoritative RR list to see what probes we might need to send 2993 2994 m->NextScheduledProbe = m->timenow + 0x78000000; 2995 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) 3000 { 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... 3004 { 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) 3007 { 3008 SetNextAnnounceProbeTime(m, ar); 3009 } 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) 3012 { 3013 if (ar->AddressProxy.type == mDNSAddrType_IPv4) 3014 { 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); 3017 } 3018 else if (ar->AddressProxy.type == mDNSAddrType_IPv6) 3019 { 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); 3026 } 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; 3034 ar->ProbeCount--; 3035 SetNextAnnounceProbeTime(m, ar); 3036 if (ar->ProbeCount == 0) 3037 { 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... 3040 AuthRecord *r2; 3041 for (r2 = m->DuplicateRecords; r2; r2=r2->next) 3042 if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, ar)) 3043 r2->ProbeCount = 0; 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); 3053 } 3054 } 3055 // else, if it has now finished probing, move it to state Verified, 3056 // and update m->NextScheduledResponse so it will be announced 3057 else 3058 { 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); 3064 } 3065 } 3066 } 3067 m->CurrentRecord = m->DuplicateRecords; 3068 while (m->CurrentRecord) 3069 { 3070 ar = m->CurrentRecord; 3071 m->CurrentRecord = ar->next; 3072 if (ar->resrec.RecordType == kDNSRecordTypeUnique && ar->ProbeCount == 0 && !ar->Acknowledged) 3073 AcknowledgeRecord(m, ar); 3074 } 3075 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 3078 while (intf) 3079 { 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) 3085 { 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 3089 3090 // Put query questions in this packet 3091 for (q = m->Questions; q && q != m->NewQuestions; q=q->next) 3092 { 3093 if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow == intf->InterfaceID)) 3094 { 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); 3098 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)) 3102 { 3103 q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf); 3104 if (q->WakeOnResolveCount) 3105 { 3106 mDNSSendWakeOnResolve(m, q); 3107 q->WakeOnResolveCount--; 3108 } 3109 } 3110 } 3111 } 3112 3113 // Put probe questions in this packet 3114 for (ar = m->ResourceRecords; ar; ar=ar->next) 3115 if (ar->SendRNow == intf->InterfaceID) 3116 { 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)); 3123 if (newptr) 3124 { 3125 queryptr = newptr; 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); 3131 } 3132 } 3133 } 3134 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) 3137 { 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); 3142 if (newptr) 3143 { 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); 3146 queryptr = newptr; 3147 KnownAnswerList = ka->NextInKAList; 3148 ka->NextInKAList = mDNSNULL; 3149 } 3150 else 3151 { 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; 3157 break; 3158 } 3159 } 3160 3161 for (ar = m->ResourceRecords; ar; ar=ar->next) 3162 if (ar->IncludeInProbe) 3163 { 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)); 3168 } 3169 3170 if (queryptr > m->omsg.data) 3171 { 3172 if (OwnerRecordSpace) 3173 { 3174 AuthRecord opt; 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); 3183 if (!queryptr) 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)); 3191 } 3192 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. 3206 } 3207 else // Nothing more to send on this interface; go to next 3208 { 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); 3213 #endif 3214 intf = next; 3215 } 3216 } 3217 3218 // 4. Final housekeeping 3219 3220 // 4a. Debugging check: Make sure we announced all our records 3221 for (ar = m->ResourceRecords; ar; ar=ar->next) 3222 if (ar->SendRNow) 3223 { 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; 3227 } 3228 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) 3237 { 3238 cr->UnansweredQueries++; 3239 cr->CRActiveQuestion->SendQNow = mDNSNULL; 3240 SetNextCacheCheckTimeForRecord(m, cr); 3241 } 3242 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) 3247 if (q->SendQNow) 3248 { 3249 DNSQuestion *x; 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; 3253 } 3254 } 3255 3256 mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password) 3257 { 3258 int i, j; 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; } 3262 3263 // 0x00 Destination address 3264 for (i=0; i<6; i++) *ptr++ = EthAddr->b[i]; 3265 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]; 3268 3269 // 0x0C Ethertype (0x0842) 3270 *ptr++ = 0x08; 3271 *ptr++ = 0x42; 3272 3273 // 0x0E Wakeup sync sequence 3274 for (i=0; i<6; i++) *ptr++ = 0xFF; 3275 3276 // 0x14 Wakeup data 3277 for (j=0; j<16; j++) for (i=0; i<6; i++) *ptr++ = EthAddr->b[i]; 3278 3279 // 0x74 Password 3280 for (i=0; i<6; i++) *ptr++ = password->b[i]; 3281 3282 mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID); 3283 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); 3291 } 3292 3293 // *************************************************************************** 3294 #if COMPILER_LIKES_PRAGMA_MARK 3295 #pragma mark - 3296 #pragma mark - RR List Management & Task Management 3297 #endif 3298 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) 3304 { 3305 DNSQuestion *const q = m->CurrentQuestion; 3306 mDNSBool followcname = FollowCNAME(q, &rr->resrec, AddRecord); 3307 3308 verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s", 3309 q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, CRDisplayString(m, rr)); 3310 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) 3316 { 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); 3320 return; 3321 } 3322 3323 if (QuerySuppressed(q)) 3324 { 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)) 3329 return; 3330 } 3331 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. 3335 3336 rr->LastUsed = m->timenow; 3337 if (AddRecord == QC_add && !q->DuplicateOf && rr->CRActiveQuestion != q) 3338 { 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); 3344 } 3345 3346 // If this is: 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)) 3356 { 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)); 3363 } 3364 3365 if (rr->DelayDelivery) return; // We'll come back later when CacheRecordDeferredAdd() calls us 3366 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; 3370 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)) 3373 { 3374 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls 3375 if (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype)) 3376 { 3377 CacheRecord neg; 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); 3380 } 3381 else 3382 q->QuestionCallback(m, q, &rr->resrec, AddRecord); 3383 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 3384 } 3385 // Note: Proceed with caution here because client callback function is allowed to do anything, 3386 // including starting/stopping queries, registering/deregistering records, etc. 3387 3388 if (followcname && m->CurrentQuestion == q) 3389 AnswerQuestionByFollowingCNAME(m, q, &rr->resrec); 3390 } 3391 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. 3394 // 3395 // 1) There are no cache records 3396 // 2) There are cache records but the DNSServers between question and cache record don't match. 3397 // 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 3402 // 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 3407 // question 3408 3409 mDNSlocal void AnswerQuestionsForDNSServerChanges(mDNS *const m) 3410 { 3411 DNSQuestion *q; 3412 DNSQuestion *qnext; 3413 CacheRecord *rr; 3414 mDNSu32 slot; 3415 CacheGroup *cg; 3416 3417 if (m->CurrentQuestion) 3418 LogMsg("AnswerQuestionsForDNSServerChanges: ERROR m->CurrentQuestion already set: %##s (%s)", 3419 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 3420 3421 for (q = m->Questions; q && q != m->NewQuestions; q = qnext) 3422 { 3423 qnext = q->next; 3424 3425 // multicast or DNSServers did not change. 3426 if (mDNSOpaque16IsZero(q->TargetQID)) continue; 3427 if (!q->deliverAddEvents) continue; 3428 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) 3438 { 3439 if (SameNameRecordAnswersQuestion(&rr->resrec, q)) 3440 { 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) 3450 { 3451 DNSQuestion *qptr; 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; } 3456 } 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 3462 } 3463 } 3464 } 3465 m->CurrentQuestion = mDNSNULL; 3466 } 3467 3468 mDNSlocal void CacheRecordDeferredAdd(mDNS *const m, CacheRecord *rr) 3469 { 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) 3476 { 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; 3482 } 3483 m->CurrentQuestion = mDNSNULL; 3484 } 3485 3486 mDNSlocal mDNSs32 CheckForSoonToExpireRecords(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const mDNSu32 slot) 3487 { 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)); 3498 else return(0); 3499 } 3500 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) 3510 { 3511 DNSQuestion *q; 3512 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) 3516 { 3517 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 3518 { 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) 3526 { 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) 3530 { 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); 3536 } 3537 } 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) 3547 { 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; 3554 } 3555 } 3556 } 3557 3558 if (!rr->DelayDelivery) 3559 { 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) 3564 { 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; 3570 } 3571 m->CurrentQuestion = mDNSNULL; 3572 } 3573 3574 SetNextCacheCheckTimeForRecord(m, rr); 3575 } 3576 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) 3588 { 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) 3596 { 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; 3602 } 3603 m->CurrentQuestion = mDNSNULL; 3604 } 3605 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) 3616 { 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; 3621 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) 3625 { 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)) 3632 { 3633 verbosedebugf("CacheRecordRmv %p %s", rr, CRDisplayString(m, rr)); 3634 q->FlappingInterface1 = mDNSNULL; 3635 q->FlappingInterface2 = mDNSNULL; 3636 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) 3641 { 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; 3646 continue; 3647 } 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)); 3652 else 3653 { 3654 q->CurrentAnswers--; 3655 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--; 3656 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--; 3657 } 3658 if (rr->resrec.rdata->MaxRDLength) // Never generate "remove" events for negative results 3659 { 3660 if (q->CurrentAnswers == 0) 3661 { 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); 3665 } 3666 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv); 3667 } 3668 } 3669 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 3670 m->CurrentQuestion = q->next; 3671 } 3672 m->CurrentQuestion = mDNSNULL; 3673 } 3674 3675 mDNSlocal void ReleaseCacheEntity(mDNS *const m, CacheEntity *e) 3676 { 3677 #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1 3678 unsigned int i; 3679 for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF; 3680 #endif 3681 e->next = m->rrcache_free; 3682 m->rrcache_free = e; 3683 m->rrcache_totalused--; 3684 } 3685 3686 mDNSlocal void ReleaseCacheGroup(mDNS *const m, CacheGroup **cp) 3687 { 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); 3698 } 3699 3700 mDNSlocal void ReleaseCacheRecord(mDNS *const m, CacheRecord *r) 3701 { 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); 3706 } 3707 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) 3712 { 3713 CacheRecord **rp = &cg->members; 3714 3715 if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; } 3716 m->lock_rrcache = 1; 3717 3718 while (*rp) 3719 { 3720 CacheRecord *const rr = *rp; 3721 mDNSs32 event = RRExpireTime(rr); 3722 if (m->timenow - event >= 0) // If expired, delete it 3723 { 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 3728 { 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)) 3738 { 3739 q->ThisQInterval = InitialQuestionInterval; 3740 q->LastQTime = m->timenow - q->ThisQInterval; 3741 SetNextQueryTime(m, q); 3742 } 3743 CacheRecordRmv(m, rr); 3744 m->rrcache_active--; 3745 } 3746 ReleaseCacheRecord(m, rr); 3747 } 3748 else // else, not expired; see if we need to query 3749 { 3750 // If waiting to delay delivery, do nothing until then 3751 if (rr->DelayDelivery && rr->DelayDelivery - m->timenow > 0) 3752 event = rr->DelayDelivery; 3753 else 3754 { 3755 if (rr->DelayDelivery) CacheRecordDeferredAdd(m, rr); 3756 if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries) 3757 { 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 3761 { 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; 3768 } 3769 } 3770 } 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; 3775 rp = &rr->next; 3776 } 3777 } 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; 3781 } 3782 3783 mDNSlocal void AnswerNewQuestion(mDNS *const m) 3784 { 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); 3789 AuthRecord *lr; 3790 AuthGroup *ag; 3791 mDNSBool AnsweredFromCache = mDNSfalse; 3792 3793 verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 3794 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. 3800 // 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). 3809 // 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. 3814 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 3825 3826 if (q->NoAnswer == NoAnswer_Fail) 3827 { 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 3835 } 3836 if (m->CurrentQuestion != q) { LogInfo("AnswerNewQuestion: Question deleted while generating NoAnswer_Fail response"); goto exit; } 3837 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); 3843 if (ag) 3844 { 3845 m->CurrentRecord = ag->members; 3846 while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords) 3847 { 3848 AuthRecord *rr = m->CurrentRecord; 3849 m->CurrentRecord = rr->next; 3850 // 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. 3853 // 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. 3857 3858 if (rr->ARType == AuthRecordLocalOnly || (rr->ARType == AuthRecordP2P && q->InterfaceID == mDNSInterface_Any)) 3859 if (LocalOnlyRecordAnswersQuestion(rr, q)) 3860 { 3861 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); 3862 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 3863 } 3864 } 3865 } 3866 m->CurrentRecord = mDNSNULL; 3867 3868 if (m->CurrentQuestion != q) { LogInfo("AnswerNewQuestion: Question deleted while while giving LocalOnly record answers"); goto exit; } 3869 3870 if (q->LOAddressAnswers) 3871 { 3872 LogInfo("AnswerNewQuestion: Question %p %##s (%s) answered using local auth records LOAddressAnswers %d", 3873 q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers); 3874 goto exit; 3875 } 3876 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. 3882 if (ag) 3883 { 3884 lr = ag->NewLocalOnlyRecords; 3885 while (lr) 3886 { 3887 if (LORecordAnswersAddressType(lr) && LocalOnlyRecordAnswersQuestion(lr, q)) 3888 { 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); 3891 goto exit; 3892 } 3893 lr = lr->next; 3894 } 3895 } 3896 3897 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; } 3901 else 3902 { 3903 CacheRecord *rr; 3904 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 3905 if (SameNameRecordAnswersQuestion(&rr->resrec, q)) 3906 { 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) 3910 { 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 3914 } 3915 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 3926 } 3927 else if (RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype)) 3928 ShouldQueryImmediately = mDNSfalse; 3929 } 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; } 3933 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) 3939 { 3940 LogInfo("AnswerNewQuestion: Generating response for retrying with search domains %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 3941 GenerateNegativeResponse(m); 3942 } 3943 3944 if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving negative answer"); goto exit; } 3945 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)) 3949 { 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 3954 { 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; 3959 } 3960 } 3961 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); 3968 3969 exit: 3970 m->CurrentQuestion = mDNSNULL; 3971 m->lock_rrcache = 0; 3972 } 3973 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) 3977 { 3978 mDNSu32 slot; 3979 AuthGroup *ag; 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) 3982 3983 debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 3984 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 3989 3990 if (m->CurrentRecord) 3991 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 3992 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); 3998 if (ag) 3999 { 4000 m->CurrentRecord = ag->members; 4001 while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords) 4002 { 4003 AuthRecord *rr = m->CurrentRecord; 4004 m->CurrentRecord = rr->next; 4005 if (LocalOnlyRecordAnswersQuestion(rr, q)) 4006 { 4007 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); 4008 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 4009 } 4010 } 4011 } 4012 4013 if (m->CurrentQuestion == q) 4014 { 4015 m->CurrentRecord = m->ResourceRecords; 4016 4017 while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords) 4018 { 4019 AuthRecord *rr = m->CurrentRecord; 4020 m->CurrentRecord = rr->next; 4021 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 4022 { 4023 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); 4024 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 4025 } 4026 } 4027 } 4028 4029 m->CurrentQuestion = mDNSNULL; 4030 m->CurrentRecord = mDNSNULL; 4031 } 4032 4033 mDNSlocal CacheEntity *GetCacheEntity(mDNS *const m, const CacheGroup *const PreserveCG) 4034 { 4035 CacheEntity *e = mDNSNULL; 4036 4037 if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); } 4038 m->lock_rrcache = 1; 4039 4040 // If we have no free records, ask the client layer to give us some more memory 4041 if (!m->rrcache_free && m->MainCallback) 4042 { 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); 4046 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); 4055 else 4056 { 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 4060 } 4061 } 4062 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) 4066 { 4067 mDNSu32 oldtotalused = m->rrcache_totalused; 4068 mDNSu32 slot; 4069 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) 4070 { 4071 CacheGroup **cp = &m->rrcache_hash[slot]; 4072 while (*cp) 4073 { 4074 CacheRecord **rp = &(*cp)->members; 4075 while (*rp) 4076 { 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) 4080 rp=&(*rp)->next; 4081 else 4082 { 4083 CacheRecord *rr = *rp; 4084 *rp = (*rp)->next; // Cut record from list 4085 ReleaseCacheRecord(m, rr); 4086 } 4087 } 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); 4093 } 4094 } 4095 LogInfo("GetCacheEntity recycled %d records to reduce cache from %d to %d", 4096 oldtotalused - m->rrcache_totalused, oldtotalused, m->rrcache_totalused); 4097 } 4098 4099 if (m->rrcache_free) // If there are records in the free list, take one 4100 { 4101 e = m->rrcache_free; 4102 m->rrcache_free = e->next; 4103 if (++m->rrcache_totalused >= m->rrcache_report) 4104 { 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; 4109 } 4110 mDNSPlatformMemZero(e, sizeof(*e)); 4111 } 4112 4113 m->lock_rrcache = 0; 4114 4115 return(e); 4116 } 4117 4118 mDNSlocal CacheRecord *GetCacheRecord(mDNS *const m, CacheGroup *cg, mDNSu16 RDLength) 4119 { 4120 CacheRecord *r = (CacheRecord *)GetCacheEntity(m, cg); 4121 if (r) 4122 { 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 4125 { 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; } 4129 } 4130 } 4131 return(r); 4132 } 4133 4134 mDNSlocal CacheGroup *GetCacheGroup(mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr) 4135 { 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); 4147 if (!cg->name) 4148 { 4149 LogMsg("GetCacheGroup: Failed to allocate name storage for %##s", rr->name->c); 4150 ReleaseCacheEntity(m, (CacheEntity*)cg); 4151 return(mDNSNULL); 4152 } 4153 AssignDomainName(cg->name, rr->name); 4154 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); 4158 4159 return(cg); 4160 } 4161 4162 mDNSexport void mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr) 4163 { 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); 4175 } 4176 4177 mDNSexport mDNSs32 mDNS_TimeNow(const mDNS *const m) 4178 { 4179 mDNSs32 time; 4180 mDNSPlatformLock(m); 4181 if (m->mDNS_busy) 4182 { 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); 4185 } 4186 4187 if (m->timenow) time = m->timenow; 4188 else time = mDNS_TimeNow_NoLock(m); 4189 mDNSPlatformUnlock(m); 4190 return(time); 4191 } 4192 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) 4199 4200 // Called from mDNS_Execute() to expire stale proxy records 4201 mDNSlocal void CheckProxyRecords(mDNS *const m, AuthRecord *list) 4202 { 4203 m->CurrentRecord = list; 4204 while (m->CurrentRecord) 4205 { 4206 AuthRecord *rr = m->CurrentRecord; 4207 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering && rr->WakeUp.HMAC.l[0]) 4208 { 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 4212 { 4213 if (m->NextScheduledSPS - rr->TimeExpire > 0) 4214 m->NextScheduledSPS = rr->TimeExpire; 4215 } 4216 else // else proxy record expired, so remove it 4217 { 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 4223 } 4224 } 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; 4229 } 4230 } 4231 4232 mDNSlocal void CheckRmvEventsForLocalRecords(mDNS *const m) 4233 { 4234 while (m->CurrentRecord) 4235 { 4236 AuthRecord *rr = m->CurrentRecord; 4237 if (rr->AnsweredLocalQ && rr->resrec.RecordType == kDNSRecordTypeDeregistering) 4238 { 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 4243 { 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); 4249 } 4250 } 4251 if (m->CurrentRecord == rr) // If m->CurrentRecord was not auto-advanced, do it ourselves now 4252 m->CurrentRecord = rr->next; 4253 } 4254 } 4255 4256 mDNSlocal void TimeoutQuestions(mDNS *const m) 4257 { 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) 4264 { 4265 DNSQuestion *const q = m->CurrentQuestion; 4266 if (q->StopTime) 4267 { 4268 if (m->timenow - q->StopTime >= 0) 4269 { 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; 4273 } 4274 else 4275 { 4276 if (m->NextScheduledStopTime - q->StopTime > 0) 4277 m->NextScheduledStopTime = q->StopTime; 4278 } 4279 } 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; 4285 } 4286 m->CurrentQuestion = mDNSNULL; 4287 } 4288 4289 mDNSexport mDNSs32 mDNS_Execute(mDNS *const m) 4290 { 4291 mDNS_Lock(m); // Must grab lock before trying to read m->timenow 4292 4293 if (m->timenow - m->NextScheduledEvent >= 0) 4294 { 4295 int i; 4296 AuthRecord *head, *tail; 4297 mDNSu32 slot; 4298 AuthGroup *ag; 4299 4300 verbosedebugf("mDNS_Execute"); 4301 4302 if (m->CurrentQuestion) 4303 LogMsg("mDNS_Execute: ERROR m->CurrentQuestion already set: %##s (%s)", 4304 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4305 4306 if (m->CurrentRecord) 4307 LogMsg("mDNS_Execute: ERROR m->CurrentRecord already set: %s", ARDisplayString(m, m->CurrentRecord)); 4308 4309 // 1. If we're past the probe suppression time, we can clear it 4310 if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0; 4311 4312 // 2. If it's been more than ten seconds since the last probe failure, we can clear the counter 4313 if (m->NumFailedProbes && m->timenow - m->ProbeFailTime >= mDNSPlatformOneSecond * 10) m->NumFailedProbes = 0; 4314 4315 // 3. Purge our cache of stale old records 4316 if (m->rrcache_size && m->timenow - m->NextCacheCheck >= 0) 4317 { 4318 mDNSu32 numchecked = 0; 4319 m->NextCacheCheck = m->timenow + 0x3FFFFFFF; 4320 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) 4321 { 4322 if (m->timenow - m->rrcache_nextcheck[slot] >= 0) 4323 { 4324 CacheGroup **cp = &m->rrcache_hash[slot]; 4325 m->rrcache_nextcheck[slot] = m->timenow + 0x3FFFFFFF; 4326 while (*cp) 4327 { 4328 debugf("m->NextCacheCheck %4d Slot %3d %##s", numchecked, slot, *cp ? (*cp)->name : (domainname*)"\x04NULL"); 4329 numchecked++; 4330 CheckCacheExpiration(m, slot, *cp); 4331 if ((*cp)->members) cp=&(*cp)->next; 4332 else ReleaseCacheGroup(m, cp); 4333 } 4334 } 4335 // Even if we didn't need to actually check this slot yet, still need to 4336 // factor its nextcheck time into our overall NextCacheCheck value 4337 if (m->NextCacheCheck - m->rrcache_nextcheck[slot] > 0) 4338 m->NextCacheCheck = m->rrcache_nextcheck[slot]; 4339 } 4340 debugf("m->NextCacheCheck %4d checked, next in %d", numchecked, m->NextCacheCheck - m->timenow); 4341 } 4342 4343 if (m->timenow - m->NextScheduledSPS >= 0) 4344 { 4345 m->NextScheduledSPS = m->timenow + 0x3FFFFFFF; 4346 CheckProxyRecords(m, m->DuplicateRecords); // Clear m->DuplicateRecords first, then m->ResourceRecords 4347 CheckProxyRecords(m, m->ResourceRecords); 4348 } 4349 4350 SetSPSProxyListChanged(mDNSNULL); // Perform any deferred BPF reconfiguration now 4351 4352 // Clear AnnounceOwner if necessary. (Do this *before* SendQueries() and SendResponses().) 4353 if (m->AnnounceOwner && m->timenow - m->AnnounceOwner >= 0) m->AnnounceOwner = 0; 4354 4355 if (m->DelaySleep && m->timenow - m->DelaySleep >= 0) 4356 { 4357 m->DelaySleep = 0; 4358 if (m->SleepState == SleepState_Transferring) 4359 { 4360 LogSPS("Re-sleep delay passed; now checking for Sleep Proxy Servers"); 4361 BeginSleepProcessing(m); 4362 } 4363 } 4364 4365 // 4. See if we can answer any of our new local questions from the cache 4366 for (i=0; m->NewQuestions && i<1000; i++) 4367 { 4368 if (m->NewQuestions->DelayAnswering && m->timenow - m->NewQuestions->DelayAnswering < 0) break; 4369 AnswerNewQuestion(m); 4370 } 4371 if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit"); 4372 4373 // Make sure we deliver *all* local RMV events, and clear the corresponding rr->AnsweredLocalQ flags, *before* 4374 // we begin generating *any* new ADD events in the m->NewLocalOnlyQuestions and m->NewLocalRecords loops below. 4375 for (i=0; i<1000 && m->LocalRemoveEvents; i++) 4376 { 4377 m->LocalRemoveEvents = mDNSfalse; 4378 m->CurrentRecord = m->ResourceRecords; 4379 CheckRmvEventsForLocalRecords(m); 4380 // Walk the LocalOnly records and deliver the RMV events 4381 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 4382 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next) 4383 { 4384 m->CurrentRecord = ag->members; 4385 if (m->CurrentRecord) CheckRmvEventsForLocalRecords(m); 4386 } 4387 } 4388 4389 if (i >= 1000) LogMsg("mDNS_Execute: m->LocalRemoveEvents exceeded loop limit"); 4390 4391 for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m); 4392 if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit"); 4393 4394 head = tail = mDNSNULL; 4395 for (i=0; i<1000 && m->NewLocalRecords && m->NewLocalRecords != head; i++) 4396 { 4397 AuthRecord *rr = m->NewLocalRecords; 4398 m->NewLocalRecords = m->NewLocalRecords->next; 4399 if (LocalRecordReady(rr)) 4400 { 4401 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m, rr)); 4402 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue); 4403 } 4404 else if (!rr->next) 4405 { 4406 // If we have just one record that is not ready, we don't have to unlink and 4407 // reinsert. As the NewLocalRecords will be NULL for this case, the loop will 4408 // terminate and set the NewLocalRecords to rr. 4409 debugf("mDNS_Execute: Just one LocalAuthRecord %s, breaking out of the loop early", ARDisplayString(m, rr)); 4410 if (head != mDNSNULL || m->NewLocalRecords != mDNSNULL) 4411 LogMsg("mDNS_Execute: ERROR!!: head %p, NewLocalRecords %p", head, m->NewLocalRecords); 4412 4413 head = rr; 4414 } 4415 else 4416 { 4417 AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records 4418 debugf("mDNS_Execute: Skipping LocalAuthRecord %s", ARDisplayString(m, rr)); 4419 // if this is the first record we are skipping, move to the end of the list. 4420 // if we have already skipped records before, append it at the end. 4421 while (*p && *p != rr) p=&(*p)->next; 4422 if (*p) *p = rr->next; // Cut this record from the list 4423 else { LogMsg("mDNS_Execute: ERROR!! Cannot find record %s in ResourceRecords list", ARDisplayString(m, rr)); break; } 4424 if (!head) 4425 { 4426 while (*p) p=&(*p)->next; 4427 *p = rr; 4428 head = tail = rr; 4429 } 4430 else 4431 { 4432 tail->next = rr; 4433 tail = rr; 4434 } 4435 rr->next = mDNSNULL; 4436 } 4437 } 4438 m->NewLocalRecords = head; 4439 // debugf("mDNS_Execute: Setting NewLocalRecords to %s", (head ? ARDisplayString(m, head) : "NULL")); 4440 4441 if (i >= 1000) LogMsg("mDNS_Execute: m->NewLocalRecords exceeded loop limit"); 4442 4443 // Check to see if we have any new LocalOnly/P2P records to examine for delivering 4444 // to our local questions 4445 if (m->NewLocalOnlyRecords) 4446 { 4447 m->NewLocalOnlyRecords = mDNSfalse; 4448 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 4449 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next) 4450 { 4451 for (i=0; i<100 && ag->NewLocalOnlyRecords; i++) 4452 { 4453 AuthRecord *rr = ag->NewLocalOnlyRecords; 4454 ag->NewLocalOnlyRecords = ag->NewLocalOnlyRecords->next; 4455 // LocalOnly records should always be ready as they never probe 4456 if (LocalRecordReady(rr)) 4457 { 4458 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m, rr)); 4459 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue); 4460 } 4461 else LogMsg("mDNS_Execute: LocalOnlyRecord %s not ready", ARDisplayString(m, rr)); 4462 } 4463 // We limit about 100 per AuthGroup that can be serviced at a time 4464 if (i >= 100) LogMsg("mDNS_Execute: ag->NewLocalOnlyRecords exceeded loop limit"); 4465 } 4466 } 4467 4468 // 5. Some questions may have picked a new DNS server and the cache may answer these questions now. 4469 AnswerQuestionsForDNSServerChanges(m); 4470 4471 // 6. See what packets we need to send 4472 if (m->mDNSPlatformStatus != mStatus_NoError || (m->SleepState == SleepState_Sleeping)) 4473 DiscardDeregistrations(m); 4474 if (m->mDNSPlatformStatus == mStatus_NoError && (m->SuppressSending == 0 || m->timenow - m->SuppressSending >= 0)) 4475 { 4476 // If the platform code is ready, and we're not suppressing packet generation right now 4477 // then send our responses, probes, and questions. 4478 // We check the cache first, because there might be records close to expiring that trigger questions to refresh them. 4479 // We send queries next, because there might be final-stage probes that complete their probing here, causing 4480 // them to advance to announcing state, and we want those to be included in any announcements we send out. 4481 // Finally, we send responses, including the previously mentioned records that just completed probing. 4482 m->SuppressSending = 0; 4483 4484 // 7. Send Query packets. This may cause some probing records to advance to announcing state 4485 if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m); 4486 if (m->timenow - m->NextScheduledQuery >= 0) 4487 { 4488 DNSQuestion *q; 4489 LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second", 4490 m->timenow, m->NextScheduledQuery, m->timenow - m->NextScheduledQuery); 4491 m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond; 4492 for (q = m->Questions; q && q != m->NewQuestions; q=q->next) 4493 if (ActiveQuestion(q) && m->timenow - NextQSendTime(q) >= 0) 4494 LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4495 } 4496 if (m->timenow - m->NextScheduledProbe >= 0) 4497 { 4498 LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second", 4499 m->timenow, m->NextScheduledProbe, m->timenow - m->NextScheduledProbe); 4500 m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond; 4501 } 4502 4503 // 8. Send Response packets, including probing records just advanced to announcing state 4504 if (m->timenow - m->NextScheduledResponse >= 0) SendResponses(m); 4505 if (m->timenow - m->NextScheduledResponse >= 0) 4506 { 4507 LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second"); 4508 m->NextScheduledResponse = m->timenow + mDNSPlatformOneSecond; 4509 } 4510 } 4511 4512 // Clear RandomDelay values, ready to pick a new different value next time 4513 m->RandomQueryDelay = 0; 4514 m->RandomReconfirmDelay = 0; 4515 4516 if (m->NextScheduledStopTime && m->timenow - m->NextScheduledStopTime >= 0) TimeoutQuestions(m); 4517 #ifndef UNICAST_DISABLED 4518 if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0) UpdateAllSRVRecords(m); 4519 if (m->timenow - m->NextScheduledNATOp >= 0) CheckNATMappings(m); 4520 if (m->timenow - m->NextuDNSEvent >= 0) uDNS_Tasks(m); 4521 #endif 4522 } 4523 4524 // Note about multi-threaded systems: 4525 // On a multi-threaded system, some other thread could run right after the mDNS_Unlock(), 4526 // performing mDNS API operations that change our next scheduled event time. 4527 // 4528 // On multi-threaded systems (like the current Windows implementation) that have a single main thread 4529 // calling mDNS_Execute() (and other threads allowed to call mDNS API routines) it is the responsibility 4530 // of the mDNSPlatformUnlock() routine to signal some kind of stateful condition variable that will 4531 // signal whatever blocking primitive the main thread is using, so that it will wake up and execute one 4532 // more iteration of its loop, and immediately call mDNS_Execute() again. The signal has to be stateful 4533 // in the sense that if the main thread has not yet entered its blocking primitive, then as soon as it 4534 // does, the state of the signal will be noticed, causing the blocking primitive to return immediately 4535 // without blocking. This avoids the race condition between the signal from the other thread arriving 4536 // just *before* or just *after* the main thread enters the blocking primitive. 4537 // 4538 // On multi-threaded systems (like the current Mac OS 9 implementation) that are entirely timer-driven, 4539 // with no main mDNS_Execute() thread, it is the responsibility of the mDNSPlatformUnlock() routine to 4540 // set the timer according to the m->NextScheduledEvent value, and then when the timer fires, the timer 4541 // callback function should call mDNS_Execute() (and ignore the return value, which may already be stale 4542 // by the time it gets to the timer callback function). 4543 4544 mDNS_Unlock(m); // Calling mDNS_Unlock is what gives m->NextScheduledEvent its new value 4545 return(m->NextScheduledEvent); 4546 } 4547 4548 mDNSlocal void SuspendLLQs(mDNS *m) 4549 { 4550 DNSQuestion *q; 4551 for (q = m->Questions; q; q = q->next) 4552 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->state == LLQ_Established) 4553 { q->ReqLease = 0; sendLLQRefresh(m, q); } 4554 } 4555 4556 mDNSlocal mDNSBool QuestionHasLocalAnswers(mDNS *const m, DNSQuestion *q) 4557 { 4558 AuthRecord *rr; 4559 mDNSu32 slot; 4560 AuthGroup *ag; 4561 4562 slot = AuthHashSlot(&q->qname); 4563 ag = AuthGroupForName(&m->rrauth, slot, q->qnamehash, &q->qname); 4564 if (ag) 4565 { 4566 for (rr = ag->members; rr; rr=rr->next) 4567 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME 4568 if (LORecordAnswersAddressType(rr) && LocalOnlyRecordAnswersQuestion(rr, q)) 4569 { 4570 LogInfo("QuestionHasLocalAnswers: Question %p %##s (%s) has local answer %s", q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr)); 4571 return mDNStrue; 4572 } 4573 } 4574 return mDNSfalse; 4575 } 4576 4577 // ActivateUnicastQuery() is called from three places: 4578 // 1. When a new question is created 4579 // 2. On wake from sleep 4580 // 3. When the DNS configuration changes 4581 // In case 1 we don't want to mess with our established ThisQInterval and LastQTime (ScheduleImmediately is false) 4582 // In cases 2 and 3 we do want to cause the question to be resent immediately (ScheduleImmediately is true) 4583 mDNSlocal void ActivateUnicastQuery(mDNS *const m, DNSQuestion *const question, mDNSBool ScheduleImmediately) 4584 { 4585 // For now this AutoTunnel stuff is specific to Mac OS X. 4586 // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer 4587 #if APPLE_OSX_mDNSResponder 4588 // Even though BTMM client tunnels are only useful for AAAA queries, we need to treat v4 and v6 queries equally. 4589 // Otherwise we can get the situation where the A query completes really fast (with an NXDOMAIN result) and the 4590 // caller then gives up waiting for the AAAA result while we're still in the process of setting up the tunnel. 4591 // To level the playing field, we block both A and AAAA queries while tunnel setup is in progress, and then 4592 // returns results for both at the same time. If we are looking for the _autotunnel6 record, then skip this logic 4593 // as this would trigger looking up _autotunnel6._autotunnel6 and end up failing the original query. 4594 4595 if (RRTypeIsAddressType(question->qtype) && PrivateQuery(question) && 4596 !SameDomainLabel(question->qname.c, (const mDNSu8 *)"\x0c_autotunnel6")&& question->QuestionCallback != AutoTunnelCallback) 4597 { 4598 question->NoAnswer = NoAnswer_Suspended; 4599 AddNewClientTunnel(m, question); 4600 return; 4601 } 4602 #endif // APPLE_OSX_mDNSResponder 4603 4604 if (!question->DuplicateOf) 4605 { 4606 debugf("ActivateUnicastQuery: %##s %s%s%s", 4607 question->qname.c, DNSTypeName(question->qtype), PrivateQuery(question) ? " (Private)" : "", ScheduleImmediately ? " ScheduleImmediately" : ""); 4608 question->CNAMEReferrals = 0; 4609 if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; } 4610 if (question->LongLived) 4611 { 4612 question->state = LLQ_InitialRequest; 4613 question->id = zeroOpaque64; 4614 question->servPort = zeroIPPort; 4615 if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; } 4616 } 4617 // If the question has local answers, then we don't want answers from outside 4618 if (ScheduleImmediately && !QuestionHasLocalAnswers(m, question)) 4619 { 4620 question->ThisQInterval = InitialQuestionInterval; 4621 question->LastQTime = m->timenow - question->ThisQInterval; 4622 SetNextQueryTime(m, question); 4623 } 4624 } 4625 } 4626 4627 // Caller should hold the lock 4628 mDNSexport void mDNSCoreRestartAddressQueries(mDNS *const m, mDNSBool SearchDomainsChanged, FlushCache flushCacheRecords, 4629 CallbackBeforeStartQuery BeforeStartCallback, void *context) 4630 { 4631 DNSQuestion *q; 4632 DNSQuestion *restart = mDNSNULL; 4633 4634 if (!m->mDNS_busy) LogMsg("mDNSCoreRestartAddressQueries: ERROR!! Lock not held"); 4635 4636 // 1. Flush the cache records 4637 if (flushCacheRecords) flushCacheRecords(m); 4638 4639 // 2. Even though we may have purged the cache records above, before it can generate RMV event 4640 // we are going to stop the question. Hence we need to deliver the RMV event before we 4641 // stop the question. 4642 // 4643 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the 4644 // application callback can potentially stop the current question (detected by CurrentQuestion) or 4645 // *any* other question which could be the next one that we may process here. RestartQuestion 4646 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal 4647 // if the "next" question is stopped while the CurrentQuestion is stopped 4648 4649 if (m->RestartQuestion) 4650 LogMsg("mDNSCoreRestartAddressQueries: ERROR!! m->RestartQuestion already set: %##s (%s)", 4651 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); 4652 4653 m->RestartQuestion = m->Questions; 4654 while (m->RestartQuestion) 4655 { 4656 q = m->RestartQuestion; 4657 m->RestartQuestion = q->next; 4658 // GetZoneData questions are referenced by other questions (original query that started the GetZoneData 4659 // question) through their "nta" pointer. Normally when the original query stops, it stops the 4660 // GetZoneData question and also frees the memory (See CancelGetZoneData). If we stop the GetZoneData 4661 // question followed by the original query that refers to this GetZoneData question, we will end up 4662 // freeing the GetZoneData question and then start the "freed" question at the end. 4663 4664 if (IsGetZoneDataQuestion(q)) 4665 { 4666 DNSQuestion *refq = q->next; 4667 LogInfo("mDNSCoreRestartAddressQueries: Skipping GetZoneDataQuestion %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 4668 // debug stuff, we just try to find the referencing question and don't do much with it 4669 while (refq) 4670 { 4671 if (q == &refq->nta->question) 4672 { 4673 LogInfo("mDNSCoreRestartAddressQueries: Question %p %##s (%s) referring to GetZoneDataQuestion %p, not stopping", refq, refq->qname.c, DNSTypeName(refq->qtype), q); 4674 } 4675 refq = refq->next; 4676 } 4677 continue; 4678 } 4679 4680 // This function is called when /etc/hosts changes and that could affect A, AAAA and CNAME queries 4681 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA && q->qtype != kDNSType_CNAME) continue; 4682 4683 // If the search domains did not change, then we restart all the queries. Otherwise, only 4684 // for queries for which we "might" have appended search domains ("might" because we may 4685 // find results before we apply search domains even though AppendSearchDomains is set to 1) 4686 if (!SearchDomainsChanged || q->AppendSearchDomains) 4687 { 4688 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero 4689 // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before 4690 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers). Let us say that 4691 // /etc/hosts has an A Record for web.apple.com. Any queries for web.apple.com will be answered locally. 4692 // But this can't prevent a CNAME/AAAA query to not to be sent on the wire. When it is sent on the wire, 4693 // it could create cache entries. When we are restarting queries, we can't deliver the cache RMV events 4694 // for the original query using these cache entries as ADDs were never delivered using these cache 4695 // entries and hence this order is needed. 4696 4697 // If the query is suppressed, the RMV events won't be delivered 4698 if (!CacheRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Cache Record RMV events"); continue; } 4699 4700 // SuppressQuery status does not affect questions that are answered using local records 4701 if (!LocalRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Local Record RMV events"); continue; } 4702 4703 LogInfo("mDNSCoreRestartAddressQueries: Stop question %p %##s (%s), AppendSearchDomains %d, qnameOrig %p", q, 4704 q->qname.c, DNSTypeName(q->qtype), q->AppendSearchDomains, q->qnameOrig); 4705 mDNS_StopQuery_internal(m, q); 4706 // Reset state so that it looks like it was in the beginning i.e it should look at /etc/hosts, cache 4707 // and then search domains should be appended. At the beginning, qnameOrig was NULL. 4708 if (q->qnameOrig) 4709 { 4710 LogInfo("mDNSCoreRestartAddressQueries: qnameOrig %##s", q->qnameOrig); 4711 AssignDomainName(&q->qname, q->qnameOrig); 4712 mDNSPlatformMemFree(q->qnameOrig); 4713 q->qnameOrig = mDNSNULL; 4714 q->RetryWithSearchDomains = ApplySearchDomainsFirst(q) ? 1 : 0; 4715 } 4716 q->SearchListIndex = 0; 4717 q->next = restart; 4718 restart = q; 4719 } 4720 } 4721 4722 // 3. Callback before we start the query 4723 if (BeforeStartCallback) BeforeStartCallback(m, context); 4724 4725 // 4. Restart all the stopped queries 4726 while (restart) 4727 { 4728 q = restart; 4729 restart = restart->next; 4730 q->next = mDNSNULL; 4731 LogInfo("mDNSCoreRestartAddressQueries: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 4732 mDNS_StartQuery_internal(m, q); 4733 } 4734 } 4735 4736 mDNSexport void mDNSCoreRestartQueries(mDNS *const m) 4737 { 4738 DNSQuestion *q; 4739 4740 #ifndef UNICAST_DISABLED 4741 // Retrigger all our uDNS questions 4742 if (m->CurrentQuestion) 4743 LogMsg("mDNSCoreRestartQueries: ERROR m->CurrentQuestion already set: %##s (%s)", 4744 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4745 m->CurrentQuestion = m->Questions; 4746 while (m->CurrentQuestion) 4747 { 4748 q = m->CurrentQuestion; 4749 m->CurrentQuestion = m->CurrentQuestion->next; 4750 if (!mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) ActivateUnicastQuery(m, q, mDNStrue); 4751 } 4752 #endif 4753 4754 // Retrigger all our mDNS questions 4755 for (q = m->Questions; q; q=q->next) // Scan our list of questions 4756 if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) 4757 { 4758 q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question 4759 q->RequestUnicast = 2; // Set to 2 because is decremented once *before* we check it 4760 q->LastQTime = m->timenow - q->ThisQInterval; 4761 q->RecentAnswerPkts = 0; 4762 ExpireDupSuppressInfo(q->DupSuppress, m->timenow); 4763 m->NextScheduledQuery = m->timenow; 4764 } 4765 } 4766 4767 // *************************************************************************** 4768 #if COMPILER_LIKES_PRAGMA_MARK 4769 #pragma mark - 4770 #pragma mark - Power Management (Sleep/Wake) 4771 #endif 4772 4773 mDNSexport void mDNS_UpdateAllowSleep(mDNS *const m) 4774 { 4775 #ifndef IDLESLEEPCONTROL_DISABLED 4776 mDNSBool allowSleep = mDNStrue; 4777 char reason[128]; 4778 4779 reason[0] = 0; 4780 4781 if (m->SystemSleepOnlyIfWakeOnLAN) 4782 { 4783 // Don't sleep if we are a proxy for any services 4784 if (m->ProxyRecords) 4785 { 4786 allowSleep = mDNSfalse; 4787 mDNS_snprintf(reason, sizeof(reason), "sleep proxy for %d records", m->ProxyRecords); 4788 LogInfo("Sleep disabled because we are proxying %d records", m->ProxyRecords); 4789 } 4790 4791 if (allowSleep && mDNSCoreHaveAdvertisedMulticastServices(m)) 4792 { 4793 // Scan the list of active interfaces 4794 NetworkInterfaceInfo *intf; 4795 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 4796 { 4797 if (intf->McastTxRx && !intf->Loopback) 4798 { 4799 // Disallow sleep if this interface doesn't support NetWake 4800 if (!intf->NetWake) 4801 { 4802 allowSleep = mDNSfalse; 4803 mDNS_snprintf(reason, sizeof(reason), "%s does not support NetWake", intf->ifname); 4804 LogInfo("Sleep disabled because %s does not support NetWake", intf->ifname); 4805 break; 4806 } 4807 4808 // Disallow sleep if there is no sleep proxy server 4809 if (FindSPSInCache1(m, &intf->NetWakeBrowse, mDNSNULL, mDNSNULL) == mDNSNULL) 4810 { 4811 allowSleep = mDNSfalse; 4812 mDNS_snprintf(reason, sizeof(reason), "%s does not support NetWake", intf->ifname); 4813 LogInfo("Sleep disabled because %s has no sleep proxy", intf->ifname); 4814 break; 4815 } 4816 } 4817 } 4818 } 4819 } 4820 4821 // Call the platform code to enable/disable sleep 4822 mDNSPlatformSetAllowSleep(m, allowSleep, reason); 4823 #endif /* !defined(IDLESLEEPCONTROL_DISABLED) */ 4824 } 4825 4826 mDNSlocal void SendSPSRegistrationForOwner(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id, const OwnerOptData *const owner) 4827 { 4828 const int optspace = DNSOpt_Header_Space + DNSOpt_LeaseData_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC); 4829 const int sps = intf->NextSPSAttempt / 3; 4830 AuthRecord *rr; 4831 4832 if (!intf->SPSAddr[sps].type) 4833 { 4834 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond; 4835 if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0) 4836 m->NextScheduledSPRetry = intf->NextSPSAttemptTime; 4837 LogSPS("SendSPSRegistration: %s SPS %d (%d) %##s not yet resolved", intf->ifname, intf->NextSPSAttempt, sps, intf->NetWakeResolve[sps].qname.c); 4838 goto exit; 4839 } 4840 4841 // Mark our mDNS records (not unicast records) for transfer to SPS 4842 if (mDNSOpaque16IsZero(id)) 4843 for (rr = m->ResourceRecords; rr; rr=rr->next) 4844 if (rr->resrec.RecordType > kDNSRecordTypeDeregistering) 4845 if (rr->resrec.InterfaceID == intf->InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name)))) 4846 if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner))) 4847 rr->SendRNow = mDNSInterfaceMark; // mark it now 4848 4849 while (1) 4850 { 4851 mDNSu8 *p = m->omsg.data; 4852 // To comply with RFC 2782, PutResourceRecord suppresses name compression for SRV records in unicast updates. 4853 // For now we follow that same logic for SPS registrations too. 4854 // If we decide to compress SRV records in SPS registrations in the future, we can achieve that by creating our 4855 // initial DNSMessage with h.flags set to zero, and then update it to UpdateReqFlags right before sending the packet. 4856 InitializeDNSMessage(&m->omsg.h, mDNSOpaque16IsZero(id) ? mDNS_NewMessageID(m) : id, UpdateReqFlags); 4857 4858 for (rr = m->ResourceRecords; rr; rr=rr->next) 4859 if (rr->SendRNow || (!mDNSOpaque16IsZero(id) && !AuthRecord_uDNS(rr) && mDNSSameOpaque16(rr->updateid, id) && m->timenow - (rr->LastAPTime + rr->ThisAPInterval) >= 0)) 4860 if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner))) 4861 { 4862 mDNSu8 *newptr; 4863 const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.mDNS_numUpdates ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData) - optspace; 4864 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 4865 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the 'unique' bit so PutResourceRecord will set it 4866 newptr = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit); 4867 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear 'unique' bit back to normal state 4868 if (!newptr) 4869 LogSPS("SendSPSRegistration put %s FAILED %d/%d %s", intf->ifname, p - m->omsg.data, limit - m->omsg.data, ARDisplayString(m, rr)); 4870 else 4871 { 4872 LogSPS("SendSPSRegistration put %s %s", intf->ifname, ARDisplayString(m, rr)); 4873 rr->SendRNow = mDNSNULL; 4874 rr->ThisAPInterval = mDNSPlatformOneSecond; 4875 rr->LastAPTime = m->timenow; 4876 rr->updateid = m->omsg.h.id; 4877 if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 4878 m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval); 4879 p = newptr; 4880 } 4881 } 4882 4883 if (!m->omsg.h.mDNS_numUpdates) break; 4884 else 4885 { 4886 AuthRecord opt; 4887 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 4888 opt.resrec.rrclass = NormalMaxDNSMessageData; 4889 opt.resrec.rdlength = sizeof(rdataOPT) * 2; // Two options in this OPT record 4890 opt.resrec.rdestimate = sizeof(rdataOPT) * 2; 4891 opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; 4892 opt.resrec.rdata->u.opt[0].optlen = DNSOpt_LeaseData_Space - 4; 4893 opt.resrec.rdata->u.opt[0].u.updatelease = DEFAULT_UPDATE_LEASE; 4894 if (!owner->HMAC.l[0]) // If no owner data, 4895 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[1]); // use our own interface information 4896 else // otherwise, use the owner data we were given 4897 { 4898 opt.resrec.rdata->u.opt[1].u.owner = *owner; 4899 opt.resrec.rdata->u.opt[1].opt = kDNSOpt_Owner; 4900 opt.resrec.rdata->u.opt[1].optlen = DNSOpt_Owner_Space(&owner->HMAC, &owner->IMAC) - 4; 4901 } 4902 LogSPS("SendSPSRegistration put %s %s", intf->ifname, ARDisplayString(m, &opt)); 4903 p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); 4904 if (!p) 4905 LogMsg("SendSPSRegistration: Failed to put OPT record (%d updates) %s", m->omsg.h.mDNS_numUpdates, ARDisplayString(m, &opt)); 4906 else 4907 { 4908 mStatus err; 4909 4910 LogSPS("SendSPSRegistration: Sending Update %s %d (%d) id %5d with %d records %d bytes to %#a:%d", intf->ifname, intf->NextSPSAttempt, sps, 4911 mDNSVal16(m->omsg.h.id), m->omsg.h.mDNS_numUpdates, p - m->omsg.data, &intf->SPSAddr[sps], mDNSVal16(intf->SPSPort[sps])); 4912 // if (intf->NextSPSAttempt < 5) m->omsg.h.flags = zeroID; // For simulating packet loss 4913 err = mDNSSendDNSMessage(m, &m->omsg, p, intf->InterfaceID, mDNSNULL, &intf->SPSAddr[sps], intf->SPSPort[sps], mDNSNULL, mDNSNULL); 4914 if (err) LogSPS("SendSPSRegistration: mDNSSendDNSMessage err %d", err); 4915 if (err && intf->SPSAddr[sps].type == mDNSAddrType_IPv6 && intf->NetWakeResolve[sps].ThisQInterval == -1) 4916 { 4917 LogSPS("SendSPSRegistration %d %##s failed to send to IPv6 address; will try IPv4 instead", sps, intf->NetWakeResolve[sps].qname.c); 4918 intf->NetWakeResolve[sps].qtype = kDNSType_A; 4919 mDNS_StartQuery_internal(m, &intf->NetWakeResolve[sps]); 4920 return; 4921 } 4922 } 4923 } 4924 } 4925 4926 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond * 10; // If successful, update NextSPSAttemptTime 4927 4928 exit: 4929 if (mDNSOpaque16IsZero(id) && intf->NextSPSAttempt < 8) intf->NextSPSAttempt++; 4930 } 4931 4932 mDNSlocal mDNSBool RecordIsFirstOccurrenceOfOwner(mDNS *const m, const AuthRecord *const rr) 4933 { 4934 AuthRecord *ar; 4935 for (ar = m->ResourceRecords; ar && ar != rr; ar=ar->next) 4936 if (mDNSPlatformMemSame(&rr->WakeUp, &ar->WakeUp, sizeof(rr->WakeUp))) return mDNSfalse; 4937 return mDNStrue; 4938 } 4939 4940 mDNSlocal void SendSPSRegistration(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id) 4941 { 4942 AuthRecord *ar; 4943 OwnerOptData owner = zeroOwner; 4944 4945 SendSPSRegistrationForOwner(m, intf, id, &owner); 4946 4947 for (ar = m->ResourceRecords; ar; ar=ar->next) 4948 { 4949 if (!mDNSPlatformMemSame(&owner, &ar->WakeUp, sizeof(owner)) && RecordIsFirstOccurrenceOfOwner(m, ar)) 4950 { 4951 owner = ar->WakeUp; 4952 SendSPSRegistrationForOwner(m, intf, id, &owner); 4953 } 4954 } 4955 } 4956 4957 // RetrySPSRegistrations is called from SendResponses, with the lock held 4958 mDNSlocal void RetrySPSRegistrations(mDNS *const m) 4959 { 4960 AuthRecord *rr; 4961 NetworkInterfaceInfo *intf; 4962 4963 // First make sure none of our interfaces' NextSPSAttemptTimes are inadvertently set to m->timenow + mDNSPlatformOneSecond * 10 4964 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 4965 if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10) 4966 intf->NextSPSAttemptTime++; 4967 4968 // Retry any record registrations that are due 4969 for (rr = m->ResourceRecords; rr; rr=rr->next) 4970 if (!AuthRecord_uDNS(rr) && !mDNSOpaque16IsZero(rr->updateid) && m->timenow - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 4971 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 4972 if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID) 4973 { 4974 LogSPS("RetrySPSRegistrations: %s", ARDisplayString(m, rr)); 4975 SendSPSRegistration(m, intf, rr->updateid); 4976 } 4977 4978 // For interfaces where we did an SPS registration attempt, increment intf->NextSPSAttempt 4979 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 4980 if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10 && intf->NextSPSAttempt < 8) 4981 intf->NextSPSAttempt++; 4982 } 4983 4984 mDNSlocal void NetWakeResolve(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 4985 { 4986 NetworkInterfaceInfo *intf = (NetworkInterfaceInfo *)question->QuestionContext; 4987 int sps = (int)(question - intf->NetWakeResolve); 4988 (void)m; // Unused 4989 LogSPS("NetWakeResolve: SPS: %d Add: %d %s", sps, AddRecord, RRDisplayString(m, answer)); 4990 4991 if (!AddRecord) return; // Don't care about REMOVE events 4992 if (answer->rrtype != question->qtype) return; // Don't care about CNAMEs 4993 4994 // if (answer->rrtype == kDNSType_AAAA && sps == 0) return; // To test failing to resolve sleep proxy's address 4995 4996 if (answer->rrtype == kDNSType_SRV) 4997 { 4998 // 1. Got the SRV record; now look up the target host's IPv6 link-local address 4999 mDNS_StopQuery(m, question); 5000 intf->SPSPort[sps] = answer->rdata->u.srv.port; 5001 AssignDomainName(&question->qname, &answer->rdata->u.srv.target); 5002 question->qtype = kDNSType_AAAA; 5003 mDNS_StartQuery(m, question); 5004 } 5005 else if (answer->rrtype == kDNSType_AAAA && answer->rdlength == sizeof(mDNSv6Addr) && mDNSv6AddressIsLinkLocal(&answer->rdata->u.ipv6)) 5006 { 5007 // 2. Got the target host's IPv6 link-local address; record address and initiate an SPS registration if appropriate 5008 mDNS_StopQuery(m, question); 5009 question->ThisQInterval = -1; 5010 intf->SPSAddr[sps].type = mDNSAddrType_IPv6; 5011 intf->SPSAddr[sps].ip.v6 = answer->rdata->u.ipv6; 5012 mDNS_Lock(m); 5013 if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now 5014 mDNS_Unlock(m); 5015 } 5016 else if (answer->rrtype == kDNSType_AAAA && answer->rdlength == 0) 5017 { 5018 // 3. Got negative response -- target host apparently has IPv6 disabled -- so try looking up the target host's IPv4 address(es) instead 5019 mDNS_StopQuery(m, question); 5020 LogSPS("NetWakeResolve: SPS %d %##s has no IPv6 address, will try IPv4 instead", sps, question->qname.c); 5021 question->qtype = kDNSType_A; 5022 mDNS_StartQuery(m, question); 5023 } 5024 else if (answer->rrtype == kDNSType_A && answer->rdlength == sizeof(mDNSv4Addr)) 5025 { 5026 // 4. Got an IPv4 address for the target host; record address and initiate an SPS registration if appropriate 5027 mDNS_StopQuery(m, question); 5028 question->ThisQInterval = -1; 5029 intf->SPSAddr[sps].type = mDNSAddrType_IPv4; 5030 intf->SPSAddr[sps].ip.v4 = answer->rdata->u.ipv4; 5031 mDNS_Lock(m); 5032 if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now 5033 mDNS_Unlock(m); 5034 } 5035 } 5036 5037 mDNSexport mDNSBool mDNSCoreHaveAdvertisedMulticastServices(mDNS *const m) 5038 { 5039 AuthRecord *rr; 5040 for (rr = m->ResourceRecords; rr; rr=rr->next) 5041 if (rr->resrec.rrtype == kDNSType_SRV && !AuthRecord_uDNS(rr) && !mDNSSameIPPort(rr->resrec.rdata->u.srv.port, DiscardPort)) 5042 return mDNStrue; 5043 return mDNSfalse; 5044 } 5045 5046 mDNSlocal void SendSleepGoodbyes(mDNS *const m) 5047 { 5048 AuthRecord *rr; 5049 m->SleepState = SleepState_Sleeping; 5050 5051 #ifndef UNICAST_DISABLED 5052 SleepRecordRegistrations(m); // If we have no SPS, need to deregister our uDNS records 5053 #endif /* UNICAST_DISABLED */ 5054 5055 // Mark all the records we need to deregister and send them 5056 for (rr = m->ResourceRecords; rr; rr=rr->next) 5057 if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) 5058 rr->ImmedAnswer = mDNSInterfaceMark; 5059 SendResponses(m); 5060 } 5061 5062 // BeginSleepProcessing is called, with the lock held, from either mDNS_Execute or mDNSCoreMachineSleep 5063 mDNSlocal void BeginSleepProcessing(mDNS *const m) 5064 { 5065 mDNSBool SendGoodbyes = mDNStrue; 5066 const CacheRecord *sps[3] = { mDNSNULL }; 5067 5068 m->NextScheduledSPRetry = m->timenow; 5069 5070 if (!m->SystemWakeOnLANEnabled) LogSPS("BeginSleepProcessing: m->SystemWakeOnLANEnabled is false"); 5071 else if (!mDNSCoreHaveAdvertisedMulticastServices(m)) LogSPS("BeginSleepProcessing: No advertised services"); 5072 else // If we have at least one advertised service 5073 { 5074 NetworkInterfaceInfo *intf; 5075 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 5076 { 5077 if (!intf->NetWake) LogSPS("BeginSleepProcessing: %-6s not capable of magic packet wakeup", intf->ifname); 5078 #if APPLE_OSX_mDNSResponder 5079 else if (ActivateLocalProxy(m, intf->ifname) == mStatus_NoError) 5080 { 5081 SendGoodbyes = mDNSfalse; 5082 LogSPS("BeginSleepProcessing: %-6s using local proxy", intf->ifname); 5083 // This will leave m->SleepState set to SleepState_Transferring, 5084 // which is okay because with no outstanding resolves, or updates in flight, 5085 // mDNSCoreReadyForSleep() will conclude correctly that all the updates have already completed 5086 } 5087 #endif // APPLE_OSX_mDNSResponder 5088 else 5089 { 5090 FindSPSInCache(m, &intf->NetWakeBrowse, sps); 5091 if (!sps[0]) LogSPS("BeginSleepProcessing: %-6s %#a No Sleep Proxy Server found (Next Browse Q in %d, interval %d)", 5092 intf->ifname, &intf->ip, NextQSendTime(&intf->NetWakeBrowse) - m->timenow, intf->NetWakeBrowse.ThisQInterval); 5093 else 5094 { 5095 int i; 5096 SendGoodbyes = mDNSfalse; 5097 intf->NextSPSAttempt = 0; 5098 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond; 5099 // Don't need to set m->NextScheduledSPRetry here because we already set "m->NextScheduledSPRetry = m->timenow" above 5100 for (i=0; i<3; i++) 5101 { 5102 #if ForceAlerts 5103 if (intf->SPSAddr[i].type) 5104 { LogMsg("BeginSleepProcessing: %s %d intf->SPSAddr[i].type %d", intf->ifname, i, intf->SPSAddr[i].type); *(long*)0 = 0; } 5105 if (intf->NetWakeResolve[i].ThisQInterval >= 0) 5106 { LogMsg("BeginSleepProcessing: %s %d intf->NetWakeResolve[i].ThisQInterval %d", intf->ifname, i, intf->NetWakeResolve[i].ThisQInterval); *(long*)0 = 0; } 5107 #endif 5108 intf->SPSAddr[i].type = mDNSAddrType_None; 5109 if (intf->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery(m, &intf->NetWakeResolve[i]); 5110 intf->NetWakeResolve[i].ThisQInterval = -1; 5111 if (sps[i]) 5112 { 5113 LogSPS("BeginSleepProcessing: %-6s Found Sleep Proxy Server %d TTL %d %s", intf->ifname, i, sps[i]->resrec.rroriginalttl, CRDisplayString(m, sps[i])); 5114 mDNS_SetupQuestion(&intf->NetWakeResolve[i], intf->InterfaceID, &sps[i]->resrec.rdata->u.name, kDNSType_SRV, NetWakeResolve, intf); 5115 intf->NetWakeResolve[i].ReturnIntermed = mDNStrue; 5116 mDNS_StartQuery_internal(m, &intf->NetWakeResolve[i]); 5117 } 5118 } 5119 } 5120 } 5121 } 5122 } 5123 5124 if (SendGoodbyes) // If we didn't find even one Sleep Proxy 5125 { 5126 LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server"); 5127 SendSleepGoodbyes(m); 5128 } 5129 } 5130 5131 // Call mDNSCoreMachineSleep(m, mDNStrue) when the machine is about to go to sleep. 5132 // Call mDNSCoreMachineSleep(m, mDNSfalse) when the machine is has just woken up. 5133 // Normally, the platform support layer below mDNSCore should call this, not the client layer above. 5134 mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleep) 5135 { 5136 AuthRecord *rr; 5137 5138 LogSPS("%s (old state %d) at %ld", sleep ? "Sleeping" : "Waking", m->SleepState, m->timenow); 5139 5140 if (sleep && !m->SleepState) // Going to sleep 5141 { 5142 mDNS_Lock(m); 5143 // If we're going to sleep, need to stop advertising that we're a Sleep Proxy Server 5144 if (m->SPSSocket) 5145 { 5146 mDNSu8 oldstate = m->SPSState; 5147 mDNS_DropLockBeforeCallback(); // mDNS_DeregisterService expects to be called without the lock held, so we emulate that here 5148 m->SPSState = 2; 5149 if (oldstate == 1) mDNS_DeregisterService(m, &m->SPSRecords); 5150 mDNS_ReclaimLockAfterCallback(); 5151 } 5152 5153 m->SleepState = SleepState_Transferring; 5154 if (m->SystemWakeOnLANEnabled && m->DelaySleep) 5155 { 5156 // If we just woke up moments ago, allow ten seconds for networking to stabilize before going back to sleep 5157 LogSPS("mDNSCoreMachineSleep: Re-sleeping immediately after waking; will delay for %d ticks", m->DelaySleep - m->timenow); 5158 m->SleepLimit = NonZeroTime(m->DelaySleep + mDNSPlatformOneSecond * 10); 5159 } 5160 else 5161 { 5162 m->DelaySleep = 0; 5163 m->SleepLimit = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 10); 5164 BeginSleepProcessing(m); 5165 } 5166 5167 #ifndef UNICAST_DISABLED 5168 SuspendLLQs(m); 5169 #endif 5170 mDNS_Unlock(m); 5171 // RemoveAutoTunnel6Record needs to be called outside the lock, as it grabs the lock also. 5172 #if APPLE_OSX_mDNSResponder 5173 RemoveAutoTunnel6Record(m); 5174 #endif 5175 LogSPS("mDNSCoreMachineSleep: m->SleepState %d (%s) seq %d", m->SleepState, 5176 m->SleepState == SleepState_Transferring ? "Transferring" : 5177 m->SleepState == SleepState_Sleeping ? "Sleeping" : "?", m->SleepSeqNum); 5178 } 5179 else if (!sleep) // Waking up 5180 { 5181 mDNSu32 slot; 5182 CacheGroup *cg; 5183 CacheRecord *cr; 5184 NetworkInterfaceInfo *intf; 5185 5186 mDNS_Lock(m); 5187 // Reset SleepLimit back to 0 now that we're awake again. 5188 m->SleepLimit = 0; 5189 5190 // If we were previously sleeping, but now we're not, increment m->SleepSeqNum to indicate that we're entering a new period of wakefulness 5191 if (m->SleepState != SleepState_Awake) 5192 { 5193 m->SleepState = SleepState_Awake; 5194 m->SleepSeqNum++; 5195 // If the machine wakes and then immediately tries to sleep again (e.g. a maintenance wake) 5196 // then we enforce a minimum delay of 16 seconds before we begin sleep processing. 5197 // This is to allow time for the Ethernet link to come up, DHCP to get an address, mDNS to issue queries, etc., 5198 // before we make our determination of whether there's a Sleep Proxy out there we should register with. 5199 m->DelaySleep = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 16); 5200 } 5201 5202 if (m->SPSState == 3) 5203 { 5204 m->SPSState = 0; 5205 mDNSCoreBeSleepProxyServer_internal(m, m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower); 5206 } 5207 5208 // In case we gave up waiting and went to sleep before we got an ack from the Sleep Proxy, 5209 // on wake we go through our record list and clear updateid back to zero 5210 for (rr = m->ResourceRecords; rr; rr=rr->next) rr->updateid = zeroID; 5211 5212 // ... and the same for NextSPSAttempt 5213 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) intf->NextSPSAttempt = -1; 5214 5215 // Restart unicast and multicast queries 5216 mDNSCoreRestartQueries(m); 5217 5218 // and reactivtate service registrations 5219 m->NextSRVUpdate = NonZeroTime(m->timenow + mDNSPlatformOneSecond); 5220 LogInfo("mDNSCoreMachineSleep waking: NextSRVUpdate in %d %d", m->NextSRVUpdate - m->timenow, m->timenow); 5221 5222 // 2. Re-validate our cache records 5223 FORALL_CACHERECORDS(slot, cg, cr) 5224 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForWake); 5225 5226 // 3. Retrigger probing and announcing for all our authoritative records 5227 for (rr = m->ResourceRecords; rr; rr=rr->next) 5228 if (AuthRecord_uDNS(rr)) 5229 { 5230 ActivateUnicastRegistration(m, rr); 5231 } 5232 else 5233 { 5234 if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique; 5235 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); 5236 rr->AnnounceCount = InitialAnnounceCount; 5237 rr->SendNSECNow = mDNSNULL; 5238 InitializeLastAPTime(m, rr); 5239 } 5240 5241 // 4. Refresh NAT mappings 5242 // We don't want to have to assume that all hardware can necessarily keep accurate 5243 // track of passage of time while asleep, so on wake we refresh our NAT mappings 5244 // We typically wake up with no interfaces active, so there's no need to rush to try to find our external address. 5245 // When we get a network configuration change, mDNSMacOSXNetworkChanged calls uDNS_SetupDNSConfig, which calls 5246 // mDNS_SetPrimaryInterfaceInfo, which then sets m->retryGetAddr to immediately request our external address from the NAT gateway. 5247 m->retryIntervalGetAddr = NATMAP_INIT_RETRY; 5248 m->retryGetAddr = m->timenow + mDNSPlatformOneSecond * 5; 5249 LogInfo("mDNSCoreMachineSleep: retryGetAddr in %d %d", m->retryGetAddr - m->timenow, m->timenow); 5250 RecreateNATMappings(m); 5251 mDNS_Unlock(m); 5252 } 5253 } 5254 5255 mDNSexport mDNSBool mDNSCoreReadyForSleep(mDNS *m, mDNSs32 now) 5256 { 5257 DNSQuestion *q; 5258 AuthRecord *rr; 5259 NetworkInterfaceInfo *intf; 5260 5261 mDNS_Lock(m); 5262 5263 if (m->DelaySleep) goto notready; 5264 5265 // If we've not hit the sleep limit time, and it's not time for our next retry, we can skip these checks 5266 if (m->SleepLimit - now > 0 && m->NextScheduledSPRetry - now > 0) goto notready; 5267 5268 m->NextScheduledSPRetry = now + 0x40000000UL; 5269 5270 // See if we might need to retransmit any lost Sleep Proxy Registrations 5271 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 5272 if (intf->NextSPSAttempt >= 0) 5273 { 5274 if (now - intf->NextSPSAttemptTime >= 0) 5275 { 5276 LogSPS("mDNSCoreReadyForSleep: retrying for %s SPS %d try %d", 5277 intf->ifname, intf->NextSPSAttempt/3, intf->NextSPSAttempt); 5278 SendSPSRegistration(m, intf, zeroID); 5279 // Don't need to "goto notready" here, because if we do still have record registrations 5280 // that have not been acknowledged yet, we'll catch that in the record list scan below. 5281 } 5282 else 5283 if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0) 5284 m->NextScheduledSPRetry = intf->NextSPSAttemptTime; 5285 } 5286 5287 // Scan list of interfaces, and see if we're still waiting for any sleep proxy resolves to complete 5288 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 5289 { 5290 int sps = (intf->NextSPSAttempt == 0) ? 0 : (intf->NextSPSAttempt-1)/3; 5291 if (intf->NetWakeResolve[sps].ThisQInterval >= 0) 5292 { 5293 LogSPS("mDNSCoreReadyForSleep: waiting for SPS Resolve %s %##s (%s)", 5294 intf->ifname, intf->NetWakeResolve[sps].qname.c, DNSTypeName(intf->NetWakeResolve[sps].qtype)); 5295 goto spsnotready; 5296 } 5297 } 5298 5299 // Scan list of registered records 5300 for (rr = m->ResourceRecords; rr; rr = rr->next) 5301 if (!AuthRecord_uDNS(rr)) 5302 if (!mDNSOpaque16IsZero(rr->updateid)) 5303 { LogSPS("mDNSCoreReadyForSleep: waiting for SPS Update ID %d %s", mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto spsnotready; } 5304 5305 // Scan list of private LLQs, and make sure they've all completed their handshake with the server 5306 for (q = m->Questions; q; q = q->next) 5307 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->ReqLease == 0 && q->tcp) 5308 { 5309 LogSPS("mDNSCoreReadyForSleep: waiting for LLQ %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 5310 goto notready; 5311 } 5312 5313 // Scan list of registered records 5314 for (rr = m->ResourceRecords; rr; rr = rr->next) 5315 if (AuthRecord_uDNS(rr)) 5316 { 5317 if (rr->state == regState_Refresh && rr->tcp) 5318 { LogSPS("mDNSCoreReadyForSleep: waiting for Record Update ID %d %s", mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto notready; } 5319 #if APPLE_OSX_mDNSResponder 5320 if (!RecordReadyForSleep(m, rr)) { LogSPS("mDNSCoreReadyForSleep: waiting for %s", ARDisplayString(m, rr)); goto notready; } 5321 #endif 5322 } 5323 5324 mDNS_Unlock(m); 5325 return mDNStrue; 5326 5327 spsnotready: 5328 5329 // If we failed to complete sleep proxy registration within ten seconds, we give up on that 5330 // and allow up to ten seconds more to complete wide-area deregistration instead 5331 if (now - m->SleepLimit >= 0) 5332 { 5333 LogMsg("Failed to register with SPS, now sending goodbyes"); 5334 5335 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 5336 if (intf->NetWakeBrowse.ThisQInterval >= 0) 5337 { 5338 LogSPS("ReadyForSleep mDNS_DeactivateNetWake %s %##s (%s)", 5339 intf->ifname, intf->NetWakeResolve[0].qname.c, DNSTypeName(intf->NetWakeResolve[0].qtype)); 5340 mDNS_DeactivateNetWake_internal(m, intf); 5341 } 5342 5343 for (rr = m->ResourceRecords; rr; rr = rr->next) 5344 if (!AuthRecord_uDNS(rr)) 5345 if (!mDNSOpaque16IsZero(rr->updateid)) 5346 { 5347 LogSPS("ReadyForSleep clearing updateid for %s", ARDisplayString(m, rr)); 5348 rr->updateid = zeroID; 5349 } 5350 5351 // We'd really like to allow up to ten seconds more here, 5352 // but if we don't respond to the sleep notification within 30 seconds 5353 // we'll be put back to sleep forcibly without the chance to schedule the next maintenance wake. 5354 // Right now we wait 16 sec after wake for all the interfaces to come up, then we wait up to 10 seconds 5355 // more for SPS resolves and record registrations to complete, which puts us at 26 seconds. 5356 // If we allow just one more second to send our goodbyes, that puts us at 27 seconds. 5357 m->SleepLimit = now + mDNSPlatformOneSecond * 1; 5358 5359 SendSleepGoodbyes(m); 5360 } 5361 5362 notready: 5363 mDNS_Unlock(m); 5364 return mDNSfalse; 5365 } 5366 5367 mDNSexport mDNSs32 mDNSCoreIntervalToNextWake(mDNS *const m, mDNSs32 now) 5368 { 5369 AuthRecord *ar; 5370 5371 // Even when we have no wake-on-LAN-capable interfaces, or we failed to find a sleep proxy, or we have other 5372 // failure scenarios, we still want to wake up in at most 120 minutes, to see if the network environment has changed. 5373 // E.g. we might wake up and find no wireless network because the base station got rebooted just at that moment, 5374 // and if that happens we don't want to just give up and go back to sleep and never try again. 5375 mDNSs32 e = now + (120 * 60 * mDNSPlatformOneSecond); // Sleep for at most 120 minutes 5376 5377 NATTraversalInfo *nat; 5378 for (nat = m->NATTraversals; nat; nat=nat->next) 5379 if (nat->Protocol && nat->ExpiryTime && nat->ExpiryTime - now > mDNSPlatformOneSecond*4) 5380 { 5381 mDNSs32 t = nat->ExpiryTime - (nat->ExpiryTime - now) / 10; // Wake up when 90% of the way to the expiry time 5382 if (e - t > 0) e = t; 5383 LogSPS("ComputeWakeTime: %p %s Int %5d Ext %5d Err %d Retry %5d Interval %5d Expire %5d Wake %5d", 5384 nat, nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP", 5385 mDNSVal16(nat->IntPort), mDNSVal16(nat->ExternalPort), nat->Result, 5386 nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0, 5387 nat->retryInterval / mDNSPlatformOneSecond, 5388 nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0, 5389 (t - now) / mDNSPlatformOneSecond); 5390 } 5391 5392 // This loop checks both the time we need to renew wide-area registrations, 5393 // and the time we need to renew Sleep Proxy registrations 5394 for (ar = m->ResourceRecords; ar; ar = ar->next) 5395 if (ar->expire && ar->expire - now > mDNSPlatformOneSecond*4) 5396 { 5397 mDNSs32 t = ar->expire - (ar->expire - now) / 10; // Wake up when 90% of the way to the expiry time 5398 if (e - t > 0) e = t; 5399 LogSPS("ComputeWakeTime: %p Int %7d Next %7d Expire %7d Wake %7d %s", 5400 ar, ar->ThisAPInterval / mDNSPlatformOneSecond, 5401 (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond, 5402 ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0, 5403 (t - now) / mDNSPlatformOneSecond, ARDisplayString(m, ar)); 5404 } 5405 5406 return(e - now); 5407 } 5408 5409 // *************************************************************************** 5410 #if COMPILER_LIKES_PRAGMA_MARK 5411 #pragma mark - 5412 #pragma mark - Packet Reception Functions 5413 #endif 5414 5415 #define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo) 5416 5417 mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end, 5418 const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, DNSMessage *const response, AuthRecord *ResponseRecords) 5419 { 5420 mDNSu8 *responseptr = response->data; 5421 const mDNSu8 *const limit = response->data + sizeof(response->data); 5422 const mDNSu8 *ptr = query->data; 5423 AuthRecord *rr; 5424 mDNSu32 maxttl = 0x70000000; 5425 int i; 5426 5427 // Initialize the response fields so we can answer the questions 5428 InitializeDNSMessage(&response->h, query->h.id, ResponseFlags); 5429 5430 // *** 5431 // *** 1. Write out the list of questions we are actually going to answer with this packet 5432 // *** 5433 if (LegacyQuery) 5434 { 5435 maxttl = kStaticCacheTTL; 5436 for (i=0; i<query->h.numQuestions; i++) // For each question... 5437 { 5438 DNSQuestion q; 5439 ptr = getQuestion(query, ptr, end, InterfaceID, &q); // get the question... 5440 if (!ptr) return(mDNSNULL); 5441 5442 for (rr=ResponseRecords; rr; rr=rr->NextResponse) // and search our list of proposed answers 5443 { 5444 if (rr->NR_AnswerTo == ptr) // If we're going to generate a record answering this question 5445 { // then put the question in the question section 5446 responseptr = putQuestion(response, responseptr, limit, &q.qname, q.qtype, q.qclass); 5447 if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL); } 5448 break; // break out of the ResponseRecords loop, and go on to the next question 5449 } 5450 } 5451 } 5452 5453 if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL); } 5454 } 5455 5456 // *** 5457 // *** 2. Write Answers 5458 // *** 5459 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 5460 if (rr->NR_AnswerTo) 5461 { 5462 mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAnswers, &rr->resrec, 5463 maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl); 5464 if (p) responseptr = p; 5465 else { debugf("GenerateUnicastResponse: Ran out of space for answers!"); response->h.flags.b[0] |= kDNSFlag0_TC; } 5466 } 5467 5468 // *** 5469 // *** 3. Write Additionals 5470 // *** 5471 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 5472 if (rr->NR_AdditionalTo && !rr->NR_AnswerTo) 5473 { 5474 mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAdditionals, &rr->resrec, 5475 maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl); 5476 if (p) responseptr = p; 5477 else debugf("GenerateUnicastResponse: No more space for additionals"); 5478 } 5479 5480 return(responseptr); 5481 } 5482 5483 // AuthRecord *our is our Resource Record 5484 // CacheRecord *pkt is the Resource Record from the response packet we've witnessed on the network 5485 // Returns 0 if there is no conflict 5486 // Returns +1 if there was a conflict and we won 5487 // Returns -1 if there was a conflict and we lost and have to rename 5488 mDNSlocal int CompareRData(const AuthRecord *const our, const CacheRecord *const pkt) 5489 { 5490 mDNSu8 ourdata[256], *ourptr = ourdata, *ourend; 5491 mDNSu8 pktdata[256], *pktptr = pktdata, *pktend; 5492 if (!our) { LogMsg("CompareRData ERROR: our is NULL"); return(+1); } 5493 if (!pkt) { LogMsg("CompareRData ERROR: pkt is NULL"); return(+1); } 5494 5495 ourend = putRData(mDNSNULL, ourdata, ourdata + sizeof(ourdata), &our->resrec); 5496 pktend = putRData(mDNSNULL, pktdata, pktdata + sizeof(pktdata), &pkt->resrec); 5497 while (ourptr < ourend && pktptr < pktend && *ourptr == *pktptr) { ourptr++; pktptr++; } 5498 if (ourptr >= ourend && pktptr >= pktend) return(0); // If data identical, not a conflict 5499 5500 if (ourptr >= ourend) return(-1); // Our data ran out first; We lost 5501 if (pktptr >= pktend) return(+1); // Packet data ran out first; We won 5502 if (*pktptr > *ourptr) return(-1); // Our data is numerically lower; We lost 5503 if (*pktptr < *ourptr) return(+1); // Packet data is numerically lower; We won 5504 5505 LogMsg("CompareRData ERROR: Invalid state"); 5506 return(-1); 5507 } 5508 5509 // See if we have an authoritative record that's identical to this packet record, 5510 // whose canonical DependentOn record is the specified master record. 5511 // The DependentOn pointer is typically used for the TXT record of service registrations 5512 // It indicates that there is no inherent conflict detection for the TXT record 5513 // -- it depends on the SRV record to resolve name conflicts 5514 // If we find any identical ResourceRecords in our authoritative list, then follow their DependentOn 5515 // pointer chain (if any) to make sure we reach the canonical DependentOn record 5516 // If the record has no DependentOn, then just return that record's pointer 5517 // Returns NULL if we don't have any local RRs that are identical to the one from the packet 5518 mDNSlocal mDNSBool MatchDependentOn(const mDNS *const m, const CacheRecord *const pktrr, const AuthRecord *const master) 5519 { 5520 const AuthRecord *r1; 5521 for (r1 = m->ResourceRecords; r1; r1=r1->next) 5522 { 5523 if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec)) 5524 { 5525 const AuthRecord *r2 = r1; 5526 while (r2->DependentOn) r2 = r2->DependentOn; 5527 if (r2 == master) return(mDNStrue); 5528 } 5529 } 5530 for (r1 = m->DuplicateRecords; r1; r1=r1->next) 5531 { 5532 if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec)) 5533 { 5534 const AuthRecord *r2 = r1; 5535 while (r2->DependentOn) r2 = r2->DependentOn; 5536 if (r2 == master) return(mDNStrue); 5537 } 5538 } 5539 return(mDNSfalse); 5540 } 5541 5542 // Find the canonical RRSet pointer for this RR received in a packet. 5543 // If we find any identical AuthRecord in our authoritative list, then follow its RRSet 5544 // pointers (if any) to make sure we return the canonical member of this name/type/class 5545 // Returns NULL if we don't have any local RRs that are identical to the one from the packet 5546 mDNSlocal const AuthRecord *FindRRSet(const mDNS *const m, const CacheRecord *const pktrr) 5547 { 5548 const AuthRecord *rr; 5549 for (rr = m->ResourceRecords; rr; rr=rr->next) 5550 { 5551 if (IdenticalResourceRecord(&rr->resrec, &pktrr->resrec)) 5552 { 5553 while (rr->RRSet && rr != rr->RRSet) rr = rr->RRSet; 5554 return(rr); 5555 } 5556 } 5557 return(mDNSNULL); 5558 } 5559 5560 // PacketRRConflict is called when we've received an RR (pktrr) which has the same name 5561 // as one of our records (our) but different rdata. 5562 // 1. If our record is not a type that's supposed to be unique, we don't care. 5563 // 2a. If our record is marked as dependent on some other record for conflict detection, ignore this one. 5564 // 2b. If the packet rr exactly matches one of our other RRs, and *that* record's DependentOn pointer 5565 // points to our record, ignore this conflict (e.g. the packet record matches one of our 5566 // TXT records, and that record is marked as dependent on 'our', its SRV record). 5567 // 3. If we have some *other* RR that exactly matches the one from the packet, and that record and our record 5568 // are members of the same RRSet, then this is not a conflict. 5569 mDNSlocal mDNSBool PacketRRConflict(const mDNS *const m, const AuthRecord *const our, const CacheRecord *const pktrr) 5570 { 5571 // If not supposed to be unique, not a conflict 5572 if (!(our->resrec.RecordType & kDNSRecordTypeUniqueMask)) return(mDNSfalse); 5573 5574 // If a dependent record, not a conflict 5575 if (our->DependentOn || MatchDependentOn(m, pktrr, our)) return(mDNSfalse); 5576 else 5577 { 5578 // If the pktrr matches a member of ourset, not a conflict 5579 const AuthRecord *ourset = our->RRSet ? our->RRSet : our; 5580 const AuthRecord *pktset = FindRRSet(m, pktrr); 5581 if (pktset == ourset) return(mDNSfalse); 5582 5583 // For records we're proxying, where we don't know the full 5584 // relationship between the records, having any matching record 5585 // in our AuthRecords list is sufficient evidence of non-conflict 5586 if (our->WakeUp.HMAC.l[0] && pktset) return(mDNSfalse); 5587 } 5588 5589 // Okay, this is a conflict 5590 return(mDNStrue); 5591 } 5592 5593 // Note: ResolveSimultaneousProbe calls mDNS_Deregister_internal which can call a user callback, which may change 5594 // the record list and/or question list. 5595 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 5596 mDNSlocal void ResolveSimultaneousProbe(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end, 5597 DNSQuestion *q, AuthRecord *our) 5598 { 5599 int i; 5600 const mDNSu8 *ptr = LocateAuthorities(query, end); 5601 mDNSBool FoundUpdate = mDNSfalse; 5602 5603 for (i = 0; i < query->h.numAuthorities; i++) 5604 { 5605 ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 5606 if (!ptr) break; 5607 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && ResourceRecordAnswersQuestion(&m->rec.r.resrec, q)) 5608 { 5609 FoundUpdate = mDNStrue; 5610 if (PacketRRConflict(m, our, &m->rec.r)) 5611 { 5612 int result = (int)our->resrec.rrclass - (int)m->rec.r.resrec.rrclass; 5613 if (!result) result = (int)our->resrec.rrtype - (int)m->rec.r.resrec.rrtype; 5614 if (!result) result = CompareRData(our, &m->rec.r); 5615 if (result) 5616 { 5617 const char *const msg = (result < 0) ? "lost:" : (result > 0) ? "won: " : "tie: "; 5618 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); 5619 LogMsg("ResolveSimultaneousProbe: %p Our Record %d %s %08lX %s", our->resrec.InterfaceID, our->ProbeCount, msg, our->resrec.rdatahash, ARDisplayString(m, our)); 5620 } 5621 // 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. 5622 // Instead we pause for one second, to give the other host (if real) a chance to establish its name, and then try probing again. 5623 // If there really is another live host out there with the same name, it will answer our probes and we'll then rename. 5624 if (result < 0) 5625 { 5626 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond); 5627 our->ProbeCount = DefaultProbeCountForTypeUnique; 5628 our->AnnounceCount = InitialAnnounceCount; 5629 InitializeLastAPTime(m, our); 5630 goto exit; 5631 } 5632 } 5633 #if 0 5634 else 5635 { 5636 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); 5637 LogMsg("ResolveSimultaneousProbe: %p Our Record %d ign: %08lX %s", our->resrec.InterfaceID, our->ProbeCount, our->resrec.rdatahash, ARDisplayString(m, our)); 5638 } 5639 #endif 5640 } 5641 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 5642 } 5643 if (!FoundUpdate) 5644 LogInfo("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name->c, DNSTypeName(our->resrec.rrtype)); 5645 exit: 5646 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 5647 } 5648 5649 mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, const ResourceRecord *const pktrr) 5650 { 5651 mDNSu32 slot = HashSlot(pktrr->name); 5652 CacheGroup *cg = CacheGroupForRecord(m, slot, pktrr); 5653 CacheRecord *rr; 5654 mDNSBool match; 5655 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 5656 { 5657 match = !pktrr->InterfaceID ? pktrr->rDNSServer == rr->resrec.rDNSServer : pktrr->InterfaceID == rr->resrec.InterfaceID; 5658 if (match && IdenticalSameNameRecord(pktrr, &rr->resrec)) break; 5659 } 5660 return(rr); 5661 } 5662 5663 // Called from mDNSCoreReceiveUpdate when we get a sleep proxy registration request, 5664 // to check our lists and discard any stale duplicates of this record we already have 5665 mDNSlocal void ClearIdenticalProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist) 5666 { 5667 if (m->CurrentRecord) 5668 LogMsg("ClearIdenticalProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 5669 m->CurrentRecord = thelist; 5670 while (m->CurrentRecord) 5671 { 5672 AuthRecord *const rr = m->CurrentRecord; 5673 if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) 5674 if (IdenticalResourceRecord(&rr->resrec, &m->rec.r.resrec)) 5675 { 5676 LogSPS("ClearIdenticalProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s", 5677 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); 5678 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host 5679 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it 5680 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 5681 SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID); 5682 } 5683 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 5684 // new records could have been added to the end of the list as a result of that call. 5685 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 5686 m->CurrentRecord = rr->next; 5687 } 5688 } 5689 5690 // Called from ProcessQuery when we get an mDNS packet with an owner record in it 5691 mDNSlocal void ClearProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist) 5692 { 5693 if (m->CurrentRecord) 5694 LogMsg("ClearProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 5695 m->CurrentRecord = thelist; 5696 while (m->CurrentRecord) 5697 { 5698 AuthRecord *const rr = m->CurrentRecord; 5699 if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) 5700 if (owner->seq != rr->WakeUp.seq || m->timenow - rr->TimeRcvd > mDNSPlatformOneSecond * 60) 5701 { 5702 if (rr->AddressProxy.type == mDNSAddrType_IPv6) 5703 { 5704 // We don't do this here because we know that the host is waking up at this point, so we don't send 5705 // Unsolicited Neighbor Advertisements -- even Neighbor Advertisements agreeing with what the host should be 5706 // saying itself -- because it can cause some IPv6 stacks to falsely conclude that there's an address conflict. 5707 #if MDNS_USE_Unsolicited_Neighbor_Advertisements 5708 LogSPS("NDP Announcement -- Releasing traffic for H-MAC %.6a I-MAC %.6a %s", 5709 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); 5710 SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, &rr->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth); 5711 #endif 5712 } 5713 LogSPS("ClearProxyRecords: Removing %3d AC %2d %02X H-MAC %.6a I-MAC %.6a %d %d %s", 5714 m->ProxyRecords, rr->AnnounceCount, rr->resrec.RecordType, 5715 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); 5716 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) rr->resrec.RecordType = kDNSRecordTypeShared; 5717 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host 5718 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it, since real host is now back and functional 5719 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 5720 SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID); 5721 } 5722 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 5723 // new records could have been added to the end of the list as a result of that call. 5724 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 5725 m->CurrentRecord = rr->next; 5726 } 5727 } 5728 5729 // ProcessQuery examines a received query to see if we have any answers to give 5730 mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end, 5731 const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast, 5732 mDNSBool QueryWasLocalUnicast, DNSMessage *const response) 5733 { 5734 mDNSBool FromLocalSubnet = srcaddr && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); 5735 AuthRecord *ResponseRecords = mDNSNULL; 5736 AuthRecord **nrp = &ResponseRecords; 5737 CacheRecord *ExpectedAnswers = mDNSNULL; // Records in our cache we expect to see updated 5738 CacheRecord **eap = &ExpectedAnswers; 5739 DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet 5740 DNSQuestion **dqp = &DupQuestions; 5741 mDNSs32 delayresponse = 0; 5742 mDNSBool SendLegacyResponse = mDNSfalse; 5743 const mDNSu8 *ptr; 5744 mDNSu8 *responseptr = mDNSNULL; 5745 AuthRecord *rr; 5746 int i; 5747 5748 // *** 5749 // *** 1. Look in Additional Section for an OPT record 5750 // *** 5751 ptr = LocateOptRR(query, end, DNSOpt_OwnerData_ID_Space); 5752 if (ptr) 5753 { 5754 ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAdd, &m->rec); 5755 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) 5756 { 5757 const rdataOPT *opt; 5758 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 5759 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently 5760 // delete all our own AuthRecords (which are identified by having zero MAC tags on them). 5761 for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++) 5762 if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0]) 5763 { 5764 ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords); 5765 ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords); 5766 } 5767 } 5768 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 5769 } 5770 5771 // *** 5772 // *** 2. Parse Question Section and mark potential answers 5773 // *** 5774 ptr = query->data; 5775 for (i=0; i<query->h.numQuestions; i++) // For each question... 5776 { 5777 mDNSBool QuestionNeedsMulticastResponse; 5778 int NumAnswersForThisQuestion = 0; 5779 AuthRecord *NSECAnswer = mDNSNULL; 5780 DNSQuestion pktq, *q; 5781 ptr = getQuestion(query, ptr, end, InterfaceID, &pktq); // get the question... 5782 if (!ptr) goto exit; 5783 5784 // The only queries that *need* a multicast response are: 5785 // * Queries sent via multicast 5786 // * from port 5353 5787 // * that don't have the kDNSQClass_UnicastResponse bit set 5788 // These queries need multicast responses because other clients will: 5789 // * suppress their own identical questions when they see these questions, and 5790 // * expire their cache records if they don't see the expected responses 5791 // For other queries, we may still choose to send the occasional multicast response anyway, 5792 // to keep our neighbours caches warm, and for ongoing conflict detection. 5793 QuestionNeedsMulticastResponse = QueryWasMulticast && !LegacyQuery && !(pktq.qclass & kDNSQClass_UnicastResponse); 5794 // Clear the UnicastResponse flag -- don't want to confuse the rest of the code that follows later 5795 pktq.qclass &= ~kDNSQClass_UnicastResponse; 5796 5797 // Note: We use the m->CurrentRecord mechanism here because calling ResolveSimultaneousProbe 5798 // can result in user callbacks which may change the record list and/or question list. 5799 // Also note: we just mark potential answer records here, without trying to build the 5800 // "ResponseRecords" list, because we don't want to risk user callbacks deleting records 5801 // from that list while we're in the middle of trying to build it. 5802 if (m->CurrentRecord) 5803 LogMsg("ProcessQuery ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 5804 m->CurrentRecord = m->ResourceRecords; 5805 while (m->CurrentRecord) 5806 { 5807 rr = m->CurrentRecord; 5808 m->CurrentRecord = rr->next; 5809 if (AnyTypeRecordAnswersQuestion(&rr->resrec, &pktq) && (QueryWasMulticast || QueryWasLocalUnicast || rr->AllowRemoteQuery)) 5810 { 5811 if (RRTypeAnswersQuestionType(&rr->resrec, pktq.qtype)) 5812 { 5813 if (rr->resrec.RecordType == kDNSRecordTypeUnique) 5814 ResolveSimultaneousProbe(m, query, end, &pktq, rr); 5815 else if (ResourceRecordIsValidAnswer(rr)) 5816 { 5817 NumAnswersForThisQuestion++; 5818 // Note: We should check here if this is a probe-type query, and if so, generate an immediate 5819 // unicast answer back to the source, because timeliness in answering probes is important. 5820 5821 // Notes: 5822 // NR_AnswerTo pointing into query packet means "answer via immediate legacy unicast" (may *also* choose to multicast) 5823 // NR_AnswerTo == (mDNSu8*)~1 means "answer via delayed unicast" (to modern querier; may promote to multicast instead) 5824 // NR_AnswerTo == (mDNSu8*)~0 means "definitely answer via multicast" (can't downgrade to unicast later) 5825 // If we're not multicasting this record because the kDNSQClass_UnicastResponse bit was set, 5826 // but the multicast querier is not on a matching subnet (e.g. because of overlaid subnets on one link) 5827 // then we'll multicast it anyway (if we unicast, the receiver will ignore it because it has an apparently non-local source) 5828 if (QuestionNeedsMulticastResponse || (!FromLocalSubnet && QueryWasMulticast && !LegacyQuery)) 5829 { 5830 // We only mark this question for sending if it is at least one second since the last time we multicast it 5831 // on this interface. If it is more than a second, or LastMCInterface is different, then we may multicast it. 5832 // This is to guard against the case where someone blasts us with queries as fast as they can. 5833 if (m->timenow - (rr->LastMCTime + mDNSPlatformOneSecond) >= 0 || 5834 (rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID)) 5835 rr->NR_AnswerTo = (mDNSu8*)~0; 5836 } 5837 else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = LegacyQuery ? ptr : (mDNSu8*)~1; 5838 } 5839 } 5840 else if ((rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && ResourceRecordIsValidAnswer(rr)) 5841 { 5842 // If we don't have any answers for this question, but we do own another record with the same name, 5843 // then we'll want to mark it to generate an NSEC record on this interface 5844 if (!NSECAnswer) NSECAnswer = rr; 5845 } 5846 } 5847 } 5848 5849 if (NumAnswersForThisQuestion == 0 && NSECAnswer) 5850 { 5851 NumAnswersForThisQuestion++; 5852 NSECAnswer->SendNSECNow = InterfaceID; 5853 m->NextScheduledResponse = m->timenow; 5854 } 5855 5856 // If we couldn't answer this question, someone else might be able to, 5857 // so use random delay on response to reduce collisions 5858 if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms 5859 5860 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 5861 if (QuestionNeedsMulticastResponse) 5862 #else 5863 // We only do the following accelerated cache expiration and duplicate question suppression processing 5864 // for non-truncated multicast queries with multicast responses. 5865 // For any query generating a unicast response we don't do this because we can't assume we will see the response. 5866 // For truncated queries we don't do this because a response we're expecting might be suppressed by a subsequent 5867 // known-answer packet, and when there's packet loss we can't safely assume we'll receive *all* known-answer packets. 5868 if (QuestionNeedsMulticastResponse && !(query->h.flags.b[0] & kDNSFlag0_TC)) 5869 #endif 5870 { 5871 const mDNSu32 slot = HashSlot(&pktq.qname); 5872 CacheGroup *cg = CacheGroupForName(m, slot, pktq.qnamehash, &pktq.qname); 5873 CacheRecord *cr; 5874 5875 // Make a list indicating which of our own cache records we expect to see updated as a result of this query 5876 // Note: Records larger than 1K are not habitually multicast, so don't expect those to be updated 5877 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 5878 if (!(query->h.flags.b[0] & kDNSFlag0_TC)) 5879 #endif 5880 for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next) 5881 if (SameNameRecordAnswersQuestion(&cr->resrec, &pktq) && cr->resrec.rdlength <= SmallRecordLimit) 5882 if (!cr->NextInKAList && eap != &cr->NextInKAList) 5883 { 5884 *eap = cr; 5885 eap = &cr->NextInKAList; 5886 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 5887 if (cr->MPUnansweredQ == 0 || m->timenow - cr->MPLastUnansweredQT >= mDNSPlatformOneSecond) 5888 { 5889 // Although MPUnansweredQ is only really used for multi-packet query processing, 5890 // we increment it for both single-packet and multi-packet queries, so that it stays in sync 5891 // with the MPUnansweredKA value, which by necessity is incremented for both query types. 5892 cr->MPUnansweredQ++; 5893 cr->MPLastUnansweredQT = m->timenow; 5894 cr->MPExpectingKA = mDNStrue; 5895 } 5896 #endif 5897 } 5898 5899 // Check if this question is the same as any of mine. 5900 // We only do this for non-truncated queries. Right now it would be too complicated to try 5901 // to keep track of duplicate suppression state between multiple packets, especially when we 5902 // can't guarantee to receive all of the Known Answer packets that go with a particular query. 5903 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 5904 if (!(query->h.flags.b[0] & kDNSFlag0_TC)) 5905 #endif 5906 for (q = m->Questions; q; q=q->next) 5907 if (!q->Target.type && ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4) 5908 if (!q->InterfaceID || q->InterfaceID == InterfaceID) 5909 if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList) 5910 if (q->qtype == pktq.qtype && 5911 q->qclass == pktq.qclass && 5912 q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname)) 5913 { *dqp = q; dqp = &q->NextInDQList; } 5914 } 5915 } 5916 5917 // *** 5918 // *** 3. Now we can safely build the list of marked answers 5919 // *** 5920 for (rr = m->ResourceRecords; rr; rr=rr->next) // Now build our list of potential answers 5921 if (rr->NR_AnswerTo) // If we marked the record... 5922 AddRecordToResponseList(&nrp, rr, mDNSNULL); // ... add it to the list 5923 5924 // *** 5925 // *** 4. Add additional records 5926 // *** 5927 AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID); 5928 5929 // *** 5930 // *** 5. Parse Answer Section and cancel any records disallowed by Known-Answer list 5931 // *** 5932 for (i=0; i<query->h.numAnswers; i++) // For each record in the query's answer section... 5933 { 5934 // Get the record... 5935 CacheRecord *ourcacherr; 5936 ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &m->rec); 5937 if (!ptr) goto exit; 5938 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) 5939 { 5940 // See if this Known-Answer suppresses any of our currently planned answers 5941 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 5942 if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&m->rec.r, rr)) 5943 { rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; } 5944 5945 // See if this Known-Answer suppresses any previously scheduled answers (for multi-packet KA suppression) 5946 for (rr=m->ResourceRecords; rr; rr=rr->next) 5947 { 5948 // If we're planning to send this answer on this interface, and only on this interface, then allow KA suppression 5949 if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&m->rec.r, rr)) 5950 { 5951 if (srcaddr->type == mDNSAddrType_IPv4) 5952 { 5953 if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zerov4Addr; 5954 } 5955 else if (srcaddr->type == mDNSAddrType_IPv6) 5956 { 5957 if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr; 5958 } 5959 if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester)) 5960 { 5961 rr->ImmedAnswer = mDNSNULL; 5962 rr->ImmedUnicast = mDNSfalse; 5963 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 5964 LogMsg("Suppressed after%4d: %s", m->timenow - rr->ImmedAnswerMarkTime, ARDisplayString(m, rr)); 5965 #endif 5966 } 5967 } 5968 } 5969 5970 ourcacherr = FindIdenticalRecordInCache(m, &m->rec.r.resrec); 5971 5972 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 5973 // See if this Known-Answer suppresses any answers we were expecting for our cache records. We do this always, 5974 // 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). 5975 if (ourcacherr && ourcacherr->MPExpectingKA && m->timenow - ourcacherr->MPLastUnansweredQT < mDNSPlatformOneSecond) 5976 { 5977 ourcacherr->MPUnansweredKA++; 5978 ourcacherr->MPExpectingKA = mDNSfalse; 5979 } 5980 #endif 5981 5982 // Having built our ExpectedAnswers list from the questions in this packet, we then remove 5983 // any records that are suppressed by the Known Answer list in this packet. 5984 eap = &ExpectedAnswers; 5985 while (*eap) 5986 { 5987 CacheRecord *cr = *eap; 5988 if (cr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&m->rec.r.resrec, &cr->resrec)) 5989 { *eap = cr->NextInKAList; cr->NextInKAList = mDNSNULL; } 5990 else eap = &cr->NextInKAList; 5991 } 5992 5993 // See if this Known-Answer is a surprise to us. If so, we shouldn't suppress our own query. 5994 if (!ourcacherr) 5995 { 5996 dqp = &DupQuestions; 5997 while (*dqp) 5998 { 5999 DNSQuestion *q = *dqp; 6000 if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q)) 6001 { *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; } 6002 else dqp = &q->NextInDQList; 6003 } 6004 } 6005 } 6006 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 6007 } 6008 6009 // *** 6010 // *** 6. Cancel any additionals that were added because of now-deleted records 6011 // *** 6012 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 6013 if (rr->NR_AdditionalTo && !MustSendRecord(rr->NR_AdditionalTo)) 6014 { rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; } 6015 6016 // *** 6017 // *** 7. Mark the send flags on the records we plan to send 6018 // *** 6019 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 6020 { 6021 if (rr->NR_AnswerTo) 6022 { 6023 mDNSBool SendMulticastResponse = mDNSfalse; // Send modern multicast response 6024 mDNSBool SendUnicastResponse = mDNSfalse; // Send modern unicast response (not legacy unicast response) 6025 6026 // If it's been a while since we multicast this, then send a multicast response for conflict detection, etc. 6027 if (m->timenow - (rr->LastMCTime + TicksTTL(rr)/4) >= 0) 6028 { 6029 SendMulticastResponse = mDNStrue; 6030 // If this record was marked for modern (delayed) unicast response, then mark it as promoted to 6031 // multicast response instead (don't want to end up ALSO setting SendUnicastResponse in the check below). 6032 // If this record was marked for legacy unicast response, then we mustn't change the NR_AnswerTo value. 6033 if (rr->NR_AnswerTo == (mDNSu8*)~1) rr->NR_AnswerTo = (mDNSu8*)~0; 6034 } 6035 6036 // If the client insists on a multicast response, then we'd better send one 6037 if (rr->NR_AnswerTo == (mDNSu8*)~0) SendMulticastResponse = mDNStrue; 6038 else if (rr->NR_AnswerTo == (mDNSu8*)~1) SendUnicastResponse = mDNStrue; 6039 else if (rr->NR_AnswerTo) SendLegacyResponse = mDNStrue; 6040 6041 if (SendMulticastResponse || SendUnicastResponse) 6042 { 6043 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 6044 rr->ImmedAnswerMarkTime = m->timenow; 6045 #endif 6046 m->NextScheduledResponse = m->timenow; 6047 // If we're already planning to send this on another interface, just send it on all interfaces 6048 if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID) 6049 rr->ImmedAnswer = mDNSInterfaceMark; 6050 else 6051 { 6052 rr->ImmedAnswer = InterfaceID; // Record interface to send it on 6053 if (SendUnicastResponse) rr->ImmedUnicast = mDNStrue; 6054 if (srcaddr->type == mDNSAddrType_IPv4) 6055 { 6056 if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4; 6057 else if (!mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = onesIPv4Addr; 6058 } 6059 else if (srcaddr->type == mDNSAddrType_IPv6) 6060 { 6061 if (mDNSIPv6AddressIsZero(rr->v6Requester)) rr->v6Requester = srcaddr->ip.v6; 6062 else if (!mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = onesIPv6Addr; 6063 } 6064 } 6065 } 6066 // If TC flag is set, it means we should expect that additional known answers may be coming in another packet, 6067 // so we allow roughly half a second before deciding to reply (we've observed inter-packet delays of 100-200ms on 802.11) 6068 // else, if record is a shared one, spread responses over 100ms to avoid implosion of simultaneous responses 6069 // else, for a simple unique record reply, we can reply immediately; no need for delay 6070 if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; // Divided by 50 = 400ms 6071 else if (rr->resrec.RecordType == kDNSRecordTypeShared) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms 6072 } 6073 else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == (mDNSu8*)~0) 6074 { 6075 // Since additional records are an optimization anyway, we only ever send them on one interface at a time 6076 // If two clients on different interfaces do queries that invoke the same optional additional answer, 6077 // then the earlier client is out of luck 6078 rr->ImmedAdditional = InterfaceID; 6079 // No need to set m->NextScheduledResponse here 6080 // We'll send these additional records when we send them, or not, as the case may be 6081 } 6082 } 6083 6084 // *** 6085 // *** 8. If we think other machines are likely to answer these questions, set our packet suppression timer 6086 // *** 6087 if (delayresponse && (!m->SuppressSending || (m->SuppressSending - m->timenow) < (delayresponse + 49) / 50)) 6088 { 6089 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 6090 mDNSs32 oldss = m->SuppressSending; 6091 if (oldss && delayresponse) 6092 LogMsg("Current SuppressSending delay%5ld; require%5ld", m->SuppressSending - m->timenow, (delayresponse + 49) / 50); 6093 #endif 6094 // Pick a random delay: 6095 // We start with the base delay chosen above (typically either 1 second or 20 seconds), 6096 // and add a random value in the range 0-5 seconds (making 1-6 seconds or 20-25 seconds). 6097 // This is an integer value, with resolution determined by the platform clock rate. 6098 // We then divide that by 50 to get the delay value in ticks. We defer the division until last 6099 // to get better results on platforms with coarse clock granularity (e.g. ten ticks per second). 6100 // The +49 before dividing is to ensure we round up, not down, to ensure that even 6101 // on platforms where the native clock rate is less than fifty ticks per second, 6102 // we still guarantee that the final calculated delay is at least one platform tick. 6103 // We want to make sure we don't ever allow the delay to be zero ticks, 6104 // because if that happens we'll fail the Bonjour Conformance Test. 6105 // Our final computed delay is 20-120ms for normal delayed replies, 6106 // or 400-500ms in the case of multi-packet known-answer lists. 6107 m->SuppressSending = m->timenow + (delayresponse + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*5) + 49) / 50; 6108 if (m->SuppressSending == 0) m->SuppressSending = 1; 6109 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 6110 if (oldss && delayresponse) 6111 LogMsg("Set SuppressSending to %5ld", m->SuppressSending - m->timenow); 6112 #endif 6113 } 6114 6115 // *** 6116 // *** 9. If query is from a legacy client, or from a new client requesting a unicast reply, then generate a unicast response too 6117 // *** 6118 if (SendLegacyResponse) 6119 responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords); 6120 6121 exit: 6122 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 6123 6124 // *** 6125 // *** 10. Finally, clear our link chains ready for use next time 6126 // *** 6127 while (ResponseRecords) 6128 { 6129 rr = ResponseRecords; 6130 ResponseRecords = rr->NextResponse; 6131 rr->NextResponse = mDNSNULL; 6132 rr->NR_AnswerTo = mDNSNULL; 6133 rr->NR_AdditionalTo = mDNSNULL; 6134 } 6135 6136 while (ExpectedAnswers) 6137 { 6138 CacheRecord *cr = ExpectedAnswers; 6139 ExpectedAnswers = cr->NextInKAList; 6140 cr->NextInKAList = mDNSNULL; 6141 6142 // For non-truncated queries, we can definitively say that we should expect 6143 // to be seeing a response for any records still left in the ExpectedAnswers list 6144 if (!(query->h.flags.b[0] & kDNSFlag0_TC)) 6145 if (cr->UnansweredQueries == 0 || m->timenow - cr->LastUnansweredTime >= mDNSPlatformOneSecond) 6146 { 6147 cr->UnansweredQueries++; 6148 cr->LastUnansweredTime = m->timenow; 6149 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 6150 if (cr->UnansweredQueries > 1) 6151 debugf("ProcessQuery: (!TC) UAQ %lu MPQ %lu MPKA %lu %s", 6152 cr->UnansweredQueries, cr->MPUnansweredQ, cr->MPUnansweredKA, CRDisplayString(m, cr)); 6153 #endif 6154 SetNextCacheCheckTimeForRecord(m, cr); 6155 } 6156 6157 // If we've seen multiple unanswered queries for this record, 6158 // then mark it to expire in five seconds if we don't get a response by then. 6159 if (cr->UnansweredQueries >= MaxUnansweredQueries) 6160 { 6161 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 6162 // Only show debugging message if this record was not about to expire anyway 6163 if (RRExpireTime(cr) - m->timenow > 4 * mDNSPlatformOneSecond) 6164 debugf("ProcessQuery: (Max) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s", 6165 cr->UnansweredQueries, cr->MPUnansweredQ, cr->MPUnansweredKA, CRDisplayString(m, cr)); 6166 #endif 6167 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 6168 } 6169 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 6170 // Make a guess, based on the multi-packet query / known answer counts, whether we think we 6171 // should have seen an answer for this. (We multiply MPQ by 4 and MPKA by 5, to allow for 6172 // possible packet loss of up to 20% of the additional KA packets.) 6173 else if (cr->MPUnansweredQ * 4 > cr->MPUnansweredKA * 5 + 8) 6174 { 6175 // We want to do this conservatively. 6176 // If there are so many machines on the network that they have to use multi-packet known-answer lists, 6177 // then we don't want them to all hit the network simultaneously with their final expiration queries. 6178 // By setting the record to expire in four minutes, we achieve two things: 6179 // (a) the 90-95% final expiration queries will be less bunched together 6180 // (b) we allow some time for us to witness enough other failed queries that we don't have to do our own 6181 mDNSu32 remain = (mDNSu32)(RRExpireTime(cr) - m->timenow) / 4; 6182 if (remain > 240 * (mDNSu32)mDNSPlatformOneSecond) 6183 remain = 240 * (mDNSu32)mDNSPlatformOneSecond; 6184 6185 // Only show debugging message if this record was not about to expire anyway 6186 if (RRExpireTime(cr) - m->timenow > 4 * mDNSPlatformOneSecond) 6187 debugf("ProcessQuery: (MPQ) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s", 6188 cr->UnansweredQueries, cr->MPUnansweredQ, cr->MPUnansweredKA, CRDisplayString(m, cr)); 6189 6190 if (remain <= 60 * (mDNSu32)mDNSPlatformOneSecond) 6191 cr->UnansweredQueries++; // Treat this as equivalent to one definite unanswered query 6192 cr->MPUnansweredQ = 0; // Clear MPQ/MPKA statistics 6193 cr->MPUnansweredKA = 0; 6194 cr->MPExpectingKA = mDNSfalse; 6195 6196 if (remain < kDefaultReconfirmTimeForNoAnswer) 6197 remain = kDefaultReconfirmTimeForNoAnswer; 6198 mDNS_Reconfirm_internal(m, cr, remain); 6199 } 6200 #endif 6201 } 6202 6203 while (DupQuestions) 6204 { 6205 DNSQuestion *q = DupQuestions; 6206 DupQuestions = q->NextInDQList; 6207 q->NextInDQList = mDNSNULL; 6208 i = RecordDupSuppressInfo(q->DupSuppress, m->timenow, InterfaceID, srcaddr->type); 6209 debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s %d", q->qname.c, DNSTypeName(q->qtype), InterfaceID, 6210 srcaddr->type == mDNSAddrType_IPv4 ? "v4" : "v6", i); 6211 } 6212 6213 return(responseptr); 6214 } 6215 6216 mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, 6217 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, 6218 const mDNSInterfaceID InterfaceID) 6219 { 6220 mDNSu8 *responseend = mDNSNULL; 6221 mDNSBool QueryWasLocalUnicast = srcaddr && dstaddr && 6222 !mDNSAddrIsDNSMulticast(dstaddr) && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); 6223 6224 if (!InterfaceID && dstaddr && mDNSAddrIsDNSMulticast(dstaddr)) 6225 { 6226 LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " 6227 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes (Multicast, but no InterfaceID)", 6228 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, 6229 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 6230 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 6231 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 6232 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data); 6233 return; 6234 } 6235 6236 verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " 6237 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes", 6238 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, 6239 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 6240 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 6241 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 6242 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data); 6243 6244 responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID, 6245 !mDNSSameIPPort(srcport, MulticastDNSPort), mDNSAddrIsDNSMulticast(dstaddr), QueryWasLocalUnicast, &m->omsg); 6246 6247 if (responseend) // If responseend is non-null, that means we built a unicast response packet 6248 { 6249 debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld", 6250 m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s", 6251 m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s", 6252 m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s", 6253 srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type); 6254 mDNSSendDNSMessage(m, &m->omsg, responseend, InterfaceID, mDNSNULL, srcaddr, srcport, mDNSNULL, mDNSNULL); 6255 } 6256 } 6257 6258 #if 0 6259 mDNSlocal mDNSBool TrustedSource(const mDNS *const m, const mDNSAddr *const srcaddr) 6260 { 6261 DNSServer *s; 6262 (void)m; // Unused 6263 (void)srcaddr; // Unused 6264 for (s = m->DNSServers; s; s = s->next) 6265 if (mDNSSameAddress(srcaddr, &s->addr)) return(mDNStrue); 6266 return(mDNSfalse); 6267 } 6268 #endif 6269 6270 struct UDPSocket_struct 6271 { 6272 mDNSIPPort port; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port 6273 }; 6274 6275 mDNSlocal DNSQuestion *ExpectingUnicastResponseForQuestion(const mDNS *const m, const mDNSIPPort port, const mDNSOpaque16 id, const DNSQuestion *const question, mDNSBool tcp) 6276 { 6277 DNSQuestion *q; 6278 for (q = m->Questions; q; q=q->next) 6279 { 6280 if (!tcp && !q->LocalSocket) continue; 6281 if (mDNSSameIPPort(tcp ? q->tcpSrcPort : q->LocalSocket->port, port) && 6282 mDNSSameOpaque16(q->TargetQID, id) && 6283 q->qtype == question->qtype && 6284 q->qclass == question->qclass && 6285 q->qnamehash == question->qnamehash && 6286 SameDomainName(&q->qname, &question->qname)) 6287 return(q); 6288 } 6289 return(mDNSNULL); 6290 } 6291 6292 // This function is called when we receive a unicast response. This could be the case of a unicast response from the 6293 // DNS server or a response to the QU query. Hence, the cache record's InterfaceId can be both NULL or non-NULL (QU case) 6294 mDNSlocal DNSQuestion *ExpectingUnicastResponseForRecord(mDNS *const m, 6295 const mDNSAddr *const srcaddr, const mDNSBool SrcLocal, const mDNSIPPort port, const mDNSOpaque16 id, const CacheRecord *const rr, mDNSBool tcp) 6296 { 6297 DNSQuestion *q; 6298 (void)id; 6299 (void)srcaddr; 6300 6301 for (q = m->Questions; q; q=q->next) 6302 { 6303 if (!q->DuplicateOf && ResourceRecordAnswersUnicastResponse(&rr->resrec, q)) 6304 { 6305 if (!mDNSOpaque16IsZero(q->TargetQID)) 6306 { 6307 debugf("ExpectingUnicastResponseForRecord msg->h.id %d q->TargetQID %d for %s", mDNSVal16(id), mDNSVal16(q->TargetQID), CRDisplayString(m, rr)); 6308 6309 if (mDNSSameOpaque16(q->TargetQID, id)) 6310 { 6311 mDNSIPPort srcp; 6312 if (!tcp) 6313 { 6314 srcp = q->LocalSocket ? q->LocalSocket->port : zeroIPPort; 6315 } 6316 else 6317 { 6318 srcp = q->tcpSrcPort; 6319 } 6320 if (mDNSSameIPPort(srcp, port)) return(q); 6321 6322 // if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue); 6323 // if (q->LongLived && mDNSSameAddress(srcaddr, &q->servAddr)) return(mDNStrue); Shouldn't need this now that we have LLQType checking 6324 // if (TrustedSource(m, srcaddr)) return(mDNStrue); 6325 LogInfo("WARNING: Ignoring suspect uDNS response for %##s (%s) [q->Target %#a:%d] from %#a:%d %s", 6326 q->qname.c, DNSTypeName(q->qtype), &q->Target, mDNSVal16(srcp), srcaddr, mDNSVal16(port), CRDisplayString(m, rr)); 6327 return(mDNSNULL); 6328 } 6329 } 6330 else 6331 { 6332 if (SrcLocal && q->ExpectUnicastResp && (mDNSu32)(m->timenow - q->ExpectUnicastResp) < (mDNSu32)(mDNSPlatformOneSecond*2)) 6333 return(q); 6334 } 6335 } 6336 } 6337 return(mDNSNULL); 6338 } 6339 6340 // Certain data types need more space for in-memory storage than their in-packet rdlength would imply 6341 // Currently this applies only to rdata types containing more than one domainname, 6342 // or types where the domainname is not the last item in the structure. 6343 // In addition, NSEC currently requires less space for in-memory storage than its in-packet representation. 6344 mDNSlocal mDNSu16 GetRDLengthMem(const ResourceRecord *const rr) 6345 { 6346 switch (rr->rrtype) 6347 { 6348 case kDNSType_SOA: return sizeof(rdataSOA); 6349 case kDNSType_RP: return sizeof(rdataRP); 6350 case kDNSType_PX: return sizeof(rdataPX); 6351 case kDNSType_NSEC:return sizeof(rdataNSEC); 6352 default: return rr->rdlength; 6353 } 6354 } 6355 6356 mDNSexport CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg, mDNSs32 delay) 6357 { 6358 CacheRecord *rr = mDNSNULL; 6359 mDNSu16 RDLength = GetRDLengthMem(&m->rec.r.resrec); 6360 6361 if (!m->rec.r.resrec.InterfaceID) debugf("CreateNewCacheEntry %s", CRDisplayString(m, &m->rec.r)); 6362 6363 //if (RDLength > InlineCacheRDSize) 6364 // LogInfo("Rdata len %4d > InlineCacheRDSize %d %s", RDLength, InlineCacheRDSize, CRDisplayString(m, &m->rec.r)); 6365 6366 if (!cg) cg = GetCacheGroup(m, slot, &m->rec.r.resrec); // If we don't have a CacheGroup for this name, make one now 6367 if (cg) rr = GetCacheRecord(m, cg, RDLength); // Make a cache record, being careful not to recycle cg 6368 if (!rr) NoCacheAnswer(m, &m->rec.r); 6369 else 6370 { 6371 RData *saveptr = rr->resrec.rdata; // Save the rr->resrec.rdata pointer 6372 *rr = m->rec.r; // Block copy the CacheRecord object 6373 rr->resrec.rdata = saveptr; // Restore rr->resrec.rdata after the structure assignment 6374 rr->resrec.name = cg->name; // And set rr->resrec.name to point into our CacheGroup header 6375 rr->DelayDelivery = delay; 6376 6377 // If this is an oversized record with external storage allocated, copy rdata to external storage 6378 if (rr->resrec.rdata == (RData*)&rr->smallrdatastorage && RDLength > InlineCacheRDSize) 6379 LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s", m->rec.r.resrec.name->c); 6380 else if (rr->resrec.rdata != (RData*)&rr->smallrdatastorage && RDLength <= InlineCacheRDSize) 6381 LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s", m->rec.r.resrec.name->c); 6382 if (RDLength > InlineCacheRDSize) 6383 mDNSPlatformMemCopy(rr->resrec.rdata, m->rec.r.resrec.rdata, sizeofRDataHeader + RDLength); 6384 6385 rr->next = mDNSNULL; // Clear 'next' pointer 6386 *(cg->rrcache_tail) = rr; // Append this record to tail of cache slot list 6387 cg->rrcache_tail = &(rr->next); // Advance tail pointer 6388 6389 CacheRecordAdd(m, rr); // CacheRecordAdd calls SetNextCacheCheckTimeForRecord(m, rr); for us 6390 } 6391 return(rr); 6392 } 6393 6394 mDNSlocal void RefreshCacheRecord(mDNS *const m, CacheRecord *rr, mDNSu32 ttl) 6395 { 6396 rr->TimeRcvd = m->timenow; 6397 rr->resrec.rroriginalttl = ttl; 6398 rr->UnansweredQueries = 0; 6399 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 6400 rr->MPUnansweredQ = 0; 6401 rr->MPUnansweredKA = 0; 6402 rr->MPExpectingKA = mDNSfalse; 6403 #endif 6404 SetNextCacheCheckTimeForRecord(m, rr); 6405 } 6406 6407 mDNSexport void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease) 6408 { 6409 CacheRecord *rr; 6410 const mDNSu32 slot = HashSlot(&q->qname); 6411 CacheGroup *cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname); 6412 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 6413 if (rr->CRActiveQuestion == q) 6414 { 6415 //LogInfo("GrantCacheExtensions: new lease %d / %s", lease, CRDisplayString(m, rr)); 6416 RefreshCacheRecord(m, rr, lease); 6417 } 6418 } 6419 6420 mDNSlocal mDNSu32 GetEffectiveTTL(const uDNS_LLQType LLQType, mDNSu32 ttl) // TTL in seconds 6421 { 6422 if (LLQType == uDNS_LLQ_Entire) ttl = kLLQ_DefLease; 6423 else if (LLQType == uDNS_LLQ_Events) 6424 { 6425 // If the TTL is -1 for uDNS LLQ event packet, that means "remove" 6426 if (ttl == 0xFFFFFFFF) ttl = 0; 6427 else ttl = kLLQ_DefLease; 6428 } 6429 else // else not LLQ (standard uDNS response) 6430 { 6431 // The TTL is already capped to a maximum value in GetLargeResourceRecord, but just to be extra safe we 6432 // also do this check here to make sure we can't get overflow below when we add a quarter to the TTL 6433 if (ttl > 0x60000000UL / mDNSPlatformOneSecond) ttl = 0x60000000UL / mDNSPlatformOneSecond; 6434 6435 // Adjustment factor to avoid race condition: 6436 // 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. 6437 // If we do our normal refresh at 80% of the TTL, our local caching server will return 20 seconds, so we'll do another 6438 // 80% refresh after 16 seconds, and then the server will return 4 seconds, and so on, in the fashion of Zeno's paradox. 6439 // To avoid this, we extend the record's effective TTL to give it a little extra grace period. 6440 // We adjust the 100 second TTL to 126. This means that when we do our 80% query at 101 seconds, 6441 // the cached copy at our local caching server will already have expired, so the server will be forced 6442 // to fetch a fresh copy from the authoritative server, and then return a fresh record with the full TTL of 3600 seconds. 6443 ttl += ttl/4 + 2; 6444 6445 // For mDNS, TTL zero means "delete this record" 6446 // For uDNS, TTL zero means: this data is true at this moment, but don't cache it. 6447 // For the sake of network efficiency, we impose a minimum effective TTL of 15 seconds. 6448 // This means that we'll do our 80, 85, 90, 95% queries at 12.00, 12.75, 13.50, 14.25 seconds 6449 // respectively, and then if we get no response, delete the record from the cache at 15 seconds. 6450 // This gives the server up to three seconds to respond between when we send our 80% query at 12 seconds 6451 // and when we delete the record at 15 seconds. Allowing cache lifetimes less than 15 seconds would 6452 // (with the current code) result in the server having even less than three seconds to respond 6453 // before we deleted the record and reported a "remove" event to any active questions. 6454 // Furthermore, with the current code, if we were to allow a TTL of less than 2 seconds 6455 // then things really break (e.g. we end up making a negative cache entry). 6456 // In the future we may want to revisit this and consider properly supporting non-cached (TTL=0) uDNS answers. 6457 if (ttl < 15) ttl = 15; 6458 } 6459 6460 return ttl; 6461 } 6462 6463 // Note: mDNSCoreReceiveResponse calls mDNS_Deregister_internal which can call a user callback, which may change 6464 // the record list and/or question list. 6465 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 6466 // InterfaceID non-NULL tells us the interface this multicast response was received on 6467 // InterfaceID NULL tells us this was a unicast response 6468 // dstaddr NULL tells us we received this over an outgoing TCP connection we made 6469 mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m, 6470 const DNSMessage *const response, const mDNSu8 *end, 6471 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, 6472 const mDNSInterfaceID InterfaceID) 6473 { 6474 int i; 6475 mDNSBool ResponseMCast = dstaddr && mDNSAddrIsDNSMulticast(dstaddr); 6476 mDNSBool ResponseSrcLocal = !srcaddr || mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); 6477 DNSQuestion *llqMatch = mDNSNULL; 6478 uDNS_LLQType LLQType = uDNS_recvLLQResponse(m, response, end, srcaddr, srcport, &llqMatch); 6479 6480 // "(CacheRecord*)1" is a special (non-zero) end-of-list marker 6481 // We use this non-zero marker so that records in our CacheFlushRecords list will always have NextInCFList 6482 // set non-zero, and that tells GetCacheEntity() that they're not, at this moment, eligible for recycling. 6483 CacheRecord *CacheFlushRecords = (CacheRecord*)1; 6484 CacheRecord **cfp = &CacheFlushRecords; 6485 6486 // All records in a DNS response packet are treated as equally valid statements of truth. If we want 6487 // to guard against spoof responses, then the only credible protection against that is cryptographic 6488 // security, e.g. DNSSEC., not worring about which section in the spoof packet contained the record 6489 int firstauthority = response->h.numAnswers; 6490 int firstadditional = firstauthority + response->h.numAuthorities; 6491 int totalrecords = firstadditional + response->h.numAdditionals; 6492 const mDNSu8 *ptr = response->data; 6493 DNSServer *uDNSServer = mDNSNULL; 6494 6495 debugf("Received Response from %#-15a addressed to %#-15a on %p with " 6496 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes LLQType %d", 6497 srcaddr, dstaddr, InterfaceID, 6498 response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,", 6499 response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,", 6500 response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,", 6501 response->h.numAdditionals, response->h.numAdditionals == 1 ? " " : "s", end - response->data, LLQType); 6502 6503 // According to RFC 2181 <http://www.ietf.org/rfc/rfc2181.txt> 6504 // When a DNS client receives a reply with TC 6505 // set, it should ignore that response, and query again, using a 6506 // mechanism, such as a TCP connection, that will permit larger replies. 6507 // It feels wrong to be throwing away data after the network went to all the trouble of delivering it to us, but 6508 // delivering some records of the RRSet first and then the remainder a couple of milliseconds later was causing 6509 // failures in our Microsoft Active Directory client, which expects to get the entire set of answers at once. 6510 // <rdar://problem/6690034> Can't bind to Active Directory 6511 // In addition, if the client immediately canceled its query after getting the initial partial response, then we'll 6512 // abort our TCP connection, and not complete the operation, and end up with an incomplete RRSet in our cache. 6513 // Next time there's a query for this RRSet we'll see answers in our cache, and assume we have the whole RRSet already, 6514 // and not even do the TCP query. 6515 // Accordingly, if we get a uDNS reply with kDNSFlag0_TC set, we bail out and wait for the TCP response containing the entire RRSet. 6516 if (!InterfaceID && (response->h.flags.b[0] & kDNSFlag0_TC)) return; 6517 6518 if (LLQType == uDNS_LLQ_Ignore) return; 6519 6520 // 1. We ignore questions (if any) in mDNS response packets 6521 // 2. If this is an LLQ response, we handle it much the same 6522 // 3. If we get a uDNS UDP response with the TC (truncated) bit set, then we can't treat this 6523 // answer as being the authoritative complete RRSet, and respond by deleting all other 6524 // matching cache records that don't appear in this packet. 6525 // Otherwise, this is a authoritative uDNS answer, so arrange for any stale records to be purged 6526 if (ResponseMCast || LLQType == uDNS_LLQ_Events || (response->h.flags.b[0] & kDNSFlag0_TC)) 6527 ptr = LocateAnswers(response, end); 6528 // Otherwise, for one-shot queries, any answers in our cache that are not also contained 6529 // in this response packet are immediately deemed to be invalid. 6530 else 6531 { 6532 mDNSu8 rcode = (mDNSu8)(response->h.flags.b[1] & kDNSFlag1_RC_Mask); 6533 mDNSBool failure = !(rcode == kDNSFlag1_RC_NoErr || rcode == kDNSFlag1_RC_NXDomain || rcode == kDNSFlag1_RC_NotAuth); 6534 mDNSBool returnEarly = mDNSfalse; 6535 // We could possibly combine this with the similar loop at the end of this function -- 6536 // instead of tagging cache records here and then rescuing them if we find them in the answer section, 6537 // we could instead use the "m->PktNum" mechanism to tag each cache record with the packet number in 6538 // which it was received (or refreshed), and then at the end if we find any cache records which 6539 // answer questions in this packet's question section, but which aren't tagged with this packet's 6540 // packet number, then we deduce they are old and delete them 6541 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) 6542 { 6543 DNSQuestion q, *qptr = mDNSNULL; 6544 ptr = getQuestion(response, ptr, end, InterfaceID, &q); 6545 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr))) 6546 { 6547 if (!failure) 6548 { 6549 CacheRecord *rr; 6550 const mDNSu32 slot = HashSlot(&q.qname); 6551 CacheGroup *cg = CacheGroupForName(m, slot, q.qnamehash, &q.qname); 6552 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 6553 if (SameNameRecordAnswersQuestion(&rr->resrec, qptr)) 6554 { 6555 debugf("uDNS marking %p %##s (%s) %p %s", q.InterfaceID, q.qname.c, DNSTypeName(q.qtype), 6556 rr->resrec.InterfaceID, CRDisplayString(m, rr)); 6557 // Don't want to disturb rroriginalttl here, because code below might need it for the exponential backoff doubling algorithm 6558 rr->TimeRcvd = m->timenow - TicksTTL(rr) - 1; 6559 rr->UnansweredQueries = MaxUnansweredQueries; 6560 } 6561 } 6562 else 6563 { 6564 if (qptr) 6565 { 6566 LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to query %##s (%s)", qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype)); 6567 PenalizeDNSServer(m, qptr); 6568 } 6569 returnEarly = mDNStrue; 6570 } 6571 } 6572 } 6573 if (returnEarly) 6574 { 6575 LogInfo("Ignoring %2d Answer%s %2d Authorit%s %2d Additional%s", 6576 response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,", 6577 response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,", 6578 response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s"); 6579 // not goto exit because we won't have any CacheFlushRecords and we do not want to 6580 // generate negative cache entries (we want to query the next server) 6581 return; 6582 } 6583 } 6584 6585 for (i = 0; i < totalrecords && ptr && ptr < end; i++) 6586 { 6587 // All responses sent via LL multicast are acceptable for caching 6588 // All responses received over our outbound TCP connections are acceptable for caching 6589 mDNSBool AcceptableResponse = ResponseMCast || !dstaddr || LLQType; 6590 // (Note that just because we are willing to cache something, that doesn't necessarily make it a trustworthy answer 6591 // to any specific question -- any code reading records from the cache needs to make that determination for itself.) 6592 6593 const mDNSu8 RecordType = 6594 (i < firstauthority ) ? (mDNSu8)kDNSRecordTypePacketAns : 6595 (i < firstadditional) ? (mDNSu8)kDNSRecordTypePacketAuth : (mDNSu8)kDNSRecordTypePacketAdd; 6596 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &m->rec); 6597 if (!ptr) goto exit; // Break out of the loop and clean up our CacheFlushRecords list before exiting 6598 if (m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative) { m->rec.r.resrec.RecordType = 0; continue; } 6599 6600 // Don't want to cache OPT or TSIG pseudo-RRs 6601 if (m->rec.r.resrec.rrtype == kDNSType_TSIG) { m->rec.r.resrec.RecordType = 0; continue; } 6602 if (m->rec.r.resrec.rrtype == kDNSType_OPT) 6603 { 6604 const rdataOPT *opt; 6605 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 6606 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently 6607 // delete all our own AuthRecords (which are identified by having zero MAC tags on them). 6608 for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++) 6609 if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0]) 6610 { 6611 ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords); 6612 ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords); 6613 } 6614 m->rec.r.resrec.RecordType = 0; 6615 continue; 6616 } 6617 6618 // if a CNAME record points to itself, then don't add it to the cache 6619 if ((m->rec.r.resrec.rrtype == kDNSType_CNAME) && SameDomainName(m->rec.r.resrec.name, &m->rec.r.resrec.rdata->u.name)) 6620 { 6621 LogInfo("mDNSCoreReceiveResponse: CNAME loop domain name %##s", m->rec.r.resrec.name->c); 6622 m->rec.r.resrec.RecordType = 0; 6623 continue; 6624 } 6625 6626 // When we receive uDNS LLQ responses, we assume a long cache lifetime -- 6627 // In the case of active LLQs, we'll get remove events when the records actually do go away 6628 // In the case of polling LLQs, we assume the record remains valid until the next poll 6629 if (!mDNSOpaque16IsZero(response->h.id)) 6630 m->rec.r.resrec.rroriginalttl = GetEffectiveTTL(LLQType, m->rec.r.resrec.rroriginalttl); 6631 6632 // If response was not sent via LL multicast, 6633 // then see if it answers a recent query of ours, which would also make it acceptable for caching. 6634 if (!ResponseMCast) 6635 { 6636 if (LLQType) 6637 { 6638 // For Long Lived queries that are both sent over UDP and Private TCP, LLQType is set. 6639 // Even though it is AcceptableResponse, we need a matching DNSServer pointer for the 6640 // queries to get ADD/RMV events. To lookup the question, we can't use 6641 // ExpectingUnicastResponseForRecord as the port numbers don't match. uDNS_recvLLQRespose 6642 // has already matched the question using the 64 bit Id in the packet and we use that here. 6643 6644 if (llqMatch != mDNSNULL) m->rec.r.resrec.rDNSServer = uDNSServer = llqMatch->qDNSServer; 6645 } 6646 else if (!AcceptableResponse || !dstaddr) 6647 { 6648 // For responses that come over TCP (Responses that can't fit within UDP) or TLS (Private queries 6649 // that are not long lived e.g., AAAA lookup in a Private domain), it is indicated by !dstaddr. 6650 // Even though it is AcceptableResponse, we still need a DNSServer pointer for the resource records that 6651 // we create. 6652 6653 DNSQuestion *q = ExpectingUnicastResponseForRecord(m, srcaddr, ResponseSrcLocal, dstport, response->h.id, &m->rec.r, !dstaddr); 6654 6655 // Intialize the DNS server on the resource record which will now filter what questions we answer with 6656 // this record. 6657 // 6658 // We could potentially lookup the DNS server based on the source address, but that may not work always 6659 // and that's why ExpectingUnicastResponseForRecord does not try to verify whether the response came 6660 // from the DNS server that queried. We follow the same logic here. If we can find a matching quetion based 6661 // on the "id" and "source port", then this response answers the question and assume the response 6662 // came from the same DNS server that we sent the query to. 6663 6664 if (q != mDNSNULL) 6665 { 6666 AcceptableResponse = mDNStrue; 6667 if (!InterfaceID) 6668 { 6669 debugf("mDNSCoreReceiveResponse: InterfaceID %p %##s (%s)", q->InterfaceID, q->qname.c, DNSTypeName(q->qtype)); 6670 m->rec.r.resrec.rDNSServer = uDNSServer = q->qDNSServer; 6671 } 6672 } 6673 else 6674 { 6675 // If we can't find a matching question, we need to see whether we have seen records earlier that matched 6676 // the question. The code below does that. So, make this record unacceptable for now 6677 if (!InterfaceID) 6678 { 6679 debugf("mDNSCoreReceiveResponse: Can't find question for record name %##s", m->rec.r.resrec.name->c); 6680 AcceptableResponse = mDNSfalse; 6681 } 6682 } 6683 } 6684 } 6685 6686 // 1. Check that this packet resource record does not conflict with any of ours 6687 if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype != kDNSType_NSEC) 6688 { 6689 if (m->CurrentRecord) 6690 LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 6691 m->CurrentRecord = m->ResourceRecords; 6692 while (m->CurrentRecord) 6693 { 6694 AuthRecord *rr = m->CurrentRecord; 6695 m->CurrentRecord = rr->next; 6696 // We accept all multicast responses, and unicast responses resulting from queries we issued 6697 // For other unicast responses, this code accepts them only for responses with an 6698 // (apparently) local source address that pertain to a record of our own that's in probing state 6699 if (!AcceptableResponse && !(ResponseSrcLocal && rr->resrec.RecordType == kDNSRecordTypeUnique)) continue; 6700 6701 if (PacketRRMatchesSignature(&m->rec.r, rr)) // If interface, name, type (if shared record) and class match... 6702 { 6703 // ... check to see if type and rdata are identical 6704 if (IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec)) 6705 { 6706 // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us 6707 if (m->rec.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState) 6708 { 6709 // If we were planning to send on this -- and only this -- interface, then we don't need to any more 6710 if (rr->ImmedAnswer == InterfaceID) { rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse; } 6711 } 6712 else 6713 { 6714 if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; } 6715 else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; } 6716 } 6717 } 6718 // else, the packet RR has different type or different rdata -- check to see if this is a conflict 6719 else if (m->rec.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &m->rec.r)) 6720 { 6721 LogInfo("mDNSCoreReceiveResponse: Pkt Record: %08lX %s", m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); 6722 LogInfo("mDNSCoreReceiveResponse: Our Record: %08lX %s", rr-> resrec.rdatahash, ARDisplayString(m, rr)); 6723 6724 // If this record is marked DependentOn another record for conflict detection purposes, 6725 // then *that* record has to be bumped back to probing state to resolve the conflict 6726 if (rr->DependentOn) 6727 { 6728 while (rr->DependentOn) rr = rr->DependentOn; 6729 LogInfo("mDNSCoreReceiveResponse: Dep Record: %08lX %s", rr-> resrec.rdatahash, ARDisplayString(m, rr)); 6730 } 6731 6732 // If we've just whacked this record's ProbeCount, don't need to do it again 6733 if (rr->ProbeCount > DefaultProbeCountForTypeUnique) 6734 LogInfo("mDNSCoreReceiveResponse: Already reset to Probing: %s", ARDisplayString(m, rr)); 6735 else if (rr->ProbeCount == DefaultProbeCountForTypeUnique) 6736 LogMsg("mDNSCoreReceiveResponse: Ignoring response received before we even began probing: %s", ARDisplayString(m, rr)); 6737 else 6738 { 6739 LogMsg("mDNSCoreReceiveResponse: Received from %#a:%d %s", srcaddr, mDNSVal16(srcport), CRDisplayString(m, &m->rec.r)); 6740 // If we'd previously verified this record, put it back to probing state and try again 6741 if (rr->resrec.RecordType == kDNSRecordTypeVerified) 6742 { 6743 LogMsg("mDNSCoreReceiveResponse: Resetting to Probing: %s", ARDisplayString(m, rr)); 6744 rr->resrec.RecordType = kDNSRecordTypeUnique; 6745 // We set ProbeCount to one more than the usual value so we know we've already touched this record. 6746 // This is because our single probe for "example-name.local" could yield a response with (say) two A records and 6747 // three AAAA records in it, and we don't want to call RecordProbeFailure() five times and count that as five conflicts. 6748 // This special value is recognised and reset to DefaultProbeCountForTypeUnique in SendQueries(). 6749 rr->ProbeCount = DefaultProbeCountForTypeUnique + 1; 6750 rr->AnnounceCount = InitialAnnounceCount; 6751 InitializeLastAPTime(m, rr); 6752 RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate 6753 } 6754 // If we're probing for this record, we just failed 6755 else if (rr->resrec.RecordType == kDNSRecordTypeUnique) 6756 { 6757 LogMsg("mDNSCoreReceiveResponse: ProbeCount %d; will deregister %s", rr->ProbeCount, ARDisplayString(m, rr)); 6758 mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); 6759 } 6760 // We assumed this record must be unique, but we were wrong. (e.g. There are two mDNSResponders on the 6761 // same machine giving different answers for the reverse mapping record, or there are two machines on the 6762 // network using the same IP address.) This is simply a misconfiguration, and there's nothing we can do 6763 // to fix it -- e.g. it's not our job to be trying to change the machine's IP address. We just discard our 6764 // record to avoid continued conflicts (as we do for a conflict on our Unique records) and get on with life. 6765 else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique) 6766 { 6767 LogMsg("mDNSCoreReceiveResponse: Unexpected conflict discarding %s", ARDisplayString(m, rr)); 6768 mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); 6769 } 6770 else 6771 LogMsg("mDNSCoreReceiveResponse: Unexpected record type %X %s", rr->resrec.RecordType, ARDisplayString(m, rr)); 6772 } 6773 } 6774 // Else, matching signature, different type or rdata, but not a considered a conflict. 6775 // If the packet record has the cache-flush bit set, then we check to see if we 6776 // have any record(s) of the same type that we should re-assert to rescue them 6777 // (see note about "multi-homing and bridged networks" at the end of this function). 6778 else if (m->rec.r.resrec.rrtype == rr->resrec.rrtype) 6779 if ((m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && m->timenow - rr->LastMCTime > mDNSPlatformOneSecond/2) 6780 { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; } 6781 } 6782 } 6783 } 6784 6785 if (!AcceptableResponse) 6786 { 6787 const CacheRecord *cr; 6788 for (cr = CacheFlushRecords; cr != (CacheRecord*)1; cr = cr->NextInCFList) 6789 { 6790 domainname *target = GetRRDomainNameTarget(&cr->resrec); 6791 // When we issue a query for A record, the response might contain both a CNAME and A records. Only the CNAME would 6792 // match the question and we already created a cache entry in the previous pass of this loop. Now when we process 6793 // the A record, it does not match the question because the record name here is the CNAME. Hence we try to 6794 // match with the previous records to make it an AcceptableResponse. We have to be careful about setting the 6795 // DNSServer value that we got in the previous pass. This can happen for other record types like SRV also. 6796 6797 if (target && cr->resrec.rdatahash == m->rec.r.resrec.namehash && SameDomainName(target, m->rec.r.resrec.name)) 6798 { 6799 debugf("mDNSCoreReceiveResponse: Found a matching entry for %##s in the CacheFlushRecords", m->rec.r.resrec.name->c); 6800 AcceptableResponse = mDNStrue; 6801 m->rec.r.resrec.rDNSServer = uDNSServer; 6802 break; 6803 } 6804 } 6805 } 6806 6807 // 2. See if we want to add this packet resource record to our cache 6808 // We only try to cache answers if we have a cache to put them in 6809 // Also, we ignore any apparent attempts at cache poisoning unicast to us that do not answer any outstanding active query 6810 if (!AcceptableResponse) LogInfo("mDNSCoreReceiveResponse ignoring %s", CRDisplayString(m, &m->rec.r)); 6811 if (m->rrcache_size && AcceptableResponse) 6812 { 6813 const mDNSu32 slot = HashSlot(m->rec.r.resrec.name); 6814 CacheGroup *cg = CacheGroupForRecord(m, slot, &m->rec.r.resrec); 6815 CacheRecord *rr; 6816 6817 // 2a. Check if this packet resource record is already in our cache 6818 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 6819 { 6820 mDNSBool match = !InterfaceID ? m->rec.r.resrec.rDNSServer == rr->resrec.rDNSServer : rr->resrec.InterfaceID == InterfaceID; 6821 // If we found this exact resource record, refresh its TTL 6822 if (match && IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec)) 6823 { 6824 if (m->rec.r.resrec.rdlength > InlineCacheRDSize) 6825 verbosedebugf("Found record size %5d interface %p already in cache: %s", 6826 m->rec.r.resrec.rdlength, InterfaceID, CRDisplayString(m, &m->rec.r)); 6827 6828 if (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) 6829 { 6830 // If this packet record has the kDNSClass_UniqueRRSet flag set, then add it to our cache flushing list 6831 if (rr->NextInCFList == mDNSNULL && cfp != &rr->NextInCFList && LLQType != uDNS_LLQ_Events) 6832 { *cfp = rr; cfp = &rr->NextInCFList; *cfp = (CacheRecord*)1; } 6833 6834 // If this packet record is marked unique, and our previous cached copy was not, then fix it 6835 if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)) 6836 { 6837 DNSQuestion *q; 6838 for (q = m->Questions; q; q=q->next) if (ResourceRecordAnswersQuestion(&rr->resrec, q)) q->UniqueAnswers++; 6839 rr->resrec.RecordType = m->rec.r.resrec.RecordType; 6840 } 6841 } 6842 6843 if (!SameRDataBody(&m->rec.r.resrec, &rr->resrec.rdata->u, SameDomainNameCS)) 6844 { 6845 // If the rdata of the packet record differs in name capitalization from the record in our cache 6846 // then mDNSPlatformMemSame will detect this. In this case, throw the old record away, so that clients get 6847 // a 'remove' event for the record with the old capitalization, and then an 'add' event for the new one. 6848 // <rdar://problem/4015377> mDNS -F returns the same domain multiple times with different casing 6849 rr->resrec.rroriginalttl = 0; 6850 rr->TimeRcvd = m->timenow; 6851 rr->UnansweredQueries = MaxUnansweredQueries; 6852 SetNextCacheCheckTimeForRecord(m, rr); 6853 LogInfo("Discarding due to domainname case change old: %s", CRDisplayString(m,rr)); 6854 LogInfo("Discarding due to domainname case change new: %s", CRDisplayString(m,&m->rec.r)); 6855 LogInfo("Discarding due to domainname case change in %d slot %3d in %d %d", 6856 NextCacheCheckEvent(rr) - m->timenow, slot, m->rrcache_nextcheck[slot] - m->timenow, m->NextCacheCheck - m->timenow); 6857 // DO NOT break out here -- we want to continue as if we never found it 6858 } 6859 else if (m->rec.r.resrec.rroriginalttl > 0) 6860 { 6861 DNSQuestion *q; 6862 //if (rr->resrec.rroriginalttl == 0) LogMsg("uDNS rescuing %s", CRDisplayString(m, rr)); 6863 RefreshCacheRecord(m, rr, m->rec.r.resrec.rroriginalttl); 6864 6865 // We have to reset the question interval to MaxQuestionInterval so that we don't keep 6866 // polling the network once we get a valid response back. For the first time when a new 6867 // cache entry is created, AnswerCurrentQuestionWithResourceRecord does that. 6868 // Subsequently, if we reissue questions from within the mDNSResponder e.g., DNS server 6869 // configuration changed, without flushing the cache, we reset the question interval here. 6870 // Currently, we do this for for both multicast and unicast questions as long as the record 6871 // type is unique. For unicast, resource record is always unique and for multicast it is 6872 // true for records like A etc. but not for PTR. 6873 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) 6874 { 6875 for (q = m->Questions; q; q=q->next) 6876 { 6877 if (!q->DuplicateOf && !q->LongLived && 6878 ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) 6879 { 6880 q->LastQTime = m->timenow; 6881 q->LastQTxTime = m->timenow; 6882 q->RecentAnswerPkts = 0; 6883 q->ThisQInterval = MaxQuestionInterval; 6884 q->RequestUnicast = mDNSfalse; 6885 q->unansweredQueries = 0; 6886 debugf("mDNSCoreReceiveResponse: Set MaxQuestionInterval for %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 6887 break; // Why break here? Aren't there other questions we might want to look at?-- SC July 2010 6888 } 6889 } 6890 } 6891 break; 6892 } 6893 else 6894 { 6895 // If the packet TTL is zero, that means we're deleting this record. 6896 // To give other hosts on the network a chance to protest, we push the deletion 6897 // out one second into the future. Also, we set UnansweredQueries to MaxUnansweredQueries. 6898 // Otherwise, we'll do final queries for this record at 80% and 90% of its apparent 6899 // lifetime (800ms and 900ms from now) which is a pointless waste of network bandwidth. 6900 // If record's current expiry time is more than a second from now, we set it to expire in one second. 6901 // If the record is already going to expire in less than one second anyway, we leave it alone -- 6902 // we don't want to let the goodbye packet *extend* the record's lifetime in our cache. 6903 debugf("DE for %s", CRDisplayString(m, rr)); 6904 if (RRExpireTime(rr) - m->timenow > mDNSPlatformOneSecond) 6905 { 6906 rr->resrec.rroriginalttl = 1; 6907 rr->TimeRcvd = m->timenow; 6908 rr->UnansweredQueries = MaxUnansweredQueries; 6909 SetNextCacheCheckTimeForRecord(m, rr); 6910 } 6911 break; 6912 } 6913 } 6914 } 6915 6916 // If packet resource record not in our cache, add it now 6917 // (unless it is just a deletion of a record we never had, in which case we don't care) 6918 if (!rr && m->rec.r.resrec.rroriginalttl > 0) 6919 { 6920 const mDNSBool AddToCFList = (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (LLQType != uDNS_LLQ_Events); 6921 const mDNSs32 delay = AddToCFList ? NonZeroTime(m->timenow + mDNSPlatformOneSecond) : 6922 CheckForSoonToExpireRecords(m, m->rec.r.resrec.name, m->rec.r.resrec.namehash, slot); 6923 // If unique, assume we may have to delay delivery of this 'add' event. 6924 // Below, where we walk the CacheFlushRecords list, we either call CacheRecordDeferredAdd() 6925 // to immediately to generate answer callbacks, or we call ScheduleNextCacheCheckTime() 6926 // to schedule an mDNS_Execute task at the appropriate time. 6927 rr = CreateNewCacheEntry(m, slot, cg, delay); 6928 if (rr) 6929 { 6930 if (AddToCFList) { *cfp = rr; cfp = &rr->NextInCFList; *cfp = (CacheRecord*)1; } 6931 else if (rr->DelayDelivery) ScheduleNextCacheCheckTime(m, slot, rr->DelayDelivery); 6932 } 6933 } 6934 } 6935 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 6936 } 6937 6938 exit: 6939 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 6940 6941 // If we've just received one or more records with their cache flush bits set, 6942 // then scan that cache slot to see if there are any old stale records we need to flush 6943 while (CacheFlushRecords != (CacheRecord*)1) 6944 { 6945 CacheRecord *r1 = CacheFlushRecords, *r2; 6946 const mDNSu32 slot = HashSlot(r1->resrec.name); 6947 const CacheGroup *cg = CacheGroupForRecord(m, slot, &r1->resrec); 6948 CacheFlushRecords = CacheFlushRecords->NextInCFList; 6949 r1->NextInCFList = mDNSNULL; 6950 6951 // Look for records in the cache with the same signature as this new one with the cache flush 6952 // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL 6953 // (as required by DNS semantics) or (b) if they're old, mark them for deletion in one second. 6954 // We make these TTL adjustments *only* for records that still have *more* than one second 6955 // remaining to live. Otherwise, a record that we tagged for deletion half a second ago 6956 // (and now has half a second remaining) could inadvertently get its life extended, by either 6957 // (a) if we got an explicit goodbye packet half a second ago, the record would be considered 6958 // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet, 6959 // or (b) otherwise, the record would not be fully resurrected, but would be reset to expire 6960 // in one second, thereby inadvertently delaying its actual expiration, instead of hastening it. 6961 // If this were to happen repeatedly, the record's expiration could be deferred indefinitely. 6962 // To avoid this, we need to ensure that the cache flushing operation will only act to 6963 // *decrease* a record's remaining lifetime, never *increase* it. 6964 for (r2 = cg ? cg->members : mDNSNULL; r2; r2=r2->next) 6965 // For Unicast (null InterfaceID) the DNSservers should also match 6966 if ((r1->resrec.InterfaceID == r2->resrec.InterfaceID) && 6967 (r1->resrec.InterfaceID || (r1->resrec.rDNSServer == r2->resrec.rDNSServer)) && 6968 r1->resrec.rrtype == r2->resrec.rrtype && 6969 r1->resrec.rrclass == r2->resrec.rrclass) 6970 { 6971 // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics) 6972 // else, if record is old, mark it to be flushed 6973 if (m->timenow - r2->TimeRcvd < mDNSPlatformOneSecond && RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond) 6974 { 6975 // If we find mismatched TTLs in an RRSet, correct them. 6976 // We only do this for records with a TTL of 2 or higher. It's possible to have a 6977 // goodbye announcement with the cache flush bit set (or a case-change on record rdata, 6978 // which we treat as a goodbye followed by an addition) and in that case it would be 6979 // inappropriate to synchronize all the other records to a TTL of 0 (or 1). 6980 // We suppress the message for the specific case of correcting from 240 to 60 for type TXT, 6981 // because certain early Bonjour devices are known to have this specific mismatch, and 6982 // there's no point filling syslog with messages about something we already know about. 6983 // We also don't log this for uDNS responses, since a caching name server is obliged 6984 // to give us an aged TTL to correct for how long it has held the record, 6985 // so our received TTLs are expected to vary in that case 6986 if (r2->resrec.rroriginalttl != r1->resrec.rroriginalttl && r1->resrec.rroriginalttl > 1) 6987 { 6988 if (!(r2->resrec.rroriginalttl == 240 && r1->resrec.rroriginalttl == 60 && r2->resrec.rrtype == kDNSType_TXT) && 6989 mDNSOpaque16IsZero(response->h.id)) 6990 LogInfo("Correcting TTL from %4d to %4d for %s", 6991 r2->resrec.rroriginalttl, r1->resrec.rroriginalttl, CRDisplayString(m, r2)); 6992 r2->resrec.rroriginalttl = r1->resrec.rroriginalttl; 6993 } 6994 r2->TimeRcvd = m->timenow; 6995 } 6996 else // else, if record is old, mark it to be flushed 6997 { 6998 verbosedebugf("Cache flush new %p age %d expire in %d %s", r1, m->timenow - r1->TimeRcvd, RRExpireTime(r1) - m->timenow, CRDisplayString(m, r1)); 6999 verbosedebugf("Cache flush old %p age %d expire in %d %s", r2, m->timenow - r2->TimeRcvd, RRExpireTime(r2) - m->timenow, CRDisplayString(m, r2)); 7000 // We set stale records to expire in one second. 7001 // This gives the owner a chance to rescue it if necessary. 7002 // This is important in the case of multi-homing and bridged networks: 7003 // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be 7004 // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit 7005 // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet 7006 // will promptly delete their cached copies of the (still valid) Ethernet IP address record. 7007 // By delaying the deletion by one second, we give X a change to notice that this bridging has 7008 // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches. 7009 7010 // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary 7011 // final expiration queries for this record. 7012 7013 // If a record is deleted twice, first with an explicit DE record, then a second time by virtue of the cache 7014 // flush bit on the new record replacing it, then we allow the record to be deleted immediately, without the usual 7015 // one-second grace period. This improves responsiveness for mDNS_Update(), as used for things like iChat status updates. 7016 // <rdar://problem/5636422> Updating TXT records is too slow 7017 // We check for "rroriginalttl == 1" because we want to include records tagged by the "packet TTL is zero" check above, 7018 // which sets rroriginalttl to 1, but not records tagged by the rdata case-change check, which sets rroriginalttl to 0. 7019 if (r2->TimeRcvd == m->timenow && r2->resrec.rroriginalttl == 1 && r2->UnansweredQueries == MaxUnansweredQueries) 7020 { 7021 LogInfo("Cache flush for DE record %s", CRDisplayString(m, r2)); 7022 r2->resrec.rroriginalttl = 0; 7023 } 7024 else if (RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond) 7025 { 7026 // We only set a record to expire in one second if it currently has *more* than a second to live 7027 // If it's already due to expire in a second or less, we just leave it alone 7028 r2->resrec.rroriginalttl = 1; 7029 r2->UnansweredQueries = MaxUnansweredQueries; 7030 r2->TimeRcvd = m->timenow - 1; 7031 // We use (m->timenow - 1) instead of m->timenow, because we use that to identify records 7032 // that we marked for deletion via an explicit DE record 7033 } 7034 } 7035 SetNextCacheCheckTimeForRecord(m, r2); 7036 } 7037 7038 if (r1->DelayDelivery) // If we were planning to delay delivery of this record, see if we still need to 7039 { 7040 r1->DelayDelivery = CheckForSoonToExpireRecords(m, r1->resrec.name, r1->resrec.namehash, slot); 7041 // If no longer delaying, deliver answer now, else schedule delivery for the appropriate time 7042 if (!r1->DelayDelivery) CacheRecordDeferredAdd(m, r1); 7043 else ScheduleNextCacheCheckTime(m, slot, r1->DelayDelivery); 7044 } 7045 } 7046 7047 // See if we need to generate negative cache entries for unanswered unicast questions 7048 ptr = response->data; 7049 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) 7050 { 7051 DNSQuestion q; 7052 DNSQuestion *qptr = mDNSNULL; 7053 ptr = getQuestion(response, ptr, end, InterfaceID, &q); 7054 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr))) 7055 { 7056 CacheRecord *rr, *neg = mDNSNULL; 7057 mDNSu32 slot = HashSlot(&q.qname); 7058 CacheGroup *cg = CacheGroupForName(m, slot, q.qnamehash, &q.qname); 7059 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 7060 if (SameNameRecordAnswersQuestion(&rr->resrec, qptr)) 7061 { 7062 // 1. If we got a fresh answer to this query, then don't need to generate a negative entry 7063 if (RRExpireTime(rr) - m->timenow > 0) break; 7064 // 2. If we already had a negative entry, keep track of it so we can resurrect it instead of creating a new one 7065 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) neg = rr; 7066 } 7067 // When we're doing parallel unicast and multicast queries for dot-local names (for supporting Microsoft 7068 // Active Directory sites) we don't want to waste memory making negative cache entries for all the unicast answers. 7069 // Otherwise we just fill up our cache with negative entries for just about every single multicast name we ever look up 7070 // (since the Microsoft Active Directory server is going to assert that pretty much every single multicast name doesn't exist). 7071 // This is not only a waste of memory, but there's also the problem of those negative entries confusing us later -- e.g. we 7072 // suppress sending our mDNS query packet because we think we already have a valid (negative) answer to that query in our cache. 7073 // The one exception is that we *DO* want to make a negative cache entry for "local. SOA", for the (common) case where we're 7074 // *not* on a Microsoft Active Directory network, and there is no authoritative server for "local". Note that this is not 7075 // in conflict with the mDNS spec, because that spec says, "Multicast DNS Zones have no SOA record," so it's okay to cache 7076 // negative answers for "local. SOA" from a uDNS server, because the mDNS spec already says that such records do not exist :-) 7077 if (!InterfaceID && q.qtype != kDNSType_SOA && IsLocalDomain(&q.qname)) 7078 { 7079 // If we did not find a positive answer and we can append search domains to this question, 7080 // generate a negative response (without creating a cache entry) to append search domains. 7081 if (qptr->AppendSearchDomains && !rr) 7082 { 7083 LogInfo("mDNSCoreReceiveResponse: Generate negative response for %##s (%s)", q.qname.c, DNSTypeName(q.qtype)); 7084 m->CurrentQuestion = qptr; 7085 GenerateNegativeResponse(m); 7086 m->CurrentQuestion = mDNSNULL; 7087 } 7088 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)); 7089 } 7090 else 7091 { 7092 if (!rr) 7093 { 7094 // We start off assuming a negative caching TTL of 60 seconds 7095 // but then look to see if we can find an SOA authority record to tell us a better value we should be using 7096 mDNSu32 negttl = 60; 7097 int repeat = 0; 7098 const domainname *name = &q.qname; 7099 mDNSu32 hash = q.qnamehash; 7100 7101 // Special case for our special Microsoft Active Directory "local SOA" check. 7102 // Some cheap home gateways don't include an SOA record in the authority section when 7103 // they send negative responses, so we don't know how long to cache the negative result. 7104 // Because we don't want to keep hitting the root name servers with our query to find 7105 // if we're on a network using Microsoft Active Directory using "local" as a private 7106 // internal top-level domain, we make sure to cache the negative result for at least one day. 7107 if (q.qtype == kDNSType_SOA && SameDomainName(&q.qname, &localdomain)) negttl = 60 * 60 * 24; 7108 7109 // If we're going to make (or update) a negative entry, then look for the appropriate TTL from the SOA record 7110 if (response->h.numAuthorities && (ptr = LocateAuthorities(response, end)) != mDNSNULL) 7111 { 7112 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 7113 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_SOA) 7114 { 7115 const rdataSOA *const soa = (const rdataSOA *)m->rec.r.resrec.rdata->u.data; 7116 mDNSu32 ttl_s = soa->min; 7117 // We use the lesser of the SOA.MIN field and the SOA record's TTL, *except* 7118 // for the SOA record for ".", where the record is reported as non-cacheable 7119 // (TTL zero) for some reason, so in this case we just take the SOA record's TTL as-is 7120 if (ttl_s > m->rec.r.resrec.rroriginalttl && m->rec.r.resrec.name->c[0]) 7121 ttl_s = m->rec.r.resrec.rroriginalttl; 7122 if (negttl < ttl_s) negttl = ttl_s; 7123 7124 // Special check for SOA queries: If we queried for a.b.c.d.com, and got no answer, 7125 // with an Authority Section SOA record for d.com, then this is a hint that the authority 7126 // is d.com, and consequently SOA records b.c.d.com and c.d.com don't exist either. 7127 // To do this we set the repeat count so the while loop below will make a series of negative cache entries for us 7128 if (q.qtype == kDNSType_SOA) 7129 { 7130 int qcount = CountLabels(&q.qname); 7131 int scount = CountLabels(m->rec.r.resrec.name); 7132 if (qcount - 1 > scount) 7133 if (SameDomainName(SkipLeadingLabels(&q.qname, qcount - scount), m->rec.r.resrec.name)) 7134 repeat = qcount - 1 - scount; 7135 } 7136 } 7137 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7138 } 7139 7140 // If we already had a negative entry in the cache, then we double our existing negative TTL. This is to avoid 7141 // the case where the record doesn't exist (e.g. particularly for things like our lb._dns-sd._udp.<domain> query), 7142 // and the server returns no SOA record (or an SOA record with a small MIN TTL) so we assume a TTL 7143 // of 60 seconds, and we end up polling the server every minute for a record that doesn't exist. 7144 // With this fix in place, when this happens, we double the effective TTL each time (up to one hour), 7145 // so that we back off our polling rate and don't keep hitting the server continually. 7146 if (neg) 7147 { 7148 if (negttl < neg->resrec.rroriginalttl * 2) 7149 negttl = neg->resrec.rroriginalttl * 2; 7150 if (negttl > 3600) 7151 negttl = 3600; 7152 } 7153 7154 negttl = GetEffectiveTTL(LLQType, negttl); // Add 25% grace period if necessary 7155 7156 // If we already had a negative cache entry just update it, else make one or more new negative cache entries 7157 if (neg) 7158 { 7159 debugf("Renewing negative TTL from %d to %d %s", neg->resrec.rroriginalttl, negttl, CRDisplayString(m, neg)); 7160 RefreshCacheRecord(m, neg, negttl); 7161 } 7162 else while (1) 7163 { 7164 debugf("mDNSCoreReceiveResponse making negative cache entry TTL %d for %##s (%s)", negttl, name->c, DNSTypeName(q.qtype)); 7165 MakeNegativeCacheRecord(m, &m->rec.r, name, hash, q.qtype, q.qclass, negttl, mDNSInterface_Any, qptr->qDNSServer); 7166 CreateNewCacheEntry(m, slot, cg, 0); // We never need any delivery delay for these generated negative cache records 7167 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7168 if (!repeat) break; 7169 repeat--; 7170 name = (const domainname *)(name->c + 1 + name->c[0]); 7171 hash = DomainNameHashValue(name); 7172 slot = HashSlot(name); 7173 cg = CacheGroupForName(m, slot, hash, name); 7174 } 7175 } 7176 } 7177 } 7178 } 7179 } 7180 7181 // ScheduleWakeup causes all proxy records with WakeUp.HMAC matching mDNSEthAddr 'e' to be deregistered, causing 7182 // multiple wakeup magic packets to be sent if appropriate, and all records to be ultimately freed after a few seconds. 7183 // ScheduleWakeup is called on mDNS record conflicts, ARP conflicts, NDP conflicts, or reception of trigger traffic 7184 // that warrants waking the sleeping host. 7185 // ScheduleWakeup must be called with the lock held (ScheduleWakeupForList uses mDNS_Deregister_internal) 7186 7187 mDNSlocal void ScheduleWakeupForList(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e, AuthRecord *const thelist) 7188 { 7189 // We don't need to use the m->CurrentRecord mechanism here because the target HMAC is nonzero, 7190 // so all we're doing is marking the record to generate a few wakeup packets 7191 AuthRecord *rr; 7192 if (!e->l[0]) { LogMsg("ScheduleWakeupForList ERROR: Target HMAC is zero"); return; } 7193 for (rr = thelist; rr; rr = rr->next) 7194 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && mDNSSameEthAddress(&rr->WakeUp.HMAC, e)) 7195 { 7196 LogInfo("ScheduleWakeupForList: Scheduling wakeup packets for %s", ARDisplayString(m, rr)); 7197 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 7198 } 7199 } 7200 7201 mDNSlocal void ScheduleWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e) 7202 { 7203 if (!e->l[0]) { LogMsg("ScheduleWakeup ERROR: Target HMAC is zero"); return; } 7204 ScheduleWakeupForList(m, InterfaceID, e, m->DuplicateRecords); 7205 ScheduleWakeupForList(m, InterfaceID, e, m->ResourceRecords); 7206 } 7207 7208 mDNSlocal void SPSRecordCallback(mDNS *const m, AuthRecord *const ar, mStatus result) 7209 { 7210 if (result && result != mStatus_MemFree) 7211 LogInfo("SPS Callback %d %s", result, ARDisplayString(m, ar)); 7212 7213 if (result == mStatus_NameConflict) 7214 { 7215 mDNS_Lock(m); 7216 LogMsg("%-7s Conflicting mDNS -- waking %.6a %s", InterfaceNameForID(m, ar->resrec.InterfaceID), &ar->WakeUp.HMAC, ARDisplayString(m, ar)); 7217 if (ar->WakeUp.HMAC.l[0]) 7218 { 7219 SendWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.IMAC, &ar->WakeUp.password); // Send one wakeup magic packet 7220 ScheduleWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.HMAC); // Schedule all other records with the same owner to be woken 7221 } 7222 mDNS_Unlock(m); 7223 } 7224 7225 if (result == mStatus_NameConflict || result == mStatus_MemFree) 7226 { 7227 m->ProxyRecords--; 7228 mDNSPlatformMemFree(ar); 7229 mDNS_UpdateAllowSleep(m); 7230 } 7231 } 7232 7233 mDNSlocal void mDNSCoreReceiveUpdate(mDNS *const m, 7234 const DNSMessage *const msg, const mDNSu8 *end, 7235 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, 7236 const mDNSInterfaceID InterfaceID) 7237 { 7238 int i; 7239 AuthRecord opt; 7240 mDNSu8 *p = m->omsg.data; 7241 OwnerOptData owner = zeroOwner; // Need to zero this, so we'll know if this Update packet was missing its Owner option 7242 mDNSu32 updatelease = 0; 7243 const mDNSu8 *ptr; 7244 7245 LogSPS("Received Update from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " 7246 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes", 7247 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, 7248 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 7249 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 7250 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 7251 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data); 7252 7253 if (!InterfaceID || !m->SPSSocket || !mDNSSameIPPort(dstport, m->SPSSocket->port)) return; 7254 7255 if (mDNS_PacketLoggingEnabled) 7256 DumpPacket(m, mStatus_NoError, mDNSfalse, "UDP", srcaddr, srcport, dstaddr, dstport, msg, end); 7257 7258 ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space + DNSOpt_OwnerData_ID_Space); 7259 if (ptr) 7260 { 7261 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); 7262 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) 7263 { 7264 const rdataOPT *o; 7265 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 7266 for (o = &m->rec.r.resrec.rdata->u.opt[0]; o < e; o++) 7267 { 7268 if (o->opt == kDNSOpt_Lease) updatelease = o->u.updatelease; 7269 else if (o->opt == kDNSOpt_Owner && o->u.owner.vers == 0) owner = o->u.owner; 7270 } 7271 } 7272 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7273 } 7274 7275 InitializeDNSMessage(&m->omsg.h, msg->h.id, UpdateRespFlags); 7276 7277 if (!updatelease || !owner.HMAC.l[0]) 7278 { 7279 static int msgs = 0; 7280 if (msgs < 100) 7281 { 7282 msgs++; 7283 LogMsg("Refusing sleep proxy registration from %#a:%d:%s%s", srcaddr, mDNSVal16(srcport), 7284 !updatelease ? " No lease" : "", !owner.HMAC.l[0] ? " No owner" : ""); 7285 } 7286 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_FormErr; 7287 } 7288 else if (m->ProxyRecords + msg->h.mDNS_numUpdates > MAX_PROXY_RECORDS) 7289 { 7290 static int msgs = 0; 7291 if (msgs < 100) 7292 { 7293 msgs++; 7294 LogMsg("Refusing sleep proxy registration from %#a:%d: Too many records %d + %d = %d > %d", srcaddr, mDNSVal16(srcport), 7295 m->ProxyRecords, msg->h.mDNS_numUpdates, m->ProxyRecords + msg->h.mDNS_numUpdates, MAX_PROXY_RECORDS); 7296 } 7297 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused; 7298 } 7299 else 7300 { 7301 LogSPS("Received Update for H-MAC %.6a I-MAC %.6a Password %.6a seq %d", &owner.HMAC, &owner.IMAC, &owner.password, owner.seq); 7302 7303 if (updatelease > 24 * 60 * 60) 7304 updatelease = 24 * 60 * 60; 7305 7306 if (updatelease > 0x40000000UL / mDNSPlatformOneSecond) 7307 updatelease = 0x40000000UL / mDNSPlatformOneSecond; 7308 7309 ptr = LocateAuthorities(msg, end); 7310 for (i = 0; i < msg->h.mDNS_numUpdates && ptr && ptr < end; i++) 7311 { 7312 ptr = GetLargeResourceRecord(m, msg, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 7313 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) 7314 { 7315 mDNSu16 RDLengthMem = GetRDLengthMem(&m->rec.r.resrec); 7316 AuthRecord *ar = mDNSPlatformMemAllocate(sizeof(AuthRecord) - sizeof(RDataBody) + RDLengthMem); 7317 if (!ar) { m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused; break; } 7318 else 7319 { 7320 mDNSu8 RecordType = m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask ? kDNSRecordTypeUnique : kDNSRecordTypeShared; 7321 m->rec.r.resrec.rrclass &= ~kDNSClass_UniqueRRSet; 7322 ClearIdenticalProxyRecords(m, &owner, m->DuplicateRecords); // Make sure we don't have any old stale duplicates of this record 7323 ClearIdenticalProxyRecords(m, &owner, m->ResourceRecords); 7324 mDNS_SetupResourceRecord(ar, mDNSNULL, InterfaceID, m->rec.r.resrec.rrtype, m->rec.r.resrec.rroriginalttl, RecordType, AuthRecordAny, SPSRecordCallback, ar); 7325 AssignDomainName(&ar->namestorage, m->rec.r.resrec.name); 7326 ar->resrec.rdlength = GetRDLength(&m->rec.r.resrec, mDNSfalse); 7327 ar->resrec.rdata->MaxRDLength = RDLengthMem; 7328 mDNSPlatformMemCopy(ar->resrec.rdata->u.data, m->rec.r.resrec.rdata->u.data, RDLengthMem); 7329 ar->ForceMCast = mDNStrue; 7330 ar->WakeUp = owner; 7331 if (m->rec.r.resrec.rrtype == kDNSType_PTR) 7332 { 7333 mDNSs32 t = ReverseMapDomainType(m->rec.r.resrec.name); 7334 if (t == mDNSAddrType_IPv4) GetIPv4FromName(&ar->AddressProxy, m->rec.r.resrec.name); 7335 else if (t == mDNSAddrType_IPv6) GetIPv6FromName(&ar->AddressProxy, m->rec.r.resrec.name); 7336 debugf("mDNSCoreReceiveUpdate: PTR %d %d %#a %s", t, ar->AddressProxy.type, &ar->AddressProxy, ARDisplayString(m, ar)); 7337 if (ar->AddressProxy.type) SetSPSProxyListChanged(InterfaceID); 7338 } 7339 ar->TimeRcvd = m->timenow; 7340 ar->TimeExpire = m->timenow + updatelease * mDNSPlatformOneSecond; 7341 if (m->NextScheduledSPS - ar->TimeExpire > 0) 7342 m->NextScheduledSPS = ar->TimeExpire; 7343 mDNS_Register_internal(m, ar); 7344 // Unsolicited Neighbor Advertisements (RFC 2461 Section 7.2.6) give us fast address cache updating, 7345 // but some older IPv6 clients get confused by them, so for now we don't send them. Without Unsolicited 7346 // Neighbor Advertisements we have to rely on Neighbor Unreachability Detection instead, which is slower. 7347 // Given this, we'll do our best to wake for existing IPv6 connections, but we don't want to encourage 7348 // new ones for sleeping clients, so we'll we send deletions for our SPS clients' AAAA records. 7349 if (m->KnownBugs & mDNS_KnownBug_LimitedIPv6) 7350 if (ar->resrec.rrtype == kDNSType_AAAA) ar->resrec.rroriginalttl = 0; 7351 m->ProxyRecords++; 7352 mDNS_UpdateAllowSleep(m); 7353 LogSPS("SPS Registered %4d %X %s", m->ProxyRecords, RecordType, ARDisplayString(m,ar)); 7354 } 7355 } 7356 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7357 } 7358 7359 if (m->omsg.h.flags.b[1] & kDNSFlag1_RC_Mask) 7360 { 7361 LogMsg("Refusing sleep proxy registration from %#a:%d: Out of memory", srcaddr, mDNSVal16(srcport)); 7362 ClearProxyRecords(m, &owner, m->DuplicateRecords); 7363 ClearProxyRecords(m, &owner, m->ResourceRecords); 7364 } 7365 else 7366 { 7367 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 7368 opt.resrec.rrclass = NormalMaxDNSMessageData; 7369 opt.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record 7370 opt.resrec.rdestimate = sizeof(rdataOPT); 7371 opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; 7372 opt.resrec.rdata->u.opt[0].u.updatelease = updatelease; 7373 p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); 7374 } 7375 } 7376 7377 if (p) mDNSSendDNSMessage(m, &m->omsg, p, InterfaceID, m->SPSSocket, srcaddr, srcport, mDNSNULL, mDNSNULL); 7378 } 7379 7380 mDNSlocal void mDNSCoreReceiveUpdateR(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *end, const mDNSInterfaceID InterfaceID) 7381 { 7382 if (InterfaceID) 7383 { 7384 mDNSu32 updatelease = 60 * 60; // If SPS fails to indicate lease time, assume one hour 7385 const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space); 7386 if (ptr) 7387 { 7388 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); 7389 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) 7390 { 7391 const rdataOPT *o; 7392 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 7393 for (o = &m->rec.r.resrec.rdata->u.opt[0]; o < e; o++) 7394 if (o->opt == kDNSOpt_Lease) 7395 { 7396 updatelease = o->u.updatelease; 7397 LogSPS("Sleep Proxy granted lease time %4d seconds", updatelease); 7398 } 7399 } 7400 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7401 } 7402 7403 if (m->CurrentRecord) 7404 LogMsg("mDNSCoreReceiveUpdateR ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 7405 m->CurrentRecord = m->ResourceRecords; 7406 while (m->CurrentRecord) 7407 { 7408 AuthRecord *const rr = m->CurrentRecord; 7409 if (rr->resrec.InterfaceID == InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name)))) 7410 if (mDNSSameOpaque16(rr->updateid, msg->h.id)) 7411 { 7412 rr->updateid = zeroID; 7413 rr->expire = NonZeroTime(m->timenow + updatelease * mDNSPlatformOneSecond); 7414 LogSPS("Sleep Proxy %s record %5d %s", rr->WakeUp.HMAC.l[0] ? "transferred" : "registered", updatelease, ARDisplayString(m,rr)); 7415 if (rr->WakeUp.HMAC.l[0]) 7416 { 7417 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host 7418 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it 7419 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 7420 } 7421 } 7422 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 7423 // new records could have been added to the end of the list as a result of that call. 7424 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 7425 m->CurrentRecord = rr->next; 7426 } 7427 } 7428 // If we were waiting to go to sleep, then this SPS registration or wide-area record deletion 7429 // may have been the thing we were waiting for, so schedule another check to see if we can sleep now. 7430 if (m->SleepLimit) m->NextScheduledSPRetry = m->timenow; 7431 } 7432 7433 mDNSexport void MakeNegativeCacheRecord(mDNS *const m, CacheRecord *const cr, 7434 const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds, mDNSInterfaceID InterfaceID, DNSServer *dnsserver) 7435 { 7436 if (cr == &m->rec.r && m->rec.r.resrec.RecordType) 7437 { 7438 LogMsg("MakeNegativeCacheRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r)); 7439 #if ForceAlerts 7440 *(long*)0 = 0; 7441 #endif 7442 } 7443 7444 // Create empty resource record 7445 cr->resrec.RecordType = kDNSRecordTypePacketNegative; 7446 cr->resrec.InterfaceID = InterfaceID; 7447 cr->resrec.rDNSServer = dnsserver; 7448 cr->resrec.name = name; // Will be updated to point to cg->name when we call CreateNewCacheEntry 7449 cr->resrec.rrtype = rrtype; 7450 cr->resrec.rrclass = rrclass; 7451 cr->resrec.rroriginalttl = ttl_seconds; 7452 cr->resrec.rdlength = 0; 7453 cr->resrec.rdestimate = 0; 7454 cr->resrec.namehash = namehash; 7455 cr->resrec.rdatahash = 0; 7456 cr->resrec.rdata = (RData*)&cr->smallrdatastorage; 7457 cr->resrec.rdata->MaxRDLength = 0; 7458 7459 cr->NextInKAList = mDNSNULL; 7460 cr->TimeRcvd = m->timenow; 7461 cr->DelayDelivery = 0; 7462 cr->NextRequiredQuery = m->timenow; 7463 cr->LastUsed = m->timenow; 7464 cr->CRActiveQuestion = mDNSNULL; 7465 cr->UnansweredQueries = 0; 7466 cr->LastUnansweredTime = 0; 7467 #if ENABLE_MULTI_PACKET_QUERY_SNOOPING 7468 cr->MPUnansweredQ = 0; 7469 cr->MPLastUnansweredQT = 0; 7470 cr->MPUnansweredKA = 0; 7471 cr->MPExpectingKA = mDNSfalse; 7472 #endif 7473 cr->NextInCFList = mDNSNULL; 7474 } 7475 7476 mDNSexport void mDNSCoreReceive(mDNS *const m, void *const pkt, const mDNSu8 *const end, 7477 const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, const mDNSIPPort dstport, 7478 const mDNSInterfaceID InterfaceID) 7479 { 7480 mDNSInterfaceID ifid = InterfaceID; 7481 DNSMessage *msg = (DNSMessage *)pkt; 7482 const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery; 7483 const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery; 7484 const mDNSu8 UpdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_Update; 7485 const mDNSu8 UpdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update; 7486 mDNSu8 QR_OP; 7487 mDNSu8 *ptr = mDNSNULL; 7488 mDNSBool TLS = (dstaddr == (mDNSAddr *)1); // For debug logs: dstaddr = 0 means TCP; dstaddr = 1 means TLS 7489 if (TLS) dstaddr = mDNSNULL; 7490 7491 #ifndef UNICAST_DISABLED 7492 if (mDNSSameAddress(srcaddr, &m->Router)) 7493 { 7494 #ifdef _LEGACY_NAT_TRAVERSAL_ 7495 if (mDNSSameIPPort(srcport, SSDPPort) || (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port))) 7496 { 7497 mDNS_Lock(m); 7498 LNT_ConfigureRouterInfo(m, InterfaceID, pkt, (mDNSu16)(end - (mDNSu8 *)pkt)); 7499 mDNS_Unlock(m); 7500 return; 7501 } 7502 #endif 7503 if (mDNSSameIPPort(srcport, NATPMPPort)) 7504 { 7505 mDNS_Lock(m); 7506 uDNS_ReceiveNATPMPPacket(m, InterfaceID, pkt, (mDNSu16)(end - (mDNSu8 *)pkt)); 7507 mDNS_Unlock(m); 7508 return; 7509 } 7510 } 7511 #ifdef _LEGACY_NAT_TRAVERSAL_ 7512 else if (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port)) { debugf("Ignoring SSDP response from %#a:%d", srcaddr, mDNSVal16(srcport)); return; } 7513 #endif 7514 7515 #endif 7516 if ((unsigned)(end - (mDNSu8 *)pkt) < sizeof(DNSMessageHeader)) 7517 { 7518 LogMsg("DNS Message from %#a:%d to %#a:%d length %d too short", srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), end - (mDNSu8 *)pkt); 7519 return; 7520 } 7521 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask); 7522 // Read the integer parts which are in IETF byte-order (MSB first, LSB second) 7523 ptr = (mDNSu8 *)&msg->h.numQuestions; 7524 msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); 7525 msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); 7526 msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]); 7527 msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]); 7528 7529 if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; } 7530 7531 // We use zero addresses and all-ones addresses at various places in the code to indicate special values like "no address" 7532 // If we accept and try to process a packet with zero or all-ones source address, that could really mess things up 7533 if (srcaddr && !mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; } 7534 7535 mDNS_Lock(m); 7536 m->PktNum++; 7537 #ifndef UNICAST_DISABLED 7538 if (!dstaddr || (!mDNSAddressIsAllDNSLinkGroup(dstaddr) && (QR_OP == StdR || QR_OP == UpdR))) 7539 if (!mDNSOpaque16IsZero(msg->h.id)) // uDNS_ReceiveMsg only needs to get real uDNS responses, not "QU" mDNS responses 7540 { 7541 ifid = mDNSInterface_Any; 7542 if (mDNS_PacketLoggingEnabled) 7543 DumpPacket(m, mStatus_NoError, mDNSfalse, TLS ? "TLS" : !dstaddr ? "TCP" : "UDP", srcaddr, srcport, dstaddr, dstport, msg, end); 7544 uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport); 7545 // Note: mDNSCore also needs to get access to received unicast responses 7546 } 7547 #endif 7548 if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid); 7549 else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid); 7550 else if (QR_OP == UpdQ) mDNSCoreReceiveUpdate (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID); 7551 else if (QR_OP == UpdR) mDNSCoreReceiveUpdateR (m, msg, end, InterfaceID); 7552 else 7553 { 7554 LogMsg("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d length %d on %p (ignored)", 7555 msg->h.flags.b[0], msg->h.flags.b[1], srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), end - (mDNSu8 *)pkt, InterfaceID); 7556 if (mDNS_LoggingEnabled) 7557 { 7558 int i = 0; 7559 while (i<end - (mDNSu8 *)pkt) 7560 { 7561 char buffer[128]; 7562 char *p = buffer + mDNS_snprintf(buffer, sizeof(buffer), "%04X", i); 7563 do if (i<end - (mDNSu8 *)pkt) p += mDNS_snprintf(p, sizeof(buffer), " %02X", ((mDNSu8 *)pkt)[i]); while (++i & 15); 7564 LogInfo("%s", buffer); 7565 } 7566 } 7567 } 7568 // Packet reception often causes a change to the task list: 7569 // 1. Inbound queries can cause us to need to send responses 7570 // 2. Conflicing response packets received from other hosts can cause us to need to send defensive responses 7571 // 3. Other hosts announcing deletion of shared records can cause us to need to re-assert those records 7572 // 4. Response packets that answer questions may cause our client to issue new questions 7573 mDNS_Unlock(m); 7574 } 7575 7576 // *************************************************************************** 7577 #if COMPILER_LIKES_PRAGMA_MARK 7578 #pragma mark - 7579 #pragma mark - Searcher Functions 7580 #endif 7581 7582 // Targets are considered the same if both queries are untargeted, or 7583 // if both are targeted to the same address+port 7584 // (If Target address is zero, TargetPort is undefined) 7585 #define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \ 7586 (mDNSSameAddress(&(A)->Target, &(B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort))) 7587 7588 // Note: We explicitly disallow making a public query be a duplicate of a private one. This is to avoid the 7589 // circular deadlock where a client does a query for something like "dns-sd -Q _dns-query-tls._tcp.company.com SRV" 7590 // and we have a key for company.com, so we try to locate the private query server for company.com, which necessarily entails 7591 // doing a standard DNS query for the _dns-query-tls._tcp SRV record for company.com. If we make the latter (public) query 7592 // a duplicate of the former (private) query, then it will block forever waiting for an answer that will never come. 7593 // 7594 // We keep SuppressUnusable questions separate so that we can return a quick response to them and not get blocked behind 7595 // the queries that are not marked SuppressUnusable. But if the query is not suppressed, they are treated the same as 7596 // non-SuppressUnusable questions. This should be fine as the goal of SuppressUnusable is to return quickly only if it 7597 // is suppressed. If it is not suppressed, we do try all the DNS servers for valid answers like any other question. 7598 // The main reason for this design is that cache entries point to a *single* question and that question is responsible 7599 // for keeping the cache fresh as long as it is active. Having multiple active question for a single cache entry 7600 // breaks this design principle. 7601 7602 // If IsLLQ(Q) is true, it means the question is both: 7603 // (a) long-lived and 7604 // (b) being performed by a unicast DNS long-lived query (either full LLQ, or polling) 7605 // for multicast questions, we don't want to treat LongLived as anything special 7606 #define IsLLQ(Q) ((Q)->LongLived && !mDNSOpaque16IsZero((Q)->TargetQID)) 7607 7608 mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question) 7609 { 7610 DNSQuestion *q; 7611 // Note: A question can only be marked as a duplicate of one that occurs *earlier* in the list. 7612 // This prevents circular references, where two questions are each marked as a duplicate of the other. 7613 // Accordingly, we break out of the loop when we get to 'question', because there's no point searching 7614 // further in the list. 7615 for (q = m->Questions; q && q != question; q=q->next) // Scan our list for another question 7616 if (q->InterfaceID == question->InterfaceID && // with the same InterfaceID, 7617 SameQTarget(q, question) && // and same unicast/multicast target settings 7618 q->qtype == question->qtype && // type, 7619 q->qclass == question->qclass && // class, 7620 IsLLQ(q) == IsLLQ(question) && // and long-lived status matches 7621 (!q->AuthInfo || question->AuthInfo) && // to avoid deadlock, don't make public query dup of a private one 7622 (q->SuppressQuery == question->SuppressQuery) && // Questions that are suppressed/not suppressed 7623 q->qnamehash == question->qnamehash && 7624 SameDomainName(&q->qname, &question->qname)) // and name 7625 return(q); 7626 return(mDNSNULL); 7627 } 7628 7629 // This is called after a question is deleted, in case other identical questions were being suppressed as duplicates 7630 mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, DNSQuestion *const question) 7631 { 7632 DNSQuestion *q; 7633 DNSQuestion *first = mDNSNULL; 7634 7635 // This is referring to some other question as duplicate. No other question can refer to this 7636 // question as a duplicate. 7637 if (question->DuplicateOf) 7638 { 7639 LogInfo("UpdateQuestionDuplicates: question %p %##s (%s) duplicate of %p %##s (%s)", 7640 question, question->qname.c, DNSTypeName(question->qtype), 7641 question->DuplicateOf, question->DuplicateOf->qname.c, DNSTypeName(question->DuplicateOf->qtype)); 7642 return; 7643 } 7644 7645 for (q = m->Questions; q; q=q->next) // Scan our list of questions 7646 if (q->DuplicateOf == question) // To see if any questions were referencing this as their duplicate 7647 { 7648 q->DuplicateOf = first; 7649 if (!first) 7650 { 7651 first = q; 7652 // If q used to be a duplicate, but now is not, 7653 // then inherit the state from the question that's going away 7654 q->LastQTime = question->LastQTime; 7655 q->ThisQInterval = question->ThisQInterval; 7656 q->ExpectUnicastResp = question->ExpectUnicastResp; 7657 q->LastAnswerPktNum = question->LastAnswerPktNum; 7658 q->RecentAnswerPkts = question->RecentAnswerPkts; 7659 q->RequestUnicast = question->RequestUnicast; 7660 q->LastQTxTime = question->LastQTxTime; 7661 q->CNAMEReferrals = question->CNAMEReferrals; 7662 q->nta = question->nta; 7663 q->servAddr = question->servAddr; 7664 q->servPort = question->servPort; 7665 q->qDNSServer = question->qDNSServer; 7666 q->validDNSServers = question->validDNSServers; 7667 q->unansweredQueries = question->unansweredQueries; 7668 q->noServerResponse = question->noServerResponse; 7669 q->triedAllServersOnce = question->triedAllServersOnce; 7670 7671 q->TargetQID = question->TargetQID; 7672 q->LocalSocket = question->LocalSocket; 7673 7674 q->state = question->state; 7675 // q->tcp = question->tcp; 7676 q->ReqLease = question->ReqLease; 7677 q->expire = question->expire; 7678 q->ntries = question->ntries; 7679 q->id = question->id; 7680 7681 question->LocalSocket = mDNSNULL; 7682 question->nta = mDNSNULL; // If we've got a GetZoneData in progress, transfer it to the newly active question 7683 // question->tcp = mDNSNULL; 7684 7685 if (q->LocalSocket) 7686 debugf("UpdateQuestionDuplicates transferred LocalSocket pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 7687 7688 if (q->nta) 7689 { 7690 LogInfo("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 7691 q->nta->ZoneDataContext = q; 7692 } 7693 7694 // Need to work out how to safely transfer this state too -- appropriate context pointers need to be updated or the code will crash 7695 if (question->tcp) LogInfo("UpdateQuestionDuplicates did not transfer tcp pointer"); 7696 7697 if (question->state == LLQ_Established) 7698 { 7699 LogInfo("UpdateQuestionDuplicates transferred LLQ state for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 7700 question->state = 0; // Must zero question->state, or mDNS_StopQuery_internal will clean up and cancel our LLQ from the server 7701 } 7702 7703 SetNextQueryTime(m,q); 7704 } 7705 } 7706 } 7707 7708 mDNSexport McastResolver *mDNS_AddMcastResolver(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, mDNSu32 timeout) 7709 { 7710 McastResolver **p = &m->McastResolvers; 7711 McastResolver *tmp = mDNSNULL; 7712 7713 if (!d) d = (const domainname *)""; 7714 7715 LogInfo("mDNS_AddMcastResolver: Adding %##s, InterfaceID %p, timeout %u", d->c, interface, timeout); 7716 7717 if (m->mDNS_busy != m->mDNS_reentrancy+1) 7718 LogMsg("mDNS_AddMcastResolver: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy); 7719 7720 while (*p) // Check if we already have this {interface, domain} tuple registered 7721 { 7722 if ((*p)->interface == interface && SameDomainName(&(*p)->domain, d)) 7723 { 7724 if (!((*p)->flags & DNSServer_FlagDelete)) LogMsg("Note: Mcast Resolver domain %##s (%p) registered more than once", d->c, interface); 7725 (*p)->flags &= ~DNSServer_FlagDelete; 7726 tmp = *p; 7727 *p = tmp->next; 7728 tmp->next = mDNSNULL; 7729 } 7730 else 7731 p=&(*p)->next; 7732 } 7733 7734 if (tmp) *p = tmp; // move to end of list, to ensure ordering from platform layer 7735 else 7736 { 7737 // allocate, add to list 7738 *p = mDNSPlatformMemAllocate(sizeof(**p)); 7739 if (!*p) LogMsg("mDNS_AddMcastResolver: ERROR!! - malloc"); 7740 else 7741 { 7742 (*p)->interface = interface; 7743 (*p)->flags = DNSServer_FlagNew; 7744 (*p)->timeout = timeout; 7745 AssignDomainName(&(*p)->domain, d); 7746 (*p)->next = mDNSNULL; 7747 } 7748 } 7749 return(*p); 7750 } 7751 7752 mDNSinline mDNSs32 PenaltyTimeForServer(mDNS *m, DNSServer *server) 7753 { 7754 mDNSs32 ptime = 0; 7755 if (server->penaltyTime != 0) 7756 { 7757 ptime = server->penaltyTime - m->timenow; 7758 if (ptime < 0) 7759 { 7760 // This should always be a positive value between 0 and DNSSERVER_PENALTY_TIME 7761 // If it does not get reset in ResetDNSServerPenalties for some reason, we do it 7762 // here 7763 LogMsg("PenaltyTimeForServer: PenaltyTime negative %d, (server penaltyTime %d, timenow %d) resetting the penalty", 7764 ptime, server->penaltyTime, m->timenow); 7765 server->penaltyTime = 0; 7766 ptime = 0; 7767 } 7768 } 7769 return ptime; 7770 } 7771 7772 //Checks to see whether the newname is a better match for the name, given the best one we have 7773 //seen so far (given in bestcount). 7774 //Returns -1 if the newname is not a better match 7775 //Returns 0 if the newname is the same as the old match 7776 //Returns 1 if the newname is a better match 7777 mDNSlocal int BetterMatchForName(const domainname *name, int namecount, const domainname *newname, int newcount, 7778 int bestcount) 7779 { 7780 // If the name contains fewer labels than the new server's domain or the new name 7781 // contains fewer labels than the current best, then it can't possibly be a better match 7782 if (namecount < newcount || newcount < bestcount) return -1; 7783 7784 // If there is no match, return -1 and the caller will skip this newname for 7785 // selection 7786 // 7787 // If we find a match and the number of labels is the same as bestcount, then 7788 // we return 0 so that the caller can do additional logic to pick one of 7789 // the best based on some other factors e.g., penaltyTime 7790 // 7791 // If we find a match and the number of labels is more than bestcount, then we 7792 // return 1 so that the caller can pick this over the old one. 7793 // 7794 // Note: newcount can either be equal or greater than bestcount beause of the 7795 // check above. 7796 7797 if (SameDomainName(SkipLeadingLabels(name, namecount - newcount), newname)) 7798 return bestcount == newcount ? 0 : 1; 7799 else 7800 return -1; 7801 } 7802 7803 // Normally, we have McastResolvers for .local, in-addr.arpa and ip6.arpa. But there 7804 // can be queries that can forced to multicast (ForceMCast) even though they don't end in these 7805 // names. In that case, we give a default timeout of 5 seconds 7806 #define DEFAULT_MCAST_TIMEOUT 5 7807 mDNSlocal mDNSu32 GetTimeoutForMcastQuestion(mDNS *m, DNSQuestion *question) 7808 { 7809 McastResolver *curmatch = mDNSNULL; 7810 int bestmatchlen = -1, namecount = CountLabels(&question->qname); 7811 McastResolver *curr; 7812 int bettermatch, currcount; 7813 for (curr = m->McastResolvers; curr; curr = curr->next) 7814 { 7815 currcount = CountLabels(&curr->domain); 7816 bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen); 7817 // Take the first best match. If there are multiple equally good matches (bettermatch = 0), we take 7818 // the timeout value from the first one 7819 if (bettermatch == 1) 7820 { 7821 curmatch = curr; 7822 bestmatchlen = currcount; 7823 } 7824 } 7825 LogInfo("GetTimeoutForMcastQuestion: question %##s curmatch %p, Timeout %d", question->qname.c, curmatch, 7826 curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT); 7827 return ( curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT); 7828 } 7829 7830 // Sets all the Valid DNS servers for a question 7831 mDNSexport mDNSu32 SetValidDNSServers(mDNS *m, DNSQuestion *question) 7832 { 7833 DNSServer *curmatch = mDNSNULL; 7834 int bestmatchlen = -1, namecount = CountLabels(&question->qname); 7835 DNSServer *curr; 7836 int bettermatch, currcount; 7837 int index = 0; 7838 mDNSu32 timeout = 0; 7839 7840 question->validDNSServers = zeroOpaque64; 7841 for (curr = m->DNSServers; curr; curr = curr->next) 7842 { 7843 debugf("SetValidDNSServers: Parsing DNS server Address %#a (Domain %##s), Scope: %d", &curr->addr, curr->domain.c, curr->scoped); 7844 // skip servers that will soon be deleted 7845 if (curr->flags & DNSServer_FlagDelete) 7846 { debugf("SetValidDNSServers: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index, &curr->addr, curr->domain.c, curr->scoped); continue; } 7847 7848 // This happens normally when you unplug the interface where we reset the interfaceID to mDNSInterface_Any for all 7849 // the DNS servers whose scope match the interfaceID. Few seconds later, we also receive the updated DNS configuration. 7850 // But any questions that has mDNSInterface_Any scope that are started/restarted before we receive the update 7851 // (e.g., CheckSuppressUnusableQuestions is called when interfaces are deregistered with the core) should not 7852 // match the scoped entries by mistake. 7853 // 7854 // Note: DNS configuration change will help pick the new dns servers but currently it does not affect the timeout 7855 7856 if (curr->scoped && curr->interface == mDNSInterface_Any) 7857 { debugf("SetValidDNSServers: Scoped DNS server %#a (Domain %##s) with Interface Any", &curr->addr, curr->domain.c); continue; } 7858 7859 currcount = CountLabels(&curr->domain); 7860 if ((!curr->scoped && (!question->InterfaceID || (question->InterfaceID == mDNSInterface_Unicast))) || (curr->interface == question->InterfaceID)) 7861 { 7862 bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen); 7863 7864 // If we found a better match (bettermatch == 1) then clear all the bits 7865 // corresponding to the old DNSServers that we have may set before and start fresh. 7866 // If we find an equal match, then include that DNSServer also by setting the corresponding 7867 // bit 7868 if ((bettermatch == 1) || (bettermatch == 0)) 7869 { 7870 curmatch = curr; 7871 bestmatchlen = currcount; 7872 if (bettermatch) { debugf("SetValidDNSServers: Resetting all the bits"); question->validDNSServers = zeroOpaque64; timeout = 0; } 7873 debugf("SetValidDNSServers: question %##s Setting the bit for DNS server Address %#a (Domain %##s), Scoped:%d index %d," 7874 " Timeout %d, interface %p", question->qname.c, &curr->addr, curr->domain.c, curr->scoped, index, curr->timeout, 7875 curr->interface); 7876 timeout += curr->timeout; 7877 bit_set_opaque64(question->validDNSServers, index); 7878 } 7879 } 7880 index++; 7881 } 7882 question->noServerResponse = 0; 7883 7884 debugf("SetValidDNSServers: ValidDNSServer bits 0x%x%x for question %p %##s (%s)", 7885 question->validDNSServers.l[1], question->validDNSServers.l[0], question, question->qname.c, DNSTypeName(question->qtype)); 7886 // If there are no matching resolvers, then use the default value to timeout 7887 return (timeout ? timeout : DEFAULT_UDNS_TIMEOUT); 7888 } 7889 7890 // Get the Best server that matches a name. If you find penalized servers, look for the one 7891 // that will come out of the penalty box soon 7892 mDNSlocal DNSServer *GetBestServer(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSOpaque64 validBits, int *selected, mDNSBool nameMatch) 7893 { 7894 DNSServer *curmatch = mDNSNULL; 7895 int bestmatchlen = -1, namecount = name ? CountLabels(name) : 0; 7896 DNSServer *curr; 7897 mDNSs32 bestPenaltyTime, currPenaltyTime; 7898 int bettermatch, currcount; 7899 int index = 0; 7900 int currindex = -1; 7901 7902 debugf("GetBestServer: ValidDNSServer bits 0x%x%x", validBits.l[1], validBits.l[0]); 7903 bestPenaltyTime = DNSSERVER_PENALTY_TIME + 1; 7904 for (curr = m->DNSServers; curr; curr = curr->next) 7905 { 7906 // skip servers that will soon be deleted 7907 if (curr->flags & DNSServer_FlagDelete) 7908 { debugf("GetBestServer: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index, &curr->addr, curr->domain.c, curr->scoped); continue; } 7909 7910 // Check if this is a valid DNSServer 7911 if (!bit_get_opaque64(validBits, index)) { debugf("GetBestServer: continuing for index %d", index); index++; continue; } 7912 7913 currcount = CountLabels(&curr->domain); 7914 currPenaltyTime = PenaltyTimeForServer(m, curr); 7915 7916 debugf("GetBestServer: Address %#a (Domain %##s), PenaltyTime(abs) %d, PenaltyTime(rel) %d", 7917 &curr->addr, curr->domain.c, curr->penaltyTime, currPenaltyTime); 7918 7919 // If there are multiple best servers for a given question, we will pick the first one 7920 // if none of them are penalized. If some of them are penalized in that list, we pick 7921 // the least penalized one. BetterMatchForName walks through all best matches and 7922 // "currPenaltyTime < bestPenaltyTime" check lets us either pick the first best server 7923 // in the list when there are no penalized servers and least one among them 7924 // when there are some penalized servers 7925 // 7926 // Notes on InterfaceID matching: 7927 // 7928 // 1) A DNSServer entry may have an InterfaceID but the scoped flag may not be set. This 7929 // is the old way of specifying an InterfaceID option for DNSServer. We recoginize these 7930 // entries by "scoped" being false. These are like any other unscoped entries except that 7931 // if it is picked e.g., domain match, when the packet is sent out later, the packet will 7932 // be sent out on that interface. Theese entries can be matched by either specifying a 7933 // zero InterfaceID or non-zero InterfaceID on the question. Specifying an InterfaceID on 7934 // the question will cause an extra check on matching the InterfaceID on the question 7935 // against the DNSServer. 7936 // 7937 // 2) A DNSServer may also have both scoped set and InterfaceID non-NULL. This 7938 // is the new way of specifying an InterfaceID option for DNSServer. These will be considered 7939 // only when the question has non-zero interfaceID. 7940 7941 if ((!curr->scoped && !InterfaceID) || (curr->interface == InterfaceID)) 7942 { 7943 7944 // If we know that all the names are already equally good matches, then skip calling BetterMatchForName. 7945 // This happens when we initially walk all the DNS servers and set the validity bit on the question. 7946 // Actually we just need PenaltyTime match, but for the sake of readability we just skip the expensive 7947 // part and still do some redundant steps e.g., InterfaceID match 7948 7949 if (nameMatch) bettermatch = BetterMatchForName(name, namecount, &curr->domain, currcount, bestmatchlen); 7950 else bettermatch = 0; 7951 7952 // If we found a better match (bettermatch == 1) then we don't need to 7953 // compare penalty times. But if we found an equal match, then we compare 7954 // the penalty times to pick a better match 7955 7956 if ((bettermatch == 1) || ((bettermatch == 0) && currPenaltyTime < bestPenaltyTime)) 7957 { currindex = index; curmatch = curr; bestmatchlen = currcount; bestPenaltyTime = currPenaltyTime; } 7958 } 7959 index++; 7960 } 7961 if (selected) *selected = currindex; 7962 return curmatch; 7963 } 7964 7965 // Look up a DNS Server, matching by name and InterfaceID 7966 mDNSexport DNSServer *GetServerForName(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID) 7967 { 7968 DNSServer *curmatch = mDNSNULL; 7969 char *ifname = mDNSNULL; // for logging purposes only 7970 mDNSOpaque64 allValid; 7971 7972 if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly)) 7973 InterfaceID = mDNSNULL; 7974 7975 if (InterfaceID) ifname = InterfaceNameForID(m, InterfaceID); 7976 7977 // By passing in all ones, we make sure that every DNS server is considered 7978 allValid.l[0] = allValid.l[1] = 0xFFFFFFFF; 7979 7980 curmatch = GetBestServer(m, name, InterfaceID, allValid, mDNSNULL, mDNStrue); 7981 7982 if (curmatch != mDNSNULL) 7983 LogInfo("GetServerForName: DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s", &curmatch->addr, 7984 mDNSVal16(curmatch->port), (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None", 7985 InterfaceID, name); 7986 else 7987 LogInfo("GetServerForName: no DNS server (Scope %s:%p) found for name %##s", ifname ? ifname : "None", InterfaceID, name); 7988 7989 return(curmatch); 7990 } 7991 7992 // Look up a DNS Server for a question within its valid DNSServer bits 7993 mDNSexport DNSServer *GetServerForQuestion(mDNS *m, DNSQuestion *question) 7994 { 7995 DNSServer *curmatch = mDNSNULL; 7996 char *ifname = mDNSNULL; // for logging purposes only 7997 mDNSInterfaceID InterfaceID = question->InterfaceID; 7998 const domainname *name = &question->qname; 7999 int currindex; 8000 8001 if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly)) 8002 InterfaceID = mDNSNULL; 8003 8004 if (InterfaceID) ifname = InterfaceNameForID(m, InterfaceID); 8005 8006 if (!mDNSOpaque64IsZero(&question->validDNSServers)) 8007 { 8008 curmatch = GetBestServer(m, name, InterfaceID, question->validDNSServers, &currindex, mDNSfalse); 8009 if (currindex != -1) bit_clr_opaque64(question->validDNSServers, currindex); 8010 } 8011 8012 if (curmatch != mDNSNULL) 8013 LogInfo("GetServerForQuestion: %p DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s (%s)", question, &curmatch->addr, 8014 mDNSVal16(curmatch->port), (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None", 8015 InterfaceID, name, DNSTypeName(question->qtype)); 8016 else 8017 LogInfo("GetServerForQuestion: %p no DNS server (Scope %s:%p) found for name %##s (%s)", question, ifname ? ifname : "None", InterfaceID, name, DNSTypeName(question->qtype)); 8018 8019 return(curmatch); 8020 } 8021 8022 8023 #define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \ 8024 (mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort))) 8025 8026 // Called in normal client context (lock not held) 8027 mDNSlocal void LLQNATCallback(mDNS *m, NATTraversalInfo *n) 8028 { 8029 DNSQuestion *q; 8030 (void)n; // Unused 8031 mDNS_Lock(m); 8032 LogInfo("LLQNATCallback external address:port %.4a:%u, NAT result %d", &n->ExternalAddress, mDNSVal16(n->ExternalPort), n->Result); 8033 for (q = m->Questions; q; q=q->next) 8034 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) 8035 startLLQHandshake(m, q); // If ExternalPort is zero, will do StartLLQPolling instead 8036 #if APPLE_OSX_mDNSResponder 8037 UpdateAutoTunnelDomainStatuses(m); 8038 #endif 8039 mDNS_Unlock(m); 8040 } 8041 8042 mDNSlocal mDNSBool ShouldSuppressQuery(mDNS *const m, domainname *qname, mDNSu16 qtype, mDNSInterfaceID InterfaceID) 8043 { 8044 NetworkInterfaceInfo *i; 8045 mDNSs32 iptype; 8046 DomainAuthInfo *AuthInfo; 8047 8048 if (qtype == kDNSType_A) iptype = mDNSAddrType_IPv4; 8049 else if (qtype == kDNSType_AAAA) iptype = mDNSAddrType_IPv6; 8050 else { LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type", qname, DNSTypeName(qtype)); return mDNSfalse; } 8051 8052 // We still want the ability to be able to listen to the local services and hence 8053 // don't fail .local requests. We always have a loopback interface which we don't 8054 // check here. 8055 if (InterfaceID != mDNSInterface_Unicast && IsLocalDomain(qname)) { LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local question", qname, DNSTypeName(qtype)); return mDNSfalse; } 8056 8057 // Skip Private domains as we have special addresses to get the hosts in the Private domain 8058 AuthInfo = GetAuthInfoForName_internal(m, qname); 8059 if (AuthInfo && !AuthInfo->deltime && AuthInfo->AutoTunnel) 8060 { LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Private Domain", qname, DNSTypeName(qtype)); return mDNSfalse; } 8061 8062 // Match on Type, Address and InterfaceID 8063 // 8064 // Check whether we are looking for a name that ends in .local, then presence of a link-local 8065 // address on the interface is sufficient. 8066 for (i = m->HostInterfaces; i; i = i->next) 8067 { 8068 if (i->ip.type != iptype) continue; 8069 8070 if (!InterfaceID || (InterfaceID == mDNSInterface_LocalOnly) || (InterfaceID == mDNSInterface_P2P) || 8071 (InterfaceID == mDNSInterface_Unicast) || (i->InterfaceID == InterfaceID)) 8072 { 8073 if (iptype == mDNSAddrType_IPv4 && !mDNSv4AddressIsLoopback(&i->ip.ip.v4) && !mDNSv4AddressIsLinkLocal(&i->ip.ip.v4)) 8074 { 8075 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local Address %.4a found", qname, DNSTypeName(qtype), 8076 &i->ip.ip.v4); 8077 return mDNSfalse; 8078 } 8079 else if (iptype == mDNSAddrType_IPv6 && 8080 !mDNSv6AddressIsLoopback(&i->ip.ip.v6) && 8081 !mDNSv6AddressIsLinkLocal(&i->ip.ip.v6) && 8082 !mDNSSameIPv6Address(i->ip.ip.v6, m->AutoTunnelHostAddr) && 8083 !mDNSSameIPv6Address(i->ip.ip.v6, m->AutoTunnelRelayAddrOut)) 8084 { 8085 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local Address %.16a found", qname, DNSTypeName(qtype), 8086 &i->ip.ip.v6); 8087 return mDNSfalse; 8088 } 8089 } 8090 } 8091 LogInfo("ShouldSuppressQuery: Query suppressed for %##s, qtype %s, because no matching interface found", qname, DNSTypeName(qtype)); 8092 return mDNStrue; 8093 } 8094 8095 mDNSlocal void CacheRecordRmvEventsForCurrentQuestion(mDNS *const m, DNSQuestion *q) 8096 { 8097 CacheRecord *rr; 8098 mDNSu32 slot; 8099 CacheGroup *cg; 8100 8101 slot = HashSlot(&q->qname); 8102 cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname); 8103 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 8104 { 8105 // Don't deliver RMV events for negative records 8106 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) 8107 { 8108 LogInfo("CacheRecordRmvEventsForCurrentQuestion: CacheRecord %s Suppressing RMV events for question %p %##s (%s), CRActiveQuestion %p, CurrentAnswers %d", 8109 CRDisplayString(m, rr), q, q->qname.c, DNSTypeName(q->qtype), rr->CRActiveQuestion, q->CurrentAnswers); 8110 continue; 8111 } 8112 8113 if (SameNameRecordAnswersQuestion(&rr->resrec, q)) 8114 { 8115 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Calling AnswerCurrentQuestionWithResourceRecord (RMV) for question %##s using resource record %s LocalAnswers %d", 8116 q->qname.c, CRDisplayString(m, rr), q->LOAddressAnswers); 8117 8118 q->CurrentAnswers--; 8119 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--; 8120 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--; 8121 8122 if (rr->CRActiveQuestion == q) 8123 { 8124 DNSQuestion *qptr; 8125 // If this was the active question for this cache entry, it was the one that was 8126 // responsible for keeping the cache entry fresh when the cache entry was reaching 8127 // its expiry. We need to handover the responsibility to someone else. Otherwise, 8128 // when the cache entry is about to expire, we won't find an active question 8129 // (pointed by CRActiveQuestion) to refresh the cache. 8130 for (qptr = m->Questions; qptr; qptr=qptr->next) 8131 if (qptr != q && ActiveQuestion(qptr) && ResourceRecordAnswersQuestion(&rr->resrec, qptr)) 8132 break; 8133 8134 if (qptr) 8135 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Updating CRActiveQuestion to %p for cache record %s, " 8136 "Original question CurrentAnswers %d, new question CurrentAnswers %d, SuppressUnusable %d, SuppressQuery %d", 8137 qptr, CRDisplayString(m,rr), q->CurrentAnswers, qptr->CurrentAnswers, qptr->SuppressUnusable, qptr->SuppressQuery); 8138 8139 rr->CRActiveQuestion = qptr; // Question used to be active; new value may or may not be null 8140 if (!qptr) m->rrcache_active--; // If no longer active, decrement rrcache_active count 8141 } 8142 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv); 8143 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 8144 } 8145 } 8146 } 8147 8148 mDNSlocal mDNSBool IsQuestionNew(mDNS *const m, DNSQuestion *question) 8149 { 8150 DNSQuestion *q; 8151 for (q = m->NewQuestions; q; q = q->next) 8152 if (q == question) return mDNStrue; 8153 return mDNSfalse; 8154 } 8155 8156 mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q) 8157 { 8158 AuthRecord *rr; 8159 mDNSu32 slot; 8160 AuthGroup *ag; 8161 8162 if (m->CurrentQuestion) 8163 LogMsg("LocalRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)", 8164 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 8165 8166 if (IsQuestionNew(m, q)) 8167 { 8168 LogInfo("LocalRecordRmvEventsForQuestion: New Question %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 8169 return mDNStrue; 8170 } 8171 m->CurrentQuestion = q; 8172 slot = AuthHashSlot(&q->qname); 8173 ag = AuthGroupForName(&m->rrauth, slot, q->qnamehash, &q->qname); 8174 if (ag) 8175 { 8176 for (rr = ag->members; rr; rr=rr->next) 8177 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME 8178 if (LORecordAnswersAddressType(rr) && LocalOnlyRecordAnswersQuestion(rr, q)) 8179 { 8180 LogInfo("LocalRecordRmvEventsForQuestion: Delivering possible Rmv events with record %s", 8181 ARDisplayString(m, rr)); 8182 if (q->CurrentAnswers <= 0 || q->LOAddressAnswers <= 0) 8183 { 8184 LogMsg("LocalRecordRmvEventsForQuestion: ERROR!! CurrentAnswers or LOAddressAnswers is zero %p %##s" 8185 " (%s) CurrentAnswers %d, LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype), 8186 q->CurrentAnswers, q->LOAddressAnswers); 8187 continue; 8188 } 8189 AnswerLocalQuestionWithLocalAuthRecord(m, rr, QC_rmv); // MUST NOT dereference q again 8190 if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; } 8191 } 8192 } 8193 m->CurrentQuestion = mDNSNULL; 8194 return mDNStrue; 8195 } 8196 8197 // Returns false if the question got deleted while delivering the RMV events 8198 // The caller should handle the case 8199 mDNSlocal mDNSBool CacheRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q) 8200 { 8201 if (m->CurrentQuestion) 8202 LogMsg("CacheRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)", 8203 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 8204 8205 // If it is a new question, we have not delivered any ADD events yet. So, don't deliver RMV events. 8206 // If this question was answered using local auth records, then you can't deliver RMVs using cache 8207 if (!IsQuestionNew(m, q) && !q->LOAddressAnswers) 8208 { 8209 m->CurrentQuestion = q; 8210 CacheRecordRmvEventsForCurrentQuestion(m, q); 8211 if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; } 8212 m->CurrentQuestion = mDNSNULL; 8213 } 8214 else { LogInfo("CacheRecordRmvEventsForQuestion: Question %p %##s (%s) is a new question", q, q->qname.c, DNSTypeName(q->qtype)); } 8215 return mDNStrue; 8216 } 8217 8218 // The caller should hold the lock 8219 mDNSexport void CheckSuppressUnusableQuestions(mDNS *const m) 8220 { 8221 DNSQuestion *q; 8222 DNSQuestion *restart = mDNSNULL; 8223 8224 // We look through all questions including new questions. During network change events, 8225 // we potentially restart questions here in this function that ends up as new questions, 8226 // which may be suppressed at this instance. Before it is handled we get another network 8227 // event that changes the status e.g., address becomes available. If we did not process 8228 // new questions, we would never change its SuppressQuery status. 8229 // 8230 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the 8231 // application callback can potentially stop the current question (detected by CurrentQuestion) or 8232 // *any* other question which could be the next one that we may process here. RestartQuestion 8233 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal 8234 // if the "next" question is stopped while the CurrentQuestion is stopped 8235 if (m->RestartQuestion) 8236 LogMsg("CheckSuppressUnusableQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)", 8237 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); 8238 m->RestartQuestion = m->Questions; 8239 while (m->RestartQuestion) 8240 { 8241 q = m->RestartQuestion; 8242 m->RestartQuestion = q->next; 8243 if (!mDNSOpaque16IsZero(q->TargetQID) && q->SuppressUnusable) 8244 { 8245 mDNSBool old = q->SuppressQuery; 8246 q->SuppressQuery = ShouldSuppressQuery(m, &q->qname, q->qtype, q->InterfaceID); 8247 if (q->SuppressQuery != old) 8248 { 8249 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero 8250 // LOddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before 8251 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers) 8252 8253 if (q->SuppressQuery) 8254 { 8255 // Previously it was not suppressed, Generate RMV events for the ADDs that we might have delivered before 8256 // followed by a negative cache response. Temporarily turn off suppression so that 8257 // AnswerCurrentQuestionWithResourceRecord can answer the question 8258 q->SuppressQuery = mDNSfalse; 8259 if (!CacheRecordRmvEventsForQuestion(m, q)) { LogInfo("CheckSuppressUnusableQuestions: Question deleted while delivering RMV events"); continue; } 8260 q->SuppressQuery = mDNStrue; 8261 } 8262 8263 // SuppressUnusable does not affect questions that are answered from the local records (/etc/hosts) 8264 // and SuppressQuery status does not mean anything for these questions. As we are going to stop the 8265 // question below, we need to deliver the RMV events so that the ADDs that will be delivered during 8266 // the restart will not be a duplicate ADD 8267 if (!LocalRecordRmvEventsForQuestion(m, q)) { LogInfo("CheckSuppressUnusableQuestions: Question deleted while delivering RMV events"); continue; } 8268 8269 // There are two cases here. 8270 // 8271 // 1. Previously it was suppressed and now it is not suppressed, restart the question so 8272 // that it will start as a new question. Note that we can't just call ActivateUnicastQuery 8273 // because when we get the response, if we had entries in the cache already, it will not answer 8274 // this question if the cache entry did not change. Hence, we need to restart 8275 // the query so that it can be answered from the cache. 8276 // 8277 // 2. Previously it was not suppressed and now it is suppressed. We need to restart the questions 8278 // so that we redo the duplicate checks in mDNS_StartQuery_internal. A SuppressUnusable question 8279 // is a duplicate of non-SuppressUnusable question if it is not suppressed (SuppressQuery is false). 8280 // A SuppressUnusable question is not a duplicate of non-SuppressUnusable question if it is suppressed 8281 // (SuppressQuery is true). The reason for this is that when a question is suppressed, we want an 8282 // immediate response and not want to be blocked behind a question that is querying DNS servers. When 8283 // the question is not suppressed, we don't want two active questions sending packets on the wire. 8284 // This affects both efficiency and also the current design where there is only one active question 8285 // pointed to from a cache entry. 8286 // 8287 // We restart queries in a two step process by first calling stop and build a temporary list which we 8288 // will restart at the end. The main reason for the two step process is to handle duplicate questions. 8289 // If there are duplicate questions, calling stop inherits the values from another question on the list (which 8290 // will soon become the real question) including q->ThisQInterval which might be zero if it was 8291 // suppressed before. At the end when we have restarted all questions, none of them is active as each 8292 // inherits from one another and we need to reactivate one of the questions here which is a little hacky. 8293 // 8294 // It is much cleaner and less error prone to build a list of questions and restart at the end. 8295 8296 LogInfo("CheckSuppressUnusableQuestions: Stop question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 8297 mDNS_StopQuery_internal(m, q); 8298 q->next = restart; 8299 restart = q; 8300 } 8301 } 8302 } 8303 while (restart) 8304 { 8305 q = restart; 8306 restart = restart->next; 8307 q->next = mDNSNULL; 8308 LogInfo("CheckSuppressUnusableQuestions: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 8309 mDNS_StartQuery_internal(m, q); 8310 } 8311 } 8312 8313 mDNSexport mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question) 8314 { 8315 if (question->Target.type && !ValidQuestionTarget(question)) 8316 { 8317 LogMsg("mDNS_StartQuery_internal: Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery? for question %##s)", 8318 question->Target.type, mDNSVal16(question->TargetPort), question->qname.c); 8319 question->Target.type = mDNSAddrType_None; 8320 } 8321 8322 if (!question->Target.type) question->TargetPort = zeroIPPort; // If no question->Target specified clear TargetPort 8323 8324 question->TargetQID = 8325 #ifndef UNICAST_DISABLED 8326 (question->Target.type || Question_uDNS(question)) ? mDNS_NewMessageID(m) : 8327 #endif // UNICAST_DISABLED 8328 zeroID; 8329 8330 debugf("mDNS_StartQuery: %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 8331 8332 if (m->rrcache_size == 0) // Can't do queries if we have no cache space allocated 8333 return(mStatus_NoCache); 8334 else 8335 { 8336 int i; 8337 DNSQuestion **q; 8338 8339 if (!ValidateDomainName(&question->qname)) 8340 { 8341 LogMsg("Attempt to start query with invalid qname %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 8342 return(mStatus_Invalid); 8343 } 8344 8345 // Note: It important that new questions are appended at the *end* of the list, not prepended at the start 8346 q = &m->Questions; 8347 if (question->InterfaceID == mDNSInterface_LocalOnly || question->InterfaceID == mDNSInterface_P2P) q = &m->LocalOnlyQuestions; 8348 while (*q && *q != question) q=&(*q)->next; 8349 8350 if (*q) 8351 { 8352 LogMsg("Error! Tried to add a question %##s (%s) %p that's already in the active list", 8353 question->qname.c, DNSTypeName(question->qtype), question); 8354 return(mStatus_AlreadyRegistered); 8355 } 8356 8357 *q = question; 8358 8359 // If this question is referencing a specific interface, verify it exists 8360 if (question->InterfaceID && question->InterfaceID != mDNSInterface_LocalOnly && question->InterfaceID != mDNSInterface_Unicast && question->InterfaceID != mDNSInterface_P2P) 8361 { 8362 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, question->InterfaceID); 8363 if (!intf) 8364 LogMsg("Note: InterfaceID %p for question %##s (%s) not currently found in active interface list", 8365 question->InterfaceID, question->qname.c, DNSTypeName(question->qtype)); 8366 } 8367 8368 // Note: In the case where we already have the answer to this question in our cache, that may be all the client 8369 // wanted, and they may immediately cancel their question. In this case, sending an actual query on the wire would 8370 // be a waste. For that reason, we schedule our first query to go out in half a second (InitialQuestionInterval). 8371 // If AnswerNewQuestion() finds that we have *no* relevant answers currently in our cache, then it will accelerate 8372 // that to go out immediately. 8373 question->next = mDNSNULL; 8374 question->qnamehash = DomainNameHashValue(&question->qname); // MUST do this before FindDuplicateQuestion() 8375 question->DelayAnswering = CheckForSoonToExpireRecords(m, &question->qname, question->qnamehash, HashSlot(&question->qname)); 8376 question->LastQTime = m->timenow; 8377 question->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question 8378 question->ExpectUnicastResp = 0; 8379 question->LastAnswerPktNum = m->PktNum; 8380 question->RecentAnswerPkts = 0; 8381 question->CurrentAnswers = 0; 8382 question->LargeAnswers = 0; 8383 question->UniqueAnswers = 0; 8384 question->LOAddressAnswers = 0; 8385 question->FlappingInterface1 = mDNSNULL; 8386 question->FlappingInterface2 = mDNSNULL; 8387 // Must do AuthInfo and SuppressQuery before calling FindDuplicateQuestion() 8388 question->AuthInfo = GetAuthInfoForQuestion(m, question); 8389 if (question->SuppressUnusable) 8390 question->SuppressQuery = ShouldSuppressQuery(m, &question->qname, question->qtype, question->InterfaceID); 8391 else 8392 question->SuppressQuery = 0; 8393 question->DuplicateOf = FindDuplicateQuestion(m, question); 8394 question->NextInDQList = mDNSNULL; 8395 question->SendQNow = mDNSNULL; 8396 question->SendOnAll = mDNSfalse; 8397 question->RequestUnicast = 0; 8398 question->LastQTxTime = m->timenow; 8399 question->CNAMEReferrals = 0; 8400 8401 // We'll create our question->LocalSocket on demand, if needed. 8402 // We won't need one for duplicate questions, or from questions answered immediately out of the cache. 8403 // We also don't need one for LLQs because (when we're using NAT) we want them all to share a single 8404 // NAT mapping for receiving inbound add/remove events. 8405 question->LocalSocket = mDNSNULL; 8406 question->deliverAddEvents = mDNSfalse; 8407 question->qDNSServer = mDNSNULL; 8408 question->unansweredQueries = 0; 8409 question->nta = mDNSNULL; 8410 question->servAddr = zeroAddr; 8411 question->servPort = zeroIPPort; 8412 question->tcp = mDNSNULL; 8413 question->NoAnswer = NoAnswer_Normal; 8414 8415 question->state = LLQ_InitialRequest; 8416 question->ReqLease = 0; 8417 question->expire = 0; 8418 question->ntries = 0; 8419 question->id = zeroOpaque64; 8420 question->validDNSServers = zeroOpaque64; 8421 question->triedAllServersOnce = 0; 8422 question->noServerResponse = 0; 8423 question->StopTime = 0; 8424 if (question->WakeOnResolve) 8425 { 8426 question->WakeOnResolveCount = InitialWakeOnResolveCount; 8427 mDNS_PurgeBeforeResolve(m, question); 8428 } 8429 else 8430 question->WakeOnResolveCount = 0; 8431 8432 if (question->DuplicateOf) question->AuthInfo = question->DuplicateOf->AuthInfo; 8433 8434 for (i=0; i<DupSuppressInfoSize; i++) 8435 question->DupSuppress[i].InterfaceID = mDNSNULL; 8436 8437 debugf("mDNS_StartQuery: Question %##s (%s) Interface %p Now %d Send in %d Answer in %d (%p) %s (%p)", 8438 question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, m->timenow, 8439 NextQSendTime(question) - m->timenow, 8440 question->DelayAnswering ? question->DelayAnswering - m->timenow : 0, 8441 question, question->DuplicateOf ? "duplicate of" : "not duplicate", question->DuplicateOf); 8442 8443 if (question->DelayAnswering) 8444 LogInfo("mDNS_StartQuery_internal: Delaying answering for %d ticks while cache stabilizes for %##s (%s)", 8445 question->DelayAnswering - m->timenow, question->qname.c, DNSTypeName(question->qtype)); 8446 8447 if (question->InterfaceID == mDNSInterface_LocalOnly || question->InterfaceID == mDNSInterface_P2P) 8448 { 8449 if (!m->NewLocalOnlyQuestions) m->NewLocalOnlyQuestions = question; 8450 } 8451 else 8452 { 8453 if (!m->NewQuestions) m->NewQuestions = question; 8454 8455 // If the question's id is non-zero, then it's Wide Area 8456 // MUST NOT do this Wide Area setup until near the end of 8457 // mDNS_StartQuery_internal -- this code may itself issue queries (e.g. SOA, 8458 // NS, etc.) and if we haven't finished setting up our own question and setting 8459 // m->NewQuestions if necessary then we could end up recursively re-entering 8460 // this routine with the question list data structures in an inconsistent state. 8461 if (!mDNSOpaque16IsZero(question->TargetQID)) 8462 { 8463 // Duplicate questions should have the same DNSServers so that when we find 8464 // a matching resource record, all of them get the answers. Calling GetServerForQuestion 8465 // for the duplicate question may get a different DNS server from the original question 8466 mDNSu32 timeout = SetValidDNSServers(m, question); 8467 // We set the timeout whenever mDNS_StartQuery_internal is called. This means if we have 8468 // a networking change/search domain change that calls this function again we keep 8469 // reinitializing the timeout value which means it may never timeout. If this becomes 8470 // a common case in the future, we can easily fix this by adding extra state that 8471 // indicates that we have already set the StopTime. 8472 if (question->TimeoutQuestion) 8473 question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); 8474 if (question->DuplicateOf) 8475 { 8476 question->validDNSServers = question->DuplicateOf->validDNSServers; 8477 question->qDNSServer = question->DuplicateOf->qDNSServer; 8478 LogInfo("mDNS_StartQuery_internal: Duplicate question %p (%p) %##s (%s), Timeout %d, DNS Server %#a:%d", 8479 question, question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype), timeout, 8480 question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, 8481 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort)); 8482 } 8483 else 8484 { 8485 question->qDNSServer = GetServerForQuestion(m, question); 8486 LogInfo("mDNS_StartQuery_internal: question %p %##s (%s) Timeout %d, DNS Server %#a:%d", 8487 question, question->qname.c, DNSTypeName(question->qtype), timeout, 8488 question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, 8489 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort)); 8490 } 8491 ActivateUnicastQuery(m, question, mDNSfalse); 8492 8493 // If long-lived query, and we don't have our NAT mapping active, start it now 8494 if (question->LongLived && !m->LLQNAT.clientContext) 8495 { 8496 m->LLQNAT.Protocol = NATOp_MapUDP; 8497 m->LLQNAT.IntPort = m->UnicastPort4; 8498 m->LLQNAT.RequestedPort = m->UnicastPort4; 8499 m->LLQNAT.clientCallback = LLQNATCallback; 8500 m->LLQNAT.clientContext = (void*)1; // Means LLQ NAT Traversal is active 8501 mDNS_StartNATOperation_internal(m, &m->LLQNAT); 8502 } 8503 8504 #if APPLE_OSX_mDNSResponder 8505 if (question->LongLived) 8506 UpdateAutoTunnelDomainStatuses(m); 8507 #endif 8508 8509 } 8510 else 8511 { 8512 if (question->TimeoutQuestion) 8513 question->StopTime = NonZeroTime(m->timenow + GetTimeoutForMcastQuestion(m, question) * mDNSPlatformOneSecond); 8514 } 8515 if (question->StopTime) SetNextQueryStopTime(m, question); 8516 SetNextQueryTime(m,question); 8517 } 8518 8519 return(mStatus_NoError); 8520 } 8521 } 8522 8523 // CancelGetZoneData is an internal routine (i.e. must be called with the lock already held) 8524 mDNSexport void CancelGetZoneData(mDNS *const m, ZoneData *nta) 8525 { 8526 debugf("CancelGetZoneData %##s (%s)", nta->question.qname.c, DNSTypeName(nta->question.qtype)); 8527 // This function may be called anytime to free the zone information.The question may or may not have stopped. 8528 // If it was already stopped, mDNS_StopQuery_internal would have set q->ThisQInterval to -1 and should not 8529 // call it again 8530 if (nta->question.ThisQInterval != -1) 8531 { 8532 mDNS_StopQuery_internal(m, &nta->question); 8533 if (nta->question.ThisQInterval != -1) 8534 LogMsg("CancelGetZoneData: Question %##s (%s) ThisQInterval %d not -1", nta->question.qname.c, DNSTypeName(nta->question.qtype), nta->question.ThisQInterval); 8535 } 8536 mDNSPlatformMemFree(nta); 8537 } 8538 8539 mDNSexport mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question) 8540 { 8541 const mDNSu32 slot = HashSlot(&question->qname); 8542 CacheGroup *cg = CacheGroupForName(m, slot, question->qnamehash, &question->qname); 8543 CacheRecord *rr; 8544 DNSQuestion **qp = &m->Questions; 8545 8546 //LogInfo("mDNS_StopQuery_internal %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 8547 8548 if (question->InterfaceID == mDNSInterface_LocalOnly || question->InterfaceID == mDNSInterface_P2P) qp = &m->LocalOnlyQuestions; 8549 while (*qp && *qp != question) qp=&(*qp)->next; 8550 if (*qp) *qp = (*qp)->next; 8551 else 8552 { 8553 #if !ForceAlerts 8554 if (question->ThisQInterval >= 0) // Only log error message if the query was supposed to be active 8555 #endif 8556 LogMsg("mDNS_StopQuery_internal: Question %##s (%s) not found in active list", 8557 question->qname.c, DNSTypeName(question->qtype)); 8558 #if ForceAlerts 8559 *(long*)0 = 0; 8560 #endif 8561 return(mStatus_BadReferenceErr); 8562 } 8563 8564 // Take care to cut question from list *before* calling UpdateQuestionDuplicates 8565 UpdateQuestionDuplicates(m, question); 8566 // But don't trash ThisQInterval until afterwards. 8567 question->ThisQInterval = -1; 8568 8569 // If there are any cache records referencing this as their active question, then see if there is any 8570 // other question that is also referencing them, else their CRActiveQuestion needs to get set to NULL. 8571 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 8572 { 8573 if (rr->CRActiveQuestion == question) 8574 { 8575 DNSQuestion *q; 8576 // Checking for ActiveQuestion filters questions that are suppressed also 8577 // as suppressed questions are not active 8578 for (q = m->Questions; q; q=q->next) // Scan our list of questions 8579 if (ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) 8580 break; 8581 if (q) 8582 debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s, Original question CurrentAnswers %d, new question " 8583 "CurrentAnswers %d, SuppressQuery %d", q, CRDisplayString(m,rr), question->CurrentAnswers, q->CurrentAnswers, q->SuppressQuery); 8584 rr->CRActiveQuestion = q; // Question used to be active; new value may or may not be null 8585 if (!q) m->rrcache_active--; // If no longer active, decrement rrcache_active count 8586 } 8587 } 8588 8589 // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv() is about to look at, 8590 // bump its pointer forward one question. 8591 if (m->CurrentQuestion == question) 8592 { 8593 debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)", 8594 question->qname.c, DNSTypeName(question->qtype)); 8595 m->CurrentQuestion = question->next; 8596 } 8597 8598 if (m->NewQuestions == question) 8599 { 8600 debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)", 8601 question->qname.c, DNSTypeName(question->qtype)); 8602 m->NewQuestions = question->next; 8603 } 8604 8605 if (m->NewLocalOnlyQuestions == question) m->NewLocalOnlyQuestions = question->next; 8606 8607 if (m->RestartQuestion == question) 8608 { 8609 LogMsg("mDNS_StopQuery_internal: Just deleted the current restart question: %##s (%s)", 8610 question->qname.c, DNSTypeName(question->qtype)); 8611 m->RestartQuestion = question->next; 8612 } 8613 8614 // Take care not to trash question->next until *after* we've updated m->CurrentQuestion and m->NewQuestions 8615 question->next = mDNSNULL; 8616 8617 // LogMsg("mDNS_StopQuery_internal: Question %##s (%s) removed", question->qname.c, DNSTypeName(question->qtype)); 8618 8619 // And finally, cancel any associated GetZoneData operation that's still running. 8620 // Must not do this until last, because there's a good chance the GetZoneData question is the next in the list, 8621 // so if we delete it earlier in this routine, we could find that our "question->next" pointer above is already 8622 // invalid before we even use it. By making sure that we update m->CurrentQuestion and m->NewQuestions if necessary 8623 // *first*, then they're all ready to be updated a second time if necessary when we cancel our GetZoneData query. 8624 if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; } 8625 if (question->LocalSocket) { mDNSPlatformUDPClose(question->LocalSocket); question->LocalSocket = mDNSNULL; } 8626 if (!mDNSOpaque16IsZero(question->TargetQID) && question->LongLived) 8627 { 8628 // Scan our list to see if any more wide-area LLQs remain. If not, stop our NAT Traversal. 8629 DNSQuestion *q; 8630 for (q = m->Questions; q; q=q->next) 8631 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) break; 8632 if (!q) 8633 { 8634 if (!m->LLQNAT.clientContext) // Should never happen, but just in case... 8635 LogMsg("mDNS_StopQuery ERROR LLQNAT.clientContext NULL"); 8636 else 8637 { 8638 LogInfo("Stopping LLQNAT"); 8639 mDNS_StopNATOperation_internal(m, &m->LLQNAT); 8640 m->LLQNAT.clientContext = mDNSNULL; // Means LLQ NAT Traversal not running 8641 } 8642 } 8643 8644 // If necessary, tell server it can delete this LLQ state 8645 if (question->state == LLQ_Established) 8646 { 8647 question->ReqLease = 0; 8648 sendLLQRefresh(m, question); 8649 // If we need need to make a TCP connection to cancel the LLQ, that's going to take a little while. 8650 // We clear the tcp->question backpointer so that when the TCP connection completes, it doesn't 8651 // crash trying to access our cancelled question, but we don't cancel the TCP operation itself -- 8652 // we let that run out its natural course and complete asynchronously. 8653 if (question->tcp) 8654 { 8655 question->tcp->question = mDNSNULL; 8656 question->tcp = mDNSNULL; 8657 } 8658 } 8659 #if APPLE_OSX_mDNSResponder 8660 UpdateAutoTunnelDomainStatuses(m); 8661 #endif 8662 } 8663 // wait until we send the refresh above which needs the nta 8664 if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; } 8665 8666 return(mStatus_NoError); 8667 } 8668 8669 mDNSexport mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question) 8670 { 8671 mStatus status; 8672 mDNS_Lock(m); 8673 status = mDNS_StartQuery_internal(m, question); 8674 mDNS_Unlock(m); 8675 return(status); 8676 } 8677 8678 mDNSexport mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question) 8679 { 8680 mStatus status; 8681 mDNS_Lock(m); 8682 status = mDNS_StopQuery_internal(m, question); 8683 mDNS_Unlock(m); 8684 return(status); 8685 } 8686 8687 // Note that mDNS_StopQueryWithRemoves() does not currently implement the full generality of the other APIs 8688 // Specifically, question callbacks invoked as a result of this call cannot themselves make API calls. 8689 // We invoke the callback without using mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback 8690 // specifically to catch and report if the client callback does try to make API calls 8691 mDNSexport mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question) 8692 { 8693 mStatus status; 8694 DNSQuestion *qq; 8695 mDNS_Lock(m); 8696 8697 // Check if question is new -- don't want to give remove events for a question we haven't even answered yet 8698 for (qq = m->NewQuestions; qq; qq=qq->next) if (qq == question) break; 8699 8700 status = mDNS_StopQuery_internal(m, question); 8701 if (status == mStatus_NoError && !qq) 8702 { 8703 const CacheRecord *rr; 8704 const mDNSu32 slot = HashSlot(&question->qname); 8705 CacheGroup *const cg = CacheGroupForName(m, slot, question->qnamehash, &question->qname); 8706 LogInfo("Generating terminal removes for %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 8707 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 8708 if (rr->resrec.RecordType != kDNSRecordTypePacketNegative && SameNameRecordAnswersQuestion(&rr->resrec, question)) 8709 { 8710 // Don't use mDNS_DropLockBeforeCallback() here, since we don't allow API calls 8711 if (question->QuestionCallback) 8712 question->QuestionCallback(m, question, &rr->resrec, mDNSfalse); 8713 } 8714 } 8715 mDNS_Unlock(m); 8716 return(status); 8717 } 8718 8719 mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const cr) 8720 { 8721 mStatus status; 8722 mDNS_Lock(m); 8723 status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 8724 if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0); 8725 mDNS_Unlock(m); 8726 return(status); 8727 } 8728 8729 mDNSexport mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr) 8730 { 8731 mStatus status = mStatus_BadReferenceErr; 8732 CacheRecord *cr; 8733 mDNS_Lock(m); 8734 cr = FindIdenticalRecordInCache(m, rr); 8735 debugf("mDNS_ReconfirmByValue: %p %s", cr, RRDisplayString(m, rr)); 8736 if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 8737 if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0); 8738 mDNS_Unlock(m); 8739 return(status); 8740 } 8741 8742 mDNSlocal mStatus mDNS_StartBrowse_internal(mDNS *const m, DNSQuestion *const question, 8743 const domainname *const srv, const domainname *const domain, 8744 const mDNSInterfaceID InterfaceID, mDNSBool ForceMCast, mDNSQuestionCallback *Callback, void *Context) 8745 { 8746 question->InterfaceID = InterfaceID; 8747 question->Target = zeroAddr; 8748 question->qtype = kDNSType_PTR; 8749 question->qclass = kDNSClass_IN; 8750 question->LongLived = mDNStrue; 8751 question->ExpectUnique = mDNSfalse; 8752 question->ForceMCast = ForceMCast; 8753 question->ReturnIntermed = mDNSfalse; 8754 question->SuppressUnusable = mDNSfalse; 8755 question->SearchListIndex = 0; 8756 question->AppendSearchDomains = 0; 8757 question->RetryWithSearchDomains = mDNSfalse; 8758 question->TimeoutQuestion = 0; 8759 question->WakeOnResolve = 0; 8760 question->qnameOrig = mDNSNULL; 8761 question->QuestionCallback = Callback; 8762 question->QuestionContext = Context; 8763 if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) return(mStatus_BadParamErr); 8764 8765 return(mDNS_StartQuery_internal(m, question)); 8766 } 8767 8768 mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question, 8769 const domainname *const srv, const domainname *const domain, 8770 const mDNSInterfaceID InterfaceID, mDNSBool ForceMCast, mDNSQuestionCallback *Callback, void *Context) 8771 { 8772 mStatus status; 8773 mDNS_Lock(m); 8774 status = mDNS_StartBrowse_internal(m, question, srv, domain, InterfaceID, ForceMCast, Callback, Context); 8775 mDNS_Unlock(m); 8776 return(status); 8777 } 8778 8779 mDNSlocal mDNSBool MachineHasActiveIPv6(mDNS *const m) 8780 { 8781 NetworkInterfaceInfo *intf; 8782 for (intf = m->HostInterfaces; intf; intf = intf->next) 8783 if (intf->ip.type == mDNSAddrType_IPv6) return(mDNStrue); 8784 return(mDNSfalse); 8785 } 8786 8787 mDNSlocal void FoundServiceInfoSRV(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 8788 { 8789 ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext; 8790 mDNSBool PortChanged = !mDNSSameIPPort(query->info->port, answer->rdata->u.srv.port); 8791 if (!AddRecord) return; 8792 if (answer->rrtype != kDNSType_SRV) return; 8793 8794 query->info->port = answer->rdata->u.srv.port; 8795 8796 // If this is our first answer, then set the GotSRV flag and start the address query 8797 if (!query->GotSRV) 8798 { 8799 query->GotSRV = mDNStrue; 8800 query->qAv4.InterfaceID = answer->InterfaceID; 8801 AssignDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target); 8802 query->qAv6.InterfaceID = answer->InterfaceID; 8803 AssignDomainName(&query->qAv6.qname, &answer->rdata->u.srv.target); 8804 mDNS_StartQuery(m, &query->qAv4); 8805 // Only do the AAAA query if this machine actually has IPv6 active 8806 if (MachineHasActiveIPv6(m)) mDNS_StartQuery(m, &query->qAv6); 8807 } 8808 // If this is not our first answer, only re-issue the address query if the target host name has changed 8809 else if ((query->qAv4.InterfaceID != query->qSRV.InterfaceID && query->qAv4.InterfaceID != answer->InterfaceID) || 8810 !SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target)) 8811 { 8812 mDNS_StopQuery(m, &query->qAv4); 8813 if (query->qAv6.ThisQInterval >= 0) mDNS_StopQuery(m, &query->qAv6); 8814 if (SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target) && !PortChanged) 8815 { 8816 // If we get here, it means: 8817 // 1. This is not our first SRV answer 8818 // 2. The interface ID is different, but the target host and port are the same 8819 // This implies that we're seeing the exact same SRV record on more than one interface, so we should 8820 // make our address queries at least as broad as the original SRV query so that we catch all the answers. 8821 query->qAv4.InterfaceID = query->qSRV.InterfaceID; // Will be mDNSInterface_Any, or a specific interface 8822 query->qAv6.InterfaceID = query->qSRV.InterfaceID; 8823 } 8824 else 8825 { 8826 query->qAv4.InterfaceID = answer->InterfaceID; 8827 AssignDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target); 8828 query->qAv6.InterfaceID = answer->InterfaceID; 8829 AssignDomainName(&query->qAv6.qname, &answer->rdata->u.srv.target); 8830 } 8831 debugf("FoundServiceInfoSRV: Restarting address queries for %##s (%s)", query->qAv4.qname.c, DNSTypeName(query->qAv4.qtype)); 8832 mDNS_StartQuery(m, &query->qAv4); 8833 // Only do the AAAA query if this machine actually has IPv6 active 8834 if (MachineHasActiveIPv6(m)) mDNS_StartQuery(m, &query->qAv6); 8835 } 8836 else if (query->ServiceInfoQueryCallback && query->GotADD && query->GotTXT && PortChanged) 8837 { 8838 if (++query->Answers >= 100) 8839 debugf("**** WARNING **** Have given %lu answers for %##s (SRV) %##s %u", 8840 query->Answers, query->qSRV.qname.c, answer->rdata->u.srv.target.c, 8841 mDNSVal16(answer->rdata->u.srv.port)); 8842 query->ServiceInfoQueryCallback(m, query); 8843 } 8844 // CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's 8845 // callback function is allowed to do anything, including deleting this query and freeing its memory. 8846 } 8847 8848 mDNSlocal void FoundServiceInfoTXT(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 8849 { 8850 ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext; 8851 if (!AddRecord) return; 8852 if (answer->rrtype != kDNSType_TXT) return; 8853 if (answer->rdlength > sizeof(query->info->TXTinfo)) return; 8854 8855 query->GotTXT = mDNStrue; 8856 query->info->TXTlen = answer->rdlength; 8857 query->info->TXTinfo[0] = 0; // In case answer->rdlength is zero 8858 mDNSPlatformMemCopy(query->info->TXTinfo, answer->rdata->u.txt.c, answer->rdlength); 8859 8860 verbosedebugf("FoundServiceInfoTXT: %##s GotADD=%d", query->info->name.c, query->GotADD); 8861 8862 // CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's 8863 // callback function is allowed to do anything, including deleting this query and freeing its memory. 8864 if (query->ServiceInfoQueryCallback && query->GotADD) 8865 { 8866 if (++query->Answers >= 100) 8867 debugf("**** WARNING **** have given %lu answers for %##s (TXT) %#s...", 8868 query->Answers, query->qSRV.qname.c, answer->rdata->u.txt.c); 8869 query->ServiceInfoQueryCallback(m, query); 8870 } 8871 } 8872 8873 mDNSlocal void FoundServiceInfo(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 8874 { 8875 ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext; 8876 //LogInfo("FoundServiceInfo %d %s", AddRecord, RRDisplayString(m, answer)); 8877 if (!AddRecord) return; 8878 8879 if (answer->rrtype == kDNSType_A) 8880 { 8881 query->info->ip.type = mDNSAddrType_IPv4; 8882 query->info->ip.ip.v4 = answer->rdata->u.ipv4; 8883 } 8884 else if (answer->rrtype == kDNSType_AAAA) 8885 { 8886 query->info->ip.type = mDNSAddrType_IPv6; 8887 query->info->ip.ip.v6 = answer->rdata->u.ipv6; 8888 } 8889 else 8890 { 8891 debugf("FoundServiceInfo: answer %##s type %d (%s) unexpected", answer->name->c, answer->rrtype, DNSTypeName(answer->rrtype)); 8892 return; 8893 } 8894 8895 query->GotADD = mDNStrue; 8896 query->info->InterfaceID = answer->InterfaceID; 8897 8898 verbosedebugf("FoundServiceInfo v%ld: %##s GotTXT=%d", query->info->ip.type, query->info->name.c, query->GotTXT); 8899 8900 // CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's 8901 // callback function is allowed to do anything, including deleting this query and freeing its memory. 8902 if (query->ServiceInfoQueryCallback && query->GotTXT) 8903 { 8904 if (++query->Answers >= 100) 8905 debugf(answer->rrtype == kDNSType_A ? 8906 "**** WARNING **** have given %lu answers for %##s (A) %.4a" : 8907 "**** WARNING **** have given %lu answers for %##s (AAAA) %.16a", 8908 query->Answers, query->qSRV.qname.c, &answer->rdata->u.data); 8909 query->ServiceInfoQueryCallback(m, query); 8910 } 8911 } 8912 8913 // On entry, the client must have set the name and InterfaceID fields of the ServiceInfo structure 8914 // If the query is not interface-specific, then InterfaceID may be zero 8915 // Each time the Callback is invoked, the remainder of the fields will have been filled in 8916 // In addition, InterfaceID will be updated to give the interface identifier corresponding to that response 8917 mDNSexport mStatus mDNS_StartResolveService(mDNS *const m, 8918 ServiceInfoQuery *query, ServiceInfo *info, mDNSServiceInfoQueryCallback *Callback, void *Context) 8919 { 8920 mStatus status; 8921 mDNS_Lock(m); 8922 8923 query->qSRV.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question 8924 query->qSRV.InterfaceID = info->InterfaceID; 8925 query->qSRV.Target = zeroAddr; 8926 AssignDomainName(&query->qSRV.qname, &info->name); 8927 query->qSRV.qtype = kDNSType_SRV; 8928 query->qSRV.qclass = kDNSClass_IN; 8929 query->qSRV.LongLived = mDNSfalse; 8930 query->qSRV.ExpectUnique = mDNStrue; 8931 query->qSRV.ForceMCast = mDNSfalse; 8932 query->qSRV.ReturnIntermed = mDNSfalse; 8933 query->qSRV.SuppressUnusable = mDNSfalse; 8934 query->qSRV.SearchListIndex = 0; 8935 query->qSRV.AppendSearchDomains = 0; 8936 query->qSRV.RetryWithSearchDomains = mDNSfalse; 8937 query->qSRV.TimeoutQuestion = 0; 8938 query->qSRV.WakeOnResolve = 0; 8939 query->qSRV.qnameOrig = mDNSNULL; 8940 query->qSRV.QuestionCallback = FoundServiceInfoSRV; 8941 query->qSRV.QuestionContext = query; 8942 8943 query->qTXT.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question 8944 query->qTXT.InterfaceID = info->InterfaceID; 8945 query->qTXT.Target = zeroAddr; 8946 AssignDomainName(&query->qTXT.qname, &info->name); 8947 query->qTXT.qtype = kDNSType_TXT; 8948 query->qTXT.qclass = kDNSClass_IN; 8949 query->qTXT.LongLived = mDNSfalse; 8950 query->qTXT.ExpectUnique = mDNStrue; 8951 query->qTXT.ForceMCast = mDNSfalse; 8952 query->qTXT.ReturnIntermed = mDNSfalse; 8953 query->qTXT.SuppressUnusable = mDNSfalse; 8954 query->qTXT.SearchListIndex = 0; 8955 query->qTXT.AppendSearchDomains = 0; 8956 query->qTXT.RetryWithSearchDomains = mDNSfalse; 8957 query->qTXT.TimeoutQuestion = 0; 8958 query->qTXT.WakeOnResolve = 0; 8959 query->qTXT.qnameOrig = mDNSNULL; 8960 query->qTXT.QuestionCallback = FoundServiceInfoTXT; 8961 query->qTXT.QuestionContext = query; 8962 8963 query->qAv4.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question 8964 query->qAv4.InterfaceID = info->InterfaceID; 8965 query->qAv4.Target = zeroAddr; 8966 query->qAv4.qname.c[0] = 0; 8967 query->qAv4.qtype = kDNSType_A; 8968 query->qAv4.qclass = kDNSClass_IN; 8969 query->qAv4.LongLived = mDNSfalse; 8970 query->qAv4.ExpectUnique = mDNStrue; 8971 query->qAv4.ForceMCast = mDNSfalse; 8972 query->qAv4.ReturnIntermed = mDNSfalse; 8973 query->qAv4.SuppressUnusable = mDNSfalse; 8974 query->qAv4.SearchListIndex = 0; 8975 query->qAv4.AppendSearchDomains = 0; 8976 query->qAv4.RetryWithSearchDomains = mDNSfalse; 8977 query->qAv4.TimeoutQuestion = 0; 8978 query->qAv4.WakeOnResolve = 0; 8979 query->qAv4.qnameOrig = mDNSNULL; 8980 query->qAv4.QuestionCallback = FoundServiceInfo; 8981 query->qAv4.QuestionContext = query; 8982 8983 query->qAv6.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question 8984 query->qAv6.InterfaceID = info->InterfaceID; 8985 query->qAv6.Target = zeroAddr; 8986 query->qAv6.qname.c[0] = 0; 8987 query->qAv6.qtype = kDNSType_AAAA; 8988 query->qAv6.qclass = kDNSClass_IN; 8989 query->qAv6.LongLived = mDNSfalse; 8990 query->qAv6.ExpectUnique = mDNStrue; 8991 query->qAv6.ForceMCast = mDNSfalse; 8992 query->qAv6.ReturnIntermed = mDNSfalse; 8993 query->qAv6.SuppressUnusable = mDNSfalse; 8994 query->qAv6.SearchListIndex = 0; 8995 query->qAv6.AppendSearchDomains = 0; 8996 query->qAv6.RetryWithSearchDomains = mDNSfalse; 8997 query->qAv6.TimeoutQuestion = 0; 8998 query->qAv6.WakeOnResolve = 0; 8999 query->qAv6.qnameOrig = mDNSNULL; 9000 query->qAv6.QuestionCallback = FoundServiceInfo; 9001 query->qAv6.QuestionContext = query; 9002 9003 query->GotSRV = mDNSfalse; 9004 query->GotTXT = mDNSfalse; 9005 query->GotADD = mDNSfalse; 9006 query->Answers = 0; 9007 9008 query->info = info; 9009 query->ServiceInfoQueryCallback = Callback; 9010 query->ServiceInfoQueryContext = Context; 9011 9012 // info->name = Must already be set up by client 9013 // info->interface = Must already be set up by client 9014 info->ip = zeroAddr; 9015 info->port = zeroIPPort; 9016 info->TXTlen = 0; 9017 9018 // We use mDNS_StartQuery_internal here because we're already holding the lock 9019 status = mDNS_StartQuery_internal(m, &query->qSRV); 9020 if (status == mStatus_NoError) status = mDNS_StartQuery_internal(m, &query->qTXT); 9021 if (status != mStatus_NoError) mDNS_StopResolveService(m, query); 9022 9023 mDNS_Unlock(m); 9024 return(status); 9025 } 9026 9027 mDNSexport void mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *q) 9028 { 9029 mDNS_Lock(m); 9030 // We use mDNS_StopQuery_internal here because we're already holding the lock 9031 if (q->qSRV.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qSRV); 9032 if (q->qTXT.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qTXT); 9033 if (q->qAv4.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qAv4); 9034 if (q->qAv6.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qAv6); 9035 mDNS_Unlock(m); 9036 } 9037 9038 mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom, 9039 const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context) 9040 { 9041 question->InterfaceID = InterfaceID; 9042 question->Target = zeroAddr; 9043 question->qtype = kDNSType_PTR; 9044 question->qclass = kDNSClass_IN; 9045 question->LongLived = mDNSfalse; 9046 question->ExpectUnique = mDNSfalse; 9047 question->ForceMCast = mDNSfalse; 9048 question->ReturnIntermed = mDNSfalse; 9049 question->SuppressUnusable = mDNSfalse; 9050 question->SearchListIndex = 0; 9051 question->AppendSearchDomains = 0; 9052 question->RetryWithSearchDomains = mDNSfalse; 9053 question->TimeoutQuestion = 0; 9054 question->WakeOnResolve = 0; 9055 question->qnameOrig = mDNSNULL; 9056 question->QuestionCallback = Callback; 9057 question->QuestionContext = Context; 9058 if (DomainType > mDNS_DomainTypeMax) return(mStatus_BadParamErr); 9059 if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr); 9060 if (!dom) dom = &localdomain; 9061 if (!AppendDomainName(&question->qname, dom)) return(mStatus_BadParamErr); 9062 return(mDNS_StartQuery(m, question)); 9063 } 9064 9065 // *************************************************************************** 9066 #if COMPILER_LIKES_PRAGMA_MARK 9067 #pragma mark - 9068 #pragma mark - Responder Functions 9069 #endif 9070 9071 mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr) 9072 { 9073 mStatus status; 9074 mDNS_Lock(m); 9075 status = mDNS_Register_internal(m, rr); 9076 mDNS_Unlock(m); 9077 return(status); 9078 } 9079 9080 mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl, 9081 const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback) 9082 { 9083 if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata)) 9084 { 9085 LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(&rr->resrec, &newrdata->u, m->MsgBuffer)); 9086 return(mStatus_Invalid); 9087 } 9088 9089 mDNS_Lock(m); 9090 9091 // If TTL is unspecified, leave TTL unchanged 9092 if (newttl == 0) newttl = rr->resrec.rroriginalttl; 9093 9094 // If we already have an update queued up which has not gone through yet, give the client a chance to free that memory 9095 if (rr->NewRData) 9096 { 9097 RData *n = rr->NewRData; 9098 rr->NewRData = mDNSNULL; // Clear the NewRData pointer ... 9099 if (rr->UpdateCallback) 9100 rr->UpdateCallback(m, rr, n, rr->newrdlength); // ...and let the client free this memory, if necessary 9101 } 9102 9103 rr->NewRData = newrdata; 9104 rr->newrdlength = newrdlength; 9105 rr->UpdateCallback = Callback; 9106 9107 #ifndef UNICAST_DISABLED 9108 if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P && !IsLocalDomain(rr->resrec.name)) 9109 { 9110 mStatus status = uDNS_UpdateRecord(m, rr); 9111 // The caller frees the memory on error, don't retain stale pointers 9112 if (status != mStatus_NoError) { rr->NewRData = mDNSNULL; rr->newrdlength = 0; } 9113 mDNS_Unlock(m); 9114 return(status); 9115 } 9116 #endif 9117 9118 if (RRLocalOnly(rr) || (rr->resrec.rroriginalttl == newttl && 9119 rr->resrec.rdlength == newrdlength && mDNSPlatformMemSame(rr->resrec.rdata->u.data, newrdata->u.data, newrdlength))) 9120 CompleteRDataUpdate(m, rr); 9121 else 9122 { 9123 rr->AnnounceCount = InitialAnnounceCount; 9124 InitializeLastAPTime(m, rr); 9125 while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr); 9126 if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--; 9127 if (!rr->NextUpdateCredit) rr->NextUpdateCredit = NonZeroTime(m->timenow + kUpdateCreditRefreshInterval); 9128 if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1); 9129 if (rr->UpdateCredits <= 5) 9130 { 9131 mDNSu32 delay = 6 - rr->UpdateCredits; // Delay 1 second, then 2, then 3, etc. up to 6 seconds maximum 9132 if (!rr->UpdateBlocked) rr->UpdateBlocked = NonZeroTime(m->timenow + (mDNSs32)delay * mDNSPlatformOneSecond); 9133 rr->ThisAPInterval *= 4; 9134 rr->LastAPTime = rr->UpdateBlocked - rr->ThisAPInterval; 9135 LogMsg("Excessive update rate for %##s; delaying announcement by %ld second%s", 9136 rr->resrec.name->c, delay, delay > 1 ? "s" : ""); 9137 } 9138 rr->resrec.rroriginalttl = newttl; 9139 } 9140 9141 mDNS_Unlock(m); 9142 return(mStatus_NoError); 9143 } 9144 9145 // Note: mDNS_Deregister calls mDNS_Deregister_internal which can call a user callback, which may change 9146 // the record list and/or question list. 9147 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 9148 mDNSexport mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr) 9149 { 9150 mStatus status; 9151 mDNS_Lock(m); 9152 status = mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 9153 mDNS_Unlock(m); 9154 return(status); 9155 } 9156 9157 // Circular reference: AdvertiseInterface references mDNS_HostNameCallback, which calls mDNS_SetFQDN, which call AdvertiseInterface 9158 mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result); 9159 9160 mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m) 9161 { 9162 NetworkInterfaceInfo *intf; 9163 for (intf = m->HostInterfaces; intf; intf = intf->next) 9164 if (intf->Advertise) break; 9165 return(intf); 9166 } 9167 9168 mDNSlocal void AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set) 9169 { 9170 char buffer[MAX_REVERSE_MAPPING_NAME]; 9171 NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m); 9172 if (!primary) primary = set; // If no existing advertised interface, this new NetworkInterfaceInfo becomes our new primary 9173 9174 // Send dynamic update for non-linklocal IPv4 Addresses 9175 mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kHostNameTTL, kDNSRecordTypeUnique, AuthRecordAny, mDNS_HostNameCallback, set); 9176 mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 9177 mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kHostNameTTL, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 9178 9179 #if ANSWER_REMOTE_HOSTNAME_QUERIES 9180 set->RR_A .AllowRemoteQuery = mDNStrue; 9181 set->RR_PTR .AllowRemoteQuery = mDNStrue; 9182 set->RR_HINFO.AllowRemoteQuery = mDNStrue; 9183 #endif 9184 // 1. Set up Address record to map from host name ("foo.local.") to IP address 9185 // 2. Set up reverse-lookup PTR record to map from our address back to our host name 9186 AssignDomainName(&set->RR_A.namestorage, &m->MulticastHostname); 9187 if (set->ip.type == mDNSAddrType_IPv4) 9188 { 9189 set->RR_A.resrec.rrtype = kDNSType_A; 9190 set->RR_A.resrec.rdata->u.ipv4 = set->ip.ip.v4; 9191 // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code 9192 mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.", 9193 set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]); 9194 } 9195 else if (set->ip.type == mDNSAddrType_IPv6) 9196 { 9197 int i; 9198 set->RR_A.resrec.rrtype = kDNSType_AAAA; 9199 set->RR_A.resrec.rdata->u.ipv6 = set->ip.ip.v6; 9200 for (i = 0; i < 16; i++) 9201 { 9202 static const char hexValues[] = "0123456789ABCDEF"; 9203 buffer[i * 4 ] = hexValues[set->ip.ip.v6.b[15 - i] & 0x0F]; 9204 buffer[i * 4 + 1] = '.'; 9205 buffer[i * 4 + 2] = hexValues[set->ip.ip.v6.b[15 - i] >> 4]; 9206 buffer[i * 4 + 3] = '.'; 9207 } 9208 mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa."); 9209 } 9210 9211 MakeDomainNameFromDNSNameString(&set->RR_PTR.namestorage, buffer); 9212 set->RR_PTR.AutoTarget = Target_AutoHost; // Tell mDNS that the target of this PTR is to be kept in sync with our host name 9213 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 9214 9215 set->RR_A.RRSet = &primary->RR_A; // May refer to self 9216 9217 mDNS_Register_internal(m, &set->RR_A); 9218 mDNS_Register_internal(m, &set->RR_PTR); 9219 9220 if (!NO_HINFO && m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254) 9221 { 9222 mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data; 9223 AssignDomainName(&set->RR_HINFO.namestorage, &m->MulticastHostname); 9224 set->RR_HINFO.DependentOn = &set->RR_A; 9225 mDNSPlatformMemCopy(p, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]); 9226 p += 1 + (int)p[0]; 9227 mDNSPlatformMemCopy(p, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]); 9228 mDNS_Register_internal(m, &set->RR_HINFO); 9229 } 9230 else 9231 { 9232 debugf("Not creating HINFO record: platform support layer provided no information"); 9233 set->RR_HINFO.resrec.RecordType = kDNSRecordTypeUnregistered; 9234 } 9235 } 9236 9237 mDNSlocal void DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set) 9238 { 9239 NetworkInterfaceInfo *intf; 9240 9241 // If we still have address records referring to this one, update them 9242 NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m); 9243 AuthRecord *A = primary ? &primary->RR_A : mDNSNULL; 9244 for (intf = m->HostInterfaces; intf; intf = intf->next) 9245 if (intf->RR_A.RRSet == &set->RR_A) 9246 intf->RR_A.RRSet = A; 9247 9248 // Unregister these records. 9249 // When doing the mDNS_Exit processing, we first call DeadvertiseInterface for each interface, so by the time the platform 9250 // support layer gets to call mDNS_DeregisterInterface, the address and PTR records have already been deregistered for it. 9251 // Also, in the event of a name conflict, one or more of our records will have been forcibly deregistered. 9252 // To avoid unnecessary and misleading warning messages, we check the RecordType before calling mDNS_Deregister_internal(). 9253 if (set->RR_A. resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_A, mDNS_Dereg_normal); 9254 if (set->RR_PTR. resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_PTR, mDNS_Dereg_normal); 9255 if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal); 9256 } 9257 9258 mDNSexport void mDNS_SetFQDN(mDNS *const m) 9259 { 9260 domainname newmname; 9261 NetworkInterfaceInfo *intf; 9262 AuthRecord *rr; 9263 newmname.c[0] = 0; 9264 9265 if (!AppendDomainLabel(&newmname, &m->hostlabel)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; } 9266 if (!AppendLiteralLabelString(&newmname, "local")) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; } 9267 9268 mDNS_Lock(m); 9269 9270 if (SameDomainNameCS(&m->MulticastHostname, &newmname)) debugf("mDNS_SetFQDN - hostname unchanged"); 9271 else 9272 { 9273 AssignDomainName(&m->MulticastHostname, &newmname); 9274 9275 // 1. Stop advertising our address records on all interfaces 9276 for (intf = m->HostInterfaces; intf; intf = intf->next) 9277 if (intf->Advertise) DeadvertiseInterface(m, intf); 9278 9279 // 2. Start advertising our address records using the new name 9280 for (intf = m->HostInterfaces; intf; intf = intf->next) 9281 if (intf->Advertise) AdvertiseInterface(m, intf); 9282 } 9283 9284 // 3. Make sure that any AutoTarget SRV records (and the like) get updated 9285 for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->AutoTarget) SetTargetToHostName(m, rr); 9286 for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->AutoTarget) SetTargetToHostName(m, rr); 9287 9288 mDNS_Unlock(m); 9289 } 9290 9291 mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 9292 { 9293 (void)rr; // Unused parameter 9294 9295 #if MDNS_DEBUGMSGS 9296 { 9297 char *msg = "Unknown result"; 9298 if (result == mStatus_NoError) msg = "Name registered"; 9299 else if (result == mStatus_NameConflict) msg = "Name conflict"; 9300 debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result); 9301 } 9302 #endif 9303 9304 if (result == mStatus_NoError) 9305 { 9306 // Notify the client that the host name is successfully registered 9307 if (m->MainCallback) 9308 m->MainCallback(m, mStatus_NoError); 9309 } 9310 else if (result == mStatus_NameConflict) 9311 { 9312 domainlabel oldlabel = m->hostlabel; 9313 9314 // 1. First give the client callback a chance to pick a new name 9315 if (m->MainCallback) 9316 m->MainCallback(m, mStatus_NameConflict); 9317 9318 // 2. If the client callback didn't do it, add (or increment) an index ourselves 9319 // This needs to be case-INSENSITIVE compare, because we need to know that the name has been changed so as to 9320 // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again. 9321 if (SameDomainLabel(m->hostlabel.c, oldlabel.c)) 9322 IncrementLabelSuffix(&m->hostlabel, mDNSfalse); 9323 9324 // 3. Generate the FQDNs from the hostlabel, 9325 // and make sure all SRV records, etc., are updated to reference our new hostname 9326 mDNS_SetFQDN(m); 9327 LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead", oldlabel.c, m->hostlabel.c); 9328 } 9329 else if (result == mStatus_MemFree) 9330 { 9331 // .local hostnames do not require goodbyes - we ignore the MemFree (which is sent directly by 9332 // mDNS_Deregister_internal), and allow the caller to deallocate immediately following mDNS_DeadvertiseInterface 9333 debugf("mDNS_HostNameCallback: MemFree (ignored)"); 9334 } 9335 else 9336 LogMsg("mDNS_HostNameCallback: Unknown error %d for registration of record %s", result, rr->resrec.name->c); 9337 } 9338 9339 mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active) 9340 { 9341 NetworkInterfaceInfo *intf; 9342 active->IPv4Available = mDNSfalse; 9343 active->IPv6Available = mDNSfalse; 9344 for (intf = m->HostInterfaces; intf; intf = intf->next) 9345 if (intf->InterfaceID == active->InterfaceID) 9346 { 9347 if (intf->ip.type == mDNSAddrType_IPv4 && intf->McastTxRx) active->IPv4Available = mDNStrue; 9348 if (intf->ip.type == mDNSAddrType_IPv6 && intf->McastTxRx) active->IPv6Available = mDNStrue; 9349 } 9350 } 9351 9352 mDNSlocal void RestartRecordGetZoneData(mDNS * const m) 9353 { 9354 AuthRecord *rr; 9355 LogInfo("RestartRecordGetZoneData: ResourceRecords"); 9356 for (rr = m->ResourceRecords; rr; rr=rr->next) 9357 if (AuthRecord_uDNS(rr) && rr->state != regState_NoTarget) 9358 { 9359 debugf("RestartRecordGetZoneData: StartGetZoneData for %##s", rr->resrec.name->c); 9360 // Zero out the updateid so that if we have a pending response from the server, it won't 9361 // be accepted as a valid response. If we accept the response, we might free the new "nta" 9362 if (rr->nta) { rr->updateid = zeroID; CancelGetZoneData(m, rr->nta); } 9363 rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationGotZoneData, rr); 9364 } 9365 } 9366 9367 mDNSlocal void InitializeNetWakeState(mDNS *const m, NetworkInterfaceInfo *set) 9368 { 9369 int i; 9370 set->NetWakeBrowse.ThisQInterval = -1; 9371 for (i=0; i<3; i++) 9372 { 9373 set->NetWakeResolve[i].ThisQInterval = -1; 9374 set->SPSAddr[i].type = mDNSAddrType_None; 9375 } 9376 set->NextSPSAttempt = -1; 9377 set->NextSPSAttemptTime = m->timenow; 9378 } 9379 9380 mDNSexport void mDNS_ActivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set) 9381 { 9382 NetworkInterfaceInfo *p = m->HostInterfaces; 9383 while (p && p != set) p=p->next; 9384 if (!p) { LogMsg("mDNS_ActivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set); return; } 9385 9386 if (set->InterfaceActive) 9387 { 9388 LogSPS("ActivateNetWake for %s (%#a)", set->ifname, &set->ip); 9389 mDNS_StartBrowse_internal(m, &set->NetWakeBrowse, &SleepProxyServiceType, &localdomain, set->InterfaceID, mDNSfalse, m->SPSBrowseCallback, set); 9390 } 9391 } 9392 9393 mDNSexport void mDNS_DeactivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set) 9394 { 9395 NetworkInterfaceInfo *p = m->HostInterfaces; 9396 while (p && p != set) p=p->next; 9397 if (!p) { LogMsg("mDNS_DeactivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set); return; } 9398 9399 if (set->NetWakeBrowse.ThisQInterval >= 0) 9400 { 9401 int i; 9402 LogSPS("DeactivateNetWake for %s (%#a)", set->ifname, &set->ip); 9403 9404 // Stop our browse and resolve operations 9405 mDNS_StopQuery_internal(m, &set->NetWakeBrowse); 9406 for (i=0; i<3; i++) if (set->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery_internal(m, &set->NetWakeResolve[i]); 9407 9408 // Make special call to the browse callback to let it know it can to remove all records for this interface 9409 if (m->SPSBrowseCallback) 9410 { 9411 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 9412 m->SPSBrowseCallback(m, &set->NetWakeBrowse, mDNSNULL, mDNSfalse); 9413 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 9414 } 9415 9416 // Reset our variables back to initial state, so we're ready for when NetWake is turned back on 9417 // (includes resetting NetWakeBrowse.ThisQInterval back to -1) 9418 InitializeNetWakeState(m, set); 9419 } 9420 } 9421 9422 mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping) 9423 { 9424 AuthRecord *rr; 9425 mDNSBool FirstOfType = mDNStrue; 9426 NetworkInterfaceInfo **p = &m->HostInterfaces; 9427 9428 if (!set->InterfaceID) 9429 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID", &set->ip); return(mStatus_Invalid); } 9430 9431 if (!mDNSAddressIsValidNonZero(&set->mask)) 9432 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a", &set->ip, &set->mask); return(mStatus_Invalid); } 9433 9434 mDNS_Lock(m); 9435 9436 // Assume this interface will be active now, unless we find a duplicate already in the list 9437 set->InterfaceActive = mDNStrue; 9438 set->IPv4Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx); 9439 set->IPv6Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx); 9440 9441 InitializeNetWakeState(m, set); 9442 9443 // Scan list to see if this InterfaceID is already represented 9444 while (*p) 9445 { 9446 if (*p == set) 9447 { 9448 LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo that's already in the list"); 9449 mDNS_Unlock(m); 9450 return(mStatus_AlreadyRegistered); 9451 } 9452 9453 if ((*p)->InterfaceID == set->InterfaceID) 9454 { 9455 // This InterfaceID already represented by a different interface in the list, so mark this instance inactive for now 9456 set->InterfaceActive = mDNSfalse; 9457 if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse; 9458 if (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx) (*p)->IPv4Available = mDNStrue; 9459 if (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx) (*p)->IPv6Available = mDNStrue; 9460 } 9461 9462 p=&(*p)->next; 9463 } 9464 9465 set->next = mDNSNULL; 9466 *p = set; 9467 9468 if (set->Advertise) 9469 AdvertiseInterface(m, set); 9470 9471 LogInfo("mDNS_RegisterInterface: InterfaceID %p %s (%#a) %s", set->InterfaceID, set->ifname, &set->ip, 9472 set->InterfaceActive ? 9473 "not represented in list; marking active and retriggering queries" : 9474 "already represented in list; marking inactive for now"); 9475 9476 if (set->NetWake) mDNS_ActivateNetWake_internal(m, set); 9477 9478 // In early versions of OS X the IPv6 address remains on an interface even when the interface is turned off, 9479 // giving the false impression that there's an active representative of this interface when there really isn't. 9480 // Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records, 9481 // even if we believe that we previously had an active representative of this interface. 9482 if (set->McastTxRx && (FirstOfType || set->InterfaceActive)) 9483 { 9484 DNSQuestion *q; 9485 // Normally, after an interface comes up, we pause half a second before beginning probing. 9486 // This is to guard against cases where there's rapid interface changes, where we could be confused by 9487 // seeing packets we ourselves sent just moments ago (perhaps when this interface had a different address) 9488 // which are then echoed back after a short delay by some Ethernet switches and some 802.11 base stations. 9489 // We don't want to do a probe, and then see a stale echo of an announcement we ourselves sent, 9490 // and think it's a conflicting answer to our probe. 9491 // In the case of a flapping interface, we pause for five seconds, and reduce the announcement count to one packet. 9492 const mDNSs32 probedelay = flapping ? mDNSPlatformOneSecond * 5 : mDNSPlatformOneSecond / 2; 9493 const mDNSu8 numannounce = flapping ? (mDNSu8)1 : InitialAnnounceCount; 9494 9495 // Use a small amount of randomness: 9496 // In the case of a network administrator turning on an Ethernet hub so that all the 9497 // connected machines establish link at exactly the same time, we don't want them all 9498 // to go and hit the network with identical queries at exactly the same moment. 9499 // We set a random delay of up to InitialQuestionInterval (1/3 second). 9500 // We must *never* set m->SuppressSending to more than that (or set it repeatedly in a way 9501 // that causes mDNSResponder to remain in a prolonged state of SuppressSending, because 9502 // suppressing packet sending for more than about 1/3 second can cause protocol correctness 9503 // to start to break down (e.g. we don't answer probes fast enough, and get name conflicts). 9504 // See <rdar://problem/4073853> mDNS: m->SuppressSending set too enthusiastically 9505 if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval); 9506 9507 if (flapping) LogMsg("mDNS_RegisterInterface: Frequent transitions for interface %s (%#a)", set->ifname, &set->ip); 9508 9509 LogInfo("mDNS_RegisterInterface: %s (%#a) probedelay %d", set->ifname, &set->ip, probedelay); 9510 if (m->SuppressProbes == 0 || 9511 m->SuppressProbes - NonZeroTime(m->timenow + probedelay) < 0) 9512 m->SuppressProbes = NonZeroTime(m->timenow + probedelay); 9513 9514 // Include OWNER option in packets for 60 seconds after connecting to the network. Setting 9515 // it here also handles the wake up case as the network link comes UP after waking causing 9516 // us to reconnect to the network. If we do this as part of the wake up code, it is possible 9517 // that the network link comes UP after 60 seconds and we never set the OWNER option 9518 m->AnnounceOwner = NonZeroTime(m->timenow + 60 * mDNSPlatformOneSecond); 9519 LogInfo("mDNS_RegisterInterface: Setting AnnounceOwner"); 9520 9521 for (q = m->Questions; q; q=q->next) // Scan our list of questions 9522 if (mDNSOpaque16IsZero(q->TargetQID)) 9523 if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) // If non-specific Q, or Q on this specific interface, 9524 { // then reactivate this question 9525 // If flapping, delay between first and second queries is nine seconds instead of one second 9526 mDNSBool dodelay = flapping && (q->FlappingInterface1 == set->InterfaceID || q->FlappingInterface2 == set->InterfaceID); 9527 mDNSs32 initial = dodelay ? InitialQuestionInterval * QuestionIntervalStep2 : InitialQuestionInterval; 9528 mDNSs32 qdelay = dodelay ? mDNSPlatformOneSecond * 5 : 0; 9529 if (dodelay) LogInfo("No cache records expired for %##s (%s); okay to delay questions a little", q->qname.c, DNSTypeName(q->qtype)); 9530 9531 if (!q->ThisQInterval || q->ThisQInterval > initial) 9532 { 9533 q->ThisQInterval = initial; 9534 q->RequestUnicast = 2; // Set to 2 because is decremented once *before* we check it 9535 } 9536 q->LastQTime = m->timenow - q->ThisQInterval + qdelay; 9537 q->RecentAnswerPkts = 0; 9538 SetNextQueryTime(m,q); 9539 } 9540 9541 // For all our non-specific authoritative resource records (and any dormant records specific to this interface) 9542 // we now need them to re-probe if necessary, and then re-announce. 9543 for (rr = m->ResourceRecords; rr; rr=rr->next) 9544 if (!AuthRecord_uDNS(rr)) 9545 if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID) 9546 { 9547 if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique; 9548 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); 9549 if (rr->AnnounceCount < numannounce) rr->AnnounceCount = numannounce; 9550 rr->SendNSECNow = mDNSNULL; 9551 InitializeLastAPTime(m, rr); 9552 } 9553 } 9554 9555 RestartRecordGetZoneData(m); 9556 9557 CheckSuppressUnusableQuestions(m); 9558 9559 mDNS_UpdateAllowSleep(m); 9560 9561 mDNS_Unlock(m); 9562 return(mStatus_NoError); 9563 } 9564 9565 // Note: mDNS_DeregisterInterface calls mDNS_Deregister_internal which can call a user callback, which may change 9566 // the record list and/or question list. 9567 // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 9568 mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping) 9569 { 9570 NetworkInterfaceInfo **p = &m->HostInterfaces; 9571 mDNSBool revalidate = mDNSfalse; 9572 9573 mDNS_Lock(m); 9574 9575 // Find this record in our list 9576 while (*p && *p != set) p=&(*p)->next; 9577 if (!*p) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list"); mDNS_Unlock(m); return; } 9578 9579 mDNS_DeactivateNetWake_internal(m, set); 9580 9581 // Unlink this record from our list 9582 *p = (*p)->next; 9583 set->next = mDNSNULL; 9584 9585 if (!set->InterfaceActive) 9586 { 9587 // If this interface not the active member of its set, update the v4/v6Available flags for the active member 9588 NetworkInterfaceInfo *intf; 9589 for (intf = m->HostInterfaces; intf; intf = intf->next) 9590 if (intf->InterfaceActive && intf->InterfaceID == set->InterfaceID) 9591 UpdateInterfaceProtocols(m, intf); 9592 } 9593 else 9594 { 9595 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, set->InterfaceID); 9596 if (intf) 9597 { 9598 LogInfo("mDNS_DeregisterInterface: Another representative of InterfaceID %p %s (%#a) exists;" 9599 " making it active", set->InterfaceID, set->ifname, &set->ip); 9600 if (intf->InterfaceActive) 9601 LogMsg("mDNS_DeregisterInterface: ERROR intf->InterfaceActive already set for %s (%#a)", set->ifname, &set->ip); 9602 intf->InterfaceActive = mDNStrue; 9603 UpdateInterfaceProtocols(m, intf); 9604 9605 if (intf->NetWake) mDNS_ActivateNetWake_internal(m, intf); 9606 9607 // See if another representative *of the same type* exists. If not, we mave have gone from 9608 // dual-stack to v6-only (or v4-only) so we need to reconfirm which records are still valid. 9609 for (intf = m->HostInterfaces; intf; intf = intf->next) 9610 if (intf->InterfaceID == set->InterfaceID && intf->ip.type == set->ip.type) 9611 break; 9612 if (!intf) revalidate = mDNStrue; 9613 } 9614 else 9615 { 9616 mDNSu32 slot; 9617 CacheGroup *cg; 9618 CacheRecord *rr; 9619 DNSQuestion *q; 9620 DNSServer *s; 9621 9622 LogInfo("mDNS_DeregisterInterface: Last representative of InterfaceID %p %s (%#a) deregistered;" 9623 " marking questions etc. dormant", set->InterfaceID, set->ifname, &set->ip); 9624 9625 if (set->McastTxRx && flapping) 9626 LogMsg("DeregisterInterface: Frequent transitions for interface %s (%#a)", set->ifname, &set->ip); 9627 9628 // 1. Deactivate any questions specific to this interface, and tag appropriate questions 9629 // so that mDNS_RegisterInterface() knows how swiftly it needs to reactivate them 9630 for (q = m->Questions; q; q=q->next) 9631 { 9632 if (q->InterfaceID == set->InterfaceID) q->ThisQInterval = 0; 9633 if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) 9634 { 9635 q->FlappingInterface2 = q->FlappingInterface1; 9636 q->FlappingInterface1 = set->InterfaceID; // Keep history of the last two interfaces to go away 9637 } 9638 } 9639 9640 // 2. Flush any cache records received on this interface 9641 revalidate = mDNSfalse; // Don't revalidate if we're flushing the records 9642 FORALL_CACHERECORDS(slot, cg, rr) 9643 if (rr->resrec.InterfaceID == set->InterfaceID) 9644 { 9645 // If this interface is deemed flapping, 9646 // postpone deleting the cache records in case the interface comes back again 9647 if (set->McastTxRx && flapping) 9648 { 9649 // For a flapping interface we want these record to go away after 30 seconds 9650 mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface); 9651 // We set UnansweredQueries = MaxUnansweredQueries so we don't waste time doing any queries for them -- 9652 // if the interface does come back, any relevant questions will be reactivated anyway 9653 rr->UnansweredQueries = MaxUnansweredQueries; 9654 } 9655 else 9656 mDNS_PurgeCacheResourceRecord(m, rr); 9657 } 9658 9659 // 3. Any DNS servers specific to this interface are now unusable 9660 for (s = m->DNSServers; s; s = s->next) 9661 if (s->interface == set->InterfaceID) 9662 { 9663 s->interface = mDNSInterface_Any; 9664 s->teststate = DNSServer_Disabled; 9665 } 9666 } 9667 } 9668 9669 // If we were advertising on this interface, deregister those address and reverse-lookup records now 9670 if (set->Advertise) DeadvertiseInterface(m, set); 9671 9672 // If we have any cache records received on this interface that went away, then re-verify them. 9673 // In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off, 9674 // giving the false impression that there's an active representative of this interface when there really isn't. 9675 // Don't need to do this when shutting down, because *all* interfaces are about to go away 9676 if (revalidate && !m->ShutdownTime) 9677 { 9678 mDNSu32 slot; 9679 CacheGroup *cg; 9680 CacheRecord *rr; 9681 FORALL_CACHERECORDS(slot, cg, rr) 9682 if (rr->resrec.InterfaceID == set->InterfaceID) 9683 mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface); 9684 } 9685 9686 CheckSuppressUnusableQuestions(m); 9687 9688 mDNS_UpdateAllowSleep(m); 9689 9690 mDNS_Unlock(m); 9691 } 9692 9693 mDNSlocal void ServiceCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 9694 { 9695 ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext; 9696 (void)m; // Unused parameter 9697 9698 #if MDNS_DEBUGMSGS 9699 { 9700 char *msg = "Unknown result"; 9701 if (result == mStatus_NoError) msg = "Name Registered"; 9702 else if (result == mStatus_NameConflict) msg = "Name Conflict"; 9703 else if (result == mStatus_MemFree) msg = "Memory Free"; 9704 debugf("ServiceCallback: %##s (%s) %s (%d)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result); 9705 } 9706 #endif 9707 9708 // Only pass on the NoError acknowledgement for the SRV record (when it finishes probing) 9709 if (result == mStatus_NoError && rr != &sr->RR_SRV) return; 9710 9711 // If we got a name conflict on either SRV or TXT, forcibly deregister this service, and record that we did that 9712 if (result == mStatus_NameConflict) 9713 { 9714 sr->Conflict = mDNStrue; // Record that this service set had a conflict 9715 mDNS_DeregisterService(m, sr); // Unlink the records from our list 9716 return; 9717 } 9718 9719 if (result == mStatus_MemFree) 9720 { 9721 // If the SRV/TXT/PTR records, or the _services._dns-sd._udp record, or any of the subtype PTR records, 9722 // are still in the process of deregistering, don't pass on the NameConflict/MemFree message until 9723 // every record is finished cleaning up. 9724 mDNSu32 i; 9725 ExtraResourceRecord *e = sr->Extras; 9726 9727 if (sr->RR_SRV.resrec.RecordType != kDNSRecordTypeUnregistered) return; 9728 if (sr->RR_TXT.resrec.RecordType != kDNSRecordTypeUnregistered) return; 9729 if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return; 9730 if (sr->RR_ADV.resrec.RecordType != kDNSRecordTypeUnregistered) return; 9731 for (i=0; i<sr->NumSubTypes; i++) if (sr->SubTypes[i].resrec.RecordType != kDNSRecordTypeUnregistered) return; 9732 9733 while (e) 9734 { 9735 if (e->r.resrec.RecordType != kDNSRecordTypeUnregistered) return; 9736 e = e->next; 9737 } 9738 9739 // If this ServiceRecordSet was forcibly deregistered, and now its memory is ready for reuse, 9740 // then we can now report the NameConflict to the client 9741 if (sr->Conflict) result = mStatus_NameConflict; 9742 9743 } 9744 9745 LogInfo("ServiceCallback: All records %s for %##s", (result == mStatus_MemFree ? "Unregistered": "Registered"), sr->RR_PTR.resrec.name->c); 9746 // CAUTION: MUST NOT do anything more with sr after calling sr->Callback(), because the client's callback 9747 // function is allowed to do anything, including deregistering this service and freeing its memory. 9748 if (sr->ServiceCallback) 9749 sr->ServiceCallback(m, sr, result); 9750 } 9751 9752 mDNSlocal void NSSCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 9753 { 9754 ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext; 9755 if (sr->ServiceCallback) 9756 sr->ServiceCallback(m, sr, result); 9757 } 9758 9759 // Note: 9760 // Name is first label of domain name (any dots in the name are actual dots, not label separators) 9761 // Type is service type (e.g. "_ipp._tcp.") 9762 // Domain is fully qualified domain name (i.e. ending with a null label) 9763 // We always register a TXT, even if it is empty (so that clients are not 9764 // left waiting forever looking for a nonexistent record.) 9765 // If the host parameter is mDNSNULL or the root domain (ASCII NUL), 9766 // then the default host name (m->MulticastHostname) is automatically used 9767 // If the optional target host parameter is set, then the storage it points to must remain valid for the lifetime of the service registration 9768 mDNSexport mStatus mDNS_RegisterService(mDNS *const m, ServiceRecordSet *sr, 9769 const domainlabel *const name, const domainname *const type, const domainname *const domain, 9770 const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen, 9771 AuthRecord *SubTypes, mDNSu32 NumSubTypes, 9772 mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context, mDNSu32 flags) 9773 { 9774 mStatus err; 9775 mDNSu32 i; 9776 mDNSu32 hostTTL; 9777 AuthRecType artype; 9778 mDNSu8 recordType = (flags & regFlagKnownUnique) ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique; 9779 9780 sr->ServiceCallback = Callback; 9781 sr->ServiceContext = Context; 9782 sr->Conflict = mDNSfalse; 9783 9784 sr->Extras = mDNSNULL; 9785 sr->NumSubTypes = NumSubTypes; 9786 sr->SubTypes = SubTypes; 9787 9788 if (InterfaceID == mDNSInterface_LocalOnly) 9789 artype = AuthRecordLocalOnly; 9790 else if (InterfaceID == mDNSInterface_P2P) 9791 artype = AuthRecordP2P; 9792 else if ((InterfaceID == mDNSInterface_Any) && (flags & regFlagIncludeP2P)) 9793 artype = AuthRecordAnyIncludeP2P; 9794 else 9795 artype = AuthRecordAny; 9796 9797 // Initialize the AuthRecord objects to sane values 9798 // Need to initialize everything correctly *before* making the decision whether to do a RegisterNoSuchService and bail out 9799 mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeAdvisory, artype, ServiceCallback, sr); 9800 mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr); 9801 9802 if (SameDomainName(type, (const domainname *) "\x4" "_ubd" "\x4" "_tcp")) 9803 hostTTL = kHostNameSmallTTL; 9804 else 9805 hostTTL = kHostNameTTL; 9806 9807 mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, hostTTL, recordType, artype, ServiceCallback, sr); 9808 mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kStandardTTL, kDNSRecordTypeUnique, artype, ServiceCallback, sr); 9809 9810 // If port number is zero, that means the client is really trying to do a RegisterNoSuchService 9811 if (mDNSIPPortIsZero(port)) 9812 return(mDNS_RegisterNoSuchService(m, &sr->RR_SRV, name, type, domain, mDNSNULL, InterfaceID, NSSCallback, sr, (flags & regFlagIncludeP2P))); 9813 9814 // If the client is registering an oversized TXT record, 9815 // it is the client's responsibility to alloate a ServiceRecordSet structure that is large enough for it 9816 if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen) 9817 sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen; 9818 9819 // Set up the record names 9820 // For now we only create an advisory record for the main type, not for subtypes 9821 // We need to gain some operational experience before we decide if there's a need to create them for subtypes too 9822 if (ConstructServiceName(&sr->RR_ADV.namestorage, (const domainlabel*)"\x09_services", (const domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL) 9823 return(mStatus_BadParamErr); 9824 if (ConstructServiceName(&sr->RR_PTR.namestorage, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr); 9825 if (ConstructServiceName(&sr->RR_SRV.namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr); 9826 AssignDomainName(&sr->RR_TXT.namestorage, sr->RR_SRV.resrec.name); 9827 9828 // 1. Set up the ADV record rdata to advertise our service type 9829 AssignDomainName(&sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name); 9830 9831 // 2. Set up the PTR record rdata to point to our service name 9832 // We set up two additionals, so when a client asks for this PTR we automatically send the SRV and the TXT too 9833 // Note: uDNS registration code assumes that Additional1 points to the SRV record 9834 AssignDomainName(&sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name); 9835 sr->RR_PTR.Additional1 = &sr->RR_SRV; 9836 sr->RR_PTR.Additional2 = &sr->RR_TXT; 9837 9838 // 2a. Set up any subtype PTRs to point to our service name 9839 // If the client is using subtypes, it is the client's responsibility to have 9840 // already set the first label of the record name to the subtype being registered 9841 for (i=0; i<NumSubTypes; i++) 9842 { 9843 domainname st; 9844 AssignDomainName(&st, sr->SubTypes[i].resrec.name); 9845 st.c[1+st.c[0]] = 0; // Only want the first label, not the whole FQDN (particularly for mDNS_RenameAndReregisterService()) 9846 AppendDomainName(&st, type); 9847 mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr); 9848 if (ConstructServiceName(&sr->SubTypes[i].namestorage, mDNSNULL, &st, domain) == mDNSNULL) return(mStatus_BadParamErr); 9849 AssignDomainName(&sr->SubTypes[i].resrec.rdata->u.name, &sr->RR_SRV.namestorage); 9850 sr->SubTypes[i].Additional1 = &sr->RR_SRV; 9851 sr->SubTypes[i].Additional2 = &sr->RR_TXT; 9852 } 9853 9854 // 3. Set up the SRV record rdata. 9855 sr->RR_SRV.resrec.rdata->u.srv.priority = 0; 9856 sr->RR_SRV.resrec.rdata->u.srv.weight = 0; 9857 sr->RR_SRV.resrec.rdata->u.srv.port = port; 9858 9859 // Setting AutoTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name 9860 if (host && host->c[0]) AssignDomainName(&sr->RR_SRV.resrec.rdata->u.srv.target, host); 9861 else { sr->RR_SRV.AutoTarget = Target_AutoHost; sr->RR_SRV.resrec.rdata->u.srv.target.c[0] = '\0'; } 9862 9863 // 4. Set up the TXT record rdata, 9864 // and set DependentOn because we're depending on the SRV record to find and resolve conflicts for us 9865 // Note: uDNS registration code assumes that DependentOn points to the SRV record 9866 if (txtinfo == mDNSNULL) sr->RR_TXT.resrec.rdlength = 0; 9867 else if (txtinfo != sr->RR_TXT.resrec.rdata->u.txt.c) 9868 { 9869 sr->RR_TXT.resrec.rdlength = txtlen; 9870 if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr); 9871 mDNSPlatformMemCopy(sr->RR_TXT.resrec.rdata->u.txt.c, txtinfo, txtlen); 9872 } 9873 sr->RR_TXT.DependentOn = &sr->RR_SRV; 9874 9875 mDNS_Lock(m); 9876 // It is important that we register SRV first. uDNS assumes that SRV is registered first so 9877 // that if the SRV cannot find a target, rest of the records that belong to this service 9878 // will not be activated. 9879 err = mDNS_Register_internal(m, &sr->RR_SRV); 9880 // If we can't register the SRV record due to errors, bail out. It has not been inserted in 9881 // any list and hence no need to deregister. We could probably do similar checks for other 9882 // records below and bail out. For now, this seems to be sufficient to address rdar://9304275 9883 if (err) 9884 { 9885 mDNS_Unlock(m); 9886 return err; 9887 } 9888 if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT); 9889 // We register the RR_PTR last, because we want to be sure that in the event of a forced call to 9890 // mDNS_StartExit, the RR_PTR will be the last one to be forcibly deregistered, since that is what triggers 9891 // the mStatus_MemFree callback to ServiceCallback, which in turn passes on the mStatus_MemFree back to 9892 // the client callback, which is then at liberty to free the ServiceRecordSet memory at will. We need to 9893 // make sure we've deregistered all our records and done any other necessary cleanup before that happens. 9894 if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV); 9895 for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]); 9896 if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR); 9897 9898 mDNS_Unlock(m); 9899 9900 if (err) mDNS_DeregisterService(m, sr); 9901 return(err); 9902 } 9903 9904 mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr, 9905 ExtraResourceRecord *extra, RData *