1/* -*- Mode: C; tab-width: 4 -*- 2 * 3 * Copyright (c) 2002-2017 Apple 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 26#include "DNSCommon.h" // Defines general DNS utility routines 27#include "uDNS.h" // Defines entry points into unicast-specific routines 28#include "nsec.h" 29#include "dnssec.h" 30#include "anonymous.h" 31 32// Disable certain benign warnings with Microsoft compilers 33#if (defined(_MSC_VER)) 34// Disable "conditional expression is constant" warning for debug macros. 35// Otherwise, this generates warnings for the perfectly natural construct "while(1)" 36// If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know 37 #pragma warning(disable:4127) 38 39// Disable "assignment within conditional expression". 40// Other compilers understand the convention that if you place the assignment expression within an extra pair 41// of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary. 42// The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal 43// to the compiler that the assignment is intentional, we have to just turn this warning off completely. 44 #pragma warning(disable:4706) 45#endif 46 47#include "dns_sd.h" // for kDNSServiceFlags* definitions 48#include "dns_sd_internal.h" 49 50#define IID(a) ((int32_t)(intptr_t)(a)) 51 52#if APPLE_OSX_mDNSResponder 53#include <WebFilterDNS/WebFilterDNS.h> 54 55// Delay in seconds before disabling multicast after there are no active queries or registrations. 56#define BONJOUR_DISABLE_DELAY 60 57 58#if !NO_WCF 59WCFConnection *WCFConnectionNew(void) __attribute__((weak_import)); 60void WCFConnectionDealloc(WCFConnection* c) __attribute__((weak_import)); 61 62// Do we really need to define a macro for "if"? 63#define CHECK_WCF_FUNCTION(X) if (X) 64#endif // ! NO_WCF 65 66#else 67 68#define NO_WCF 1 69#endif // APPLE_OSX_mDNSResponder 70 71#if AWD_METRICS 72#include "Metrics.h" 73#endif 74 75#if USE_DNS64 76#include "DNS64.h" 77#endif 78 79#ifdef UNIT_TEST 80#include "unittest.h" 81#endif 82 83// Forward declarations 84mDNSlocal void BeginSleepProcessing(mDNS *const m); 85mDNSlocal void RetrySPSRegistrations(mDNS *const m); 86mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password, mDNSBool unicastOnly); 87mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q); 88mDNSlocal void mDNS_PurgeForQuestion(mDNS *const m, DNSQuestion *q); 89mDNSlocal void CheckForDNSSECRecords(mDNS *const m, DNSQuestion *q); 90mDNSlocal void mDNS_SendKeepalives(mDNS *const m); 91mDNSlocal void mDNS_ExtractKeepaliveInfo(AuthRecord *ar, mDNSu32 *timeout, mDNSAddr *laddr, mDNSAddr *raddr, mDNSEthAddr *eth, 92 mDNSu32 *seq, mDNSu32 *ack, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu16 *win); 93 94mDNSlocal void AdvertiseAllInterfaceRecords(mDNS *const m); 95mDNSlocal void DeadvertiseAllInterfaceRecords(mDNS *const m); 96mDNSlocal void FreeNSECRecords(mDNS *const m, CacheRecord *NSECRecords); 97mDNSlocal void mDNSParseNSEC3Records(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, 98 const mDNSInterfaceID InterfaceID, CacheRecord **NSEC3Records); 99mDNSlocal mDNSu8 *GetValueForMACAddr(mDNSu8 *ptr, mDNSu8 *limit, mDNSEthAddr *eth); 100 101 102// *************************************************************************** 103#if COMPILER_LIKES_PRAGMA_MARK 104#pragma mark - Program Constants 105#endif 106 107// To Turn OFF mDNS_Tracer set MDNS_TRACER to 0 or undef it 108#define MDNS_TRACER 1 109 110#define NO_HINFO 1 111 112// Any records bigger than this are considered 'large' records 113#define SmallRecordLimit 1024 114 115#define kMaxUpdateCredits 10 116#define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6) 117 118// define special NR_AnswerTo values 119#define NR_AnswerMulticast (mDNSu8*)~0 120#define NR_AnswerUnicast (mDNSu8*)~1 121 122// Question default timeout values 123#define DEFAULT_MCAST_TIMEOUT 5 124#define DEFAULT_LO_OR_P2P_TIMEOUT 5 125 126// The code (see SendQueries() and BuildQuestion()) needs to have the 127// RequestUnicast value set to a value one greater than the number of times you want the query 128// sent with the "request unicast response" (QU) bit set. 129#define SET_QU_IN_FIRST_QUERY 2 130#define kDefaultRequestUnicastCount SET_QU_IN_FIRST_QUERY 131 132// The time needed to offload records to a sleep proxy after powerd sends the kIOMessageSystemWillSleep notification 133#define DARK_WAKE_DELAY_SLEEP 5 134#define kDarkWakeDelaySleep (mDNSPlatformOneSecond * DARK_WAKE_DELAY_SLEEP) 135 136// The maximum number of times we delay probing to prevent spurious conflicts due to stale packets 137#define MAX_CONFLICT_PROCESSING_DELAYS 3 138 139// RFC 6762 defines Passive Observation Of Failures (POOF) 140// 141// A host observes the multicast queries issued by the other hosts on 142// the network. One of the major benefits of also sending responses 143// using multicast is that it allows all hosts to see the responses 144// (or lack thereof) to those queries. 145// 146// If a host sees queries, for which a record in its cache would be 147// expected to be given as an answer in a multicast response, but no 148// such answer is seen, then the host may take this as an indication 149// that the record may no longer be valid. 150// 151// After seeing two or more of these queries, and seeing no multicast 152// response containing the expected answer within ten seconds, then even 153// though its TTL may indicate that it is not yet due to expire, that 154// record SHOULD be flushed from the cache. 155// 156// <https://tools.ietf.org/html/rfc6762#section-10.5> 157 158#define POOF_ENABLED 1 159 160mDNSexport const char *const mDNS_DomainTypeNames[] = 161{ 162 "b._dns-sd._udp.", // Browse 163 "db._dns-sd._udp.", // Default Browse 164 "lb._dns-sd._udp.", // Automatic Browse 165 "r._dns-sd._udp.", // Registration 166 "dr._dns-sd._udp." // Default Registration 167}; 168 169#ifdef UNICAST_DISABLED 170#define uDNS_IsActiveQuery(q, u) mDNSfalse 171#endif 172 173// *************************************************************************** 174#if COMPILER_LIKES_PRAGMA_MARK 175#pragma mark - 176#pragma mark - General Utility Functions 177#endif 178 179// Returns true if this is a unique, authoritative LocalOnly record that answers questions of type 180// A, AAAA , CNAME, or PTR. The caller should answer the question with this record and not send out 181// the question on the wire if LocalOnlyRecordAnswersQuestion() also returns true. 182// Main use is to handle /etc/hosts records and the LocalOnly PTR records created for localhost. 183#define UniqueLocalOnlyRecord(rr) ((rr)->ARType == AuthRecordLocalOnly && \ 184 (rr)->resrec.RecordType & kDNSRecordTypeUniqueMask && \ 185 ((rr)->resrec.rrtype == kDNSType_A || (rr)->resrec.rrtype == kDNSType_AAAA || \ 186 (rr)->resrec.rrtype == kDNSType_CNAME || \ 187 (rr)->resrec.rrtype == kDNSType_PTR)) 188 189mDNSlocal void SetNextQueryStopTime(mDNS *const m, const DNSQuestion *const q) 190{ 191 mDNS_CheckLock(m); 192 193 if (m->NextScheduledStopTime - q->StopTime > 0) 194 m->NextScheduledStopTime = q->StopTime; 195} 196 197mDNSexport void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q) 198{ 199 mDNS_CheckLock(m); 200 201 if (ActiveQuestion(q)) 202 { 203 // Depending on whether this is a multicast or unicast question we want to set either: 204 // m->NextScheduledQuery = NextQSendTime(q) or 205 // m->NextuDNSEvent = NextQSendTime(q) 206 mDNSs32 *const timer = mDNSOpaque16IsZero(q->TargetQID) ? &m->NextScheduledQuery : &m->NextuDNSEvent; 207 if (*timer - NextQSendTime(q) > 0) 208 *timer = NextQSendTime(q); 209 } 210} 211 212mDNSlocal void ReleaseAuthEntity(AuthHash *r, AuthEntity *e) 213{ 214#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1 215 unsigned int i; 216 for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF; 217#endif 218 e->next = r->rrauth_free; 219 r->rrauth_free = e; 220 r->rrauth_totalused--; 221} 222 223mDNSlocal void ReleaseAuthGroup(AuthHash *r, AuthGroup **cp) 224{ 225 AuthEntity *e = (AuthEntity *)(*cp); 226 LogMsg("ReleaseAuthGroup: Releasing AuthGroup %##s", (*cp)->name->c); 227 if ((*cp)->rrauth_tail != &(*cp)->members) 228 LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrauth_tail != &(*cp)->members)"); 229 if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name); 230 (*cp)->name = mDNSNULL; 231 *cp = (*cp)->next; // Cut record from list 232 ReleaseAuthEntity(r, e); 233} 234 235mDNSlocal AuthEntity *GetAuthEntity(AuthHash *r, const AuthGroup *const PreserveAG) 236{ 237 AuthEntity *e = mDNSNULL; 238 239 if (r->rrauth_lock) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); } 240 r->rrauth_lock = 1; 241 242 if (!r->rrauth_free) 243 { 244 // We allocate just one AuthEntity at a time because we need to be able 245 // free them all individually which normally happens when we parse /etc/hosts into 246 // AuthHash where we add the "new" entries and discard (free) the already added 247 // entries. If we allocate as chunks, we can't free them individually. 248 AuthEntity *storage = mDNSPlatformMemAllocate(sizeof(AuthEntity)); 249 storage->next = mDNSNULL; 250 r->rrauth_free = storage; 251 } 252 253 // If we still have no free records, recycle all the records we can. 254 // Enumerating the entire auth is moderately expensive, so when we do it, we reclaim all the records we can in one pass. 255 if (!r->rrauth_free) 256 { 257 mDNSu32 oldtotalused = r->rrauth_totalused; 258 mDNSu32 slot; 259 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 260 { 261 AuthGroup **cp = &r->rrauth_hash[slot]; 262 while (*cp) 263 { 264 if ((*cp)->members || (*cp)==PreserveAG) cp=&(*cp)->next; 265 else ReleaseAuthGroup(r, cp); 266 } 267 } 268 LogInfo("GetAuthEntity: Recycled %d records to reduce auth cache from %d to %d", 269 oldtotalused - r->rrauth_totalused, oldtotalused, r->rrauth_totalused); 270 } 271 272 if (r->rrauth_free) // If there are records in the free list, take one 273 { 274 e = r->rrauth_free; 275 r->rrauth_free = e->next; 276 if (++r->rrauth_totalused >= r->rrauth_report) 277 { 278 LogInfo("RR Auth now using %ld objects", r->rrauth_totalused); 279 if (r->rrauth_report < 100) r->rrauth_report += 10; 280 else if (r->rrauth_report < 1000) r->rrauth_report += 100; 281 else r->rrauth_report += 1000; 282 } 283 mDNSPlatformMemZero(e, sizeof(*e)); 284 } 285 286 r->rrauth_lock = 0; 287 288 return(e); 289} 290 291mDNSexport AuthGroup *AuthGroupForName(AuthHash *r, const mDNSu32 namehash, const domainname *const name) 292{ 293 AuthGroup *ag; 294 const mDNSu32 slot = namehash % AUTH_HASH_SLOTS; 295 296 for (ag = r->rrauth_hash[slot]; ag; ag=ag->next) 297 if (ag->namehash == namehash && SameDomainName(ag->name, name)) 298 break; 299 return(ag); 300} 301 302mDNSexport AuthGroup *AuthGroupForRecord(AuthHash *r, const ResourceRecord *const rr) 303{ 304 return(AuthGroupForName(r, rr->namehash, rr->name)); 305} 306 307mDNSlocal AuthGroup *GetAuthGroup(AuthHash *r, const ResourceRecord *const rr) 308{ 309 mDNSu16 namelen = DomainNameLength(rr->name); 310 AuthGroup *ag = (AuthGroup*)GetAuthEntity(r, mDNSNULL); 311 const mDNSu32 slot = rr->namehash % AUTH_HASH_SLOTS; 312 if (!ag) { LogMsg("GetAuthGroup: Failed to allocate memory for %##s", rr->name->c); return(mDNSNULL); } 313 ag->next = r->rrauth_hash[slot]; 314 ag->namehash = rr->namehash; 315 ag->members = mDNSNULL; 316 ag->rrauth_tail = &ag->members; 317 ag->NewLocalOnlyRecords = mDNSNULL; 318 if (namelen > sizeof(ag->namestorage)) 319 ag->name = mDNSPlatformMemAllocate(namelen); 320 else 321 ag->name = (domainname*)ag->namestorage; 322 if (!ag->name) 323 { 324 LogMsg("GetAuthGroup: Failed to allocate name storage for %##s", rr->name->c); 325 ReleaseAuthEntity(r, (AuthEntity*)ag); 326 return(mDNSNULL); 327 } 328 AssignDomainName(ag->name, rr->name); 329 330 if (AuthGroupForRecord(r, rr)) LogMsg("GetAuthGroup: Already have AuthGroup for %##s", rr->name->c); 331 r->rrauth_hash[slot] = ag; 332 if (AuthGroupForRecord(r, rr) != ag) LogMsg("GetAuthGroup: Not finding AuthGroup for %##s", rr->name->c); 333 334 return(ag); 335} 336 337// Returns the AuthGroup in which the AuthRecord was inserted 338mDNSexport AuthGroup *InsertAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr) 339{ 340 AuthGroup *ag; 341 342 (void)m; 343 ag = AuthGroupForRecord(r, &rr->resrec); 344 if (!ag) ag = GetAuthGroup(r, &rr->resrec); // If we don't have a AuthGroup for this name, make one now 345 if (ag) 346 { 347 *(ag->rrauth_tail) = rr; // Append this record to tail of cache slot list 348 ag->rrauth_tail = &(rr->next); // Advance tail pointer 349 } 350 return ag; 351} 352 353mDNSexport AuthGroup *RemoveAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr) 354{ 355 AuthGroup *a; 356 AuthRecord **rp; 357 358 a = AuthGroupForRecord(r, &rr->resrec); 359 if (!a) { LogMsg("RemoveAuthRecord: ERROR!! AuthGroup not found for %s", ARDisplayString(m, rr)); return mDNSNULL; } 360 rp = &a->members; 361 while (*rp) 362 { 363 if (*rp != rr) 364 rp=&(*rp)->next; 365 else 366 { 367 // We don't break here, so that we can set the tail below without tracking "prev" pointers 368 369 LogInfo("RemoveAuthRecord: removing auth record %s from table", ARDisplayString(m, rr)); 370 *rp = (*rp)->next; // Cut record from list 371 } 372 } 373 // TBD: If there are no more members, release authgroup ? 374 a->rrauth_tail = rp; 375 return a; 376} 377 378mDNSexport CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 namehash, const domainname *const name) 379{ 380 CacheGroup *cg; 381 mDNSu32 slot = HashSlotFromNameHash(namehash); 382 for (cg = m->rrcache_hash[slot]; cg; cg=cg->next) 383 if (cg->namehash == namehash && SameDomainName(cg->name, name)) 384 break; 385 return(cg); 386} 387 388mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const ResourceRecord *const rr) 389{ 390 return(CacheGroupForName(m, rr->namehash, rr->name)); 391} 392 393mDNSexport mDNSBool mDNS_AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr) 394{ 395 NetworkInterfaceInfo *intf; 396 397 if (addr->type == mDNSAddrType_IPv4) 398 { 399 // Normally we resist touching the NotAnInteger fields, but here we're doing tricky bitwise masking so we make an exception 400 if (mDNSv4AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue); 401 for (intf = m->HostInterfaces; intf; intf = intf->next) 402 if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx) 403 if (((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) & intf->mask.ip.v4.NotAnInteger) == 0) 404 return(mDNStrue); 405 } 406 407 if (addr->type == mDNSAddrType_IPv6) 408 { 409 if (mDNSv6AddressIsLinkLocal(&addr->ip.v6)) return(mDNStrue); 410 for (intf = m->HostInterfaces; intf; intf = intf->next) 411 if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx) 412 if ((((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) & intf->mask.ip.v6.l[0]) == 0) && 413 (((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) & intf->mask.ip.v6.l[1]) == 0) && 414 (((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) & intf->mask.ip.v6.l[2]) == 0) && 415 (((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) & intf->mask.ip.v6.l[3]) == 0)) 416 return(mDNStrue); 417 } 418 419 return(mDNSfalse); 420} 421 422mDNSlocal NetworkInterfaceInfo *FirstInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID) 423{ 424 NetworkInterfaceInfo *intf = m->HostInterfaces; 425 while (intf && intf->InterfaceID != InterfaceID) intf = intf->next; 426 return(intf); 427} 428 429mDNSlocal NetworkInterfaceInfo *FirstIPv4LLInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID) 430{ 431 NetworkInterfaceInfo *intf; 432 433 if (!InterfaceID) 434 return mDNSNULL; 435 436 // Note: We don't check for InterfaceActive, as the active interface could be IPv6 and 437 // we still want to find the first IPv4 Link-Local interface 438 for (intf = m->HostInterfaces; intf; intf = intf->next) 439 { 440 if (intf->InterfaceID == InterfaceID && 441 intf->ip.type == mDNSAddrType_IPv4 && mDNSv4AddressIsLinkLocal(&intf->ip.ip.v4)) 442 { 443 debugf("FirstIPv4LLInterfaceForID: found LL interface with address %.4a", &intf->ip.ip.v4); 444 return intf; 445 } 446 } 447 return (mDNSNULL); 448} 449 450mDNSexport char *InterfaceNameForID(mDNS *const m, const mDNSInterfaceID InterfaceID) 451{ 452 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 453 return(intf ? intf->ifname : mDNSNULL); 454} 455 456// Caller should hold the lock 457mDNSlocal void GenerateNegativeResponse(mDNS *const m, mDNSInterfaceID InterfaceID, QC_result qc) 458{ 459 DNSQuestion *q; 460 if (!m->CurrentQuestion) { LogMsg("GenerateNegativeResponse: ERROR!! CurrentQuestion not set"); return; } 461 q = m->CurrentQuestion; 462 LogInfo("GenerateNegativeResponse: Generating negative response for question %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 463 464 MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, InterfaceID, mDNSNULL); 465 466 // We need to force the response through in the following cases 467 // 468 // a) SuppressUnusable questions that are suppressed 469 // b) Append search domains and retry the question 470 // 471 // The question may not have set Intermediates in which case we don't deliver negative responses. So, to force 472 // through we use "QC_forceresponse". 473 AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, qc); 474 if (m->CurrentQuestion == q) { q->ThisQInterval = 0; } // Deactivate this question 475 // Don't touch the question after this 476 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 477} 478 479mDNSexport void AnswerQuestionByFollowingCNAME(mDNS *const m, DNSQuestion *q, ResourceRecord *rr) 480{ 481 const mDNSBool selfref = SameDomainName(&q->qname, &rr->rdata->u.name); 482 if (q->CNAMEReferrals >= 10 || selfref) 483 { 484 LogMsg("AnswerQuestionByFollowingCNAME: %p %##s (%s) NOT following CNAME referral %d%s for %s", 485 q, q->qname.c, DNSTypeName(q->qtype), q->CNAMEReferrals, selfref ? " (Self-Referential)" : "", RRDisplayString(m, rr)); 486 } 487 else 488 { 489 const mDNSu32 c = q->CNAMEReferrals + 1; // Stash a copy of the new q->CNAMEReferrals value 490 UDPSocket *sock = q->LocalSocket; 491 mDNSOpaque16 id = q->TargetQID; 492#if AWD_METRICS 493 uDNSMetrics metrics; 494#endif 495 496 q->LocalSocket = mDNSNULL; 497 498 // The SameDomainName check above is to ignore bogus CNAME records that point right back at 499 // themselves. Without that check we can get into a case where we have two duplicate questions, 500 // A and B, and when we stop question A, UpdateQuestionDuplicates copies the value of CNAMEReferrals 501 // from A to B, and then A is re-appended to the end of the list as a duplicate of B (because 502 // the target name is still the same), and then when we stop question B, UpdateQuestionDuplicates 503 // copies the B's value of CNAMEReferrals back to A, and we end up not incrementing CNAMEReferrals 504 // for either of them. This is not a problem for CNAME loops of two or more records because in 505 // those cases the newly re-appended question A has a different target name and therefore cannot be 506 // a duplicate of any other question ('B') which was itself a duplicate of the previous question A. 507 508 // Right now we just stop and re-use the existing query. If we really wanted to be 100% perfect, 509 // and track CNAMEs coming and going, we should really create a subordinate query here, 510 // which we would subsequently cancel and retract if the CNAME referral record were removed. 511 // In reality this is such a corner case we'll ignore it until someone actually needs it. 512 513 LogInfo("AnswerQuestionByFollowingCNAME: %p %##s (%s) following CNAME referral %d for %s", 514 q, q->qname.c, DNSTypeName(q->qtype), q->CNAMEReferrals, RRDisplayString(m, rr)); 515 516#if AWD_METRICS 517 if ((q->CNAMEReferrals == 0) && !q->metrics.originalQName) 518 { 519 domainname * qName; 520 mDNSu16 qNameLen; 521 522 qNameLen = DomainNameLength(&q->qname); 523 if ((qNameLen > 0) && (qNameLen <= MAX_DOMAIN_NAME)) 524 { 525 qName = mDNSPlatformMemAllocate(qNameLen); 526 if (qName) 527 { 528 mDNSPlatformMemCopy(qName->c, q->qname.c, qNameLen); 529 q->metrics.originalQName = qName; 530 } 531 } 532 } 533 metrics = q->metrics; 534 mDNSPlatformMemZero(&q->metrics, sizeof(q->metrics)); 535#endif 536 mDNS_StopQuery_internal(m, q); // Stop old query 537 AssignDomainName(&q->qname, &rr->rdata->u.name); // Update qname 538 q->qnamehash = DomainNameHashValue(&q->qname); // and namehash 539 // If a unicast query results in a CNAME that points to a .local, we need to re-try 540 // this as unicast. Setting the mDNSInterface_Unicast tells mDNS_StartQuery_internal 541 // to try this as unicast query even though it is a .local name 542 if (!mDNSOpaque16IsZero(q->TargetQID) && IsLocalDomain(&q->qname)) 543 { 544 LogInfo("AnswerQuestionByFollowingCNAME: Resolving a .local CNAME %p %##s (%s) Record %s", 545 q, q->qname.c, DNSTypeName(q->qtype), RRDisplayString(m, rr)); 546 q->InterfaceID = mDNSInterface_Unicast; 547 } 548 mDNS_StartQuery_internal(m, q); // start new query 549 // Record how many times we've done this. We need to do this *after* mDNS_StartQuery_internal, 550 // because mDNS_StartQuery_internal re-initializes CNAMEReferrals to zero 551 q->CNAMEReferrals = c; 552#if AWD_METRICS 553 q->metrics = metrics; 554#endif 555 if (sock) 556 { 557 // If our new query is a duplicate, then it can't have a socket of its own, so we have to close the one we saved. 558 if (q->DuplicateOf) mDNSPlatformUDPClose(sock); 559 else 560 { 561 // Transplant the old socket into the new question, and copy the query ID across too. 562 // No need to close the old q->LocalSocket value because it won't have been created yet (they're made lazily on-demand). 563 q->LocalSocket = sock; 564 q->TargetQID = id; 565 } 566 } 567 } 568} 569 570#ifdef USE_LIBIDN 571 572#include <unicode/uidna.h> 573 574// #define DEBUG_PUNYCODE 1 575 576mDNSlocal mDNSu8 *PunycodeConvert(const mDNSu8 *const src, mDNSu8 *const dst, const mDNSu8 *const end) 577{ 578 UErrorCode errorCode = U_ZERO_ERROR; 579 UIDNAInfo info = UIDNA_INFO_INITIALIZER; 580 UIDNA *uts46 = uidna_openUTS46(UIDNA_USE_STD3_RULES|UIDNA_NONTRANSITIONAL_TO_UNICODE, &errorCode); 581 int32_t len = uidna_nameToASCII_UTF8(uts46, (const char *)src+1, src[0], (char *)dst+1, end-(dst+1), &info, &errorCode); 582 uidna_close(uts46); 583 #if DEBUG_PUNYCODE 584 if (errorCode) LogMsg("uidna_nameToASCII_UTF8(%##s) failed errorCode %d", src, errorCode); 585 if (info.errors) LogMsg("uidna_nameToASCII_UTF8(%##s) failed info.errors 0x%08X", src, info.errors); 586 if (len > MAX_DOMAIN_LABEL) LogMsg("uidna_nameToASCII_UTF8(%##s) result too long %d", src, len); 587 #endif 588 if (errorCode || info.errors || len > MAX_DOMAIN_LABEL) return mDNSNULL; 589 *dst = len; 590 return(dst + 1 + len); 591} 592 593mDNSlocal mDNSBool IsHighASCIILabel(const mDNSu8 *d) 594{ 595 int i; 596 for (i=1; i<=d[0]; i++) if (d[i] & 0x80) return mDNStrue; 597 return mDNSfalse; 598} 599 600mDNSlocal const mDNSu8 *FindLastHighASCIILabel(const domainname *const d) 601{ 602 const mDNSu8 *ptr = d->c; 603 const mDNSu8 *ans = mDNSNULL; 604 while (ptr[0]) 605 { 606 const mDNSu8 *const next = ptr + 1 + ptr[0]; 607 if (ptr[0] > MAX_DOMAIN_LABEL || next >= d->c + MAX_DOMAIN_NAME) return mDNSNULL; 608 if (IsHighASCIILabel(ptr)) ans = ptr; 609 ptr = next; 610 } 611 return ans; 612} 613 614mDNSlocal mDNSBool PerformNextPunycodeConversion(const DNSQuestion *const q, domainname *const newname) 615{ 616 const mDNSu8 *h = FindLastHighASCIILabel(&q->qname); 617 #if DEBUG_PUNYCODE 618 LogMsg("PerformNextPunycodeConversion: %##s (%s) Last High-ASCII Label %##s", q->qname.c, DNSTypeName(q->qtype), h); 619 #endif 620 if (!h) return mDNSfalse; // There are no high-ascii labels to convert 621 622 mDNSu8 *const dst = PunycodeConvert(h, newname->c + (h - q->qname.c), newname->c + MAX_DOMAIN_NAME); 623 if (!dst) 624 return mDNSfalse; // The label was not convertible to Punycode 625 else 626 { 627 // If Punycode conversion of final eligible label was successful, copy the rest of the domainname 628 const mDNSu8 *const src = h + 1 + h[0]; 629 const mDNSu8 remainder = DomainNameLength((domainname*)src); 630 if (dst + remainder > newname->c + MAX_DOMAIN_NAME) return mDNSfalse; // Name too long -- cannot be converted to Punycode 631 632 mDNSPlatformMemCopy(newname->c, q->qname.c, h - q->qname.c); // Fill in the leading part 633 mDNSPlatformMemCopy(dst, src, remainder); // Fill in the trailing part 634 #if DEBUG_PUNYCODE 635 LogMsg("PerformNextPunycodeConversion: %##s converted to %##s", q->qname.c, newname->c); 636 #endif 637 return mDNStrue; 638 } 639} 640 641#endif // USE_LIBIDN 642 643// For a single given DNSQuestion pointed to by CurrentQuestion, deliver an add/remove result for the single given AuthRecord 644// Note: All the callers should use the m->CurrentQuestion to see if the question is still valid or not 645mDNSlocal void AnswerLocalQuestionWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) 646{ 647 DNSQuestion *q = m->CurrentQuestion; 648 mDNSBool followcname; 649 650 if (!q) 651 { 652 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: ERROR!! CurrentQuestion NULL while answering with %s", ARDisplayString(m, rr)); 653 return; 654 } 655 656 followcname = FollowCNAME(q, &rr->resrec, AddRecord); 657 658 // We should not be delivering results for record types Unregistered, Deregistering, and (unverified) Unique 659 if (!(rr->resrec.RecordType & kDNSRecordTypeActiveMask)) 660 { 661 LogMsg("AnswerLocalQuestionWithLocalAuthRecord: *NOT* delivering %s event for local record type %X %s", 662 AddRecord ? "Add" : "Rmv", rr->resrec.RecordType, ARDisplayString(m, rr)); 663 return; 664 } 665 666 // Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it 667 if (AddRecord) rr->AnsweredLocalQ = mDNStrue; 668 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 669 if (q->QuestionCallback && !q->NoAnswer) 670 { 671 q->CurrentAnswers += AddRecord ? 1 : -1; 672 if (UniqueLocalOnlyRecord(rr)) 673 { 674 if (!followcname || q->ReturnIntermed) 675 { 676 // Don't send this packet on the wire as we answered from /etc/hosts 677 q->ThisQInterval = 0; 678 q->LOAddressAnswers += AddRecord ? 1 : -1; 679 q->QuestionCallback(m, q, &rr->resrec, AddRecord); 680 } 681 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 682 // The callback above could have caused the question to stop. Detect that 683 // using m->CurrentQuestion 684 if (followcname && m->CurrentQuestion == q) 685 AnswerQuestionByFollowingCNAME(m, q, &rr->resrec); 686 return; 687 } 688 else 689 { 690 q->QuestionCallback(m, q, &rr->resrec, AddRecord); 691 } 692 } 693 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 694} 695 696mDNSlocal void AnswerInterfaceAnyQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) 697{ 698 if (m->CurrentQuestion) 699 LogMsg("AnswerInterfaceAnyQuestionsWithLocalAuthRecord: ERROR m->CurrentQuestion already set: %##s (%s)", 700 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 701 m->CurrentQuestion = m->Questions; 702 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) 703 { 704 mDNSBool answered; 705 DNSQuestion *q = m->CurrentQuestion; 706 if (RRAny(rr)) 707 answered = ResourceRecordAnswersQuestion(&rr->resrec, q); 708 else 709 answered = LocalOnlyRecordAnswersQuestion(rr, q); 710 if (answered) 711 AnswerLocalQuestionWithLocalAuthRecord(m, rr, AddRecord); // MUST NOT dereference q again 712 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 713 m->CurrentQuestion = q->next; 714 } 715 m->CurrentQuestion = mDNSNULL; 716} 717 718// When a new local AuthRecord is created or deleted, AnswerAllLocalQuestionsWithLocalAuthRecord() 719// delivers the appropriate add/remove events to listening questions: 720// 1. It runs though all our LocalOnlyQuestions delivering answers as appropriate, 721// stopping if it reaches a NewLocalOnlyQuestion -- brand-new questions are handled by AnswerNewLocalOnlyQuestion(). 722// 2. If the AuthRecord is marked mDNSInterface_LocalOnly or mDNSInterface_P2P, then it also runs though 723// our main question list, delivering answers to mDNSInterface_Any questions as appropriate, 724// stopping if it reaches a NewQuestion -- brand-new questions are handled by AnswerNewQuestion(). 725// 726// AnswerAllLocalQuestionsWithLocalAuthRecord is used by the m->NewLocalRecords loop in mDNS_Execute(), 727// and by mDNS_Deregister_internal() 728 729mDNSlocal void AnswerAllLocalQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) 730{ 731 if (m->CurrentQuestion) 732 LogMsg("AnswerAllLocalQuestionsWithLocalAuthRecord ERROR m->CurrentQuestion already set: %##s (%s)", 733 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 734 735 m->CurrentQuestion = m->LocalOnlyQuestions; 736 while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions) 737 { 738 mDNSBool answered; 739 DNSQuestion *q = m->CurrentQuestion; 740 // We are called with both LocalOnly/P2P record or a regular AuthRecord 741 if (RRAny(rr)) 742 answered = ResourceRecordAnswersQuestion(&rr->resrec, q); 743 else 744 answered = LocalOnlyRecordAnswersQuestion(rr, q); 745 if (answered) 746 AnswerLocalQuestionWithLocalAuthRecord(m, rr, AddRecord); // MUST NOT dereference q again 747 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 748 m->CurrentQuestion = q->next; 749 } 750 751 m->CurrentQuestion = mDNSNULL; 752 753 // If this AuthRecord is marked LocalOnly or P2P, then we want to deliver it to all local 'mDNSInterface_Any' questions 754 if (rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P) 755 AnswerInterfaceAnyQuestionsWithLocalAuthRecord(m, rr, AddRecord); 756 757} 758 759// *************************************************************************** 760#if COMPILER_LIKES_PRAGMA_MARK 761#pragma mark - 762#pragma mark - Resource Record Utility Functions 763#endif 764 765#define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA) 766 767#define ResourceRecordIsValidAnswer(RR) ( ((RR)->resrec.RecordType & kDNSRecordTypeActiveMask) && \ 768 ((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \ 769 ((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \ 770 ((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) ) 771 772#define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \ 773 (ResourceRecordIsValidAnswer(RR) && \ 774 ((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID))) 775 776#define DefaultProbeCountForTypeUnique ((mDNSu8)3) 777#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0) 778 779// See RFC 6762: "8.3 Announcing" 780// "The Multicast DNS responder MUST send at least two unsolicited responses, one second apart." 781// Send 4, which is really 8 since we send on both IPv4 and IPv6. 782#define InitialAnnounceCount ((mDNSu8)4) 783 784// For goodbye packets we set the count to 3, and for wakeups we set it to 18 785// (which will be up to 15 wakeup attempts over the course of 30 seconds, 786// and then if the machine fails to wake, 3 goodbye packets). 787#define GoodbyeCount ((mDNSu8)3) 788#define WakeupCount ((mDNSu8)18) 789#define MAX_PROBE_RESTARTS ((mDNSu8)20) 790 791// Number of wakeups we send if WakeOnResolve is set in the question 792#define InitialWakeOnResolveCount ((mDNSu8)3) 793 794// Note that the announce intervals use exponential backoff, doubling each time. The probe intervals do not. 795// This means that because the announce interval is doubled after sending the first packet, the first 796// observed on-the-wire inter-packet interval between announcements is actually one second. 797// The half-second value here may be thought of as a conceptual (non-existent) half-second delay *before* the first packet is sent. 798#define DefaultProbeIntervalForTypeUnique (mDNSPlatformOneSecond/4) 799#define DefaultAnnounceIntervalForTypeShared (mDNSPlatformOneSecond/2) 800#define DefaultAnnounceIntervalForTypeUnique (mDNSPlatformOneSecond/2) 801 802#define DefaultAPIntervalForRecordType(X) ((X) &kDNSRecordTypeActiveSharedMask ? DefaultAnnounceIntervalForTypeShared : \ 803 (X) &kDNSRecordTypeUnique ? DefaultProbeIntervalForTypeUnique : \ 804 (X) &kDNSRecordTypeActiveUniqueMask ? DefaultAnnounceIntervalForTypeUnique : 0) 805 806#define TimeToAnnounceThisRecord(RR,time) ((RR)->AnnounceCount && (time) - ((RR)->LastAPTime + (RR)->ThisAPInterval) >= 0) 807#define TicksTTL(RR) ((mDNSs32)(RR)->resrec.rroriginalttl * mDNSPlatformOneSecond) 808#define RRExpireTime(RR) ((RR)->TimeRcvd + TicksTTL(RR)) 809 810// Adjustment factor to avoid race condition (used for unicast cache entries) : 811// Suppose real record has TTL of 3600, and our local caching server has held it for 3500 seconds, so it returns an aged TTL of 100. 812// If we do our normal refresh at 80% of the TTL, our local caching server will return 20 seconds, so we'll do another 813// 80% refresh after 16 seconds, and then the server will return 4 seconds, and so on, in the fashion of Zeno's paradox. 814// To avoid this, we extend the record's effective TTL to give it a little extra grace period. 815// We adjust the 100 second TTL to 127. This means that when we do our 80% query at 102 seconds, 816// the cached copy at our local caching server will already have expired, so the server will be forced 817// to fetch a fresh copy from the authoritative server, and then return a fresh record with the full TTL of 3600 seconds. 818 819#define RRAdjustTTL(ttl) ((ttl) + ((ttl)/4) + 2) 820#define RRUnadjustedTTL(ttl) ((((ttl) - 2) * 4) / 5) 821 822#define MaxUnansweredQueries 4 823 824// SameResourceRecordSignature returns true if two resources records have the same name, type, and class, and may be sent 825// (or were received) on the same interface (i.e. if *both* records specify an interface, then it has to match). 826// TTL and rdata may differ. 827// This is used for cache flush management: 828// When sending a unique record, all other records matching "SameResourceRecordSignature" must also be sent 829// When receiving a unique record, all old cache records matching "SameResourceRecordSignature" are flushed 830 831// SameResourceRecordNameClassInterface is functionally the same as SameResourceRecordSignature, except rrtype does not have to match 832 833#define SameResourceRecordSignature(A,B) (A)->resrec.rrtype == (B)->resrec.rrtype && SameResourceRecordNameClassInterface((A),(B)) 834 835mDNSlocal mDNSBool SameResourceRecordNameClassInterface(const AuthRecord *const r1, const AuthRecord *const r2) 836{ 837 if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse); } 838 if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse); } 839 if (r1->resrec.InterfaceID && 840 r2->resrec.InterfaceID && 841 r1->resrec.InterfaceID != r2->resrec.InterfaceID) return(mDNSfalse); 842 return (mDNSBool)( 843 r1->resrec.rrclass == r2->resrec.rrclass && 844 r1->resrec.namehash == r2->resrec.namehash && 845 SameDomainName(r1->resrec.name, r2->resrec.name)); 846} 847 848// PacketRRMatchesSignature behaves as SameResourceRecordSignature, except that types may differ if our 849// authoratative record is unique (as opposed to shared). For unique records, we are supposed to have 850// complete ownership of *all* types for this name, so *any* record type with the same name is a conflict. 851// In addition, when probing we send our questions with the wildcard type kDNSQType_ANY, 852// so a response of any type should match, even if it is not actually the type the client plans to use. 853 854// For now, to make it easier to avoid false conflicts, we treat SPS Proxy records like shared records, 855// and require the rrtypes to match for the rdata to be considered potentially conflicting 856mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr) 857{ 858 if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse); } 859 if (!authrr) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL"); return(mDNSfalse); } 860 if (pktrr->resrec.InterfaceID && 861 authrr->resrec.InterfaceID && 862 pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse); 863 if (!(authrr->resrec.RecordType & kDNSRecordTypeUniqueMask) || authrr->WakeUp.HMAC.l[0]) 864 if (pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse); 865 if ((authrr->resrec.InterfaceID == mDNSInterface_Any) && 866 !mDNSPlatformValidRecordForInterface(authrr, pktrr->resrec.InterfaceID)) return(mDNSfalse); 867 return (mDNSBool)( 868 pktrr->resrec.rrclass == authrr->resrec.rrclass && 869 pktrr->resrec.namehash == authrr->resrec.namehash && 870 SameDomainName(pktrr->resrec.name, authrr->resrec.name)); 871} 872 873// CacheRecord *ka is the CacheRecord from the known answer list in the query. 874// This is the information that the requester believes to be correct. 875// AuthRecord *rr is the answer we are proposing to give, if not suppressed. 876// This is the information that we believe to be correct. 877// We've already determined that we plan to give this answer on this interface 878// (either the record is non-specific, or it is specific to this interface) 879// so now we just need to check the name, type, class, rdata and TTL. 880mDNSlocal mDNSBool ShouldSuppressKnownAnswer(const CacheRecord *const ka, const AuthRecord *const rr) 881{ 882 // If RR signature is different, or data is different, then don't suppress our answer 883 if (!IdenticalResourceRecord(&ka->resrec, &rr->resrec)) return(mDNSfalse); 884 885 // If the requester's indicated TTL is less than half the real TTL, 886 // we need to give our answer before the requester's copy expires. 887 // If the requester's indicated TTL is at least half the real TTL, 888 // then we can suppress our answer this time. 889 // If the requester's indicated TTL is greater than the TTL we believe, 890 // then that's okay, and we don't need to do anything about it. 891 // (If two responders on the network are offering the same information, 892 // that's okay, and if they are offering the information with different TTLs, 893 // the one offering the lower TTL should defer to the one offering the higher TTL.) 894 return (mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2); 895} 896 897mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr) 898{ 899 if (rr->resrec.RecordType == kDNSRecordTypeUnique) 900 { 901 if ((rr->LastAPTime + rr->ThisAPInterval) - m->timenow > mDNSPlatformOneSecond * 10) 902 { 903 LogMsg("SetNextAnnounceProbeTime: ProbeCount %d Next in %d %s", rr->ProbeCount, (rr->LastAPTime + rr->ThisAPInterval) - m->timenow, ARDisplayString(m, rr)); 904 LogMsg("SetNextAnnounceProbeTime: m->SuppressProbes %d m->timenow %d diff %d", m->SuppressProbes, m->timenow, m->SuppressProbes - m->timenow); 905 } 906 if (m->NextScheduledProbe - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 907 m->NextScheduledProbe = (rr->LastAPTime + rr->ThisAPInterval); 908 // Some defensive code: 909 // If (rr->LastAPTime + rr->ThisAPInterval) happens to be far in the past, we don't want to allow 910 // NextScheduledProbe to be set excessively in the past, because that can cause bad things to happen. 911 // See: <rdar://problem/7795434> mDNS: Sometimes advertising stops working and record interval is set to zero 912 if (m->NextScheduledProbe - m->timenow < 0) 913 m->NextScheduledProbe = m->timenow; 914 } 915 else if (rr->AnnounceCount && (ResourceRecordIsValidAnswer(rr) || rr->resrec.RecordType == kDNSRecordTypeDeregistering)) 916 { 917 if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 918 m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval); 919 } 920} 921 922mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr) 923{ 924 // For reverse-mapping Sleep Proxy PTR records, probe interval is one second 925 rr->ThisAPInterval = rr->AddressProxy.type ? mDNSPlatformOneSecond : DefaultAPIntervalForRecordType(rr->resrec.RecordType); 926 927 // * If this is a record type that's going to probe, then we use the m->SuppressProbes time. 928 // * Otherwise, if it's not going to probe, but m->SuppressProbes is set because we have other 929 // records that are going to probe, then we delay its first announcement so that it will 930 // go out synchronized with the first announcement for the other records that *are* probing. 931 // This is a minor performance tweak that helps keep groups of related records synchronized together. 932 // The addition of "interval / 2" is to make sure that, in the event that any of the probes are 933 // delayed by a few milliseconds, this announcement does not inadvertently go out *before* the probing is complete. 934 // When the probing is complete and those records begin to announce, these records will also be picked up and accelerated, 935 // because they will meet the criterion of being at least half-way to their scheduled announcement time. 936 // * If it's not going to probe and m->SuppressProbes is not already set then we should announce immediately. 937 938 if (rr->ProbeCount) 939 { 940 // If we have no probe suppression time set, or it is in the past, set it now 941 if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0) 942 { 943 // To allow us to aggregate probes when a group of services are registered together, 944 // the first probe is delayed by a random delay in the range 1/8 to 1/4 second. 945 // This means the common-case behaviour is: 946 // randomized wait; probe 947 // 1/4 second wait; probe 948 // 1/4 second wait; probe 949 // 1/4 second wait; announce (i.e. service is normally announced 7/8 to 1 second after being registered) 950 m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2)); 951 952 // If we already have a *probe* scheduled to go out sooner, then use that time to get better aggregation 953 if (m->SuppressProbes - m->NextScheduledProbe >= 0) 954 m->SuppressProbes = NonZeroTime(m->NextScheduledProbe); 955 if (m->SuppressProbes - m->timenow < 0) // Make sure we don't set m->SuppressProbes excessively in the past 956 m->SuppressProbes = m->timenow; 957 958 // If we already have a *query* scheduled to go out sooner, then use that time to get better aggregation 959 if (m->SuppressProbes - m->NextScheduledQuery >= 0) 960 m->SuppressProbes = NonZeroTime(m->NextScheduledQuery); 961 if (m->SuppressProbes - m->timenow < 0) // Make sure we don't set m->SuppressProbes excessively in the past 962 m->SuppressProbes = m->timenow; 963 964 // except... don't expect to be able to send before the m->SuppressSending timer fires 965 if (m->SuppressSending && m->SuppressProbes - m->SuppressSending < 0) 966 m->SuppressProbes = NonZeroTime(m->SuppressSending); 967 968 if (m->SuppressProbes - m->timenow > mDNSPlatformOneSecond * 8) 969 { 970 LogMsg("InitializeLastAPTime ERROR m->SuppressProbes %d m->NextScheduledProbe %d m->NextScheduledQuery %d m->SuppressSending %d %d", 971 m->SuppressProbes - m->timenow, 972 m->NextScheduledProbe - m->timenow, 973 m->NextScheduledQuery - m->timenow, 974 m->SuppressSending, 975 m->SuppressSending - m->timenow); 976 m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2)); 977 } 978 } 979 rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval; 980 } 981 // Skip kDNSRecordTypeKnownUnique and kDNSRecordTypeShared records here and set their LastAPTime in the "else" block below so 982 // that they get announced immediately, otherwise, their announcement would be delayed until the based on the SuppressProbes value. 983 else if ((rr->resrec.RecordType != kDNSRecordTypeKnownUnique) && (rr->resrec.RecordType != kDNSRecordTypeShared) && m->SuppressProbes && (m->SuppressProbes - m->timenow >= 0)) 984 rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval + DefaultProbeIntervalForTypeUnique * DefaultProbeCountForTypeUnique + rr->ThisAPInterval / 2; 985 else 986 rr->LastAPTime = m->timenow - rr->ThisAPInterval; 987 988 // For reverse-mapping Sleep Proxy PTR records we don't want to start probing instantly -- we 989 // wait one second to give the client a chance to go to sleep, and then start our ARP/NDP probing. 990 // After three probes one second apart with no answer, we conclude the client is now sleeping 991 // and we can begin broadcasting our announcements to take over ownership of that IP address. 992 // If we don't wait for the client to go to sleep, then when the client sees our ARP Announcements there's a risk 993 // (depending on the OS and networking stack it's using) that it might interpret it as a conflict and change its IP address. 994 if (rr->AddressProxy.type) 995 rr->LastAPTime = m->timenow; 996 997 // Set LastMCTime to now, to inhibit multicast responses 998 // (no need to send additional multicast responses when we're announcing anyway) 999 rr->LastMCTime = m->timenow; 1000 rr->LastMCInterface = mDNSInterfaceMark; 1001 1002 SetNextAnnounceProbeTime(m, rr); 1003} 1004 1005mDNSlocal const domainname *SetUnicastTargetToHostName(mDNS *const m, AuthRecord *rr) 1006{ 1007 const domainname *target; 1008 if (rr->AutoTarget) 1009 { 1010 // For autotunnel services pointing at our IPv6 ULA we don't need or want a NAT mapping, but for all other 1011 // advertised services referencing our uDNS hostname, we want NAT mappings automatically created as appropriate, 1012 // with the port number in our advertised SRV record automatically tracking the external mapped port. 1013 DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name); 1014 if (!AuthInfo || !AuthInfo->AutoTunnel) rr->AutoTarget = Target_AutoHostAndNATMAP; 1015 } 1016 1017 target = GetServiceTarget(m, rr); 1018 if (!target || target->c[0] == 0) 1019 { 1020 // defer registration until we've got a target 1021 LogInfo("SetUnicastTargetToHostName No target for %s", ARDisplayString(m, rr)); 1022 rr->state = regState_NoTarget; 1023 return mDNSNULL; 1024 } 1025 else 1026 { 1027 LogInfo("SetUnicastTargetToHostName target %##s for resource record %s", target->c, ARDisplayString(m,rr)); 1028 return target; 1029 } 1030} 1031 1032// Right now this only applies to mDNS (.local) services where the target host is always m->MulticastHostname 1033// Eventually we should unify this with GetServiceTarget() in uDNS.c 1034mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr) 1035{ 1036 domainname *const target = GetRRDomainNameTarget(&rr->resrec); 1037 const domainname *newname = &m->MulticastHostname; 1038 1039 if (!target) LogInfo("SetTargetToHostName: Don't know how to set the target of rrtype %s", DNSTypeName(rr->resrec.rrtype)); 1040 1041 if (!(rr->ForceMCast || rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P || IsLocalDomain(&rr->namestorage))) 1042 { 1043 const domainname *const n = SetUnicastTargetToHostName(m, rr); 1044 if (n) newname = n; 1045 else { if (target) target->c[0] = 0; SetNewRData(&rr->resrec, mDNSNULL, 0); return; } 1046 } 1047 1048 if (target && SameDomainName(target, newname)) 1049 debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name->c, target->c); 1050 1051 if (target && !SameDomainName(target, newname)) 1052 { 1053 AssignDomainName(target, newname); 1054 SetNewRData(&rr->resrec, mDNSNULL, 0); // Update rdlength, rdestimate, rdatahash 1055 1056 // If we're in the middle of probing this record, we need to start again, 1057 // because changing its rdata may change the outcome of the tie-breaker. 1058 // (If the record type is kDNSRecordTypeUnique (unconfirmed unique) then DefaultProbeCountForRecordType is non-zero.) 1059 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); 1060 1061 // If we've announced this record, we really should send a goodbye packet for the old rdata before 1062 // changing to the new rdata. However, in practice, we only do SetTargetToHostName for unique records, 1063 // so when we announce them we'll set the kDNSClass_UniqueRRSet and clear any stale data that way. 1064 if (rr->RequireGoodbye && rr->resrec.RecordType == kDNSRecordTypeShared) 1065 debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating", 1066 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1067 1068 rr->AnnounceCount = InitialAnnounceCount; 1069 rr->RequireGoodbye = mDNSfalse; 1070 rr->ProbeRestartCount = 0; 1071 InitializeLastAPTime(m, rr); 1072 } 1073} 1074 1075mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr) 1076{ 1077 if (rr->RecordCallback) 1078 { 1079 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function 1080 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc. 1081 rr->Acknowledged = mDNStrue; 1082 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 1083 rr->RecordCallback(m, rr, mStatus_NoError); 1084 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 1085 } 1086} 1087 1088mDNSexport void ActivateUnicastRegistration(mDNS *const m, AuthRecord *const rr) 1089{ 1090 // Make sure that we don't activate the SRV record and associated service records, if it is in 1091 // NoTarget state. First time when a service is being instantiated, SRV record may be in NoTarget state. 1092 // We should not activate any of the other reords (PTR, TXT) that are part of the service. When 1093 // the target becomes available, the records will be reregistered. 1094 if (rr->resrec.rrtype != kDNSType_SRV) 1095 { 1096 AuthRecord *srvRR = mDNSNULL; 1097 if (rr->resrec.rrtype == kDNSType_PTR) 1098 srvRR = rr->Additional1; 1099 else if (rr->resrec.rrtype == kDNSType_TXT) 1100 srvRR = rr->DependentOn; 1101 if (srvRR) 1102 { 1103 if (srvRR->resrec.rrtype != kDNSType_SRV) 1104 { 1105 LogMsg("ActivateUnicastRegistration: ERROR!! Resource record %s wrong, expecting SRV type", ARDisplayString(m, srvRR)); 1106 } 1107 else 1108 { 1109 LogInfo("ActivateUnicastRegistration: Found Service Record %s in state %d for %##s (%s)", 1110 ARDisplayString(m, srvRR), srvRR->state, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1111 rr->state = srvRR->state; 1112 } 1113 } 1114 } 1115 1116 if (rr->state == regState_NoTarget) 1117 { 1118 LogInfo("ActivateUnicastRegistration record %s in regState_NoTarget, not activating", ARDisplayString(m, rr)); 1119 return; 1120 } 1121 // When we wake up from sleep, we call ActivateUnicastRegistration. It is possible that just before we went to sleep, 1122 // the service/record was being deregistered. In that case, we should not try to register again. For the cases where 1123 // the records are deregistered due to e.g., no target for the SRV record, we would have returned from above if it 1124 // was already in NoTarget state. If it was in the process of deregistration but did not complete fully before we went 1125 // 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. 1126 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) 1127 { 1128 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to DeregPending", ARDisplayString(m, rr), rr->state); 1129 rr->state = regState_DeregPending; 1130 } 1131 else 1132 { 1133 LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to Pending", ARDisplayString(m, rr), rr->state); 1134 rr->state = regState_Pending; 1135 } 1136 rr->ProbeCount = 0; 1137 rr->ProbeRestartCount = 0; 1138 rr->AnnounceCount = 0; 1139 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 1140 rr->LastAPTime = m->timenow - rr->ThisAPInterval; 1141 rr->expire = 0; // Forget about all the leases, start fresh 1142 rr->uselease = mDNStrue; 1143 rr->updateid = zeroID; 1144 rr->SRVChanged = mDNSfalse; 1145 rr->updateError = mStatus_NoError; 1146 // RestartRecordGetZoneData calls this function whenever a new interface gets registered with core. 1147 // The records might already be registered with the server and hence could have NAT state. 1148 if (rr->NATinfo.clientContext) 1149 { 1150 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 1151 rr->NATinfo.clientContext = mDNSNULL; 1152 } 1153 if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; } 1154 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 1155 if (m->NextuDNSEvent - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 1156 m->NextuDNSEvent = (rr->LastAPTime + rr->ThisAPInterval); 1157} 1158 1159// Two records qualify to be local duplicates if: 1160// (a) the RecordTypes are the same, or 1161// (b) one is Unique and the other Verified 1162// (c) either is in the process of deregistering 1163#define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || \ 1164 ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified) || \ 1165 ((A)->resrec.RecordType == kDNSRecordTypeDeregistering || (B)->resrec.RecordType == kDNSRecordTypeDeregistering)) 1166 1167#define RecordIsLocalDuplicate(A,B) \ 1168 ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(& (A)->resrec, & (B)->resrec)) 1169 1170mDNSlocal AuthRecord *CheckAuthIdenticalRecord(AuthHash *r, AuthRecord *rr) 1171{ 1172 const AuthGroup *a; 1173 AuthRecord *rp; 1174 1175 a = AuthGroupForRecord(r, &rr->resrec); 1176 if (!a) return mDNSNULL; 1177 rp = a->members; 1178 while (rp) 1179 { 1180 if (!RecordIsLocalDuplicate(rp, rr)) 1181 rp = rp->next; 1182 else 1183 { 1184 if (rp->resrec.RecordType == kDNSRecordTypeDeregistering) 1185 { 1186 rp->AnnounceCount = 0; 1187 rp = rp->next; 1188 } 1189 else return rp; 1190 } 1191 } 1192 return (mDNSNULL); 1193} 1194 1195mDNSlocal mDNSBool CheckAuthRecordConflict(AuthHash *r, AuthRecord *rr) 1196{ 1197 const AuthGroup *a; 1198 const AuthRecord *rp; 1199 1200 a = AuthGroupForRecord(r, &rr->resrec); 1201 if (!a) return mDNSfalse; 1202 rp = a->members; 1203 while (rp) 1204 { 1205 const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr; 1206 const AuthRecord *s2 = rp->RRSet ? rp->RRSet : rp; 1207 if (s1 != s2 && SameResourceRecordSignature(rp, rr) && !IdenticalSameNameRecord(&rp->resrec, &rr->resrec)) 1208 return mDNStrue; 1209 else 1210 rp = rp->next; 1211 } 1212 return (mDNSfalse); 1213} 1214 1215// checks to see if "rr" is already present 1216mDNSlocal AuthRecord *CheckAuthSameRecord(AuthHash *r, AuthRecord *rr) 1217{ 1218 const AuthGroup *a; 1219 AuthRecord *rp; 1220 1221 a = AuthGroupForRecord(r, &rr->resrec); 1222 if (!a) return mDNSNULL; 1223 rp = a->members; 1224 while (rp) 1225 { 1226 if (rp != rr) 1227 rp = rp->next; 1228 else 1229 { 1230 return rp; 1231 } 1232 } 1233 return (mDNSNULL); 1234} 1235 1236 1237mDNSlocal void DecrementAutoTargetServices(mDNS *const m, AuthRecord *const rr) 1238{ 1239 if (RRLocalOnly(rr)) 1240 { 1241 // A sanity check, this should be prevented in calling code. 1242 LogInfo("DecrementAutoTargetServices: called for RRLocalOnly() record: %s", ARDisplayString(m, rr)); 1243 return; 1244 } 1245 1246 if (!AuthRecord_uDNS(rr) && rr->resrec.rrtype == kDNSType_SRV && rr->AutoTarget == Target_AutoHost) 1247 { 1248 // If about to get rid of the last advertised service 1249 if (m->AutoTargetServices == 1) 1250 DeadvertiseAllInterfaceRecords(m); 1251 1252 m->AutoTargetServices--; 1253 LogInfo("DecrementAutoTargetServices: AutoTargetServices %d Record %s", m->AutoTargetServices, ARDisplayString(m, rr)); 1254 } 1255 1256#if BONJOUR_ON_DEMAND 1257 if (!AuthRecord_uDNS(rr)) 1258 { 1259 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) 1260 m->NextBonjourDisableTime = NonZeroTime(m->timenow + (BONJOUR_DISABLE_DELAY * mDNSPlatformOneSecond)); 1261 m->NumAllInterfaceRecords--; 1262 LogInfo("DecrementAutoTargetServices: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %s", 1263 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, ARDisplayString(m, rr)); 1264 } 1265#endif // BONJOUR_ON_DEMAND 1266} 1267 1268mDNSlocal void IncrementAutoTargetServices(mDNS *const m, AuthRecord *const rr) 1269{ 1270 mDNSBool enablingBonjour = 0; 1271 1272 if (RRLocalOnly(rr)) 1273 { 1274 // A sanity check, this should be prevented in calling code. 1275 LogInfo("IncrementAutoTargetServices: called for RRLocalOnly() record: %s", ARDisplayString(m, rr)); 1276 return; 1277 } 1278 1279#if BONJOUR_ON_DEMAND 1280 if (!AuthRecord_uDNS(rr)) 1281 { 1282 m->NumAllInterfaceRecords++; 1283 LogInfo("IncrementAutoTargetServices: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %s", 1284 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, ARDisplayString(m, rr)); 1285 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) 1286 { 1287 m->NextBonjourDisableTime = 0; 1288 if (m->BonjourEnabled == 0) 1289 { 1290 // Enable Bonjour immediately by scheduling network changed processing where 1291 // we will join the multicast group on each active interface. 1292 m->BonjourEnabled = 1; 1293 enablingBonjour = 1; 1294 m->NetworkChanged = m->timenow; 1295 } 1296 } 1297 } 1298#endif // BONJOUR_ON_DEMAND 1299 1300 if (!AuthRecord_uDNS(rr) && rr->resrec.rrtype == kDNSType_SRV && rr->AutoTarget == Target_AutoHost) 1301 { 1302 m->AutoTargetServices++; 1303 LogInfo("IncrementAutoTargetServices: AutoTargetServices %d Record %s", m->AutoTargetServices, ARDisplayString(m, rr)); 1304 1305 // If this is the first advertised service and we did not just enable Bonjour above, then 1306 // advertise all the interface records. If we did enable Bonjour above, the interface records will 1307 // be advertised during the network changed processing scheduled above, so no need 1308 // to do it here. 1309 if ((m->AutoTargetServices == 1) && (enablingBonjour == 0)) 1310 AdvertiseAllInterfaceRecords(m); 1311 } 1312} 1313 1314mDNSlocal void getKeepaliveRaddr(mDNS *const m, AuthRecord *rr, mDNSAddr *raddr) 1315{ 1316 mDNSAddr laddr = zeroAddr; 1317 mDNSEthAddr eth = zeroEthAddr; 1318 mDNSIPPort lport = zeroIPPort; 1319 mDNSIPPort rport = zeroIPPort; 1320 mDNSu32 timeout = 0; 1321 mDNSu32 seq = 0; 1322 mDNSu32 ack = 0; 1323 mDNSu16 win = 0; 1324 1325 if (mDNS_KeepaliveRecord(&rr->resrec)) 1326 { 1327 mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, raddr, ð, &seq, &ack, &lport, &rport, &win); 1328 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(raddr) || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport)) 1329 { 1330 LogMsg("getKeepaliveRaddr: not a valid record %s for keepalive %#a:%d %#a:%d", ARDisplayString(m, rr), &laddr, lport.NotAnInteger, raddr, rport.NotAnInteger); 1331 return; 1332 } 1333 } 1334} 1335 1336// Exported so uDNS.c can call this 1337mDNSexport mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr) 1338{ 1339 domainname *target = GetRRDomainNameTarget(&rr->resrec); 1340 AuthRecord *r; 1341 AuthRecord **p = &m->ResourceRecords; 1342 AuthRecord **d = &m->DuplicateRecords; 1343 1344 if ((mDNSs32)rr->resrec.rroriginalttl <= 0) 1345 { LogMsg("mDNS_Register_internal: TTL %X should be 1 - 0x7FFFFFFF %s", rr->resrec.rroriginalttl, ARDisplayString(m, rr)); return(mStatus_BadParamErr); } 1346 1347 if (!rr->resrec.RecordType) 1348 { LogMsg("mDNS_Register_internal: RecordType must be non-zero %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); } 1349 1350 if (m->ShutdownTime) 1351 { LogMsg("mDNS_Register_internal: Shutting down, can't register %s", ARDisplayString(m, rr)); return(mStatus_ServiceNotRunning); } 1352 1353 if (m->DivertMulticastAdvertisements && !AuthRecord_uDNS(rr)) 1354 { 1355 mDNSInterfaceID previousID = rr->resrec.InterfaceID; 1356 if (rr->resrec.InterfaceID == mDNSInterface_Any || rr->resrec.InterfaceID == mDNSInterface_P2P) 1357 { 1358 rr->resrec.InterfaceID = mDNSInterface_LocalOnly; 1359 rr->ARType = AuthRecordLocalOnly; 1360 } 1361 if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly) 1362 { 1363 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); 1364 if (intf && !intf->Advertise) { rr->resrec.InterfaceID = mDNSInterface_LocalOnly; rr->ARType = AuthRecordLocalOnly; } 1365 } 1366 if (rr->resrec.InterfaceID != previousID) 1367 LogInfo("mDNS_Register_internal: Diverting record to local-only %s", ARDisplayString(m, rr)); 1368 } 1369 1370 if (RRLocalOnly(rr)) 1371 { 1372 if (CheckAuthSameRecord(&m->rrauth, rr)) 1373 { 1374 LogMsg("mDNS_Register_internal: ERROR!! Tried to register LocalOnly AuthRecord %p %##s (%s) that's already in the list", 1375 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1376 return(mStatus_AlreadyRegistered); 1377 } 1378 } 1379 else 1380 { 1381 while (*p && *p != rr) p=&(*p)->next; 1382 if (*p) 1383 { 1384 LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the list", 1385 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1386 return(mStatus_AlreadyRegistered); 1387 } 1388 } 1389 1390 while (*d && *d != rr) d=&(*d)->next; 1391 if (*d) 1392 { 1393 LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the Duplicate list", 1394 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1395 return(mStatus_AlreadyRegistered); 1396 } 1397 1398 if (rr->DependentOn) 1399 { 1400 if (rr->resrec.RecordType == kDNSRecordTypeUnique) 1401 rr->resrec.RecordType = kDNSRecordTypeVerified; 1402 else if (rr->resrec.RecordType != kDNSRecordTypeKnownUnique) 1403 { 1404 LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique or kDNSRecordTypeKnownUnique", 1405 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1406 return(mStatus_Invalid); 1407 } 1408 if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique))) 1409 { 1410 LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X", 1411 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType); 1412 return(mStatus_Invalid); 1413 } 1414 } 1415 1416 rr->next = mDNSNULL; 1417 1418 // Field Group 1: The actual information pertaining to this resource record 1419 // Set up by client prior to call 1420 1421 // Field Group 2: Persistent metadata for Authoritative Records 1422// rr->Additional1 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client 1423// rr->Additional2 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client 1424// rr->DependentOn = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client 1425// rr->RRSet = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client 1426// rr->Callback = already set in mDNS_SetupResourceRecord 1427// rr->Context = already set in mDNS_SetupResourceRecord 1428// rr->RecordType = already set in mDNS_SetupResourceRecord 1429// rr->HostTarget = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client 1430// rr->AllowRemoteQuery = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client 1431 // Make sure target is not uninitialized data, or we may crash writing debugging log messages 1432 if (rr->AutoTarget && target) target->c[0] = 0; 1433 1434 // Field Group 3: Transient state for Authoritative Records 1435 rr->Acknowledged = mDNSfalse; 1436 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); 1437 rr->ProbeRestartCount = 0; 1438 rr->AnnounceCount = InitialAnnounceCount; 1439 rr->RequireGoodbye = mDNSfalse; 1440 rr->AnsweredLocalQ = mDNSfalse; 1441 rr->IncludeInProbe = mDNSfalse; 1442 rr->ImmedUnicast = mDNSfalse; 1443 rr->SendNSECNow = mDNSNULL; 1444 rr->ImmedAnswer = mDNSNULL; 1445 rr->ImmedAdditional = mDNSNULL; 1446 rr->SendRNow = mDNSNULL; 1447 rr->v4Requester = zerov4Addr; 1448 rr->v6Requester = zerov6Addr; 1449 rr->NextResponse = mDNSNULL; 1450 rr->NR_AnswerTo = mDNSNULL; 1451 rr->NR_AdditionalTo = mDNSNULL; 1452 if (!rr->AutoTarget) InitializeLastAPTime(m, rr); 1453// rr->LastAPTime = Set for us in InitializeLastAPTime() 1454// rr->LastMCTime = Set for us in InitializeLastAPTime() 1455// rr->LastMCInterface = Set for us in InitializeLastAPTime() 1456 rr->NewRData = mDNSNULL; 1457 rr->newrdlength = 0; 1458 rr->UpdateCallback = mDNSNULL; 1459 rr->UpdateCredits = kMaxUpdateCredits; 1460 rr->NextUpdateCredit = 0; 1461 rr->UpdateBlocked = 0; 1462 1463 // For records we're holding as proxy (except reverse-mapping PTR records) two announcements is sufficient 1464 if (rr->WakeUp.HMAC.l[0] && !rr->AddressProxy.type) rr->AnnounceCount = 2; 1465 1466 // Field Group 4: Transient uDNS state for Authoritative Records 1467 rr->state = regState_Zero; 1468 rr->uselease = 0; 1469 rr->expire = 0; 1470 rr->Private = 0; 1471 rr->updateid = zeroID; 1472 rr->updateIntID = zeroOpaque64; 1473 rr->zone = rr->resrec.name; 1474 rr->nta = mDNSNULL; 1475 rr->tcp = mDNSNULL; 1476 rr->OrigRData = 0; 1477 rr->OrigRDLen = 0; 1478 rr->InFlightRData = 0; 1479 rr->InFlightRDLen = 0; 1480 rr->QueuedRData = 0; 1481 rr->QueuedRDLen = 0; 1482 //mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo)); 1483 // We should be recording the actual internal port for this service record here. Once we initiate our NAT mapping 1484 // request we'll subsequently overwrite srv.port with the allocated external NAT port -- potentially multiple 1485 // times with different values if the external NAT port changes during the lifetime of the service registration. 1486 //if (rr->resrec.rrtype == kDNSType_SRV) rr->NATinfo.IntPort = rr->resrec.rdata->u.srv.port; 1487 1488// rr->resrec.interface = already set in mDNS_SetupResourceRecord 1489// rr->resrec.name->c = MUST be set by client 1490// rr->resrec.rrtype = already set in mDNS_SetupResourceRecord 1491// rr->resrec.rrclass = already set in mDNS_SetupResourceRecord 1492// rr->resrec.rroriginalttl = already set in mDNS_SetupResourceRecord 1493// rr->resrec.rdata = MUST be set by client, unless record type is CNAME or PTR and rr->HostTarget is set 1494 1495 // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct, 1496 // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s". 1497 // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here. 1498 if (rr->resrec.rrtype == kDNSType_TXT && rr->resrec.rdlength == 0) { rr->resrec.rdlength = 1; rr->resrec.rdata->u.txt.c[0] = 0; } 1499 1500 if (rr->AutoTarget) 1501 { 1502 SetTargetToHostName(m, rr); // Also sets rdlength and rdestimate for us, and calls InitializeLastAPTime(); 1503#ifndef UNICAST_DISABLED 1504 // If we have no target record yet, SetTargetToHostName will set rr->state == regState_NoTarget 1505 // 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. 1506 if (rr->state == regState_NoTarget) 1507 { 1508 // Initialize the target so that we don't crash while logging etc. 1509 domainname *tar = GetRRDomainNameTarget(&rr->resrec); 1510 if (tar) tar->c[0] = 0; 1511 LogInfo("mDNS_Register_internal: record %s in NoTarget state", ARDisplayString(m, rr)); 1512 } 1513#endif 1514 } 1515 else 1516 { 1517 rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse); 1518 rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue); 1519 } 1520 1521 if (!ValidateDomainName(rr->resrec.name)) 1522 { LogMsg("Attempt to register record with invalid name: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); } 1523 1524 // Don't do this until *after* we've set rr->resrec.rdlength 1525 if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata)) 1526 { LogMsg("Attempt to register record with invalid rdata: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); } 1527 1528 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name); 1529 rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(&rr->resrec); 1530 1531 if (RRLocalOnly(rr)) 1532 { 1533 // If this is supposed to be unique, make sure we don't have any name conflicts. 1534 // If we found a conflict, we may still want to insert the record in the list but mark it appropriately 1535 // (kDNSRecordTypeDeregistering) so that we deliver RMV events to the application. But this causes more 1536 // complications and not clear whether there are any benefits. See rdar:9304275 for details. 1537 // Hence, just bail out. 1538 // This comment is doesn���t make any sense. -- SC 1539 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 1540 { 1541 if (CheckAuthRecordConflict(&m->rrauth, rr)) 1542 { 1543 LogInfo("mDNS_Register_internal: Name conflict %s (%p), InterfaceID %p", ARDisplayString(m, rr), rr, rr->resrec.InterfaceID); 1544 return mStatus_NameConflict; 1545 } 1546 } 1547 } 1548 1549 // For uDNS records, we don't support duplicate checks at this time. 1550#ifndef UNICAST_DISABLED 1551 if (AuthRecord_uDNS(rr)) 1552 { 1553 if (!m->NewLocalRecords) m->NewLocalRecords = rr; 1554 // When we called SetTargetToHostName, it may have caused mDNS_Register_internal to be re-entered, appending new 1555 // 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. 1556 // Note that for AutoTunnel this should never happen, but this check makes the code future-proof. 1557 while (*p) p=&(*p)->next; 1558 *p = rr; 1559 if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified; 1560 rr->ProbeCount = 0; 1561 rr->ProbeRestartCount = 0; 1562 rr->AnnounceCount = 0; 1563 if (rr->state != regState_NoTarget) ActivateUnicastRegistration(m, rr); 1564 return(mStatus_NoError); // <--- Note: For unicast records, code currently bails out at this point 1565 } 1566#endif 1567 1568 // Now that we've finished building our new record, make sure it's not identical to one we already have 1569 if (RRLocalOnly(rr)) 1570 { 1571 rr->ProbeCount = 0; 1572 rr->ProbeRestartCount = 0; 1573 rr->AnnounceCount = 0; 1574 r = CheckAuthIdenticalRecord(&m->rrauth, rr); 1575 } 1576 else 1577 { 1578 for (r = m->ResourceRecords; r; r=r->next) 1579 if (RecordIsLocalDuplicate(r, rr)) 1580 { 1581 if (r->resrec.RecordType == kDNSRecordTypeDeregistering) r->AnnounceCount = 0; 1582 else break; 1583 } 1584 } 1585 1586 if (r) 1587 { 1588 LogInfo("mDNS_Register_internal: Adding to duplicate list %s", ARDisplayString(m,rr)); 1589 *d = rr; 1590 // If the previous copy of this record is already verified unique, 1591 // then indicate that we should move this record promptly to kDNSRecordTypeUnique state. 1592 // Setting ProbeCount to zero will cause SendQueries() to advance this record to 1593 // kDNSRecordTypeVerified state and call the client callback at the next appropriate time. 1594 if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified) 1595 rr->ProbeCount = 0; 1596 } 1597 else 1598 { 1599 LogInfo("mDNS_Register_internal: Adding to active record list %s", ARDisplayString(m,rr)); 1600 if (RRLocalOnly(rr)) 1601 { 1602 AuthGroup *ag; 1603 ag = InsertAuthRecord(m, &m->rrauth, rr); 1604 if (ag && !ag->NewLocalOnlyRecords) 1605 { 1606 m->NewLocalOnlyRecords = mDNStrue; 1607 ag->NewLocalOnlyRecords = rr; 1608 } 1609 // No probing for LocalOnly records; acknowledge them right away 1610 if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified; 1611 AcknowledgeRecord(m, rr); 1612 return(mStatus_NoError); 1613 } 1614 else 1615 { 1616 if (!m->NewLocalRecords) m->NewLocalRecords = rr; 1617 *p = rr; 1618 } 1619 } 1620 1621 if (!AuthRecord_uDNS(rr)) // This check is superfluous, given that for unicast records we (currently) bail out above 1622 { 1623 // We have inserted the record in the list. See if we have to advertise the A/AAAA, HINFO, PTR records. 1624 IncrementAutoTargetServices(m, rr); 1625 1626 // For records that are not going to probe, acknowledge them right away 1627 if (rr->resrec.RecordType != kDNSRecordTypeUnique && rr->resrec.RecordType != kDNSRecordTypeDeregistering) 1628 AcknowledgeRecord(m, rr); 1629 1630 // Adding a record may affect whether or not we should sleep 1631 mDNS_UpdateAllowSleep(m); 1632 } 1633 1634 // If this is a non-sleep proxy keepalive record, fetch the MAC address of the remote host. 1635 // This is used by the in-NIC proxy to send the keepalive packets. 1636 if (!rr->WakeUp.HMAC.l[0] && mDNS_KeepaliveRecord(&rr->resrec)) 1637 { 1638 mDNSAddr raddr; 1639 // Set the record type to known unique to prevent probing keep alive records. 1640 // Also make sure we do not announce the keepalive records. 1641 rr->resrec.RecordType = kDNSRecordTypeKnownUnique; 1642 rr->AnnounceCount = 0; 1643 getKeepaliveRaddr(m, rr, &raddr); 1644 // This is an asynchronous call. Once the remote MAC address is available, helper will schedule an 1645 // asynchronous task to update the resource record 1646 mDNSPlatformGetRemoteMacAddr(&raddr); 1647 } 1648 1649 return(mStatus_NoError); 1650} 1651 1652mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr) 1653{ 1654 m->ProbeFailTime = m->timenow; 1655 m->NumFailedProbes++; 1656 // If we've had fifteen or more probe failures, rate-limit to one every five seconds. 1657 // If a bunch of hosts have all been configured with the same name, then they'll all 1658 // conflict and run through the same series of names: name-2, name-3, name-4, etc., 1659 // up to name-10. After that they'll start adding random increments in the range 1-100, 1660 // so they're more likely to branch out in the available namespace and settle on a set of 1661 // unique names quickly. If after five more tries the host is still conflicting, then we 1662 // may have a serious problem, so we start rate-limiting so we don't melt down the network. 1663 if (m->NumFailedProbes >= 15) 1664 { 1665 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5); 1666 LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect", 1667 m->NumFailedProbes, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1668 } 1669} 1670 1671mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr) 1672{ 1673 RData *OldRData = rr->resrec.rdata; 1674 mDNSu16 OldRDLen = rr->resrec.rdlength; 1675 SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata 1676 rr->NewRData = mDNSNULL; // Clear the NewRData pointer ... 1677 if (rr->UpdateCallback) 1678 rr->UpdateCallback(m, rr, OldRData, OldRDLen); // ... and let the client know 1679} 1680 1681// Note: mDNS_Deregister_internal can call a user callback, which may change the record list and/or question list. 1682// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 1683// Exported so uDNS.c can call this 1684mDNSexport mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt) 1685{ 1686 AuthRecord *r2; 1687 mDNSu8 RecordType = rr->resrec.RecordType; 1688 AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records 1689 mDNSBool dupList = mDNSfalse; 1690 1691 if (RRLocalOnly(rr)) 1692 { 1693 AuthGroup *a; 1694 AuthRecord **rp; 1695 1696 a = AuthGroupForRecord(&m->rrauth, &rr->resrec); 1697 if (!a) return mDNSfalse; 1698 rp = &a->members; 1699 while (*rp && *rp != rr) rp=&(*rp)->next; 1700 p = rp; 1701 } 1702 else 1703 { 1704 while (*p && *p != rr) p=&(*p)->next; 1705 } 1706 1707 if (*p) 1708 { 1709 // We found our record on the main list. See if there are any duplicates that need special handling. 1710 if (drt == mDNS_Dereg_conflict) // If this was a conflict, see that all duplicates get the same treatment 1711 { 1712 // Scan for duplicates of rr, and mark them for deregistration at the end of this routine, after we've finished 1713 // deregistering rr. We need to do this scan *before* we give the client the chance to free and reuse the rr memory. 1714 for (r2 = m->DuplicateRecords; r2; r2=r2->next) if (RecordIsLocalDuplicate(r2, rr)) r2->ProbeCount = 0xFF; 1715 } 1716 else 1717 { 1718 // Before we delete the record (and potentially send a goodbye packet) 1719 // first see if we have a record on the duplicate list ready to take over from it. 1720 AuthRecord **d = &m->DuplicateRecords; 1721 while (*d && !RecordIsLocalDuplicate(*d, rr)) d=&(*d)->next; 1722 if (*d) 1723 { 1724 AuthRecord *dup = *d; 1725 debugf("mDNS_Register_internal: Duplicate record %p taking over from %p %##s (%s)", 1726 dup, rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1727 *d = dup->next; // Cut replacement record from DuplicateRecords list 1728 if (RRLocalOnly(rr)) 1729 { 1730 dup->next = mDNSNULL; 1731 if (!InsertAuthRecord(m, &m->rrauth, dup)) LogMsg("mDNS_Deregister_internal: ERROR!! cannot insert %s", ARDisplayString(m, dup)); 1732 } 1733 else 1734 { 1735 dup->next = rr->next; // And then... 1736 rr->next = dup; // ... splice it in right after the record we're about to delete 1737 } 1738 dup->resrec.RecordType = rr->resrec.RecordType; 1739 dup->ProbeCount = rr->ProbeCount; 1740 dup->ProbeRestartCount = rr->ProbeRestartCount; 1741 dup->AnnounceCount = rr->AnnounceCount; 1742 dup->RequireGoodbye = rr->RequireGoodbye; 1743 dup->AnsweredLocalQ = rr->AnsweredLocalQ; 1744 dup->ImmedAnswer = rr->ImmedAnswer; 1745 dup->ImmedUnicast = rr->ImmedUnicast; 1746 dup->ImmedAdditional = rr->ImmedAdditional; 1747 dup->v4Requester = rr->v4Requester; 1748 dup->v6Requester = rr->v6Requester; 1749 dup->ThisAPInterval = rr->ThisAPInterval; 1750 dup->LastAPTime = rr->LastAPTime; 1751 dup->LastMCTime = rr->LastMCTime; 1752 dup->LastMCInterface = rr->LastMCInterface; 1753 dup->Private = rr->Private; 1754 dup->state = rr->state; 1755 rr->RequireGoodbye = mDNSfalse; 1756 rr->AnsweredLocalQ = mDNSfalse; 1757 } 1758 } 1759 } 1760 else 1761 { 1762 // We didn't find our record on the main list; try the DuplicateRecords list instead. 1763 p = &m->DuplicateRecords; 1764 while (*p && *p != rr) p=&(*p)->next; 1765 // If we found our record on the duplicate list, then make sure we don't send a goodbye for it 1766 if (*p) 1767 { 1768 // Duplicate records are not used for sending wakeups or goodbyes. Hence, deregister them 1769 // immediately. When there is a conflict, we deregister all the conflicting duplicate records 1770 // also that have been marked above in this function. In that case, we come here and if we don't 1771 // deregister (unilink from the DuplicateRecords list), we will be recursing infinitely. Hence, 1772 // clear the HMAC which will cause it to deregister. See <rdar://problem/10380988> for 1773 // details. 1774 rr->WakeUp.HMAC = zeroEthAddr; 1775 rr->RequireGoodbye = mDNSfalse; 1776 rr->resrec.RecordType = kDNSRecordTypeDeregistering; 1777 dupList = mDNStrue; 1778 } 1779 if (*p) debugf("mDNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)", 1780 rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1781 } 1782 1783 if (!*p) 1784 { 1785 // No need to log an error message if we already know this is a potentially repeated deregistration 1786 if (drt != mDNS_Dereg_repeat) 1787 LogMsg("mDNS_Deregister_internal: Record %p not found in list %s", rr, ARDisplayString(m,rr)); 1788 return(mStatus_BadReferenceErr); 1789 } 1790 1791 // If this is a shared record and we've announced it at least once, 1792 // we need to retract that announcement before we delete the record 1793 1794 // If this is a record (including mDNSInterface_LocalOnly records) for which we've given local-only answers then 1795 // it's tempting to just do "AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse)" here, but that would not not be safe. 1796 // The AnswerAllLocalQuestionsWithLocalAuthRecord routine walks the question list invoking client callbacks, using the "m->CurrentQuestion" 1797 // mechanism to cope with the client callback modifying the question list while that's happening. 1798 // However, mDNS_Deregister could have been called from a client callback (e.g. from the domain enumeration callback FoundDomain) 1799 // which means that the "m->CurrentQuestion" mechanism is already in use to protect that list, so we can't use it twice. 1800 // More generally, if we invoke callbacks from within a client callback, then those callbacks could deregister other 1801 // records, thereby invoking yet more callbacks, without limit. 1802 // The solution is to defer delivering the "Remove" events until mDNS_Execute time, just like we do for sending 1803 // actual goodbye packets. 1804 1805#ifndef UNICAST_DISABLED 1806 if (AuthRecord_uDNS(rr)) 1807 { 1808 if (rr->RequireGoodbye) 1809 { 1810 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 1811 rr->resrec.RecordType = kDNSRecordTypeDeregistering; 1812 m->LocalRemoveEvents = mDNStrue; 1813 uDNS_DeregisterRecord(m, rr); 1814 // At this point unconditionally we bail out 1815 // Either uDNS_DeregisterRecord will have completed synchronously, and called CompleteDeregistration, 1816 // which calls us back here with RequireGoodbye set to false, or it will have initiated the deregistration 1817 // process and will complete asynchronously. Either way we don't need to do anything more here. 1818 return(mStatus_NoError); 1819 } 1820 // Sometimes the records don't complete proper deregistration i.e., don't wait for a response 1821 // from the server. In that case, if the records have been part of a group update, clear the 1822 // state here. Some recors e.g., AutoTunnel gets reused without ever being completely initialized 1823 rr->updateid = zeroID; 1824 1825 // We defer cleaning up NAT state only after sending goodbyes. This is important because 1826 // RecordRegistrationGotZoneData guards against creating NAT state if clientContext is non-NULL. 1827 // This happens today when we turn on/off interface where we get multiple network transitions 1828 // and RestartRecordGetZoneData triggers re-registration of the resource records even though 1829 // they may be in Registered state which causes NAT information to be setup multiple times. Defering 1830 // the cleanup here keeps clientContext non-NULL and hence prevents that. Note that cleaning up 1831 // NAT state here takes care of the case where we did not send goodbyes at all. 1832 if (rr->NATinfo.clientContext) 1833 { 1834 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 1835 rr->NATinfo.clientContext = mDNSNULL; 1836 } 1837 if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; } 1838 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 1839 } 1840#endif // UNICAST_DISABLED 1841 1842 if (RecordType == kDNSRecordTypeUnregistered) 1843 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered", ARDisplayString(m, rr)); 1844 else if (RecordType == kDNSRecordTypeDeregistering) 1845 { 1846 LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering", ARDisplayString(m, rr)); 1847 return(mStatus_BadReferenceErr); 1848 } 1849 1850 // <rdar://problem/7457925> Local-only questions don't get remove events for unique records 1851 // We may want to consider changing this code so that we generate local-only question "rmv" 1852 // events (and maybe goodbye packets too) for unique records as well as for shared records 1853 // Note: If we change the logic for this "if" statement, need to ensure that the code in 1854 // CompleteDeregistration() sets the appropriate state variables to gaurantee that "else" 1855 // clause will execute here and the record will be cut from the list. 1856 if (rr->WakeUp.HMAC.l[0] || 1857 (RecordType == kDNSRecordTypeShared && (rr->RequireGoodbye || rr->AnsweredLocalQ))) 1858 { 1859 verbosedebugf("mDNS_Deregister_internal: Starting deregistration for %s", ARDisplayString(m, rr)); 1860 rr->resrec.RecordType = kDNSRecordTypeDeregistering; 1861 rr->resrec.rroriginalttl = 0; 1862 rr->AnnounceCount = rr->WakeUp.HMAC.l[0] ? WakeupCount : (drt == mDNS_Dereg_rapid) ? 1 : GoodbyeCount; 1863 rr->ThisAPInterval = mDNSPlatformOneSecond * 2; 1864 rr->LastAPTime = m->timenow - rr->ThisAPInterval; 1865 m->LocalRemoveEvents = mDNStrue; 1866 if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0) 1867 m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10); 1868 } 1869 else 1870 { 1871 if (!dupList && RRLocalOnly(rr)) 1872 { 1873 AuthGroup *ag = RemoveAuthRecord(m, &m->rrauth, rr); 1874 if (ag->NewLocalOnlyRecords == rr) ag->NewLocalOnlyRecords = rr->next; 1875 } 1876 else 1877 { 1878 *p = rr->next; // Cut this record from the list 1879 if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next; 1880 DecrementAutoTargetServices(m, rr); 1881 } 1882 // If someone is about to look at this, bump the pointer forward 1883 if (m->CurrentRecord == rr) m->CurrentRecord = rr->next; 1884 rr->next = mDNSNULL; 1885 1886 // Should we generate local remove events here? 1887 // i.e. something like: 1888 // if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; } 1889 1890 verbosedebugf("mDNS_Deregister_internal: Deleting record for %s", ARDisplayString(m, rr)); 1891 rr->resrec.RecordType = kDNSRecordTypeUnregistered; 1892 1893 if ((drt == mDNS_Dereg_conflict || drt == mDNS_Dereg_repeat) && RecordType == kDNSRecordTypeShared) 1894 debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)", 1895 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1896 1897 // If we have an update queued up which never executed, give the client a chance to free that memory 1898 if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client 1899 1900 1901 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function 1902 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc. 1903 // In this case the likely client action to the mStatus_MemFree message is to free the memory, 1904 // so any attempt to touch rr after this is likely to lead to a crash. 1905 if (drt != mDNS_Dereg_conflict) 1906 { 1907 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 1908 LogInfo("mDNS_Deregister_internal: callback with mStatus_MemFree for %s", ARDisplayString(m, rr)); 1909 if (rr->RecordCallback) 1910 rr->RecordCallback(m, rr, mStatus_MemFree); // MUST NOT touch rr after this 1911 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 1912 } 1913 else 1914 { 1915 RecordProbeFailure(m, rr); 1916 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 1917 if (rr->RecordCallback) 1918 rr->RecordCallback(m, rr, mStatus_NameConflict); // MUST NOT touch rr after this 1919 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 1920 // Now that we've finished deregistering rr, check our DuplicateRecords list for any that we marked previously. 1921 // Note that with all the client callbacks going on, by the time we get here all the 1922 // records we marked may have been explicitly deregistered by the client anyway. 1923 r2 = m->DuplicateRecords; 1924 while (r2) 1925 { 1926 if (r2->ProbeCount != 0xFF) 1927 { 1928 r2 = r2->next; 1929 } 1930 else 1931 { 1932#if APPLE_OSX_mDNSResponder 1933 // See if this record was also registered with any D2D plugins. 1934 D2D_stop_advertising_record(r2); 1935#endif 1936 mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict); 1937 // As this is a duplicate record, it will be unlinked from the list 1938 // immediately 1939 r2 = m->DuplicateRecords; 1940 } 1941 } 1942 } 1943 } 1944 mDNS_UpdateAllowSleep(m); 1945 return(mStatus_NoError); 1946} 1947 1948// *************************************************************************** 1949#if COMPILER_LIKES_PRAGMA_MARK 1950#pragma mark - 1951#pragma mark - Packet Sending Functions 1952#endif 1953 1954mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add) 1955{ 1956 if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse) 1957 { 1958 **nrpp = rr; 1959 // NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo) 1960 // If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does 1961 // The referenced record will definitely be acceptable (by recursive application of this rule) 1962 if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo; 1963 rr->NR_AdditionalTo = add; 1964 *nrpp = &rr->NextResponse; 1965 } 1966 debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 1967} 1968 1969mDNSlocal void AddRRSetAdditionalsToResponseList(mDNS *const m, AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *additional, const mDNSInterfaceID InterfaceID) 1970{ 1971 AuthRecord *rr2; 1972 if (additional->resrec.RecordType & kDNSRecordTypeUniqueMask) 1973 { 1974 for (rr2 = m->ResourceRecords; rr2; rr2 = rr2->next) 1975 { 1976 if ((rr2->resrec.namehash == additional->resrec.namehash) && 1977 (rr2->resrec.rrtype == additional->resrec.rrtype) && 1978 (rr2 != additional) && 1979 (rr2->resrec.RecordType & kDNSRecordTypeUniqueMask) && 1980 (rr2->resrec.rrclass == additional->resrec.rrclass) && 1981 ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && 1982 SameDomainName(rr2->resrec.name, additional->resrec.name)) 1983 { 1984 AddRecordToResponseList(nrpp, rr2, rr); 1985 } 1986 } 1987 } 1988} 1989 1990mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID) 1991{ 1992 AuthRecord *rr, *rr2; 1993 for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put 1994 { 1995 // (Note: This is an "if", not a "while". If we add a record, we'll find it again 1996 // later in the "for" loop, and we will follow further "additional" links then.) 1997 if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID)) 1998 { 1999 AddRecordToResponseList(nrpp, rr->Additional1, rr); 2000 AddRRSetAdditionalsToResponseList(m, nrpp, rr, rr->Additional1, InterfaceID); 2001 } 2002 2003 if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID)) 2004 { 2005 AddRecordToResponseList(nrpp, rr->Additional2, rr); 2006 AddRRSetAdditionalsToResponseList(m, nrpp, rr, rr->Additional2, InterfaceID); 2007 } 2008 2009 // For SRV records, automatically add the Address record(s) for the target host 2010 if (rr->resrec.rrtype == kDNSType_SRV) 2011 { 2012 for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records 2013 if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ... 2014 ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ... 2015 rr->resrec.rdatahash == rr2->resrec.namehash && // ... whose name is the name of the SRV target 2016 SameDomainName(&rr->resrec.rdata->u.srv.target, rr2->resrec.name)) 2017 AddRecordToResponseList(nrpp, rr2, rr); 2018 } 2019 else if (RRTypeIsAddressType(rr->resrec.rrtype)) // For A or AAAA, put counterpart as additional 2020 { 2021 for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records 2022 if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ... 2023 ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ... 2024 rr->resrec.namehash == rr2->resrec.namehash && // ... and have the same name 2025 SameDomainName(rr->resrec.name, rr2->resrec.name)) 2026 AddRecordToResponseList(nrpp, rr2, rr); 2027 } 2028 else if (rr->resrec.rrtype == kDNSType_PTR) // For service PTR, see if we want to add DeviceInfo record 2029 { 2030 if (ResourceRecordIsValidInterfaceAnswer(&m->DeviceInfo, InterfaceID) && 2031 SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c)) 2032 AddRecordToResponseList(nrpp, &m->DeviceInfo, rr); 2033 } 2034 } 2035} 2036 2037mDNSlocal int AnonInfoSpace(AnonymousInfo *info) 2038{ 2039 ResourceRecord *rr = info->nsec3RR; 2040 2041 // 2 bytes for compressed name + type (2) class (2) TTL (4) rdlength (2) rdata (n) 2042 return (2 + 10 + rr->rdlength); 2043} 2044 2045mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID) 2046{ 2047 AuthRecord *rr; 2048 AuthRecord *ResponseRecords = mDNSNULL; 2049 AuthRecord **nrp = &ResponseRecords; 2050 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 2051 int AnoninfoSpace = 0; 2052 2053 // Make a list of all our records that need to be unicast to this destination 2054 for (rr = m->ResourceRecords; rr; rr=rr->next) 2055 { 2056 // If we find we can no longer unicast this answer, clear ImmedUnicast 2057 if (rr->ImmedAnswer == mDNSInterfaceMark || 2058 mDNSSameIPv4Address(rr->v4Requester, onesIPv4Addr) || 2059 mDNSSameIPv6Address(rr->v6Requester, onesIPv6Addr) ) 2060 rr->ImmedUnicast = mDNSfalse; 2061 2062 if (rr->ImmedUnicast && rr->ImmedAnswer == InterfaceID) 2063 { 2064 if ((dest->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->v4Requester, dest->ip.v4)) || 2065 (dest->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->v6Requester, dest->ip.v6))) 2066 { 2067 rr->ImmedAnswer = mDNSNULL; // Clear the state fields 2068 rr->ImmedUnicast = mDNSfalse; 2069 rr->v4Requester = zerov4Addr; 2070 rr->v6Requester = zerov6Addr; 2071 2072 // Only sent records registered for P2P over P2P interfaces 2073 if (intf && !mDNSPlatformValidRecordForInterface(rr, intf->InterfaceID)) 2074 { 2075 continue; 2076 } 2077 2078 if (rr->NextResponse == mDNSNULL && nrp != &rr->NextResponse) // rr->NR_AnswerTo 2079 { 2080 rr->NR_AnswerTo = NR_AnswerMulticast; 2081 *nrp = rr; 2082 nrp = &rr->NextResponse; 2083 } 2084 } 2085 } 2086 } 2087 2088 AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID); 2089 2090 while (ResponseRecords) 2091 { 2092 mDNSu8 *responseptr = m->omsg.data; 2093 mDNSu8 *newptr; 2094 InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags); 2095 2096 // Put answers in the packet 2097 while (ResponseRecords && ResponseRecords->NR_AnswerTo) 2098 { 2099 rr = ResponseRecords; 2100 if (rr->resrec.AnonInfo) 2101 { 2102 AnoninfoSpace += AnonInfoSpace(rr->resrec.AnonInfo); 2103 rr->resrec.AnonInfo->SendNow = mDNSInterfaceMark; 2104 } 2105 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 2106 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it 2107 2108 // Retract the limit by AnoninfoSpace which we need to put the AnoInfo option. 2109 newptr = PutResourceRecordTTLWithLimit(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl, 2110 m->omsg.data + (AllowedRRSpace(&m->omsg) - AnoninfoSpace)); 2111 2112 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state 2113 if (!newptr && m->omsg.h.numAnswers) 2114 { 2115 break; // If packet full, send it now 2116 } 2117 if (newptr) responseptr = newptr; 2118 ResponseRecords = rr->NextResponse; 2119 rr->NextResponse = mDNSNULL; 2120 rr->NR_AnswerTo = mDNSNULL; 2121 rr->NR_AdditionalTo = mDNSNULL; 2122 rr->RequireGoodbye = mDNStrue; 2123 } 2124 2125 // We have reserved the space for AnonInfo option. PutResourceRecord uses the 2126 // standard limit (AllowedRRSpace) and we should have space now. 2127 for (rr = m->ResourceRecords; rr; rr=rr->next) 2128 { 2129 if (rr->resrec.AnonInfo && rr->resrec.AnonInfo->SendNow == mDNSInterfaceMark) 2130 { 2131 ResourceRecord *nsec3RR = rr->resrec.AnonInfo->nsec3RR; 2132 2133 newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAuthorities, nsec3RR); 2134 if (newptr) 2135 { 2136 responseptr = newptr; 2137 debugf("SendDelayedUnicastResponse: Added NSEC3 Record %s on %p", RRDisplayString(m, nsec3RR), intf->InterfaceID); 2138 } 2139 else 2140 { 2141 // We allocated space and we should not fail. Don't break, we need to clear the SendNow flag. 2142 LogMsg("SendDelayedUnicastResponse: ERROR!! Cannot Add NSEC3 Record %s on %p", RRDisplayString(m, nsec3RR), intf->InterfaceID); 2143 } 2144 rr->resrec.AnonInfo->SendNow = mDNSNULL; 2145 } 2146 } 2147 2148 // Add additionals, if there's space 2149 while (ResponseRecords && !ResponseRecords->NR_AnswerTo) 2150 { 2151 rr = ResponseRecords; 2152 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 2153 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it 2154 newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &rr->resrec); 2155 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state 2156 2157 if (newptr) responseptr = newptr; 2158 if (newptr && m->omsg.h.numAnswers) rr->RequireGoodbye = mDNStrue; 2159 else if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) rr->ImmedAnswer = mDNSInterfaceMark; 2160 ResponseRecords = rr->NextResponse; 2161 rr->NextResponse = mDNSNULL; 2162 rr->NR_AnswerTo = mDNSNULL; 2163 rr->NR_AdditionalTo = mDNSNULL; 2164 } 2165 2166 if (m->omsg.h.numAnswers) 2167 mDNSSendDNSMessage(m, &m->omsg, responseptr, InterfaceID, mDNSNULL, dest, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse); 2168 } 2169} 2170 2171// CompleteDeregistration guarantees that on exit the record will have been cut from the m->ResourceRecords list 2172// and the client's mStatus_MemFree callback will have been invoked 2173mDNSexport void CompleteDeregistration(mDNS *const m, AuthRecord *rr) 2174{ 2175 LogInfo("CompleteDeregistration: called for Resource record %s", ARDisplayString(m, rr)); 2176 // Clearing rr->RequireGoodbye signals mDNS_Deregister_internal() that 2177 // it should go ahead and immediately dispose of this registration 2178 rr->resrec.RecordType = kDNSRecordTypeShared; 2179 rr->RequireGoodbye = mDNSfalse; 2180 rr->WakeUp.HMAC = zeroEthAddr; 2181 if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; } 2182 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); // Don't touch rr after this 2183} 2184 2185// DiscardDeregistrations is used on shutdown and sleep to discard (forcibly and immediately) 2186// any deregistering records that remain in the m->ResourceRecords list. 2187// DiscardDeregistrations calls mDNS_Deregister_internal which can call a user callback, 2188// which may change the record list and/or question list. 2189// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 2190mDNSlocal void DiscardDeregistrations(mDNS *const m) 2191{ 2192 if (m->CurrentRecord) 2193 LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 2194 m->CurrentRecord = m->ResourceRecords; 2195 2196 while (m->CurrentRecord) 2197 { 2198 AuthRecord *rr = m->CurrentRecord; 2199 if (!AuthRecord_uDNS(rr) && rr->resrec.RecordType == kDNSRecordTypeDeregistering) 2200 CompleteDeregistration(m, rr); // Don't touch rr after this 2201 else 2202 m->CurrentRecord = rr->next; 2203 } 2204} 2205 2206mDNSlocal mStatus GetLabelDecimalValue(const mDNSu8 *const src, mDNSu8 *dst) 2207{ 2208 int i, val = 0; 2209 if (src[0] < 1 || src[0] > 3) return(mStatus_Invalid); 2210 for (i=1; i<=src[0]; i++) 2211 { 2212 if (src[i] < '0' || src[i] > '9') return(mStatus_Invalid); 2213 val = val * 10 + src[i] - '0'; 2214 } 2215 if (val > 255) return(mStatus_Invalid); 2216 *dst = (mDNSu8)val; 2217 return(mStatus_NoError); 2218} 2219 2220mDNSlocal mStatus GetIPv4FromName(mDNSAddr *const a, const domainname *const name) 2221{ 2222 int skip = CountLabels(name) - 6; 2223 if (skip < 0) { LogMsg("GetIPFromName: Need six labels in IPv4 reverse mapping name %##s", name); return mStatus_Invalid; } 2224 if (GetLabelDecimalValue(SkipLeadingLabels(name, skip+3)->c, &a->ip.v4.b[0]) || 2225 GetLabelDecimalValue(SkipLeadingLabels(name, skip+2)->c, &a->ip.v4.b[1]) || 2226 GetLabelDecimalValue(SkipLeadingLabels(name, skip+1)->c, &a->ip.v4.b[2]) || 2227 GetLabelDecimalValue(SkipLeadingLabels(name, skip+0)->c, &a->ip.v4.b[3])) return mStatus_Invalid; 2228 a->type = mDNSAddrType_IPv4; 2229 return(mStatus_NoError); 2230} 2231 2232#define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0' ) : \ 2233 ((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) : \ 2234 ((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : -1) 2235 2236mDNSlocal mStatus GetIPv6FromName(mDNSAddr *const a, const domainname *const name) 2237{ 2238 int i, h, l; 2239 const domainname *n; 2240 2241 int skip = CountLabels(name) - 34; 2242 if (skip < 0) { LogMsg("GetIPFromName: Need 34 labels in IPv6 reverse mapping name %##s", name); return mStatus_Invalid; } 2243 2244 n = SkipLeadingLabels(name, skip); 2245 for (i=0; i<16; i++) 2246 { 2247 if (n->c[0] != 1) return mStatus_Invalid; 2248 l = HexVal(n->c[1]); 2249 n = (const domainname *)(n->c + 2); 2250 2251 if (n->c[0] != 1) return mStatus_Invalid; 2252 h = HexVal(n->c[1]); 2253 n = (const domainname *)(n->c + 2); 2254 2255 if (l<0 || h<0) return mStatus_Invalid; 2256 a->ip.v6.b[15-i] = (mDNSu8)((h << 4) | l); 2257 } 2258 2259 a->type = mDNSAddrType_IPv6; 2260 return(mStatus_NoError); 2261} 2262 2263mDNSlocal mDNSs32 ReverseMapDomainType(const domainname *const name) 2264{ 2265 int skip = CountLabels(name) - 2; 2266 if (skip >= 0) 2267 { 2268 const domainname *suffix = SkipLeadingLabels(name, skip); 2269 if (SameDomainName(suffix, (const domainname*)"\x7" "in-addr" "\x4" "arpa")) return mDNSAddrType_IPv4; 2270 if (SameDomainName(suffix, (const domainname*)"\x3" "ip6" "\x4" "arpa")) return mDNSAddrType_IPv6; 2271 } 2272 return(mDNSAddrType_None); 2273} 2274 2275mDNSlocal void SendARP(mDNS *const m, const mDNSu8 op, const AuthRecord *const rr, 2276 const mDNSv4Addr *const spa, const mDNSEthAddr *const tha, const mDNSv4Addr *const tpa, const mDNSEthAddr *const dst) 2277{ 2278 int i; 2279 mDNSu8 *ptr = m->omsg.data; 2280 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); 2281 if (!intf) { LogMsg("SendARP: No interface with InterfaceID %p found %s", rr->resrec.InterfaceID, ARDisplayString(m,rr)); return; } 2282 2283 // 0x00 Destination address 2284 for (i=0; i<6; i++) *ptr++ = dst->b[i]; 2285 2286 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us) 2287 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[0]; 2288 2289 // 0x0C ARP Ethertype (0x0806) 2290 *ptr++ = 0x08; *ptr++ = 0x06; 2291 2292 // 0x0E ARP header 2293 *ptr++ = 0x00; *ptr++ = 0x01; // Hardware address space; Ethernet = 1 2294 *ptr++ = 0x08; *ptr++ = 0x00; // Protocol address space; IP = 0x0800 2295 *ptr++ = 6; // Hardware address length 2296 *ptr++ = 4; // Protocol address length 2297 *ptr++ = 0x00; *ptr++ = op; // opcode; Request = 1, Response = 2 2298 2299 // 0x16 Sender hardware address (our MAC address) 2300 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[i]; 2301 2302 // 0x1C Sender protocol address 2303 for (i=0; i<4; i++) *ptr++ = spa->b[i]; 2304 2305 // 0x20 Target hardware address 2306 for (i=0; i<6; i++) *ptr++ = tha->b[i]; 2307 2308 // 0x26 Target protocol address 2309 for (i=0; i<4; i++) *ptr++ = tpa->b[i]; 2310 2311 // 0x2A Total ARP Packet length 42 bytes 2312 mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID); 2313} 2314 2315mDNSlocal mDNSu16 CheckSum(const void *const data, mDNSs32 length, mDNSu32 sum) 2316{ 2317 const mDNSu16 *ptr = data; 2318 while (length > 0) { length -= 2; sum += *ptr++; } 2319 sum = (sum & 0xFFFF) + (sum >> 16); 2320 sum = (sum & 0xFFFF) + (sum >> 16); 2321 return(sum != 0xFFFF ? sum : 0); 2322} 2323 2324mDNSlocal mDNSu16 IPv6CheckSum(const mDNSv6Addr *const src, const mDNSv6Addr *const dst, const mDNSu8 protocol, const void *const data, const mDNSu32 length) 2325{ 2326 IPv6PseudoHeader ph; 2327 ph.src = *src; 2328 ph.dst = *dst; 2329 ph.len.b[0] = length >> 24; 2330 ph.len.b[1] = length >> 16; 2331 ph.len.b[2] = length >> 8; 2332 ph.len.b[3] = length; 2333 ph.pro.b[0] = 0; 2334 ph.pro.b[1] = 0; 2335 ph.pro.b[2] = 0; 2336 ph.pro.b[3] = protocol; 2337 return CheckSum(&ph, sizeof(ph), CheckSum(data, length, 0)); 2338} 2339 2340mDNSlocal void SendNDP(mDNS *const m, const mDNSu8 op, const mDNSu8 flags, const AuthRecord *const rr, 2341 const mDNSv6Addr *const spa, const mDNSEthAddr *const tha, const mDNSv6Addr *const tpa, const mDNSEthAddr *const dst) 2342{ 2343 int i; 2344 mDNSOpaque16 checksum; 2345 mDNSu8 *ptr = m->omsg.data; 2346 // Some recipient hosts seem to ignore Neighbor Solicitations if the IPv6-layer destination address is not the 2347 // appropriate IPv6 solicited node multicast address, so we use that IPv6-layer destination address, even though 2348 // at the Ethernet-layer we unicast the packet to the intended target, to avoid wasting network bandwidth. 2349 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] } }; 2350 const mDNSv6Addr *const v6dst = (op == NDP_Sol) ? &mc : tpa; 2351 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); 2352 if (!intf) { LogMsg("SendNDP: No interface with InterfaceID %p found %s", rr->resrec.InterfaceID, ARDisplayString(m,rr)); return; } 2353 2354 // 0x00 Destination address 2355 for (i=0; i<6; i++) *ptr++ = dst->b[i]; 2356 // Right now we only send Neighbor Solicitations to verify whether the host we're proxying for has gone to sleep yet. 2357 // Since we know who we're looking for, we send it via Ethernet-layer unicast, rather than bothering every host on the 2358 // link with a pointless link-layer multicast. 2359 // Should we want to send traditional Neighbor Solicitations in the future, where we really don't know in advance what 2360 // Ethernet-layer address we're looking for, we'll need to send to the appropriate Ethernet-layer multicast address: 2361 // *ptr++ = 0x33; 2362 // *ptr++ = 0x33; 2363 // *ptr++ = 0xFF; 2364 // *ptr++ = tpa->b[0xD]; 2365 // *ptr++ = tpa->b[0xE]; 2366 // *ptr++ = tpa->b[0xF]; 2367 2368 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us) 2369 for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i]; 2370 2371 // 0x0C IPv6 Ethertype (0x86DD) 2372 *ptr++ = 0x86; *ptr++ = 0xDD; 2373 2374 // 0x0E IPv6 header 2375 *ptr++ = 0x60; *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00; // Version, Traffic Class, Flow Label 2376 *ptr++ = 0x00; *ptr++ = 0x20; // Length 2377 *ptr++ = 0x3A; // Protocol == ICMPv6 2378 *ptr++ = 0xFF; // Hop Limit 2379 2380 // 0x16 Sender IPv6 address 2381 for (i=0; i<16; i++) *ptr++ = spa->b[i]; 2382 2383 // 0x26 Destination IPv6 address 2384 for (i=0; i<16; i++) *ptr++ = v6dst->b[i]; 2385 2386 // 0x36 NDP header 2387 *ptr++ = op; // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement 2388 *ptr++ = 0x00; // Code 2389 *ptr++ = 0x00; *ptr++ = 0x00; // Checksum placeholder (0x38, 0x39) 2390 *ptr++ = flags; 2391 *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00; 2392 2393 if (op == NDP_Sol) // Neighbor Solicitation. The NDP "target" is the address we seek. 2394 { 2395 // 0x3E NDP target. 2396 for (i=0; i<16; i++) *ptr++ = tpa->b[i]; 2397 // 0x4E Source Link-layer Address 2398 // <http://www.ietf.org/rfc/rfc2461.txt> 2399 // MUST NOT be included when the source IP address is the unspecified address. 2400 // Otherwise, on link layers that have addresses this option MUST be included 2401 // in multicast solicitations and SHOULD be included in unicast solicitations. 2402 if (!mDNSIPv6AddressIsZero(*spa)) 2403 { 2404 *ptr++ = NDP_SrcLL; // Option Type 1 == Source Link-layer Address 2405 *ptr++ = 0x01; // Option length 1 (in units of 8 octets) 2406 for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i]; 2407 } 2408 } 2409 else // Neighbor Advertisement. The NDP "target" is the address we're giving information about. 2410 { 2411 // 0x3E NDP target. 2412 for (i=0; i<16; i++) *ptr++ = spa->b[i]; 2413 // 0x4E Target Link-layer Address 2414 *ptr++ = NDP_TgtLL; // Option Type 2 == Target Link-layer Address 2415 *ptr++ = 0x01; // Option length 1 (in units of 8 octets) 2416 for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i]; 2417 } 2418 2419 // 0x4E or 0x56 Total NDP Packet length 78 or 86 bytes 2420 m->omsg.data[0x13] = ptr - &m->omsg.data[0x36]; // Compute actual length 2421 checksum.NotAnInteger = ~IPv6CheckSum(spa, v6dst, 0x3A, &m->omsg.data[0x36], m->omsg.data[0x13]); 2422 m->omsg.data[0x38] = checksum.b[0]; 2423 m->omsg.data[0x39] = checksum.b[1]; 2424 2425 mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID); 2426} 2427 2428mDNSlocal void SetupTracerOpt(const mDNS *const m, rdataOPT *const Trace) 2429{ 2430 mDNSu32 DNS_VERS = _DNS_SD_H; 2431 Trace->u.tracer.platf = m->mDNS_plat; 2432 Trace->u.tracer.mDNSv = DNS_VERS; 2433 2434 Trace->opt = kDNSOpt_Trace; 2435 Trace->optlen = DNSOpt_TraceData_Space - 4; 2436} 2437 2438mDNSlocal void SetupOwnerOpt(const mDNS *const m, const NetworkInterfaceInfo *const intf, rdataOPT *const owner) 2439{ 2440 owner->u.owner.vers = 0; 2441 owner->u.owner.seq = m->SleepSeqNum; 2442 owner->u.owner.HMAC = m->PrimaryMAC; 2443 owner->u.owner.IMAC = intf->MAC; 2444 owner->u.owner.password = zeroEthAddr; 2445 2446 // Don't try to compute the optlen until *after* we've set up the data fields 2447 // 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 2448 owner->opt = kDNSOpt_Owner; 2449 owner->optlen = DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) - 4; 2450} 2451 2452mDNSlocal void GrantUpdateCredit(AuthRecord *rr) 2453{ 2454 if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0; 2455 else rr->NextUpdateCredit = NonZeroTime(rr->NextUpdateCredit + kUpdateCreditRefreshInterval); 2456} 2457 2458mDNSlocal mDNSBool ShouldSendGoodbyesBeforeSleep(mDNS *const m, const NetworkInterfaceInfo *intf, AuthRecord *rr) 2459{ 2460 // If there are no sleep proxies, we set the state to SleepState_Sleeping explicitly 2461 // and hence there is no need to check for Transfering state. But if we have sleep 2462 // proxies and partially sending goodbyes for some records, we will be in Transfering 2463 // state and hence need to make sure that we send goodbyes in that case too. Checking whether 2464 // we are not awake handles both cases. 2465 if ((rr->AuthFlags & AuthFlagsWakeOnly) && (m->SleepState != SleepState_Awake)) 2466 { 2467 debugf("ShouldSendGoodbyesBeforeSleep: marking for goodbye", ARDisplayString(m, rr)); 2468 return mDNStrue; 2469 } 2470 2471 if (m->SleepState != SleepState_Sleeping) 2472 return mDNSfalse; 2473 2474 // If we are going to sleep and in SleepState_Sleeping, SendGoodbyes on the interface tell you 2475 // whether you can send goodbyes or not. 2476 if (!intf->SendGoodbyes) 2477 { 2478 debugf("ShouldSendGoodbyesBeforeSleep: not sending goodbye %s, int %p", ARDisplayString(m, rr), intf->InterfaceID); 2479 return mDNSfalse; 2480 } 2481 else 2482 { 2483 debugf("ShouldSendGoodbyesBeforeSleep: sending goodbye %s, int %p", ARDisplayString(m, rr), intf->InterfaceID); 2484 return mDNStrue; 2485 } 2486} 2487 2488mDNSlocal mDNSBool IsInterfaceValidForAuthRecord(const AuthRecord *ar, mDNSInterfaceID InterfaceID) 2489{ 2490 mDNSBool result; 2491 2492 if (ar->resrec.InterfaceID == mDNSInterface_Any) 2493 { 2494 result = mDNSPlatformValidRecordForInterface(ar, InterfaceID); 2495 } 2496 else 2497 { 2498 result = (ar->resrec.InterfaceID == InterfaceID); 2499 } 2500 2501 return(result); 2502} 2503 2504// Note about acceleration of announcements to facilitate automatic coalescing of 2505// multiple independent threads of announcements into a single synchronized thread: 2506// The announcements in the packet may be at different stages of maturity; 2507// One-second interval, two-second interval, four-second interval, and so on. 2508// After we've put in all the announcements that are due, we then consider 2509// whether there are other nearly-due announcements that are worth accelerating. 2510// To be eligible for acceleration, a record MUST NOT be older (further along 2511// its timeline) than the most mature record we've already put in the packet. 2512// In other words, younger records can have their timelines accelerated to catch up 2513// with their elder bretheren; this narrows the age gap and helps them eventually get in sync. 2514// Older records cannot have their timelines accelerated; this would just widen 2515// the gap between them and their younger bretheren and get them even more out of sync. 2516 2517// Note: SendResponses calls mDNS_Deregister_internal which can call a user callback, which may change 2518// the record list and/or question list. 2519// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 2520mDNSlocal void SendResponses(mDNS *const m) 2521{ 2522 int pktcount = 0; 2523 AuthRecord *rr, *r2; 2524 mDNSs32 maxExistingAnnounceInterval = 0; 2525 const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces); 2526 2527 m->NextScheduledResponse = m->timenow + FutureTime; 2528 2529 if (m->SleepState == SleepState_Transferring) RetrySPSRegistrations(m); 2530 2531 for (rr = m->ResourceRecords; rr; rr=rr->next) 2532 if (rr->ImmedUnicast) 2533 { 2534 mDNSAddr v4 = { mDNSAddrType_IPv4, {{{0}}} }; 2535 mDNSAddr v6 = { mDNSAddrType_IPv6, {{{0}}} }; 2536 v4.ip.v4 = rr->v4Requester; 2537 v6.ip.v6 = rr->v6Requester; 2538 if (!mDNSIPv4AddressIsZero(rr->v4Requester)) SendDelayedUnicastResponse(m, &v4, rr->ImmedAnswer); 2539 if (!mDNSIPv6AddressIsZero(rr->v6Requester)) SendDelayedUnicastResponse(m, &v6, rr->ImmedAnswer); 2540 if (rr->ImmedUnicast) 2541 { 2542 LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s", ARDisplayString(m, rr)); 2543 rr->ImmedUnicast = mDNSfalse; 2544 } 2545 } 2546 2547 // *** 2548 // *** 1. Setup: Set the SendRNow and ImmedAnswer fields to indicate which interface(s) the records need to be sent on 2549 // *** 2550 2551 // Run through our list of records, and decide which ones we're going to announce on all interfaces 2552 for (rr = m->ResourceRecords; rr; rr=rr->next) 2553 { 2554 while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr); 2555 if (TimeToAnnounceThisRecord(rr, m->timenow)) 2556 { 2557 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) 2558 { 2559 if (!rr->WakeUp.HMAC.l[0]) 2560 { 2561 if (rr->AnnounceCount) rr->ImmedAnswer = mDNSInterfaceMark; // Send goodbye packet on all interfaces 2562 } 2563 else 2564 { 2565 mDNSBool unicastOnly; 2566 LogSPS("SendResponses: Sending wakeup %2d for %.6a %s", rr->AnnounceCount-3, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 2567 unicastOnly = ((rr->AnnounceCount == WakeupCount) || (rr->AnnounceCount == WakeupCount - 1)) ? mDNStrue : mDNSfalse; 2568 SendWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.IMAC, &rr->WakeUp.password, unicastOnly); 2569 for (r2 = rr; r2; r2=r2->next) 2570 if ((r2->resrec.RecordType == kDNSRecordTypeDeregistering) && r2->AnnounceCount && (r2->resrec.InterfaceID == rr->resrec.InterfaceID) && 2571 mDNSSameEthAddress(&r2->WakeUp.IMAC, &rr->WakeUp.IMAC) && !mDNSSameEthAddress(&zeroEthAddr, &r2->WakeUp.HMAC)) 2572 { 2573 // For now we only want to send a single Unsolicited Neighbor Advertisement restoring the address to the original 2574 // owner, because these packets can cause some IPv6 stacks to falsely conclude that there's an address conflict. 2575 if (r2->AddressProxy.type == mDNSAddrType_IPv6 && r2->AnnounceCount == WakeupCount) 2576 { 2577 LogSPS("NDP Announcement %2d Releasing traffic for H-MAC %.6a I-MAC %.6a %s", 2578 r2->AnnounceCount-3, &r2->WakeUp.HMAC, &r2->WakeUp.IMAC, ARDisplayString(m,r2)); 2579 SendNDP(m, NDP_Adv, NDP_Override, r2, &r2->AddressProxy.ip.v6, &r2->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth); 2580 } 2581 r2->LastAPTime = m->timenow; 2582 // After 15 wakeups without success (maybe host has left the network) send three goodbyes instead 2583 if (--r2->AnnounceCount <= GoodbyeCount) r2->WakeUp.HMAC = zeroEthAddr; 2584 } 2585 } 2586 } 2587 else if (ResourceRecordIsValidAnswer(rr)) 2588 { 2589 if (rr->AddressProxy.type) 2590 { 2591 if (!mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC)) 2592 { 2593 rr->AnnounceCount--; 2594 rr->ThisAPInterval *= 2; 2595 rr->LastAPTime = m->timenow; 2596 if (rr->AddressProxy.type == mDNSAddrType_IPv4) 2597 { 2598 LogSPS("ARP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s", 2599 rr->AnnounceCount, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); 2600 SendARP(m, 1, rr, &rr->AddressProxy.ip.v4, &zeroEthAddr, &rr->AddressProxy.ip.v4, &onesEthAddr); 2601 } 2602 else if (rr->AddressProxy.type == mDNSAddrType_IPv6) 2603 { 2604 LogSPS("NDP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s", 2605 rr->AnnounceCount, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); 2606 SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, mDNSNULL, &AllHosts_v6, &AllHosts_v6_Eth); 2607 } 2608 } 2609 } 2610 else 2611 { 2612 rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces 2613 if (maxExistingAnnounceInterval < rr->ThisAPInterval) 2614 maxExistingAnnounceInterval = rr->ThisAPInterval; 2615 if (rr->UpdateBlocked) rr->UpdateBlocked = 0; 2616 } 2617 } 2618 } 2619 } 2620 2621 // Any interface-specific records we're going to send are marked as being sent on all appropriate interfaces (which is just one) 2622 // Eligible records that are more than half-way to their announcement time are accelerated 2623 for (rr = m->ResourceRecords; rr; rr=rr->next) 2624 if ((rr->resrec.InterfaceID && rr->ImmedAnswer) || 2625 (rr->ThisAPInterval <= maxExistingAnnounceInterval && 2626 TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2) && 2627 !rr->AddressProxy.type && // Don't include ARP Annoucements when considering which records to accelerate 2628 ResourceRecordIsValidAnswer(rr))) 2629 rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces 2630 2631 // When sending SRV records (particularly when announcing a new service) automatically add related Address record(s) as additionals 2632 // Note: Currently all address records are interface-specific, so it's safe to set ImmedAdditional to their InterfaceID, 2633 // which will be non-null. If by some chance there is an address record that's not interface-specific (should never happen) 2634 // then all that means is that it won't get sent -- which would not be the end of the world. 2635 for (rr = m->ResourceRecords; rr; rr=rr->next) 2636 { 2637 if (rr->ImmedAnswer && rr->resrec.rrtype == kDNSType_SRV) 2638 for (r2=m->ResourceRecords; r2; r2=r2->next) // Scan list of resource records 2639 if (RRTypeIsAddressType(r2->resrec.rrtype) && // For all address records (A/AAAA) ... 2640 ResourceRecordIsValidAnswer(r2) && // ... which are valid for answer ... 2641 rr->LastMCTime - r2->LastMCTime >= 0 && // ... which we have not sent recently ... 2642 rr->resrec.rdatahash == r2->resrec.namehash && // ... whose name is the name of the SRV target 2643 SameDomainName(&rr->resrec.rdata->u.srv.target, r2->resrec.name) && 2644 (rr->ImmedAnswer == mDNSInterfaceMark || rr->ImmedAnswer == r2->resrec.InterfaceID)) 2645 r2->ImmedAdditional = r2->resrec.InterfaceID; // ... then mark this address record for sending too 2646 // We also make sure we send the DeviceInfo TXT record too, if necessary 2647 // We check for RecordType == kDNSRecordTypeShared because we don't want to tag the 2648 // DeviceInfo TXT record onto a goodbye packet (RecordType == kDNSRecordTypeDeregistering). 2649 if (rr->ImmedAnswer && rr->resrec.RecordType == kDNSRecordTypeShared && rr->resrec.rrtype == kDNSType_PTR) 2650 if (ResourceRecordIsValidAnswer(&m->DeviceInfo) && SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c)) 2651 { 2652 if (!m->DeviceInfo.ImmedAnswer) m->DeviceInfo.ImmedAnswer = rr->ImmedAnswer; 2653 else m->DeviceInfo.ImmedAnswer = mDNSInterfaceMark; 2654 } 2655 } 2656 2657 // If there's a record which is supposed to be unique that we're going to send, then make sure that we give 2658 // the whole RRSet as an atomic unit. That means that if we have any other records with the same name/type/class 2659 // then we need to mark them for sending too. Otherwise, if we set the kDNSClass_UniqueRRSet bit on a 2660 // record, then other RRSet members that have not been sent recently will get flushed out of client caches. 2661 // -- 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 2662 // -- If any record is marked to be sent on all interfaces, make sure the whole set is marked to be sent on all interfaces 2663 for (rr = m->ResourceRecords; rr; rr=rr->next) 2664 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 2665 { 2666 if (rr->ImmedAnswer) // If we're sending this as answer, see that its whole RRSet is similarly marked 2667 { 2668 for (r2 = m->ResourceRecords; r2; r2=r2->next) 2669 { 2670 if ((r2->resrec.RecordType & kDNSRecordTypeUniqueMask) && ResourceRecordIsValidAnswer(r2) && 2671 (r2->ImmedAnswer != mDNSInterfaceMark) && (r2->ImmedAnswer != rr->ImmedAnswer) && 2672 SameResourceRecordSignature(r2, rr) && 2673 ((rr->ImmedAnswer == mDNSInterfaceMark) || IsInterfaceValidForAuthRecord(r2, rr->ImmedAnswer))) 2674 { 2675 r2->ImmedAnswer = !r2->ImmedAnswer ? rr->ImmedAnswer : mDNSInterfaceMark; 2676 } 2677 } 2678 } 2679 else if (rr->ImmedAdditional) // If we're sending this as additional, see that its whole RRSet is similarly marked 2680 { 2681 for (r2 = m->ResourceRecords; r2; r2=r2->next) 2682 { 2683 if ((r2->resrec.RecordType & kDNSRecordTypeUniqueMask) && ResourceRecordIsValidAnswer(r2) && 2684 (r2->ImmedAdditional != rr->ImmedAdditional) && 2685 SameResourceRecordSignature(r2, rr) && 2686 IsInterfaceValidForAuthRecord(r2, rr->ImmedAdditional)) 2687 { 2688 r2->ImmedAdditional = rr->ImmedAdditional; 2689 } 2690 } 2691 } 2692 } 2693 2694 // Now set SendRNow state appropriately 2695 for (rr = m->ResourceRecords; rr; rr=rr->next) 2696 { 2697 if (rr->ImmedAnswer == mDNSInterfaceMark) // Sending this record on all appropriate interfaces 2698 { 2699 rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID; 2700 rr->ImmedAdditional = mDNSNULL; // No need to send as additional if sending as answer 2701 rr->LastMCTime = m->timenow; 2702 rr->LastMCInterface = rr->ImmedAnswer; 2703 rr->ProbeRestartCount = 0; // Reset the probe restart count 2704 // If we're announcing this record, and it's at least half-way to its ordained time, then consider this announcement done 2705 if (TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2)) 2706 { 2707 rr->AnnounceCount--; 2708 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering) 2709 rr->ThisAPInterval *= 2; 2710 rr->LastAPTime = m->timenow; 2711 debugf("Announcing %##s (%s) %d", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount); 2712 } 2713 } 2714 else if (rr->ImmedAnswer) // Else, just respond to a single query on single interface: 2715 { 2716 rr->SendRNow = rr->ImmedAnswer; // Just respond on that interface 2717 rr->ImmedAdditional = mDNSNULL; // No need to send as additional too 2718 rr->LastMCTime = m->timenow; 2719 rr->LastMCInterface = rr->ImmedAnswer; 2720 } 2721 SetNextAnnounceProbeTime(m, rr); 2722 //if (rr->SendRNow) LogMsg("%-15.4a %s", &rr->v4Requester, ARDisplayString(m, rr)); 2723 } 2724 2725 // *** 2726 // *** 2. Loop through interface list, sending records as appropriate 2727 // *** 2728 2729 while (intf) 2730 { 2731 int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0; 2732 int TraceRecordSpace = (mDNS_McastTracingEnabled && MDNS_TRACER) ? DNSOpt_Header_Space + DNSOpt_TraceData_Space : 0; 2733 int numDereg = 0; 2734 int numAnnounce = 0; 2735 int numAnswer = 0; 2736 int AnoninfoSpace = 0; 2737 mDNSu8 *responseptr = m->omsg.data; 2738 mDNSu8 *newptr; 2739 InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags); 2740 2741 // First Pass. Look for: 2742 // 1. Deregistering records that need to send their goodbye packet 2743 // 2. Updated records that need to retract their old data 2744 // 3. Answers and announcements we need to send 2745 for (rr = m->ResourceRecords; rr; rr=rr->next) 2746 { 2747 2748 // Skip this interface if the record InterfaceID is *Any and the record is not 2749 // appropriate for the interface type. 2750 if ((rr->SendRNow == intf->InterfaceID) && 2751 ((rr->resrec.InterfaceID == mDNSInterface_Any) && !mDNSPlatformValidRecordForInterface(rr, intf->InterfaceID))) 2752 { 2753 rr->SendRNow = GetNextActiveInterfaceID(intf); 2754 } 2755 else if (rr->SendRNow == intf->InterfaceID) 2756 { 2757 RData *OldRData = rr->resrec.rdata; 2758 mDNSu16 oldrdlength = rr->resrec.rdlength; 2759 mDNSu8 active = (mDNSu8) 2760 (rr->resrec.RecordType != kDNSRecordTypeDeregistering && !ShouldSendGoodbyesBeforeSleep(m, intf, rr)); 2761 newptr = mDNSNULL; 2762 if (rr->NewRData && active) 2763 { 2764 // See if we should send a courtesy "goodbye" for the old data before we replace it. 2765 if (ResourceRecordIsValidAnswer(rr) && rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) 2766 { 2767 newptr = PutRR_OS_TTL(responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0); 2768 if (newptr) { responseptr = newptr; numDereg++; rr->RequireGoodbye = mDNSfalse; } 2769 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 2770 } 2771 SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); 2772 } 2773 2774 if (rr->resrec.AnonInfo) 2775 { 2776 int tmp = AnonInfoSpace(rr->resrec.AnonInfo); 2777 2778 AnoninfoSpace += tmp; 2779 // Adjust OwnerRecordSpace/TraceRecordSpace which is used by PutRR_OS_TTL below so that 2780 // we have space to put in the NSEC3 record in the authority section. 2781 OwnerRecordSpace += tmp; 2782 TraceRecordSpace += tmp; 2783 } 2784 2785 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 2786 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it 2787 newptr = PutRR_OS_TTL(responseptr, &m->omsg.h.numAnswers, &rr->resrec, active ? rr->resrec.rroriginalttl : 0); 2788 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state 2789 if (newptr) 2790 { 2791 responseptr = newptr; 2792 rr->RequireGoodbye = active; 2793 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) numDereg++; 2794 else if (rr->LastAPTime == m->timenow) numAnnounce++;else numAnswer++; 2795 } 2796 2797 if (rr->NewRData && active) 2798 SetNewRData(&rr->resrec, OldRData, oldrdlength); 2799 2800 // The first time through (pktcount==0), if this record is verified unique 2801 // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too. 2802 if (!pktcount && active && (rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && !rr->SendNSECNow) 2803 rr->SendNSECNow = mDNSInterfaceMark; 2804 2805 if (newptr) // If succeeded in sending, advance to next interface 2806 { 2807 if (rr->resrec.AnonInfo) 2808 { 2809 debugf("SendResponses: Marking %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p", ARDisplayString(m, rr), OwnerRecordSpace, 2810 TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace); 2811 rr->resrec.AnonInfo->SendNow = intf->InterfaceID; 2812 } 2813 2814 // If sending on all interfaces, go to next interface; else we're finished now 2815 if (rr->ImmedAnswer == mDNSInterfaceMark && rr->resrec.InterfaceID == mDNSInterface_Any) 2816 rr->SendRNow = GetNextActiveInterfaceID(intf); 2817 else 2818 rr->SendRNow = mDNSNULL; 2819 } 2820 } 2821 } 2822 2823 // Get the reserved space back 2824 OwnerRecordSpace -= AnoninfoSpace; 2825 TraceRecordSpace -= AnoninfoSpace; 2826 newptr = responseptr; 2827 for (rr = m->ResourceRecords; rr; rr=rr->next) 2828 { 2829 if (rr->resrec.AnonInfo && rr->resrec.AnonInfo->SendNow == intf->InterfaceID) 2830 { 2831 ResourceRecord *nsec3RR = rr->resrec.AnonInfo->nsec3RR; 2832 2833 newptr = PutRR_OS_TTL(newptr, &m->omsg.h.numAuthorities, nsec3RR, nsec3RR->rroriginalttl); 2834 if (newptr) 2835 { 2836 responseptr = newptr; 2837 debugf("SendResponses: Added NSEC3 %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p", ARDisplayString(m, rr), OwnerRecordSpace, 2838 TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace); 2839 } 2840 else 2841 { 2842 LogMsg("SendResponses: Cannot add NSEC3 %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p", ARDisplayString(m, rr), OwnerRecordSpace, 2843 TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace); 2844 } 2845 rr->resrec.AnonInfo->SendNow = mDNSNULL; 2846 } 2847 } 2848 // Second Pass. Add additional records, if there's space. 2849 newptr = responseptr; 2850 for (rr = m->ResourceRecords; rr; rr=rr->next) 2851 if (rr->ImmedAdditional == intf->InterfaceID) 2852 if (ResourceRecordIsValidAnswer(rr)) 2853 { 2854 // If we have at least one answer already in the packet, then plan to add additionals too 2855 mDNSBool SendAdditional = (m->omsg.h.numAnswers > 0); 2856 2857 // If we're not planning to send any additionals, but this record is a unique one, then 2858 // make sure we haven't already sent any other members of its RRSet -- if we have, then they 2859 // will have had the cache flush bit set, so now we need to finish the job and send the rest. 2860 if (!SendAdditional && (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)) 2861 { 2862 const AuthRecord *a; 2863 for (a = m->ResourceRecords; a; a=a->next) 2864 if (a->LastMCTime == m->timenow && 2865 a->LastMCInterface == intf->InterfaceID && 2866 SameResourceRecordSignature(a, rr)) { SendAdditional = mDNStrue; break; } 2867 } 2868 if (!SendAdditional) // If we don't want to send this after all, 2869 rr->ImmedAdditional = mDNSNULL; // then cancel its ImmedAdditional field 2870 else if (newptr) // Else, try to add it if we can 2871 { 2872 // The first time through (pktcount==0), if this record is verified unique 2873 // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too. 2874 if (!pktcount && (rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && !rr->SendNSECNow) 2875 rr->SendNSECNow = mDNSInterfaceMark; 2876 2877 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 2878 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it 2879 newptr = PutRR_OS(newptr, &m->omsg.h.numAdditionals, &rr->resrec); 2880 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state 2881 if (newptr) 2882 { 2883 responseptr = newptr; 2884 rr->ImmedAdditional = mDNSNULL; 2885 rr->RequireGoodbye = mDNStrue; 2886 // If we successfully put this additional record in the packet, we record LastMCTime & LastMCInterface. 2887 // This matters particularly in the case where we have more than one IPv6 (or IPv4) address, because otherwise, 2888 // when we see our own multicast with the cache flush bit set, if we haven't set LastMCTime, then we'll get 2889 // all concerned and re-announce our record again to make sure it doesn't get flushed from peer caches. 2890 rr->LastMCTime = m->timenow; 2891 rr->LastMCInterface = intf->InterfaceID; 2892 } 2893 } 2894 } 2895 2896 // Third Pass. Add NSEC records, if there's space. 2897 // When we're generating an NSEC record in response to a specify query for that type 2898 // (recognized by rr->SendNSECNow == intf->InterfaceID) we should really put the NSEC in the Answer Section, 2899 // not Additional Section, but for now it's easier to handle both cases in this Additional Section loop here. 2900 for (rr = m->ResourceRecords; rr; rr=rr->next) 2901 if (rr->SendNSECNow == mDNSInterfaceMark || rr->SendNSECNow == intf->InterfaceID) 2902 { 2903 AuthRecord nsec; 2904 mDNSu8 *ptr; 2905 int len; 2906 mDNS_SetupResourceRecord(&nsec, mDNSNULL, mDNSInterface_Any, kDNSType_NSEC, rr->resrec.rroriginalttl, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 2907 nsec.resrec.rrclass |= kDNSClass_UniqueRRSet; 2908 AssignDomainName(&nsec.namestorage, rr->resrec.name); 2909 ptr = nsec.rdatastorage.u.data; 2910 len = DomainNameLength(rr->resrec.name); 2911 // We have a nxt name followed by window number, window length and a window bitmap 2912 nsec.resrec.rdlength = len + 2 + NSEC_MCAST_WINDOW_SIZE; 2913 if (nsec.resrec.rdlength <= StandardAuthRDSize) 2914 { 2915 mDNSPlatformMemZero(ptr, nsec.resrec.rdlength); 2916 AssignDomainName((domainname *)ptr, rr->resrec.name); 2917 ptr += len; 2918 *ptr++ = 0; // window number 2919 *ptr++ = NSEC_MCAST_WINDOW_SIZE; // window length 2920 for (r2 = m->ResourceRecords; r2; r2=r2->next) 2921 if (ResourceRecordIsValidAnswer(r2) && SameResourceRecordNameClassInterface(r2, rr)) 2922 { 2923 if (r2->resrec.rrtype >= kDNSQType_ANY) { LogMsg("SendResponses: Can't create NSEC for record %s", ARDisplayString(m, r2)); break; } 2924 else ptr[r2->resrec.rrtype >> 3] |= 128 >> (r2->resrec.rrtype & 7); 2925 } 2926 newptr = responseptr; 2927 if (!r2) // If we successfully built our NSEC record, add it to the packet now 2928 { 2929 newptr = PutRR_OS(responseptr, &m->omsg.h.numAdditionals, &nsec.resrec); 2930 if (newptr) responseptr = newptr; 2931 } 2932 } 2933 else LogMsg("SendResponses: not enough space (%d) in authrecord for nsec", nsec.resrec.rdlength); 2934 2935 // If we successfully put the NSEC record, clear the SendNSECNow flag 2936 // If we consider this NSEC optional, then we unconditionally clear the SendNSECNow flag, even if we fail to put this additional record 2937 if (newptr || rr->SendNSECNow == mDNSInterfaceMark) 2938 { 2939 rr->SendNSECNow = mDNSNULL; 2940 // Run through remainder of list clearing SendNSECNow flag for all other records which would generate the same NSEC 2941 for (r2 = rr->next; r2; r2=r2->next) 2942 if (SameResourceRecordNameClassInterface(r2, rr)) 2943 if (r2->SendNSECNow == mDNSInterfaceMark || r2->SendNSECNow == intf->InterfaceID) 2944 r2->SendNSECNow = mDNSNULL; 2945 } 2946 } 2947 2948 if (m->omsg.h.numAnswers || m->omsg.h.numAdditionals) 2949 { 2950 // If we have data to send, add OWNER/TRACER/OWNER+TRACER option if necessary, then send packet 2951 if (OwnerRecordSpace || TraceRecordSpace) 2952 { 2953 AuthRecord opt; 2954 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 2955 opt.resrec.rrclass = NormalMaxDNSMessageData; 2956 opt.resrec.rdlength = sizeof(rdataOPT); 2957 opt.resrec.rdestimate = sizeof(rdataOPT); 2958 if (OwnerRecordSpace && TraceRecordSpace) 2959 { 2960 opt.resrec.rdlength += sizeof(rdataOPT); // Two options in this OPT record 2961 opt.resrec.rdestimate += sizeof(rdataOPT); 2962 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); 2963 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[1]); 2964 } 2965 else if (OwnerRecordSpace) 2966 { 2967 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); 2968 } 2969 else if (TraceRecordSpace) 2970 { 2971 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[0]); 2972 } 2973 newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &opt.resrec); 2974 if (newptr) 2975 { 2976 responseptr = newptr; 2977 } 2978 else if (m->omsg.h.numAnswers + m->omsg.h.numAuthorities + m->omsg.h.numAdditionals == 1) 2979 { 2980 LogInfo("SendResponses: No space in packet for %s %s OPT record (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", TraceRecordSpace ? "TRACER" : "", 2981 m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); 2982 } 2983 else 2984 { 2985 LogMsg("SendResponses: How did we fail to have space for %s %s OPT record (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", TraceRecordSpace ? "TRACER" : "", 2986 m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); 2987 } 2988 } 2989 2990 debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p", 2991 numDereg, numDereg == 1 ? "" : "s", 2992 numAnnounce, numAnnounce == 1 ? "" : "s", 2993 numAnswer, numAnswer == 1 ? "" : "s", 2994 m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID); 2995 2996 if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse); 2997 if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse); 2998 if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10); 2999 if (++pktcount >= 1000) { LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount); break; } 3000 // There might be more things to send on this interface, so go around one more time and try again. 3001 } 3002 else // Nothing more to send on this interface; go to next 3003 { 3004 const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next); 3005 #if MDNS_DEBUGMSGS && 0 3006 const char *const msg = next ? "SendResponses: Nothing more on %p; moving to %p" : "SendResponses: Nothing more on %p"; 3007 debugf(msg, intf, next); 3008 #endif 3009 intf = next; 3010 pktcount = 0; // When we move to a new interface, reset packet count back to zero -- NSEC generation logic uses it 3011 } 3012 } 3013 3014 // *** 3015 // *** 3. Cleanup: Now that everything is sent, call client callback functions, and reset state variables 3016 // *** 3017 3018 if (m->CurrentRecord) 3019 LogMsg("SendResponses ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 3020 m->CurrentRecord = m->ResourceRecords; 3021 while (m->CurrentRecord) 3022 { 3023 rr = m->CurrentRecord; 3024 m->CurrentRecord = rr->next; 3025 3026 if (rr->SendRNow) 3027 { 3028 if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P) 3029 LogInfo("SendResponses: No active interface %d to send: %d %02X %s", 3030 IID(rr->SendRNow), IID(rr->resrec.InterfaceID), rr->resrec.RecordType, ARDisplayString(m, rr)); 3031 rr->SendRNow = mDNSNULL; 3032 } 3033 3034 if (rr->ImmedAnswer || rr->resrec.RecordType == kDNSRecordTypeDeregistering) 3035 { 3036 if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client 3037 3038 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering && rr->AnnounceCount == 0) 3039 { 3040 // For Unicast, when we get the response from the server, we will call CompleteDeregistration 3041 if (!AuthRecord_uDNS(rr)) CompleteDeregistration(m, rr); // Don't touch rr after this 3042 } 3043 else 3044 { 3045 rr->ImmedAnswer = mDNSNULL; 3046 rr->ImmedUnicast = mDNSfalse; 3047 rr->v4Requester = zerov4Addr; 3048 rr->v6Requester = zerov6Addr; 3049 } 3050 } 3051 } 3052 verbosedebugf("SendResponses: Next in %ld ticks", m->NextScheduledResponse - m->timenow); 3053} 3054 3055// Calling CheckCacheExpiration() is an expensive operation because it has to look at the entire cache, 3056// so we want to be lazy about how frequently we do it. 3057// 1. If a cache record is currently referenced by *no* active questions, 3058// then we don't mind expiring it up to a minute late (who will know?) 3059// 2. Else, if a cache record is due for some of its final expiration queries, 3060// we'll allow them to be late by up to 2% of the TTL 3061// 3. Else, if a cache record has completed all its final expiration queries without success, 3062// and is expiring, and had an original TTL more than ten seconds, we'll allow it to be one second late 3063// 4. Else, it is expiring and had an original TTL of ten seconds or less (includes explicit goodbye packets), 3064// so allow at most 1/10 second lateness 3065// 5. For records with rroriginalttl set to zero, that means we really want to delete them immediately 3066// (we have a new record with DelayDelivery set, waiting for the old record to go away before we can notify clients). 3067#define CacheCheckGracePeriod(RR) ( \ 3068 ((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \ 3069 ((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \ 3070 ((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : \ 3071 ((RR)->resrec.rroriginalttl > 0 ) ? (mDNSPlatformOneSecond/10) : 0) 3072 3073#define NextCacheCheckEvent(RR) ((RR)->NextRequiredQuery + CacheCheckGracePeriod(RR)) 3074 3075mDNSexport void ScheduleNextCacheCheckTime(mDNS *const m, const mDNSu32 slot, const mDNSs32 event) 3076{ 3077 if (m->rrcache_nextcheck[slot] - event > 0) 3078 m->rrcache_nextcheck[slot] = event; 3079 if (m->NextCacheCheck - event > 0) 3080 m->NextCacheCheck = event; 3081} 3082 3083// Note: MUST call SetNextCacheCheckTimeForRecord any time we change: 3084// rr->TimeRcvd 3085// rr->resrec.rroriginalttl 3086// rr->UnansweredQueries 3087// rr->CRActiveQuestion 3088mDNSexport void SetNextCacheCheckTimeForRecord(mDNS *const m, CacheRecord *const rr) 3089{ 3090 rr->NextRequiredQuery = RRExpireTime(rr); 3091 3092 // If we have an active question, then see if we want to schedule a refresher query for this record. 3093 // Usually we expect to do four queries, at 80-82%, 85-87%, 90-92% and then 95-97% of the TTL. 3094 if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries) 3095 { 3096 rr->NextRequiredQuery -= TicksTTL(rr)/20 * (MaxUnansweredQueries - rr->UnansweredQueries); 3097 rr->NextRequiredQuery += mDNSRandom((mDNSu32)TicksTTL(rr)/50); 3098 verbosedebugf("SetNextCacheCheckTimeForRecord: NextRequiredQuery in %ld sec CacheCheckGracePeriod %d ticks for %s", 3099 (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m,rr)); 3100 } 3101 ScheduleNextCacheCheckTime(m, HashSlotFromNameHash(rr->resrec.namehash), NextCacheCheckEvent(rr)); 3102} 3103 3104#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5) 3105#define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5) 3106#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5) 3107 3108// Delay before restarting questions on a flapping interface. 3109#define kDefaultQueryDelayTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 3) 3110// After kDefaultQueryDelayTimeForFlappingInterface seconds, allow enough time for up to three queries (0, 1, and 4 seconds) 3111// plus three seconds for "response delay" before removing the reconfirmed records from the cache. 3112#define kDefaultReconfirmTimeForFlappingInterface (kDefaultQueryDelayTimeForFlappingInterface + ((mDNSu32)mDNSPlatformOneSecond * 7)) 3113 3114mDNSexport mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval) 3115{ 3116 if (interval < kMinimumReconfirmTime) 3117 interval = kMinimumReconfirmTime; 3118 if (interval > 0x10000000) // Make sure interval doesn't overflow when we multiply by four below 3119 interval = 0x10000000; 3120 3121 // If the expected expiration time for this record is more than interval+33%, then accelerate its expiration 3122 if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3)) 3123 { 3124 // Add a 33% random amount to the interval, to avoid synchronization between multiple hosts 3125 // For all the reconfirmations in a given batch, we want to use the same random value 3126 // so that the reconfirmation questions can be grouped into a single query packet 3127 if (!m->RandomReconfirmDelay) m->RandomReconfirmDelay = 1 + mDNSRandom(FutureTime); 3128 interval += m->RandomReconfirmDelay % ((interval/3) + 1); 3129 rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3; 3130 rr->resrec.rroriginalttl = (interval * 4 + mDNSPlatformOneSecond - 1) / mDNSPlatformOneSecond; 3131 SetNextCacheCheckTimeForRecord(m, rr); 3132 } 3133 debugf("mDNS_Reconfirm_internal:%6ld ticks to go for %s %p", 3134 RRExpireTime(rr) - m->timenow, CRDisplayString(m, rr), rr->CRActiveQuestion); 3135 return(mStatus_NoError); 3136} 3137 3138// BuildQuestion puts a question into a DNS Query packet and if successful, updates the value of queryptr. 3139// It also appends to the list of known answer records that need to be included, 3140// and updates the forcast for the size of the known answer section. 3141mDNSlocal mDNSBool BuildQuestion(mDNS *const m, const NetworkInterfaceInfo *intf, DNSMessage *query, mDNSu8 **queryptr, 3142 DNSQuestion *q, CacheRecord ***kalistptrptr, mDNSu32 *answerforecast) 3143{ 3144 mDNSBool ucast = (q->LargeAnswers || q->RequestUnicast) && m->CanReceiveUnicastOn5353 && intf->SupportsUnicastMDNSResponse; 3145 mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0); 3146 const mDNSu8 *const limit = query->data + NormalMaxDNSMessageData; 3147 mDNSu8 anoninfo_space = q->AnonInfo ? AnonInfoSpace(q->AnonInfo) : 0; 3148 mDNSu8 *newptr = putQuestion(query, *queryptr, limit - *answerforecast - anoninfo_space, &q->qname, q->qtype, (mDNSu16)(q->qclass | ucbit)); 3149 if (!newptr) 3150 { 3151 debugf("BuildQuestion: No more space in this packet for question %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 3152 return(mDNSfalse); 3153 } 3154 else 3155 { 3156 mDNSu32 forecast = *answerforecast + anoninfo_space; 3157 const CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 3158 CacheRecord *rr; 3159 CacheRecord **ka = *kalistptrptr; // Make a working copy of the pointer we're going to update 3160 3161 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache, 3162 if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface 3163 !(rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && // which is a shared (i.e. not unique) record type 3164 rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not already in the known answer list 3165 rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet 3166 SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question 3167 rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow > // and its half-way-to-expiry time is at least 1 second away 3168 mDNSPlatformOneSecond) // (also ensures we never include goodbye records with TTL=1) 3169 { 3170 // We don't want to include unique records in the Known Answer section. The Known Answer section 3171 // is intended to suppress floods of shared-record replies from many other devices on the network. 3172 // That concept really does not apply to unique records, and indeed if we do send a query for 3173 // which we have a unique record already in our cache, then including that unique record as a 3174 // Known Answer, so as to suppress the only answer we were expecting to get, makes little sense. 3175 3176 *ka = rr; // Link this record into our known answer chain 3177 ka = &rr->NextInKAList; 3178 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n) 3179 forecast += 12 + rr->resrec.rdestimate; 3180 // If we're trying to put more than one question in this packet, and it doesn't fit 3181 // then undo that last question and try again next time 3182 if (query->h.numQuestions > 1 && newptr + forecast >= limit) 3183 { 3184 query->h.numQuestions--; 3185 debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d, total questions %d", 3186 q->qname.c, DNSTypeName(q->qtype), newptr + forecast - query->data, query->h.numQuestions); 3187 ka = *kalistptrptr; // Go back to where we started and retract these answer records 3188 while (*ka) { CacheRecord *c = *ka; *ka = mDNSNULL; ka = &c->NextInKAList; } 3189 return(mDNSfalse); // Return false, so we'll try again in the next packet 3190 } 3191 } 3192 3193 // Success! Update our state pointers, increment UnansweredQueries as appropriate, and return 3194 *queryptr = newptr; // Update the packet pointer 3195 *answerforecast = forecast; // Update the forecast 3196 *kalistptrptr = ka; // Update the known answer list pointer 3197 if (ucast) q->ExpectUnicastResp = NonZeroTime(m->timenow); 3198 3199 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // For every resource record in our cache, 3200 if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface 3201 rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not in the known answer list 3202 SameNameRecordAnswersQuestion(&rr->resrec, q)) // which answers our question 3203 { 3204 rr->UnansweredQueries++; // indicate that we're expecting a response 3205 rr->LastUnansweredTime = m->timenow; 3206 SetNextCacheCheckTimeForRecord(m, rr); 3207 } 3208 3209 return(mDNStrue); 3210 } 3211} 3212 3213// When we have a query looking for a specified name, but there appear to be no answers with 3214// that name, ReconfirmAntecedents() is called with depth=0 to start the reconfirmation process 3215// for any records in our cache that reference the given name (e.g. PTR and SRV records). 3216// For any such cache record we find, we also recursively call ReconfirmAntecedents() for *its* name. 3217// We increment depth each time we recurse, to guard against possible infinite loops, with a limit of 5. 3218// A typical reconfirmation scenario might go like this: 3219// Depth 0: Name "myhost.local" has no address records 3220// Depth 1: SRV "My Service._example._tcp.local." refers to "myhost.local"; may be stale 3221// Depth 2: PTR "_example._tcp.local." refers to "My Service"; may be stale 3222// Depth 3: PTR "_services._dns-sd._udp.local." refers to "_example._tcp.local."; may be stale 3223// Currently depths 4 and 5 are not expected to occur; if we did get to depth 5 we'd reconfim any records we 3224// found referring to the given name, but not recursively descend any further reconfirm *their* antecedents. 3225mDNSlocal void ReconfirmAntecedents(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const int depth) 3226{ 3227 mDNSu32 slot; 3228 CacheGroup *cg; 3229 CacheRecord *cr; 3230 debugf("ReconfirmAntecedents (depth=%d) for %##s", depth, name->c); 3231 FORALL_CACHERECORDS(slot, cg, cr) 3232 { 3233 domainname *crtarget = GetRRDomainNameTarget(&cr->resrec); 3234 if (crtarget && cr->resrec.rdatahash == namehash && SameDomainName(crtarget, name)) 3235 { 3236 LogInfo("ReconfirmAntecedents: Reconfirming (depth=%d) %s", depth, CRDisplayString(m, cr)); 3237 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 3238 if (depth < 5) 3239 ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, depth+1); 3240 } 3241 } 3242} 3243 3244// If we get no answer for a AAAA query, then before doing an automatic implicit ReconfirmAntecedents 3245// we check if we have an address record for the same name. If we do have an IPv4 address for a given 3246// name but not an IPv6 address, that's okay (it just means the device doesn't do IPv6) so the failure 3247// to get a AAAA response is not grounds to doubt the PTR/SRV chain that lead us to that name. 3248mDNSlocal const CacheRecord *CacheHasAddressTypeForName(mDNS *const m, const domainname *const name, const mDNSu32 namehash) 3249{ 3250 CacheGroup *const cg = CacheGroupForName(m, namehash, name); 3251 const CacheRecord *cr = cg ? cg->members : mDNSNULL; 3252 while (cr && !RRTypeIsAddressType(cr->resrec.rrtype)) cr=cr->next; 3253 return(cr); 3254} 3255 3256 3257mDNSlocal const CacheRecord *FindSPSInCache1(mDNS *const m, const DNSQuestion *const q, const CacheRecord *const c0, const CacheRecord *const c1) 3258{ 3259#ifndef SPC_DISABLED 3260 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 3261 const CacheRecord *cr, *bestcr = mDNSNULL; 3262 mDNSu32 bestmetric = 1000000; 3263 for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next) 3264 if (cr->resrec.rrtype == kDNSType_PTR && cr->resrec.rdlength >= 6) // If record is PTR type, with long enough name, 3265 if (cr != c0 && cr != c1) // that's not one we've seen before, 3266 if (SameNameRecordAnswersQuestion(&cr->resrec, q)) // and answers our browse query, 3267 if (!IdenticalSameNameRecord(&cr->resrec, &m->SPSRecords.RR_PTR.resrec)) // and is not our own advertised service... 3268 { 3269 mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c); 3270 if (bestmetric > metric) { bestmetric = metric; bestcr = cr; } 3271 } 3272 return(bestcr); 3273#else // SPC_DISABLED 3274 (void) m; 3275 (void) q; 3276 (void) c0; 3277 (void) c1; 3278 (void) c1; 3279 return mDNSNULL; 3280#endif // SPC_DISABLED 3281} 3282 3283mDNSlocal void CheckAndSwapSPS(const CacheRecord **sps1, const CacheRecord **sps2) 3284{ 3285 const CacheRecord *swap_sps; 3286 mDNSu32 metric1, metric2; 3287 3288 if (!(*sps1) || !(*sps2)) return; 3289 metric1 = SPSMetric((*sps1)->resrec.rdata->u.name.c); 3290 metric2 = SPSMetric((*sps2)->resrec.rdata->u.name.c); 3291 if (!SPSFeatures((*sps1)->resrec.rdata->u.name.c) && SPSFeatures((*sps2)->resrec.rdata->u.name.c) && (metric2 >= metric1)) 3292 { 3293 swap_sps = *sps1; 3294 *sps1 = *sps2; 3295 *sps2 = swap_sps; 3296 } 3297} 3298 3299mDNSlocal void ReorderSPSByFeature(const CacheRecord *sps[3]) 3300{ 3301 CheckAndSwapSPS(&sps[0], &sps[1]); 3302 CheckAndSwapSPS(&sps[0], &sps[2]); 3303 CheckAndSwapSPS(&sps[1], &sps[2]); 3304} 3305 3306 3307// Finds the three best Sleep Proxies we currently have in our cache 3308mDNSexport void FindSPSInCache(mDNS *const m, const DNSQuestion *const q, const CacheRecord *sps[3]) 3309{ 3310 sps[0] = FindSPSInCache1(m, q, mDNSNULL, mDNSNULL); 3311 sps[1] = !sps[0] ? mDNSNULL : FindSPSInCache1(m, q, sps[0], mDNSNULL); 3312 sps[2] = !sps[1] ? mDNSNULL : FindSPSInCache1(m, q, sps[0], sps[1]); 3313 3314 // SPS is already sorted by metric. We want to move the entries to the beginning of the array 3315 // only if they have equally good metric and support features. 3316 ReorderSPSByFeature(sps); 3317} 3318 3319// Only DupSuppressInfos newer than the specified 'time' are allowed to remain active 3320mDNSlocal void ExpireDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time) 3321{ 3322 int i; 3323 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL; 3324} 3325 3326mDNSlocal void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time, mDNSInterfaceID InterfaceID) 3327{ 3328 int i; 3329 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL; 3330} 3331 3332mDNSlocal mDNSBool SuppressOnThisInterface(const DupSuppressInfo ds[DupSuppressInfoSize], const NetworkInterfaceInfo * const intf) 3333{ 3334 int i; 3335 mDNSBool v4 = !intf->IPv4Available; // If this interface doesn't do v4, we don't need to find a v4 duplicate of this query 3336 mDNSBool v6 = !intf->IPv6Available; // If this interface doesn't do v6, we don't need to find a v6 duplicate of this query 3337 for (i=0; i<DupSuppressInfoSize; i++) 3338 if (ds[i].InterfaceID == intf->InterfaceID) 3339 { 3340 if (ds[i].Type == mDNSAddrType_IPv4) v4 = mDNStrue; 3341 else if (ds[i].Type == mDNSAddrType_IPv6) v6 = mDNStrue; 3342 if (v4 && v6) return(mDNStrue); 3343 } 3344 return(mDNSfalse); 3345} 3346 3347mDNSlocal void RecordDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 Time, mDNSInterfaceID InterfaceID, mDNSs32 Type) 3348{ 3349 int i, j; 3350 3351 // See if we have this one in our list somewhere already 3352 for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Type == Type) break; 3353 3354 // If not, find a slot we can re-use 3355 if (i >= DupSuppressInfoSize) 3356 { 3357 i = 0; 3358 for (j=1; j<DupSuppressInfoSize && ds[i].InterfaceID; j++) 3359 if (!ds[j].InterfaceID || ds[j].Time - ds[i].Time < 0) 3360 i = j; 3361 } 3362 3363 // Record the info about this query we saw 3364 ds[i].Time = Time; 3365 ds[i].InterfaceID = InterfaceID; 3366 ds[i].Type = Type; 3367} 3368 3369mDNSlocal void mDNSSendWakeOnResolve(mDNS *const m, DNSQuestion *q) 3370{ 3371 int len, i, cnt; 3372 mDNSInterfaceID InterfaceID = q->InterfaceID; 3373 domainname *d = &q->qname; 3374 3375 // We can't send magic packets without knowing which interface to send it on. 3376 if (InterfaceID == mDNSInterface_Any || LocalOnlyOrP2PInterface(InterfaceID)) 3377 { 3378 LogMsg("mDNSSendWakeOnResolve: ERROR!! Invalid InterfaceID %p for question %##s", InterfaceID, q->qname.c); 3379 return; 3380 } 3381 3382 // Split MAC@IPAddress and pass them separately 3383 len = d->c[0]; 3384 cnt = 0; 3385 for (i = 1; i < len; i++) 3386 { 3387 if (d->c[i] == '@') 3388 { 3389 char EthAddr[18]; // ethernet adddress : 12 bytes + 5 ":" + 1 NULL byte 3390 char IPAddr[47]; // Max IP address len: 46 bytes (IPv6) + 1 NULL byte 3391 if (cnt != 5) 3392 { 3393 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, cnt %d", q->qname.c, cnt); 3394 return; 3395 } 3396 if ((i - 1) > (int) (sizeof(EthAddr) - 1)) 3397 { 3398 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, length %d", q->qname.c, i - 1); 3399 return; 3400 } 3401 if ((len - i) > (int)(sizeof(IPAddr) - 1)) 3402 { 3403 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed IP address %##s, length %d", q->qname.c, len - i); 3404 return; 3405 } 3406 mDNSPlatformMemCopy(EthAddr, &d->c[1], i - 1); 3407 EthAddr[i - 1] = 0; 3408 mDNSPlatformMemCopy(IPAddr, &d->c[i + 1], len - i); 3409 IPAddr[len - i] = 0; 3410 m->mDNSStats.WakeOnResolves++; 3411 mDNSPlatformSendWakeupPacket(InterfaceID, EthAddr, IPAddr, InitialWakeOnResolveCount - q->WakeOnResolveCount); 3412 return; 3413 } 3414 else if (d->c[i] == ':') 3415 cnt++; 3416 } 3417 LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed WakeOnResolve name %##s", q->qname.c); 3418} 3419 3420 3421mDNSlocal mDNSBool AccelerateThisQuery(mDNS *const m, DNSQuestion *q) 3422{ 3423 // If more than 90% of the way to the query time, we should unconditionally accelerate it 3424 if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/10)) 3425 return(mDNStrue); 3426 3427 // If half-way to next scheduled query time, only accelerate if it will add less than 512 bytes to the packet 3428 if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/2)) 3429 { 3430 // We forecast: qname (n) type (2) class (2) 3431 mDNSu32 forecast = (mDNSu32)DomainNameLength(&q->qname) + 4; 3432 const CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 3433 const CacheRecord *rr; 3434 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache, 3435 if (rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet 3436 SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question 3437 rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && // and it is less than half-way to expiry 3438 rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0) // and we'll ask at least once again before NextRequiredQuery 3439 { 3440 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n) 3441 forecast += 12 + rr->resrec.rdestimate; 3442 if (forecast >= 512) return(mDNSfalse); // If this would add 512 bytes or more to the packet, don't accelerate 3443 } 3444 return(mDNStrue); 3445 } 3446 3447 return(mDNSfalse); 3448} 3449 3450// How Standard Queries are generated: 3451// 1. The Question Section contains the question 3452// 2. The Additional Section contains answers we already know, to suppress duplicate responses 3453 3454// How Probe Queries are generated: 3455// 1. The Question Section contains queries for the name we intend to use, with QType=ANY because 3456// if some other host is already using *any* records with this name, we want to know about it. 3457// 2. The Authority Section contains the proposed values we intend to use for one or more 3458// of our records with that name (analogous to the Update section of DNS Update packets) 3459// because if some other host is probing at the same time, we each want to know what the other is 3460// planning, in order to apply the tie-breaking rule to see who gets to use the name and who doesn't. 3461 3462mDNSlocal void SendQueries(mDNS *const m) 3463{ 3464 mDNSu32 slot; 3465 CacheGroup *cg; 3466 CacheRecord *cr; 3467 AuthRecord *ar; 3468 int pktcount = 0; 3469 DNSQuestion *q; 3470 // For explanation of maxExistingQuestionInterval logic, see comments for maxExistingAnnounceInterval 3471 mDNSs32 maxExistingQuestionInterval = 0; 3472 const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces); 3473 CacheRecord *KnownAnswerList = mDNSNULL; 3474 3475 // 1. If time for a query, work out what we need to do 3476 3477 // We're expecting to send a query anyway, so see if any expiring cache records are close enough 3478 // to their NextRequiredQuery to be worth batching them together with this one 3479 FORALL_CACHERECORDS(slot, cg, cr) 3480 { 3481 if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries) 3482 { 3483 if (m->timenow + TicksTTL(cr)/50 - cr->NextRequiredQuery >= 0) 3484 { 3485 debugf("Sending %d%% cache expiration query for %s", 80 + 5 * cr->UnansweredQueries, CRDisplayString(m, cr)); 3486 q = cr->CRActiveQuestion; 3487 ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(cr)/20, cr->resrec.InterfaceID); 3488 // For uDNS queries (TargetQID non-zero) we adjust LastQTime, 3489 // and bump UnansweredQueries so that we don't spin trying to send the same cache expiration query repeatedly 3490 if (q->Target.type) 3491 { 3492 q->SendQNow = mDNSInterfaceMark; // If targeted query, mark it 3493 } 3494 else if (!mDNSOpaque16IsZero(q->TargetQID)) 3495 { 3496 q->LastQTime = m->timenow - q->ThisQInterval; 3497 cr->UnansweredQueries++; 3498 m->mDNSStats.CacheRefreshQueries++; 3499 } 3500 else if (q->SendQNow == mDNSNULL) 3501 { 3502 q->SendQNow = cr->resrec.InterfaceID; 3503 } 3504 else if (q->SendQNow != cr->resrec.InterfaceID) 3505 { 3506 q->SendQNow = mDNSInterfaceMark; 3507 } 3508 3509 // Indicate that this question was marked for sending 3510 // to update an existing cached answer record. 3511 // The browse throttling logic below uses this to determine 3512 // if the query should be sent. 3513 if (mDNSOpaque16IsZero(q->TargetQID)) 3514 q->CachedAnswerNeedsUpdate = mDNStrue; 3515 } 3516 } 3517 } 3518 3519 // Scan our list of questions to see which: 3520 // *WideArea* queries need to be sent 3521 // *unicast* queries need to be sent 3522 // *multicast* queries we're definitely going to send 3523 if (m->CurrentQuestion) 3524 LogMsg("SendQueries ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 3525 m->CurrentQuestion = m->Questions; 3526 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) 3527 { 3528 q = m->CurrentQuestion; 3529 if (q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow))) 3530 { 3531 mDNSu8 *qptr = m->omsg.data; 3532 const mDNSu8 *const limit = m->omsg.data + sizeof(m->omsg.data); 3533 3534 // 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 3535 if (!q->LocalSocket) q->LocalSocket = mDNSPlatformUDPSocket(zeroIPPort); 3536 if (q->LocalSocket) 3537 { 3538 InitializeDNSMessage(&m->omsg.h, q->TargetQID, QueryFlags); 3539 qptr = putQuestion(&m->omsg, qptr, limit, &q->qname, q->qtype, q->qclass); 3540 mDNSSendDNSMessage(m, &m->omsg, qptr, mDNSInterface_Any, q->LocalSocket, &q->Target, q->TargetPort, mDNSNULL, mDNSNULL, q->UseBackgroundTrafficClass); 3541 q->ThisQInterval *= QuestionIntervalStep; 3542 } 3543 if (q->ThisQInterval > MaxQuestionInterval) 3544 q->ThisQInterval = MaxQuestionInterval; 3545 q->LastQTime = m->timenow; 3546 q->LastQTxTime = m->timenow; 3547 q->RecentAnswerPkts = 0; 3548 q->SendQNow = mDNSNULL; 3549 q->ExpectUnicastResp = NonZeroTime(m->timenow); 3550 } 3551 else if (mDNSOpaque16IsZero(q->TargetQID) && !q->Target.type && TimeToSendThisQuestion(q, m->timenow)) 3552 { 3553 //LogInfo("Time to send %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - NextQSendTime(q)); 3554 q->SendQNow = mDNSInterfaceMark; // Mark this question for sending on all interfaces 3555 if (maxExistingQuestionInterval < q->ThisQInterval) 3556 maxExistingQuestionInterval = q->ThisQInterval; 3557 } 3558 // If m->CurrentQuestion wasn't modified out from under us, advance it now 3559 // We can't do this at the start of the loop because uDNS_CheckCurrentQuestion() depends on having 3560 // m->CurrentQuestion point to the right question 3561 if (q == m->CurrentQuestion) m->CurrentQuestion = m->CurrentQuestion->next; 3562 } 3563 while (m->CurrentQuestion) 3564 { 3565 LogInfo("SendQueries question loop 1: Skipping NewQuestion %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 3566 m->CurrentQuestion = m->CurrentQuestion->next; 3567 } 3568 m->CurrentQuestion = mDNSNULL; 3569 3570 // Scan our list of questions 3571 // (a) to see if there are any more that are worth accelerating, and 3572 // (b) to update the state variables for *all* the questions we're going to send 3573 // Note: Don't set NextScheduledQuery until here, because uDNS_CheckCurrentQuestion in the loop above can add new questions to the list, 3574 // which causes NextScheduledQuery to get (incorrectly) set to m->timenow. Setting it here is the right place, because the very 3575 // 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. 3576 m->NextScheduledQuery = m->timenow + FutureTime; 3577 for (q = m->Questions; q && q != m->NewQuestions; q=q->next) 3578 { 3579 if (mDNSOpaque16IsZero(q->TargetQID) 3580 && (q->SendQNow || (!q->Target.type && ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q)))) 3581 { 3582 // If at least halfway to next query time, advance to next interval 3583 // If less than halfway to next query time, then 3584 // treat this as logically a repeat of the last transmission, without advancing the interval 3585 if (m->timenow - (q->LastQTime + (q->ThisQInterval/2)) >= 0) 3586 { 3587 // If we have reached the answer threshold for this question, 3588 // don't send it again until MaxQuestionInterval unless: 3589 // one of its cached answers needs to be refreshed, 3590 // or it's the initial query for a kDNSServiceFlagsThresholdFinder mode browse. 3591 if (q->BrowseThreshold 3592 && (q->CurrentAnswers >= q->BrowseThreshold) 3593 && (q->CachedAnswerNeedsUpdate == mDNSfalse) 3594 && !((q->flags & kDNSServiceFlagsThresholdFinder) && (q->ThisQInterval == InitialQuestionInterval))) 3595 { 3596 q->SendQNow = mDNSNULL; 3597 q->ThisQInterval = MaxQuestionInterval; 3598 q->LastQTime = m->timenow; 3599 q->RequestUnicast = 0; 3600 LogInfo("SendQueries: (%s) %##s reached threshold of %d answers", 3601 DNSTypeName(q->qtype), q->qname.c, q->BrowseThreshold); 3602 } 3603 else 3604 { 3605 // Mark this question for sending on all interfaces 3606 q->SendQNow = mDNSInterfaceMark; 3607 q->ThisQInterval *= QuestionIntervalStep; 3608 } 3609 3610 debugf("SendQueries: %##s (%s) next interval %d seconds RequestUnicast = %d", 3611 q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval / InitialQuestionInterval, q->RequestUnicast); 3612 3613 if (q->ThisQInterval > MaxQuestionInterval) 3614 { 3615 q->ThisQInterval = MaxQuestionInterval; 3616 } 3617 else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * QuestionIntervalStep3 && !q->RequestUnicast && 3618 !(RRTypeIsAddressType(q->qtype) && CacheHasAddressTypeForName(m, &q->qname, q->qnamehash))) 3619 { 3620 // Generally don't need to log this. 3621 // It's not especially noteworthy if a query finds no results -- this usually happens for domain 3622 // enumeration queries in the LL subdomain (e.g. "db._dns-sd._udp.0.0.254.169.in-addr.arpa") 3623 // and when there simply happen to be no instances of the service the client is looking 3624 // for (e.g. iTunes is set to look for RAOP devices, and the current network has none). 3625 debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents", 3626 q->qname.c, DNSTypeName(q->qtype)); 3627 // Sending third query, and no answers yet; time to begin doubting the source 3628 ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0); 3629 } 3630 } 3631 3632 // Mark for sending. (If no active interfaces, then don't even try.) 3633 q->SendOnAll = (q->SendQNow == mDNSInterfaceMark); 3634 if (q->SendOnAll) 3635 { 3636 q->SendQNow = !intf ? mDNSNULL : (q->InterfaceID) ? q->InterfaceID : intf->InterfaceID; 3637 q->LastQTime = m->timenow; 3638 } 3639 3640 // If we recorded a duplicate suppression for this question less than half an interval ago, 3641 // then we consider it recent enough that we don't need to do an identical query ourselves. 3642 ExpireDupSuppressInfo(q->DupSuppress, m->timenow - q->ThisQInterval/2); 3643 3644 q->LastQTxTime = m->timenow; 3645 q->RecentAnswerPkts = 0; 3646 if (q->RequestUnicast) q->RequestUnicast--; 3647 } 3648 // For all questions (not just the ones we're sending) check what the next scheduled event will be 3649 // We don't need to consider NewQuestions here because for those we'll set m->NextScheduledQuery in AnswerNewQuestion 3650 SetNextQueryTime(m,q); 3651 } 3652 3653 // 2. Scan our authoritative RR list to see what probes we might need to send 3654 3655 m->NextScheduledProbe = m->timenow + FutureTime; 3656 3657 if (m->CurrentRecord) 3658 LogMsg("SendQueries ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 3659 m->CurrentRecord = m->ResourceRecords; 3660 while (m->CurrentRecord) 3661 { 3662 ar = m->CurrentRecord; 3663 m->CurrentRecord = ar->next; 3664 if (!AuthRecord_uDNS(ar) && ar->resrec.RecordType == kDNSRecordTypeUnique) // For all records that are still probing... 3665 { 3666 // 1. If it's not reached its probe time, just make sure we update m->NextScheduledProbe correctly 3667 if (m->timenow - (ar->LastAPTime + ar->ThisAPInterval) < 0) 3668 { 3669 SetNextAnnounceProbeTime(m, ar); 3670 } 3671 // 2. else, if it has reached its probe time, mark it for sending and then update m->NextScheduledProbe correctly 3672 else if (ar->ProbeCount) 3673 { 3674 if (ar->AddressProxy.type == mDNSAddrType_IPv4) 3675 { 3676 // There's a problem here. If a host is waking up, and we probe to see if it responds, then 3677 // it will see those ARP probes as signalling intent to use the address, so it picks a different one. 3678 // A more benign way to find out if a host is responding to ARPs might be send a standard ARP *request* 3679 // (using our sender IP address) instead of an ARP *probe* (using all-zero sender IP address). 3680 // A similar concern may apply to the NDP Probe too. -- SC 3681 LogSPS("SendQueries ARP Probe %d %s %s", ar->ProbeCount, InterfaceNameForID(m, ar->resrec.InterfaceID), ARDisplayString(m,ar)); 3682 SendARP(m, 1, ar, &zerov4Addr, &zeroEthAddr, &ar->AddressProxy.ip.v4, &ar->WakeUp.IMAC); 3683 } 3684 else if (ar->AddressProxy.type == mDNSAddrType_IPv6) 3685 { 3686 LogSPS("SendQueries NDP Probe %d %s %s", ar->ProbeCount, InterfaceNameForID(m, ar->resrec.InterfaceID), ARDisplayString(m,ar)); 3687 // IPv6 source = zero 3688 // No target hardware address 3689 // IPv6 target address is address we're probing 3690 // Ethernet destination address is Ethernet interface address of the Sleep Proxy client we're probing 3691 SendNDP(m, NDP_Sol, 0, ar, &zerov6Addr, mDNSNULL, &ar->AddressProxy.ip.v6, &ar->WakeUp.IMAC); 3692 } 3693 // Mark for sending. (If no active interfaces, then don't even try.) 3694 ar->SendRNow = (!intf || ar->WakeUp.HMAC.l[0]) ? mDNSNULL : ar->resrec.InterfaceID ? ar->resrec.InterfaceID : intf->InterfaceID; 3695 ar->LastAPTime = m->timenow; 3696 // When we have a late conflict that resets a record to probing state we use a special marker value greater 3697 // than DefaultProbeCountForTypeUnique. Here we detect that state and reset ar->ProbeCount back to the right value. 3698 if (ar->ProbeCount > DefaultProbeCountForTypeUnique) 3699 ar->ProbeCount = DefaultProbeCountForTypeUnique; 3700 ar->ProbeCount--; 3701 SetNextAnnounceProbeTime(m, ar); 3702 if (ar->ProbeCount == 0) 3703 { 3704 // If this is the last probe for this record, then see if we have any matching records 3705 // on our duplicate list which should similarly have their ProbeCount cleared to zero... 3706 AuthRecord *r2; 3707 for (r2 = m->DuplicateRecords; r2; r2=r2->next) 3708 if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, ar)) 3709 r2->ProbeCount = 0; 3710 // ... then acknowledge this record to the client. 3711 // We do this optimistically, just as we're about to send the third probe. 3712 // This helps clients that both advertise and browse, and want to filter themselves 3713 // from the browse results list, because it helps ensure that the registration 3714 // confirmation will be delivered 1/4 second *before* the browse "add" event. 3715 // A potential downside is that we could deliver a registration confirmation and then find out 3716 // moments later that there's a name conflict, but applications have to be prepared to handle 3717 // late conflicts anyway (e.g. on connection of network cable, etc.), so this is nothing new. 3718 if (!ar->Acknowledged) AcknowledgeRecord(m, ar); 3719 } 3720 } 3721 // else, if it has now finished probing, move it to state Verified, 3722 // and update m->NextScheduledResponse so it will be announced 3723 else 3724 { 3725 if (!ar->Acknowledged) AcknowledgeRecord(m, ar); // Defensive, just in case it got missed somehow 3726 ar->resrec.RecordType = kDNSRecordTypeVerified; 3727 ar->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique; 3728 ar->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique; 3729 SetNextAnnounceProbeTime(m, ar); 3730 } 3731 } 3732 } 3733 m->CurrentRecord = m->DuplicateRecords; 3734 while (m->CurrentRecord) 3735 { 3736 ar = m->CurrentRecord; 3737 m->CurrentRecord = ar->next; 3738 if (ar->resrec.RecordType == kDNSRecordTypeUnique && ar->ProbeCount == 0 && !ar->Acknowledged) 3739 AcknowledgeRecord(m, ar); 3740 } 3741 3742 // 3. Now we know which queries and probes we're sending, 3743 // go through our interface list sending the appropriate queries on each interface 3744 while (intf) 3745 { 3746 int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0; 3747 int TraceRecordSpace = (mDNS_McastTracingEnabled && MDNS_TRACER) ? DNSOpt_Header_Space + DNSOpt_TraceData_Space : 0; 3748 mDNSu8 *queryptr = m->omsg.data; 3749 mDNSBool useBackgroundTrafficClass = mDNSfalse; // set if we should use background traffic class 3750 3751 InitializeDNSMessage(&m->omsg.h, zeroID, QueryFlags); 3752 if (KnownAnswerList) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet"); 3753 if (!KnownAnswerList) 3754 { 3755 // Start a new known-answer list 3756 CacheRecord **kalistptr = &KnownAnswerList; 3757 mDNSu32 answerforecast = OwnerRecordSpace + TraceRecordSpace; // Start by assuming we'll need at least enough space to put the Owner+Tracer Option 3758 3759 // Put query questions in this packet 3760 for (q = m->Questions; q && q != m->NewQuestions; q=q->next) 3761 { 3762 if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow == intf->InterfaceID)) 3763 { 3764 mDNSBool Suppress = mDNSfalse; 3765 debugf("SendQueries: %s question for %##s (%s) at %d forecast total %d", 3766 SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting ", 3767 q->qname.c, DNSTypeName(q->qtype), queryptr - m->omsg.data, queryptr + answerforecast - m->omsg.data); 3768 3769 // If interface is P2P type, verify that query should be sent over it. 3770 if (!mDNSPlatformValidQuestionForInterface(q, intf)) 3771 { 3772 q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf); 3773 } 3774 // If we're suppressing this question, or we successfully put it, update its SendQNow state 3775 else if ((Suppress = SuppressOnThisInterface(q->DupSuppress, intf)) || 3776 BuildQuestion(m, intf, &m->omsg, &queryptr, q, &kalistptr, &answerforecast)) 3777 { 3778 // We successfully added the question to the packet. Make sure that 3779 // we also send the NSEC3 record if required. BuildQuestion accounted for 3780 // the space. 3781 // 3782 // Note: We don't suppress anonymous questions and hence Suppress should always 3783 // be zero. 3784 3785 if (Suppress) 3786 m->mDNSStats.DupQuerySuppressions++; 3787 3788 if (!Suppress && q->AnonInfo) 3789 { 3790 debugf("SendQueries: marking for question %##s, Suppress %d", q->qname.c, Suppress); 3791 q->AnonInfo->SendNow = intf->InterfaceID; 3792 } 3793 q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf); 3794 if (q->WakeOnResolveCount) 3795 { 3796 mDNSSendWakeOnResolve(m, q); 3797 q->WakeOnResolveCount--; 3798 } 3799 3800 // use background traffic class if any included question requires it 3801 if (q->UseBackgroundTrafficClass) 3802 { 3803 useBackgroundTrafficClass = mDNStrue; 3804 } 3805 } 3806 } 3807 } 3808 3809 // Put probe questions in this packet 3810 for (ar = m->ResourceRecords; ar; ar=ar->next) 3811 { 3812 if (ar->SendRNow != intf->InterfaceID) 3813 continue; 3814 3815 // If interface is a P2P variant, verify that the probe should be sent over it. 3816 if (!mDNSPlatformValidRecordForInterface(ar, intf->InterfaceID)) 3817 { 3818 ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf); 3819 ar->IncludeInProbe = mDNSfalse; 3820 } 3821 else 3822 { 3823 mDNSBool ucast = (ar->ProbeCount >= DefaultProbeCountForTypeUnique-1) && m->CanReceiveUnicastOn5353 && intf->SupportsUnicastMDNSResponse; 3824 mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0); 3825 const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.numQuestions ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData); 3826 // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n) 3827 mDNSu32 forecast = answerforecast + 12 + ar->resrec.rdestimate; 3828 mDNSBool putProbe = mDNStrue; 3829 mDNSu16 qclass = ar->resrec.rrclass | ucbit; 3830 3831 {// Determine if this probe question is already in packet's dns message 3832 const mDNSu8 *questionptr = m->omsg.data; 3833 DNSQuestion question; 3834 mDNSu16 n; 3835 for (n = 0; n < m->omsg.h.numQuestions && questionptr; n++) 3836 { 3837 questionptr = getQuestion(&m->omsg, questionptr, limit, mDNSInterface_Any, &question); 3838 if (questionptr && (question.qtype == kDNSQType_ANY) && (question.qclass == qclass) && 3839 (question.qnamehash == ar->resrec.namehash) && SameDomainName(&question.qname, ar->resrec.name)) 3840 { 3841 putProbe = mDNSfalse; // set to false if already in message 3842 break; 3843 } 3844 } 3845 } 3846 3847 if (putProbe) 3848 { 3849 mDNSu8 *newptr = putQuestion(&m->omsg, queryptr, limit - forecast, ar->resrec.name, kDNSQType_ANY, qclass); 3850 if (newptr) 3851 { 3852 queryptr = newptr; 3853 answerforecast = forecast; 3854 ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf); 3855 ar->IncludeInProbe = mDNStrue; 3856 verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d InterfaceID= %d %d %d", 3857 ar->resrec.name->c, DNSTypeName(ar->resrec.rrtype), ar->ProbeCount, ar->resrec.InterfaceID, ar->resrec.rdestimate, answerforecast); 3858 } 3859 } 3860 else 3861 { 3862 ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf); 3863 ar->IncludeInProbe = mDNStrue; 3864 } 3865 } 3866 } 3867 } 3868 3869 // Put our known answer list (either new one from this question or questions, or remainder of old one from last time) 3870 while (KnownAnswerList) 3871 { 3872 CacheRecord *ka = KnownAnswerList; 3873 mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - ka->TimeRcvd)) / mDNSPlatformOneSecond; 3874 mDNSu8 *newptr = PutResourceRecordTTLWithLimit(&m->omsg, queryptr, &m->omsg.h.numAnswers, &ka->resrec, ka->resrec.rroriginalttl - SecsSinceRcvd, 3875 m->omsg.data + NormalMaxDNSMessageData - OwnerRecordSpace - TraceRecordSpace); 3876 if (newptr) 3877 { 3878 verbosedebugf("SendQueries: Put %##s (%s) at %d - %d", 3879 ka->resrec.name->c, DNSTypeName(ka->resrec.rrtype), queryptr - m->omsg.data, newptr - m->omsg.data); 3880 queryptr = newptr; 3881 KnownAnswerList = ka->NextInKAList; 3882 ka->NextInKAList = mDNSNULL; 3883 } 3884 else 3885 { 3886 // If we ran out of space and we have more than one question in the packet, that's an error -- 3887 // we shouldn't have put more than one question if there was a risk of us running out of space. 3888 if (m->omsg.h.numQuestions > 1) 3889 LogMsg("SendQueries: Put %d answers; No more space for known answers", m->omsg.h.numAnswers); 3890 m->omsg.h.flags.b[0] |= kDNSFlag0_TC; 3891 break; 3892 } 3893 } 3894 3895 for (ar = m->ResourceRecords; ar; ar=ar->next) 3896 { 3897 if (ar->IncludeInProbe) 3898 { 3899 mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, &ar->resrec); 3900 ar->IncludeInProbe = mDNSfalse; 3901 if (newptr) queryptr = newptr; 3902 else LogMsg("SendQueries: How did we fail to have space for the Update record %s", ARDisplayString(m,ar)); 3903 } 3904 } 3905 3906 for (q = m->Questions; q; q = q->next) 3907 { 3908 if (q->AnonInfo && q->AnonInfo->SendNow == intf->InterfaceID) 3909 { 3910 mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, q->AnonInfo->nsec3RR); 3911 if (newptr) 3912 { 3913 debugf("SendQueries: Added NSEC3 record %s on InterfaceID %p", RRDisplayString(m, q->AnonInfo->nsec3RR), intf->InterfaceID); 3914 queryptr = newptr; 3915 } 3916 else 3917 { 3918 LogMsg("SendQueries: ERROR!! Cannot add NSEC3 record %s on InterfaceID %p", RRDisplayString(m, q->AnonInfo->nsec3RR), intf->InterfaceID); 3919 } 3920 q->AnonInfo->SendNow = mDNSNULL; 3921 } 3922 } 3923 3924 if (queryptr > m->omsg.data) 3925 { 3926 // If we have data to send, add OWNER/TRACER/OWNER+TRACER option if necessary, then send packet 3927 if (OwnerRecordSpace || TraceRecordSpace) 3928 { 3929 AuthRecord opt; 3930 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 3931 opt.resrec.rrclass = NormalMaxDNSMessageData; 3932 opt.resrec.rdlength = sizeof(rdataOPT); 3933 opt.resrec.rdestimate = sizeof(rdataOPT); 3934 if (OwnerRecordSpace && TraceRecordSpace) 3935 { 3936 opt.resrec.rdlength += sizeof(rdataOPT); // Two options in this OPT record 3937 opt.resrec.rdestimate += sizeof(rdataOPT); 3938 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); 3939 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[1]); 3940 } 3941 else if (OwnerRecordSpace) 3942 { 3943 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); 3944 } 3945 else if (TraceRecordSpace) 3946 { 3947 SetupTracerOpt(m, &opt.resrec.rdata->u.opt[0]); 3948 } 3949 queryptr = PutResourceRecordTTLWithLimit(&m->omsg, queryptr, &m->omsg.h.numAdditionals, 3950 &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); 3951 if (!queryptr) 3952 { 3953 LogMsg("SendQueries: How did we fail to have space for %s %s OPT record (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", TraceRecordSpace ? "TRACER" : "", 3954 m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); 3955 } 3956 if (queryptr > m->omsg.data + NormalMaxDNSMessageData) 3957 { 3958 if (m->omsg.h.numQuestions != 1 || m->omsg.h.numAnswers != 0 || m->omsg.h.numAuthorities != 1 || m->omsg.h.numAdditionals != 1) 3959 LogMsg("SendQueries: Why did we generate oversized packet with %s %s OPT record %p %p %p (%d/%d/%d/%d) %s", OwnerRecordSpace ? "OWNER" : "", 3960 TraceRecordSpace ? "TRACER" : "", m->omsg.data, m->omsg.data + NormalMaxDNSMessageData, queryptr, m->omsg.h.numQuestions, m->omsg.h.numAnswers, 3961 m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); 3962 } 3963 } 3964 3965 if ((m->omsg.h.flags.b[0] & kDNSFlag0_TC) && m->omsg.h.numQuestions > 1) 3966 LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet", m->omsg.h.numQuestions); 3967 debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p", 3968 m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s", 3969 m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s", 3970 m->omsg.h.numAuthorities, m->omsg.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID); 3971 if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL, useBackgroundTrafficClass); 3972 if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL, useBackgroundTrafficClass); 3973 if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10); 3974 if (++pktcount >= 1000) 3975 { LogMsg("SendQueries exceeded loop limit %d: giving up", pktcount); break; } 3976 // There might be more records left in the known answer list, or more questions to send 3977 // on this interface, so go around one more time and try again. 3978 } 3979 else // Nothing more to send on this interface; go to next 3980 { 3981 const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next); 3982 #if MDNS_DEBUGMSGS && 0 3983 const char *const msg = next ? "SendQueries: Nothing more on %p; moving to %p" : "SendQueries: Nothing more on %p"; 3984 debugf(msg, intf, next); 3985 #endif 3986 intf = next; 3987 } 3988 } 3989 3990 // 4. Final housekeeping 3991 3992 // 4a. Debugging check: Make sure we announced all our records 3993 for (ar = m->ResourceRecords; ar; ar=ar->next) 3994 if (ar->SendRNow) 3995 { 3996 if (ar->ARType != AuthRecordLocalOnly && ar->ARType != AuthRecordP2P) 3997 LogInfo("SendQueries: No active interface %d to send probe: %d %s", 3998 IID(ar->SendRNow), IID(ar->resrec.InterfaceID), ARDisplayString(m, ar)); 3999 ar->SendRNow = mDNSNULL; 4000 } 4001 4002 // 4b. When we have lingering cache records that we're keeping around for a few seconds in the hope 4003 // that their interface which went away might come back again, the logic will want to send queries 4004 // for those records, but we can't because their interface isn't here any more, so to keep the 4005 // state machine ticking over we just pretend we did so. 4006 // If the interface does not come back in time, the cache record will expire naturally 4007 FORALL_CACHERECORDS(slot, cg, cr) 4008 { 4009 if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries) 4010 { 4011 if (m->timenow + TicksTTL(cr)/50 - cr->NextRequiredQuery >= 0) 4012 { 4013 cr->UnansweredQueries++; 4014 cr->CRActiveQuestion->SendQNow = mDNSNULL; 4015 SetNextCacheCheckTimeForRecord(m, cr); 4016 } 4017 } 4018 } 4019 4020 // 4c. Debugging check: Make sure we sent all our planned questions 4021 // Do this AFTER the lingering cache records check above, because that will prevent spurious warnings for questions 4022 // we legitimately couldn't send because the interface is no longer available 4023 for (q = m->Questions; q; q=q->next) 4024 { 4025 if (q->SendQNow) 4026 { 4027 DNSQuestion *x; 4028 for (x = m->NewQuestions; x; x=x->next) if (x == q) break; // Check if this question is a NewQuestion 4029 // There will not be an active interface for questions applied to mDNSInterface_BLE 4030 // so don't log the warning in that case. 4031 if (q->InterfaceID != mDNSInterface_BLE) 4032 LogInfo("SendQueries: No active interface %d to send %s question: %d %##s (%s)", 4033 IID(q->SendQNow), x ? "new" : "old", IID(q->InterfaceID), q->qname.c, DNSTypeName(q->qtype)); 4034 q->SendQNow = mDNSNULL; 4035 } 4036 q->CachedAnswerNeedsUpdate = mDNSfalse; 4037 } 4038} 4039 4040mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password, mDNSBool unicastOnly) 4041{ 4042 int i, j; 4043 4044 mDNSu8 *ptr = m->omsg.data; 4045 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 4046 if (!intf) { LogMsg("SendARP: No interface with InterfaceID %p found", InterfaceID); return; } 4047 4048 // 0x00 Destination address 4049 for (i=0; i<6; i++) *ptr++ = EthAddr->b[i]; 4050 4051 // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us) 4052 for (i=0; i<6; i++) *ptr++ = intf->MAC.b[0]; 4053 4054 // 0x0C Ethertype (0x0842) 4055 *ptr++ = 0x08; 4056 *ptr++ = 0x42; 4057 4058 // 0x0E Wakeup sync sequence 4059 for (i=0; i<6; i++) *ptr++ = 0xFF; 4060 4061 // 0x14 Wakeup data 4062 for (j=0; j<16; j++) for (i=0; i<6; i++) *ptr++ = EthAddr->b[i]; 4063 4064 // 0x74 Password 4065 for (i=0; i<6; i++) *ptr++ = password->b[i]; 4066 4067 mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID); 4068 4069 if (!unicastOnly) 4070 { 4071 // For Ethernet switches that don't flood-foward packets with unknown unicast destination MAC addresses, 4072 // broadcast is the only reliable way to get a wakeup packet to the intended target machine. 4073 // For 802.11 WPA networks, where a sleeping target machine may have missed a broadcast/multicast 4074 // key rotation, unicast is the only way to get a wakeup packet to the intended target machine. 4075 // So, we send one of each, unicast first, then broadcast second. 4076 for (i=0; i<6; i++) m->omsg.data[i] = 0xFF; 4077 mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID); 4078 } 4079} 4080 4081// *************************************************************************** 4082#if COMPILER_LIKES_PRAGMA_MARK 4083#pragma mark - 4084#pragma mark - RR List Management & Task Management 4085#endif 4086 4087// Whenever a question is answered, reset its state so that we don't query 4088// the network repeatedly. This happens first time when we answer the question and 4089// and later when we refresh the cache. 4090mDNSlocal void ResetQuestionState(mDNS *const m, DNSQuestion *q) 4091{ 4092 q->LastQTime = m->timenow; 4093 q->LastQTxTime = m->timenow; 4094 q->RecentAnswerPkts = 0; 4095 q->ThisQInterval = MaxQuestionInterval; 4096 q->RequestUnicast = 0; 4097 // Reset unansweredQueries so that we don't penalize this server later when we 4098 // start sending queries when the cache expires. 4099 q->unansweredQueries = 0; 4100 debugf("ResetQuestionState: Set MaxQuestionInterval for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4101} 4102 4103// Note: AnswerCurrentQuestionWithResourceRecord can call a user callback, which may change the record list and/or question list. 4104// Any code walking either list must use the m->CurrentQuestion (and possibly m->CurrentRecord) mechanism to protect against this. 4105// In fact, to enforce this, the routine will *only* answer the question currently pointed to by m->CurrentQuestion, 4106// which will be auto-advanced (possibly to NULL) if the client callback cancels the question. 4107mDNSexport void AnswerCurrentQuestionWithResourceRecord(mDNS *const m, CacheRecord *const rr, const QC_result AddRecord) 4108{ 4109 DNSQuestion *const q = m->CurrentQuestion; 4110 const mDNSBool followcname = FollowCNAME(q, &rr->resrec, AddRecord); 4111 4112 verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s", 4113 q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, CRDisplayString(m, rr)); 4114 4115 // When the response for the question was validated, the entire rrset was validated. If we deliver 4116 // a RMV for a single record in the rrset, we invalidate the response. If we deliver another add 4117 // in the future, we will do the revalidation again. 4118 // 4119 // Also, if we deliver an ADD for a negative cache record and it has no NSEC/NSEC3, the ValidationStatus needs 4120 // to be reset. This happens normally when we deliver a "secure" negative response followed by an insecure 4121 // negative response which can happen e.g., when disconnecting from network that leads to a negative response 4122 // due to no DNS servers. As we don't deliver RMVs for negative responses that were delivered before, we need 4123 // to do it on the next ADD of a negative cache record. This ADD could be the result of a timeout, no DNS servers 4124 // etc. in which case we need to reset the state to make sure we don't deliver them as secure. If this is 4125 // a real negative response, we would reset the state here and validate the results at the end of this function. 4126 // or the real response again if we purge the cache. 4127 if (q->ValidationRequired && ((AddRecord == QC_rmv) || 4128 (rr->resrec.RecordType == kDNSRecordTypePacketNegative && (AddRecord == QC_add)))) 4129 { 4130 q->ValidationStatus = 0; 4131 q->ValidationState = DNSSECValRequired; 4132 } 4133 4134 // Normally we don't send out the unicast query if we have answered using our local only auth records e.g., /etc/hosts. 4135 // But if the query for "A" record has a local answer but query for "AAAA" record has no local answer, we might 4136 // send the AAAA query out which will come back with CNAME and will also answer the "A" query. To prevent that, 4137 // we check to see if that query already has a unique local answer. 4138 if (q->LOAddressAnswers) 4139 { 4140 LogInfo("AnswerCurrentQuestionWithResourceRecord: Question %p %##s (%s) not answering with record %s due to " 4141 "LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr), 4142 q->LOAddressAnswers); 4143 return; 4144 } 4145 4146 if (QuerySuppressed(q)) 4147 { 4148 // If the query is suppressed, then we don't want to answer from the cache. But if this query is 4149 // supposed to time out, we still want to callback the clients. We do this only for TimeoutQuestions 4150 // that are timing out, which we know are answered with negative cache record when timing out. 4151 if (!q->TimeoutQuestion || rr->resrec.RecordType != kDNSRecordTypePacketNegative || (m->timenow - q->StopTime < 0)) 4152 return; 4153 } 4154 4155#if AWD_METRICS 4156 if ((AddRecord == QC_add) && Question_uDNS(q) && !followcname) 4157 { 4158 const domainname * queryName; 4159 mDNSu32 responseLatencyMs; 4160 mDNSBool isForCellular; 4161 4162 queryName = q->metrics.originalQName ? q->metrics.originalQName : &q->qname; 4163 isForCellular = (q->qDNSServer && q->qDNSServer->cellIntf); 4164 if (!q->metrics.answered) 4165 { 4166 if (q->metrics.querySendCount > 0) 4167 { 4168 responseLatencyMs = ((m->timenow - q->metrics.firstQueryTime) * 1000) / mDNSPlatformOneSecond; 4169 } 4170 else 4171 { 4172 responseLatencyMs = 0; 4173 } 4174 4175 MetricsUpdateDNSQueryStats(queryName, q->qtype, &rr->resrec, q->metrics.querySendCount, responseLatencyMs, isForCellular); 4176 q->metrics.answered = mDNStrue; 4177 } 4178 if (q->metrics.querySendCount > 0) 4179 { 4180 MetricsUpdateDNSResolveStats(queryName, &rr->resrec, isForCellular); 4181 } 4182 } 4183#endif 4184 // Note: Use caution here. In the case of records with rr->DelayDelivery set, AnswerCurrentQuestionWithResourceRecord(... mDNStrue) 4185 // may be called twice, once when the record is received, and again when it's time to notify local clients. 4186 // If any counters or similar are added here, care must be taken to ensure that they are not double-incremented by this. 4187 4188 rr->LastUsed = m->timenow; 4189 if (AddRecord == QC_add && !q->DuplicateOf && rr->CRActiveQuestion != q) 4190 { 4191 if (!rr->CRActiveQuestion) m->rrcache_active++; // If not previously active, increment rrcache_active count 4192 debugf("AnswerCurrentQuestionWithResourceRecord: Updating CRActiveQuestion from %p to %p for cache record %s, CurrentAnswer %d", 4193 rr->CRActiveQuestion, q, CRDisplayString(m,rr), q->CurrentAnswers); 4194 rr->CRActiveQuestion = q; // We know q is non-null 4195 SetNextCacheCheckTimeForRecord(m, rr); 4196 } 4197 4198 // If this is: 4199 // (a) a no-cache add, where we've already done at least one 'QM' query, or 4200 // (b) a normal add, where we have at least one unique-type answer, 4201 // then there's no need to keep polling the network. 4202 // (If we have an answer in the cache, then we'll automatically ask again in time to stop it expiring.) 4203 // We do this for mDNS questions and uDNS one-shot questions, but not for 4204 // uDNS LongLived questions, because that would mess up our LLQ lease renewal timing. 4205 if ((AddRecord == QC_addnocache && !q->RequestUnicast) || 4206 (AddRecord == QC_add && (q->ExpectUnique || (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)))) 4207 if (ActiveQuestion(q) && (mDNSOpaque16IsZero(q->TargetQID) || !q->LongLived)) 4208 { 4209 ResetQuestionState(m, q); 4210 } 4211 4212 if (rr->DelayDelivery) return; // We'll come back later when CacheRecordDeferredAdd() calls us 4213 4214#if USE_DNS64 4215 // If DNS64StateMachine() returns true, then the question was restarted as a different question, so return. 4216 if (!mDNSOpaque16IsZero(q->TargetQID) && DNS64StateMachine(m, q, &rr->resrec, AddRecord)) return; 4217#endif 4218 4219#ifdef USE_LIBIDN 4220 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) // If negative answer, check if we need to try Punycode conversion 4221 { 4222 domainname newname; 4223 if (PerformNextPunycodeConversion(q, &newname)) // Itertative Punycode conversion succeeded, so reissue question with new name 4224 { 4225 UDPSocket *const sock = q->LocalSocket; // Save old socket and transaction ID 4226 const mDNSOpaque16 id = q->TargetQID; 4227 q->LocalSocket = mDNSNULL; 4228 mDNS_StopQuery_internal(m, q); // Stop old query 4229 AssignDomainName(&q->qname, &newname); // Update qname 4230 q->qnamehash = DomainNameHashValue(&q->qname); // and namehash 4231 mDNS_StartQuery_internal(m, q); // Start new query 4232 4233 if (sock) // Transplant saved socket, if appropriate 4234 { 4235 if (q->DuplicateOf) mDNSPlatformUDPClose(sock); 4236 else { q->LocalSocket = sock; q->TargetQID = id; } 4237 } 4238 return; // All done for now; wait until we get the next answer 4239 } 4240 } 4241#endif // USE_LIBIDN 4242 4243 // Only deliver negative answers if client has explicitly requested them except when we are forcing a negative response 4244 // for the purpose of retrying search domains/timeout OR the question is suppressed 4245 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative || (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype))) 4246 if (!AddRecord || (AddRecord != QC_suppressed && AddRecord != QC_forceresponse && !q->ReturnIntermed)) return; 4247 4248 // For CNAME results to non-CNAME questions, only inform the client if they explicitly requested that 4249 if (q->QuestionCallback && !q->NoAnswer && (!followcname || q->ReturnIntermed)) 4250 { 4251 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls 4252 if (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype)) 4253 { 4254 CacheRecord neg; 4255 MakeNegativeCacheRecord(m, &neg, &q->qname, q->qnamehash, q->qtype, q->qclass, 1, rr->resrec.InterfaceID, q->qDNSServer); 4256 q->QuestionCallback(m, q, &neg.resrec, AddRecord); 4257 } 4258 else 4259 { 4260#if USE_DNS64 4261 if (DNS64ShouldAnswerQuestion(q, &rr->resrec)) 4262 { 4263 DNS64AnswerQuestion(m, q, &rr->resrec, AddRecord); 4264 } 4265 else 4266#endif 4267 { 4268 q->QuestionCallback(m, q, &rr->resrec, AddRecord); 4269 } 4270 } 4271 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 4272 } 4273 // If this is an "Add" operation and this question needs validation, validate the response. 4274 // In the case of negative responses, extra care should be taken. Negative cache records are 4275 // used for many purposes. For example, 4276 // 4277 // 1) Suppressing questions (SuppressUnusable) 4278 // 2) Timeout questions 4279 // 3) The name does not exist 4280 // 4) No DNS servers are available and we need a quick response for the application 4281 // 4282 // (1) and (2) are handled by "QC_add" check as AddRecord would be "QC_forceresponse" or "QC_suppressed" 4283 // in that case. For (3), it is possible that we don't get nsecs back but we still need to call 4284 // VerifySignature so that we can deliver the appropriate DNSSEC result. There is no point in verifying 4285 // signature for (4) and hence the explicit check for q->qDNSServer. 4286 // 4287 if (m->CurrentQuestion == q && (AddRecord == QC_add) && !q->ValidatingResponse && q->ValidationRequired && 4288 q->ValidationState == DNSSECValRequired && q->qDNSServer) 4289 { 4290 q->ValidationState = DNSSECValInProgress; 4291 // Treat it as callback call as that's what dnssec code expects 4292 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls 4293 VerifySignature(m, mDNSNULL, q); 4294 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 4295 return; 4296 } 4297 4298 // Note: Proceed with caution here because client callback function is allowed to do anything, 4299 // including starting/stopping queries, registering/deregistering records, etc. 4300 // 4301 // If we get a CNAME back while we are validating the response (i.e., CNAME for DS, DNSKEY, RRSIG), 4302 // don't follow them. If it is a ValidationRequired question, wait for the CNAME to be validated 4303 // first before following it 4304 if ((m->CurrentQuestion == q) && followcname && !ValidatingQuestion(q)) 4305 AnswerQuestionByFollowingCNAME(m, q, &rr->resrec); 4306} 4307 4308mDNSlocal void CacheRecordDeferredAdd(mDNS *const m, CacheRecord *rr) 4309{ 4310 rr->DelayDelivery = 0; 4311 if (m->CurrentQuestion) 4312 LogMsg("CacheRecordDeferredAdd ERROR m->CurrentQuestion already set: %##s (%s)", 4313 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4314 m->CurrentQuestion = m->Questions; 4315 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) 4316 { 4317 DNSQuestion *q = m->CurrentQuestion; 4318 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 4319 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add); 4320 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 4321 m->CurrentQuestion = q->next; 4322 } 4323 m->CurrentQuestion = mDNSNULL; 4324} 4325 4326mDNSlocal mDNSs32 CheckForSoonToExpireRecords(mDNS *const m, const domainname *const name, const mDNSu32 namehash, mDNSBool *purge) 4327{ 4328 const mDNSs32 threshhold = m->timenow + mDNSPlatformOneSecond; // See if there are any records expiring within one second 4329 const mDNSs32 start = m->timenow - 0x10000000; 4330 mDNSs32 delay = start; 4331 CacheGroup *cg = CacheGroupForName(m, namehash, name); 4332 const CacheRecord *rr; 4333 4334 if (purge) 4335 *purge = mDNSfalse; 4336 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 4337 { 4338 // If there are records that will expire soon, there are cases that need delayed 4339 // delivery of events: 4340 // 4341 // 1) A new cache entry is about to be added as a replacement. The caller needs to 4342 // deliver a RMV (for the current old entry) followed by ADD (for the new entry). 4343 // It needs to schedule the timer for the next cache expiry (ScheduleNextCacheCheckTime), 4344 // so that the cache entry can be purged (purging causes the RMV followed by ADD) 4345 // 4346 // 2) A new question is about to be answered and the caller needs to know whether it's 4347 // scheduling should be delayed so that the question is not answered with this record. 4348 // Instead of delivering an ADD (old entry) followed by RMV (old entry) and another ADD 4349 // (new entry), a single ADD can be delivered by delaying the scheduling of the question 4350 // immediately. 4351 // 4352 // When the unicast cache record is created, it's TTL has been extended beyond its value 4353 // given in the resource record (See RRAdjustTTL). If it is in the "extended" time, the 4354 // cache is already expired and we set "purge" to indicate that. When "purge" is set, the 4355 // return value of the function should be ignored by the callers. 4356 // 4357 // Note: For case (1), "purge" argument is NULL and hence the following checks are skipped. 4358 // It is okay to skip in that case because the cache records have been set to expire almost 4359 // immediately and the extended time does not apply. 4360 // 4361 // Also, if there is already an active question we don't try to optimize as purging the cache 4362 // would end up delivering RMV for the active question and hence we avoid that. 4363 4364 if (purge && !rr->resrec.InterfaceID && !rr->CRActiveQuestion && rr->resrec.rroriginalttl) 4365 { 4366 mDNSu32 uTTL = RRUnadjustedTTL(rr->resrec.rroriginalttl); 4367 if (m->timenow - (rr->TimeRcvd + ((mDNSs32)uTTL * mDNSPlatformOneSecond)) >= 0) 4368 { 4369 LogInfo("CheckForSoonToExpireRecords: %s: rroriginalttl %u, unadjustedTTL %u, currentTTL %u", 4370 CRDisplayString(m, rr), rr->resrec.rroriginalttl, uTTL, (m->timenow - rr->TimeRcvd)/mDNSPlatformOneSecond); 4371 *purge = mDNStrue; 4372 continue; 4373 } 4374 } 4375 if (threshhold - RRExpireTime(rr) >= 0) // If we have records about to expire within a second 4376 { 4377 if (delay - RRExpireTime(rr) < 0) // then delay until after they've been deleted 4378 delay = RRExpireTime(rr); 4379 } 4380 } 4381 if (delay - start > 0) 4382 return(NonZeroTime(delay)); 4383 else 4384 return(0); 4385} 4386 4387// CacheRecordAdd is only called from CreateNewCacheEntry, *never* directly as a result of a client API call. 4388// If new questions are created as a result of invoking client callbacks, they will be added to 4389// the end of the question list, and m->NewQuestions will be set to indicate the first new question. 4390// rr is a new CacheRecord just received into our cache 4391// (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique). 4392// Note: CacheRecordAdd calls AnswerCurrentQuestionWithResourceRecord which can call a user callback, 4393// which may change the record list and/or question list. 4394// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 4395mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr) 4396{ 4397 DNSQuestion *q; 4398 4399 // We stop when we get to NewQuestions -- if we increment their CurrentAnswers/LargeAnswers/UniqueAnswers 4400 // counters here we'll end up double-incrementing them when we do it again in AnswerNewQuestion(). 4401 for (q = m->Questions; q && q != m->NewQuestions; q=q->next) 4402 { 4403 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 4404 { 4405 // If this question is one that's actively sending queries, and it's received ten answers within one 4406 // second of sending the last query packet, then that indicates some radical network topology change, 4407 // so reset its exponential backoff back to the start. We must be at least at the eight-second interval 4408 // to do this. If we're at the four-second interval, or less, there's not much benefit accelerating 4409 // because we will anyway send another query within a few seconds. The first reset query is sent out 4410 // randomized over the next four seconds to reduce possible synchronization between machines. 4411 if (q->LastAnswerPktNum != m->PktNum) 4412 { 4413 q->LastAnswerPktNum = m->PktNum; 4414 if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q) && ++q->RecentAnswerPkts >= 10 && 4415 q->ThisQInterval > InitialQuestionInterval * QuestionIntervalStep3 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond) 4416 { 4417 LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst (%d); restarting exponential backoff sequence (%d)", 4418 q->qname.c, DNSTypeName(q->qtype), q->RecentAnswerPkts, q->ThisQInterval); 4419 q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4); 4420 q->ThisQInterval = InitialQuestionInterval; 4421 SetNextQueryTime(m,q); 4422 } 4423 } 4424 verbosedebugf("CacheRecordAdd %p %##s (%s) %lu %#a:%d question %p", rr, rr->resrec.name->c, 4425 DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl, rr->resrec.rDNSServer ? 4426 &rr->resrec.rDNSServer->addr : mDNSNULL, mDNSVal16(rr->resrec.rDNSServer ? 4427 rr->resrec.rDNSServer->port : zeroIPPort), q); 4428 q->CurrentAnswers++; 4429 4430 q->unansweredQueries = 0; 4431 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++; 4432 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++; 4433 if (q->CurrentAnswers > 4000) 4434 { 4435 static int msgcount = 0; 4436 if (msgcount++ < 10) 4437 LogMsg("CacheRecordAdd: %##s (%s) has %d answers; shedding records to resist DOS attack", 4438 q->qname.c, DNSTypeName(q->qtype), q->CurrentAnswers); 4439 rr->resrec.rroriginalttl = 0; 4440 rr->UnansweredQueries = MaxUnansweredQueries; 4441 } 4442 } 4443 } 4444 4445 if (!rr->DelayDelivery) 4446 { 4447 if (m->CurrentQuestion) 4448 LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4449 m->CurrentQuestion = m->Questions; 4450 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) 4451 { 4452 q = m->CurrentQuestion; 4453 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 4454 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add); 4455 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 4456 m->CurrentQuestion = q->next; 4457 } 4458 m->CurrentQuestion = mDNSNULL; 4459 } 4460 4461 SetNextCacheCheckTimeForRecord(m, rr); 4462} 4463 4464// NoCacheAnswer is only called from mDNSCoreReceiveResponse, *never* directly as a result of a client API call. 4465// If new questions are created as a result of invoking client callbacks, they will be added to 4466// the end of the question list, and m->NewQuestions will be set to indicate the first new question. 4467// rr is a new CacheRecord just received from the wire (kDNSRecordTypePacketAns/AnsUnique/Add/AddUnique) 4468// but we don't have any place to cache it. We'll deliver question 'add' events now, but we won't have any 4469// way to deliver 'remove' events in future, nor will we be able to include this in known-answer lists, 4470// so we immediately bump ThisQInterval up to MaxQuestionInterval to avoid pounding the network. 4471// Note: NoCacheAnswer calls AnswerCurrentQuestionWithResourceRecord which can call a user callback, 4472// which may change the record list and/or question list. 4473// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 4474mDNSlocal void NoCacheAnswer(mDNS *const m, CacheRecord *rr) 4475{ 4476 LogMsg("No cache space: Delivering non-cached result for %##s", m->rec.r.resrec.name->c); 4477 if (m->CurrentQuestion) 4478 LogMsg("NoCacheAnswer ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4479 m->CurrentQuestion = m->Questions; 4480 // We do this for *all* questions, not stopping when we get to m->NewQuestions, 4481 // since we're not caching the record and we'll get no opportunity to do this later 4482 while (m->CurrentQuestion) 4483 { 4484 DNSQuestion *q = m->CurrentQuestion; 4485 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 4486 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_addnocache); // QC_addnocache means "don't expect remove events for this" 4487 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 4488 m->CurrentQuestion = q->next; 4489 } 4490 m->CurrentQuestion = mDNSNULL; 4491} 4492 4493// CacheRecordRmv is only called from CheckCacheExpiration, which is called from mDNS_Execute. 4494// Note that CacheRecordRmv is *only* called for records that are referenced by at least one active question. 4495// If new questions are created as a result of invoking client callbacks, they will be added to 4496// the end of the question list, and m->NewQuestions will be set to indicate the first new question. 4497// rr is an existing cache CacheRecord that just expired and is being deleted 4498// (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique). 4499// Note: CacheRecordRmv calls AnswerCurrentQuestionWithResourceRecord which can call a user callback, 4500// which may change the record list and/or question list. 4501// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 4502mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr) 4503{ 4504 if (m->CurrentQuestion) 4505 LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set: %##s (%s)", 4506 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4507 m->CurrentQuestion = m->Questions; 4508 4509 // We stop when we get to NewQuestions -- for new questions their CurrentAnswers/LargeAnswers/UniqueAnswers counters 4510 // will all still be zero because we haven't yet gone through the cache counting how many answers we have for them. 4511 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) 4512 { 4513 DNSQuestion *q = m->CurrentQuestion; 4514 // When a question enters suppressed state, we generate RMV events and generate a negative 4515 // response. A cache may be present that answers this question e.g., cache entry generated 4516 // before the question became suppressed. We need to skip the suppressed questions here as 4517 // the RMV event has already been generated. 4518 if (!QuerySuppressed(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) 4519 { 4520 verbosedebugf("CacheRecordRmv %p %s", rr, CRDisplayString(m, rr)); 4521 q->FlappingInterface1 = mDNSNULL; 4522 q->FlappingInterface2 = mDNSNULL; 4523 4524 if (q->CurrentAnswers == 0) 4525 LogMsg("CacheRecordRmv ERROR!!: How can CurrentAnswers already be zero for %p %##s (%s) DNSServer %#a:%d", 4526 q, q->qname.c, DNSTypeName(q->qtype), q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL, 4527 mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort)); 4528 else 4529 { 4530 q->CurrentAnswers--; 4531 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--; 4532 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--; 4533 } 4534 4535 // If we have dropped below the answer threshold for this mDNS question, 4536 // restart the queries at InitialQuestionInterval. 4537 if (mDNSOpaque16IsZero(q->TargetQID) && (q->BrowseThreshold > 0) && (q->CurrentAnswers < q->BrowseThreshold)) 4538 { 4539 q->ThisQInterval = InitialQuestionInterval; 4540 q->LastQTime = m->timenow - q->ThisQInterval; 4541 SetNextQueryTime(m,q); 4542 LogInfo("CacheRecordRmv: (%s) %##s dropped below threshold of %d answers", 4543 DNSTypeName(q->qtype), q->qname.c, q->BrowseThreshold); 4544 } 4545 if (rr->resrec.rdata->MaxRDLength) // Never generate "remove" events for negative results 4546 { 4547 if (q->CurrentAnswers == 0) 4548 { 4549 LogInfo("CacheRecordRmv: Last answer for %##s (%s) expired from cache; will reconfirm antecedents", 4550 q->qname.c, DNSTypeName(q->qtype)); 4551 ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0); 4552 } 4553 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv); 4554 } 4555 } 4556 if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now 4557 m->CurrentQuestion = q->next; 4558 } 4559 m->CurrentQuestion = mDNSNULL; 4560} 4561 4562mDNSlocal void ReleaseCacheEntity(mDNS *const m, CacheEntity *e) 4563{ 4564#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1 4565 unsigned int i; 4566 for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF; 4567#endif 4568 e->next = m->rrcache_free; 4569 m->rrcache_free = e; 4570 m->rrcache_totalused--; 4571} 4572 4573mDNSlocal void ReleaseCacheGroup(mDNS *const m, CacheGroup **cp) 4574{ 4575 CacheEntity *e = (CacheEntity *)(*cp); 4576 //LogMsg("ReleaseCacheGroup: Releasing CacheGroup for %p, %##s", (*cp)->name->c, (*cp)->name->c); 4577 if ((*cp)->rrcache_tail != &(*cp)->members) 4578 LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrcache_tail != &(*cp)->members)"); 4579 //if ((*cp)->name != (domainname*)((*cp)->namestorage)) 4580 // LogMsg("ReleaseCacheGroup: %##s, %p %p", (*cp)->name->c, (*cp)->name, (domainname*)((*cp)->namestorage)); 4581 if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name); 4582 (*cp)->name = mDNSNULL; 4583 *cp = (*cp)->next; // Cut record from list 4584 ReleaseCacheEntity(m, e); 4585} 4586 4587mDNSlocal void ReleaseAdditionalCacheRecords(mDNS *const m, CacheRecord **rp) 4588{ 4589 while (*rp) 4590 { 4591 CacheRecord *rr = *rp; 4592 *rp = (*rp)->next; // Cut record from list 4593 if (rr->resrec.rdata && rr->resrec.rdata != (RData*)&rr->smallrdatastorage) 4594 { 4595 mDNSPlatformMemFree(rr->resrec.rdata); 4596 rr->resrec.rdata = mDNSNULL; 4597 } 4598 // NSEC or SOA records that are not added to the CacheGroup do not share the name 4599 // of the CacheGroup. 4600 if (rr->resrec.name) 4601 { 4602 debugf("ReleaseAdditionalCacheRecords: freeing cached record %##s (%s)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 4603 mDNSPlatformMemFree((void *)rr->resrec.name); 4604 rr->resrec.name = mDNSNULL; 4605 } 4606 // Don't count the NSEC3 records used by anonymous browse/reg 4607 if (!rr->resrec.InterfaceID) 4608 { 4609 m->rrcache_totalused_unicast -= rr->resrec.rdlength; 4610 if (DNSSECRecordType(rr->resrec.rrtype)) 4611 BumpDNSSECStats(m, kStatsActionDecrement, kStatsTypeMemoryUsage, rr->resrec.rdlength); 4612 } 4613 ReleaseCacheEntity(m, (CacheEntity *)rr); 4614 } 4615} 4616 4617mDNSexport void ReleaseCacheRecord(mDNS *const m, CacheRecord *r) 4618{ 4619 CacheGroup *cg; 4620 4621 //LogMsg("ReleaseCacheRecord: Releasing %s", CRDisplayString(m, r)); 4622 if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->smallrdatastorage) mDNSPlatformMemFree(r->resrec.rdata); 4623 r->resrec.rdata = mDNSNULL; 4624 4625 cg = CacheGroupForRecord(m, &r->resrec); 4626 4627 if (!cg) 4628 { 4629 // It is okay to have this printed for NSEC/NSEC3s 4630 LogInfo("ReleaseCacheRecord: ERROR!! cg NULL for %##s (%s)", r->resrec.name->c, DNSTypeName(r->resrec.rrtype)); 4631 } 4632 // When NSEC records are not added to the cache, it is usually cached at the "nsec" list 4633 // of the CacheRecord. But sometimes they may be freed without adding to the "nsec" list 4634 // (which is handled below) and in that case it should be freed here. 4635 if (r->resrec.name && cg && r->resrec.name != cg->name) 4636 { 4637 debugf("ReleaseCacheRecord: freeing %##s (%s)", r->resrec.name->c, DNSTypeName(r->resrec.rrtype)); 4638 mDNSPlatformMemFree((void *)r->resrec.name); 4639 } 4640 r->resrec.name = mDNSNULL; 4641 4642 if (r->resrec.AnonInfo) 4643 { 4644 debugf("ReleaseCacheRecord: freeing AnonInfo for %##s (%s)", r->resrec.name->c, DNSTypeName(r->resrec.rrtype)); 4645 FreeAnonInfo((void *)r->resrec.AnonInfo); 4646 } 4647 r->resrec.AnonInfo = mDNSNULL; 4648 4649 if (!r->resrec.InterfaceID) 4650 { 4651 m->rrcache_totalused_unicast -= r->resrec.rdlength; 4652 if (DNSSECRecordType(r->resrec.rrtype)) 4653 BumpDNSSECStats(m, kStatsActionDecrement, kStatsTypeMemoryUsage, r->resrec.rdlength); 4654 } 4655 4656 ReleaseAdditionalCacheRecords(m, &r->nsec); 4657 ReleaseAdditionalCacheRecords(m, &r->soa); 4658 4659 ReleaseCacheEntity(m, (CacheEntity *)r); 4660} 4661 4662// Note: We want to be careful that we deliver all the CacheRecordRmv calls before delivering 4663// CacheRecordDeferredAdd calls. The in-order nature of the cache lists ensures that all 4664// callbacks for old records are delivered before callbacks for newer records. 4665mDNSlocal void CheckCacheExpiration(mDNS *const m, const mDNSu32 slot, CacheGroup *const cg) 4666{ 4667 CacheRecord **rp = &cg->members; 4668 4669 if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; } 4670 m->lock_rrcache = 1; 4671 4672 while (*rp) 4673 { 4674 CacheRecord *const rr = *rp; 4675 mDNSs32 event = RRExpireTime(rr); 4676 if (m->timenow - event >= 0) // If expired, delete it 4677 { 4678 *rp = rr->next; // Cut it from the list 4679 4680 verbosedebugf("CheckCacheExpiration: Deleting%7d %7d %p %s", 4681 m->timenow - rr->TimeRcvd, rr->resrec.rroriginalttl, rr->CRActiveQuestion, CRDisplayString(m, rr)); 4682 if (rr->CRActiveQuestion) // If this record has one or more active questions, tell them it's going away 4683 { 4684 DNSQuestion *q = rr->CRActiveQuestion; 4685 // When a cache record is about to expire, we expect to do four queries at 80-82%, 85-87%, 90-92% and 4686 // then 95-97% of the TTL. If the DNS server does not respond, then we will remove the cache entry 4687 // before we pick a new DNS server. As the question interval is set to MaxQuestionInterval, we may 4688 // not send out a query anytime soon. Hence, we need to reset the question interval. If this is 4689 // a normal deferred ADD case, then AnswerCurrentQuestionWithResourceRecord will reset it to 4690 // MaxQuestionInterval. If we have inactive questions referring to negative cache entries, 4691 // don't ressurect them as they will deliver duplicate "No such Record" ADD events 4692 if (!mDNSOpaque16IsZero(q->TargetQID) && !q->LongLived && ActiveQuestion(q)) 4693 { 4694 q->ThisQInterval = InitialQuestionInterval; 4695 q->LastQTime = m->timenow - q->ThisQInterval; 4696 SetNextQueryTime(m, q); 4697 } 4698 CacheRecordRmv(m, rr); 4699 m->rrcache_active--; 4700 } 4701 ReleaseCacheRecord(m, rr); 4702 } 4703 else // else, not expired; see if we need to query 4704 { 4705 // If waiting to delay delivery, do nothing until then 4706 if (rr->DelayDelivery && rr->DelayDelivery - m->timenow > 0) 4707 event = rr->DelayDelivery; 4708 else 4709 { 4710 if (rr->DelayDelivery) CacheRecordDeferredAdd(m, rr); 4711 if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries) 4712 { 4713 if (m->timenow - rr->NextRequiredQuery < 0) // If not yet time for next query 4714 event = NextCacheCheckEvent(rr); // then just record when we want the next query 4715 else // else trigger our question to go out now 4716 { 4717 // Set NextScheduledQuery to timenow so that SendQueries() will run. 4718 // SendQueries() will see that we have records close to expiration, and send FEQs for them. 4719 m->NextScheduledQuery = m->timenow; 4720 // After sending the query we'll increment UnansweredQueries and call SetNextCacheCheckTimeForRecord(), 4721 // which will correctly update m->NextCacheCheck for us. 4722 event = m->timenow + FutureTime; 4723 } 4724 } 4725 } 4726 verbosedebugf("CheckCacheExpiration:%6d %5d %s", 4727 (event - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m, rr)); 4728 if (m->rrcache_nextcheck[slot] - event > 0) 4729 m->rrcache_nextcheck[slot] = event; 4730 rp = &rr->next; 4731 } 4732 } 4733 if (cg->rrcache_tail != rp) verbosedebugf("CheckCacheExpiration: Updating CacheGroup tail from %p to %p", cg->rrcache_tail, rp); 4734 cg->rrcache_tail = rp; 4735 m->lock_rrcache = 0; 4736} 4737 4738// "LORecord" includes both LocalOnly and P2P record. This function assumes m->CurrentQuestion is pointing to "q". 4739// 4740// If "CheckOnly" is set to "true", the question won't be answered but just check to see if there is an answer and 4741// returns true if there is an answer. 4742// 4743// If "CheckOnly" is set to "false", the question will be answered if there is a LocalOnly/P2P record and 4744// returns true to indicate the same. 4745mDNSlocal mDNSBool AnswerQuestionWithLORecord(mDNS *const m, DNSQuestion *q, mDNSBool checkOnly) 4746{ 4747 AuthRecord *lr; 4748 AuthGroup *ag; 4749 4750 if (m->CurrentRecord) 4751 LogMsg("AnswerQuestionWithLORecord ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 4752 4753 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); 4754 if (ag) 4755 { 4756 m->CurrentRecord = ag->members; 4757 while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords) 4758 { 4759 AuthRecord *rr = m->CurrentRecord; 4760 m->CurrentRecord = rr->next; 4761 // 4762 // If the question is mDNSInterface_LocalOnly, all records local to the machine should be used 4763 // to answer the query. This is handled in AnswerNewLocalOnlyQuestion. 4764 // 4765 // We handle mDNSInterface_Any and scoped questions here. See LocalOnlyRecordAnswersQuestion for more 4766 // details on how we handle this case. For P2P we just handle "Interface_Any" questions. For LocalOnly 4767 // we handle both mDNSInterface_Any and scoped questions. 4768 4769 if (rr->ARType == AuthRecordLocalOnly || (rr->ARType == AuthRecordP2P && (q->InterfaceID == mDNSInterface_Any || q->InterfaceID == mDNSInterface_BLE))) 4770 if (LocalOnlyRecordAnswersQuestion(rr, q)) 4771 { 4772 if (checkOnly) 4773 { 4774 LogInfo("AnswerQuestionWithLORecord: question %##s (%s) answered by %s", q->qname.c, DNSTypeName(q->qtype), 4775 ARDisplayString(m, rr)); 4776 m->CurrentRecord = mDNSNULL; 4777 return mDNStrue; 4778 } 4779 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); 4780 if (m->CurrentQuestion != q) 4781 break; // If callback deleted q, then we're finished here 4782 } 4783 } 4784 } 4785 m->CurrentRecord = mDNSNULL; 4786 4787 if (m->CurrentQuestion != q) 4788 { 4789 LogInfo("AnswerQuestionWithLORecord: Question deleted while while answering LocalOnly record answers"); 4790 return mDNStrue; 4791 } 4792 4793 if (q->LOAddressAnswers) 4794 { 4795 LogInfo("AnswerQuestionWithLORecord: Question %p %##s (%s) answered using local auth records LOAddressAnswers %d", 4796 q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers); 4797 return mDNStrue; 4798 } 4799 4800 // Before we go check the cache and ship this query on the wire, we have to be sure that there are 4801 // no local records that could possibly answer this question. As we did not check the NewLocalRecords, we 4802 // need to just peek at them to see whether it will answer this question. If it would answer, pretend 4803 // that we answered. AnswerAllLocalQuestionsWithLocalAuthRecord will answer shortly. This happens normally 4804 // when we add new /etc/hosts entries and restart the question. It is a new question and also a new record. 4805 if (ag) 4806 { 4807 lr = ag->NewLocalOnlyRecords; 4808 while (lr) 4809 { 4810 if (UniqueLocalOnlyRecord(lr) && LocalOnlyRecordAnswersQuestion(lr, q)) 4811 { 4812 LogInfo("AnswerQuestionWithLORecord: Question %p %##s (%s) will be answered using new local auth records " 4813 " LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers); 4814 return mDNStrue; 4815 } 4816 lr = lr->next; 4817 } 4818 } 4819 return mDNSfalse; 4820} 4821 4822// Today, we suppress questions (not send them on the wire) for several reasons e.g., 4823// AAAA query is suppressed because no IPv6 capability or PID is not allowed to make 4824// DNS requests. We need to temporarily suspend the suppress status so that we can 4825// deliver a negative response (AnswerCurrentQuestionWithResourceRecord does not answer 4826// suppressed questions) and reset it back. In the future, if there are other 4827// reasons for suppressing the query, this function should be updated. 4828mDNSlocal void AnswerSuppressedQuestion(mDNS *const m, DNSQuestion *q) 4829{ 4830 mDNSBool SuppressQuery; 4831 mDNSBool DisallowPID; 4832 4833 // If the client did not set the kDNSServiceFlagsReturnIntermediates flag, then don't generate a negative response, just 4834 // deactivate the DNSQuestion. 4835 if (!q->ReturnIntermed) 4836 { 4837 q->ThisQInterval = 0; 4838 return; 4839 } 4840 4841 SuppressQuery = q->SuppressQuery; 4842 DisallowPID = q->DisallowPID; 4843 4844 // make sure that QuerySuppressed() returns false 4845 q->SuppressQuery = mDNSfalse; 4846 q->DisallowPID = mDNSfalse; 4847 4848 GenerateNegativeResponse(m, mDNSInterface_Any, QC_suppressed); 4849 4850 q->SuppressQuery = SuppressQuery; 4851 q->DisallowPID = DisallowPID; 4852} 4853 4854mDNSlocal void AnswerNewQuestion(mDNS *const m) 4855{ 4856 mDNSBool ShouldQueryImmediately = mDNStrue; 4857 DNSQuestion *const q = m->NewQuestions; // Grab the question we're going to answer 4858#if USE_DNS64 4859 if (!mDNSOpaque16IsZero(q->TargetQID)) DNS64HandleNewQuestion(m, q); 4860#endif 4861 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 4862 mDNSBool AnsweredFromCache = mDNSfalse; 4863 4864 verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4865 4866 if (cg) CheckCacheExpiration(m, HashSlotFromNameHash(q->qnamehash), cg); 4867 if (m->NewQuestions != q) { LogInfo("AnswerNewQuestion: Question deleted while doing CheckCacheExpiration"); goto exit; } 4868 m->NewQuestions = q->next; 4869 // Advance NewQuestions to the next *after* calling CheckCacheExpiration, because if we advance it first 4870 // then CheckCacheExpiration may give this question add/remove callbacks, and it's not yet ready for that. 4871 // 4872 // Also, CheckCacheExpiration() calls CacheRecordDeferredAdd() and CacheRecordRmv(), which invoke 4873 // client callbacks, which may delete their own or any other question. Our mechanism for detecting 4874 // whether our current m->NewQuestions question got deleted by one of these callbacks is to store the 4875 // value of m->NewQuestions in 'q' before calling CheckCacheExpiration(), and then verify afterwards 4876 // that they're still the same. If m->NewQuestions has changed (because mDNS_StopQuery_internal 4877 // advanced it), that means the question was deleted, so we no longer need to worry about answering 4878 // it (and indeed 'q' is now a dangling pointer, so dereferencing it at all would be bad, and the 4879 // values we computed for slot and cg are now stale and relate to a question that no longer exists). 4880 // 4881 // We can't use the usual m->CurrentQuestion mechanism for this because CacheRecordDeferredAdd() and 4882 // CacheRecordRmv() both use that themselves when walking the list of (non-new) questions generating callbacks. 4883 // Fortunately mDNS_StopQuery_internal auto-advances both m->CurrentQuestion *AND* m->NewQuestions when 4884 // deleting a question, so luckily we have an easy alternative way of detecting if our question got deleted. 4885 4886 if (m->lock_rrcache) LogMsg("AnswerNewQuestion ERROR! Cache already locked!"); 4887 // This should be safe, because calling the client's question callback may cause the 4888 // question list to be modified, but should not ever cause the rrcache list to be modified. 4889 // If the client's question callback deletes the question, then m->CurrentQuestion will 4890 // be advanced, and we'll exit out of the loop 4891 m->lock_rrcache = 1; 4892 if (m->CurrentQuestion) 4893 LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set: %##s (%s)", 4894 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 4895 m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted 4896 4897 if (q->NoAnswer == NoAnswer_Fail) 4898 { 4899 LogMsg("AnswerNewQuestion: NoAnswer_Fail %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4900 MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, mDNSInterface_Any, q->qDNSServer); 4901 q->NoAnswer = NoAnswer_Normal; // Temporarily turn off answer suppression 4902 AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, QC_addnocache); 4903 // Don't touch the question if it has been stopped already 4904 if (m->CurrentQuestion == q) q->NoAnswer = NoAnswer_Fail; // Restore NoAnswer state 4905 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 4906 } 4907 4908 if (m->CurrentQuestion != q) 4909 { 4910 LogInfo("AnswerNewQuestion: Question deleted while generating NoAnswer_Fail response"); 4911 goto exit; 4912 } 4913 4914 // See if we want to tell it about LocalOnly/P2P records. If we answered them using LocalOnly 4915 // or P2P record, then we are done. 4916 if (AnswerQuestionWithLORecord(m, q, mDNSfalse)) 4917 goto exit; 4918 4919 // If we are not supposed to answer this question, generate a negative response. 4920 // Temporarily suspend the SuppressQuery so that AnswerCurrentQuestionWithResourceRecord can answer the question 4921 // 4922 // If it is a question trying to validate some response, it already checked the cache for a response. If it still 4923 // reissues a question it means it could not find the RRSIGs. So, we need to bypass the cache check and send 4924 // the question out. 4925 if (QuerySuppressed(q)) 4926 { 4927 AnswerSuppressedQuestion(m, q); 4928 } 4929 else if (!q->ValidatingResponse) 4930 { 4931 CacheRecord *rr; 4932 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 4933 if (SameNameRecordAnswersQuestion(&rr->resrec, q)) 4934 { 4935 // SecsSinceRcvd is whole number of elapsed seconds, rounded down 4936 mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond; 4937 if (rr->resrec.rroriginalttl <= SecsSinceRcvd) 4938 { 4939 LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %s %d %d", 4940 rr->resrec.rroriginalttl, SecsSinceRcvd, CRDisplayString(m, rr), m->timenow, rr->TimeRcvd); 4941 continue; // Go to next one in loop 4942 } 4943 4944 // If this record set is marked unique, then that means we can reasonably assume we have the whole set 4945 // -- we don't need to rush out on the network and query immediately to see if there are more answers out there 4946 if ((rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) || (q->ExpectUnique)) 4947 ShouldQueryImmediately = mDNSfalse; 4948 q->CurrentAnswers++; 4949 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++; 4950 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++; 4951 AnsweredFromCache = mDNStrue; 4952 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add); 4953 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 4954 } 4955 else if (mDNSOpaque16IsZero(q->TargetQID) && RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype)) 4956 ShouldQueryImmediately = mDNSfalse; 4957 } 4958 // We don't use LogInfo for this "Question deleted" message because it happens so routinely that 4959 // it's not remotely remarkable, and therefore unlikely to be of much help tracking down bugs. 4960 if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving cache answers"); goto exit; } 4961 4962 // Neither a local record nor a cache entry could answer this question. If this question need to be retried 4963 // with search domains, generate a negative response which will now retry after appending search domains. 4964 // If the query was suppressed above, we already generated a negative response. When it gets unsuppressed, 4965 // we will retry with search domains. 4966 if (!QuerySuppressed(q) && !AnsweredFromCache && q->RetryWithSearchDomains) 4967 { 4968 LogInfo("AnswerNewQuestion: Generating response for retrying with search domains %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4969 GenerateNegativeResponse(m, mDNSInterface_Any, QC_forceresponse); 4970 } 4971 4972 if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving negative answer"); goto exit; } 4973 4974 // Note: When a query gets suppressed or retried with search domains, we de-activate the question. 4975 // Hence we don't execute the following block of code for those cases. 4976 if (ShouldQueryImmediately && ActiveQuestion(q)) 4977 { 4978 debugf("AnswerNewQuestion: ShouldQueryImmediately %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4979 q->ThisQInterval = InitialQuestionInterval; 4980 q->LastQTime = m->timenow - q->ThisQInterval; 4981 if (mDNSOpaque16IsZero(q->TargetQID)) // For mDNS, spread packets to avoid a burst of simultaneous queries 4982 { 4983 // Compute random delay in the range 1-6 seconds, then divide by 50 to get 20-120ms 4984 if (!m->RandomQueryDelay) 4985 m->RandomQueryDelay = (mDNSPlatformOneSecond + mDNSRandom(mDNSPlatformOneSecond*5) - 1) / 50 + 1; 4986 q->LastQTime += m->RandomQueryDelay; 4987 } 4988 } 4989 4990 // IN ALL CASES make sure that m->NextScheduledQuery is set appropriately. 4991 // In cases where m->NewQuestions->DelayAnswering is set, we may have delayed generating our 4992 // answers for this question until *after* its scheduled transmission time, in which case 4993 // m->NextScheduledQuery may now be set to 'never', and in that case -- even though we're *not* doing 4994 // ShouldQueryImmediately -- we still need to make sure we set m->NextScheduledQuery correctly. 4995 SetNextQueryTime(m,q); 4996 4997exit: 4998 m->CurrentQuestion = mDNSNULL; 4999 m->lock_rrcache = 0; 5000} 5001 5002// When a NewLocalOnlyQuestion is created, AnswerNewLocalOnlyQuestion runs though our ResourceRecords delivering any 5003// appropriate answers, stopping if it reaches a NewLocalOnlyRecord -- these will be handled by AnswerAllLocalQuestionsWithLocalAuthRecord 5004mDNSlocal void AnswerNewLocalOnlyQuestion(mDNS *const m) 5005{ 5006 AuthGroup *ag; 5007 DNSQuestion *q = m->NewLocalOnlyQuestions; // Grab the question we're going to answer 5008 mDNSBool retEv = mDNSfalse; 5009 m->NewLocalOnlyQuestions = q->next; // Advance NewLocalOnlyQuestions to the next (if any) 5010 5011 debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 5012 5013 if (m->CurrentQuestion) 5014 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentQuestion already set: %##s (%s)", 5015 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 5016 m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted 5017 5018 if (m->CurrentRecord) 5019 LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 5020 5021 // 1. First walk the LocalOnly records answering the LocalOnly question 5022 // 2. As LocalOnly questions should also be answered by any other Auth records local to the machine, 5023 // walk the ResourceRecords list delivering the answers 5024 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); 5025 if (ag) 5026 { 5027 m->CurrentRecord = ag->members; 5028 while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords) 5029 { 5030 AuthRecord *rr = m->CurrentRecord; 5031 m->CurrentRecord = rr->next; 5032 if (LocalOnlyRecordAnswersQuestion(rr, q)) 5033 { 5034 retEv = mDNStrue; 5035 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); 5036 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 5037 } 5038 } 5039 } 5040 5041 if (m->CurrentQuestion == q) 5042 { 5043 m->CurrentRecord = m->ResourceRecords; 5044 5045 while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords) 5046 { 5047 AuthRecord *rr = m->CurrentRecord; 5048 m->CurrentRecord = rr->next; 5049 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 5050 { 5051 retEv = mDNStrue; 5052 AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); 5053 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 5054 } 5055 } 5056 } 5057 5058 // The local host is the authoritative source for LocalOnly questions 5059 // so if no records exist and client requested intermediates, then generate a negative response 5060 if (!retEv && (m->CurrentQuestion == q) && q->ReturnIntermed) 5061 GenerateNegativeResponse(m, mDNSInterface_LocalOnly, QC_forceresponse); 5062 5063 m->CurrentQuestion = mDNSNULL; 5064 m->CurrentRecord = mDNSNULL; 5065} 5066 5067mDNSlocal CacheEntity *GetCacheEntity(mDNS *const m, const CacheGroup *const PreserveCG) 5068{ 5069 CacheEntity *e = mDNSNULL; 5070 5071 if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); } 5072 m->lock_rrcache = 1; 5073 5074 // If we have no free records, ask the client layer to give us some more memory 5075 if (!m->rrcache_free && m->MainCallback) 5076 { 5077 if (m->rrcache_totalused != m->rrcache_size) 5078 LogMsg("GetFreeCacheRR: count mismatch: m->rrcache_totalused %lu != m->rrcache_size %lu", 5079 m->rrcache_totalused, m->rrcache_size); 5080 5081 // We don't want to be vulnerable to a malicious attacker flooding us with an infinite 5082 // number of bogus records so that we keep growing our cache until the machine runs out of memory. 5083 // To guard against this, if our cache grows above 512kB (approx 3168 records at 164 bytes each), 5084 // and we're actively using less than 1/32 of that cache, then we purge all the unused records 5085 // and recycle them, instead of allocating more memory. 5086 if (m->rrcache_size > 5000 && m->rrcache_size / 32 > m->rrcache_active) 5087 LogInfo("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu", 5088 m->rrcache_size, m->rrcache_active); 5089 else 5090 { 5091 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 5092 m->MainCallback(m, mStatus_GrowCache); 5093 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 5094 } 5095 } 5096 5097 // If we still have no free records, recycle all the records we can. 5098 // Enumerating the entire cache is moderately expensive, so when we do it, we reclaim all the records we can in one pass. 5099 if (!m->rrcache_free) 5100 { 5101 mDNSu32 oldtotalused = m->rrcache_totalused; 5102 mDNSu32 slot; 5103 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) 5104 { 5105 CacheGroup **cp = &m->rrcache_hash[slot]; 5106 while (*cp) 5107 { 5108 CacheRecord **rp = &(*cp)->members; 5109 while (*rp) 5110 { 5111 // Records that answer still-active questions are not candidates for recycling 5112 // Records that are currently linked into the CacheFlushRecords list may not be recycled, or we'll crash 5113 if ((*rp)->CRActiveQuestion || (*rp)->NextInCFList) 5114 rp=&(*rp)->next; 5115 else 5116 { 5117 CacheRecord *rr = *rp; 5118 *rp = (*rp)->next; // Cut record from list 5119 ReleaseCacheRecord(m, rr); 5120 } 5121 } 5122 if ((*cp)->rrcache_tail != rp) 5123 verbosedebugf("GetFreeCacheRR: Updating rrcache_tail[%lu] from %p to %p", slot, (*cp)->rrcache_tail, rp); 5124 (*cp)->rrcache_tail = rp; 5125 if ((*cp)->members || (*cp)==PreserveCG) cp=&(*cp)->next; 5126 else ReleaseCacheGroup(m, cp); 5127 } 5128 } 5129 LogInfo("GetCacheEntity recycled %d records to reduce cache from %d to %d", 5130 oldtotalused - m->rrcache_totalused, oldtotalused, m->rrcache_totalused); 5131 } 5132 5133 if (m->rrcache_free) // If there are records in the free list, take one 5134 { 5135 e = m->rrcache_free; 5136 m->rrcache_free = e->next; 5137 if (++m->rrcache_totalused >= m->rrcache_report) 5138 { 5139 LogInfo("RR Cache now using %ld objects", m->rrcache_totalused); 5140 if (m->rrcache_report < 100) m->rrcache_report += 10; 5141 else if (m->rrcache_report < 1000) m->rrcache_report += 100; 5142 else m->rrcache_report += 1000; 5143 } 5144 mDNSPlatformMemZero(e, sizeof(*e)); 5145 } 5146 5147 m->lock_rrcache = 0; 5148 5149 return(e); 5150} 5151 5152mDNSlocal CacheRecord *GetCacheRecord(mDNS *const m, CacheGroup *cg, mDNSu16 RDLength) 5153{ 5154 CacheRecord *r = (CacheRecord *)GetCacheEntity(m, cg); 5155 if (r) 5156 { 5157 r->resrec.rdata = (RData*)&r->smallrdatastorage; // By default, assume we're usually going to be using local storage 5158 if (RDLength > InlineCacheRDSize) // If RDLength is too big, allocate extra storage 5159 { 5160 r->resrec.rdata = (RData*)mDNSPlatformMemAllocate(sizeofRDataHeader + RDLength); 5161 if (r->resrec.rdata) r->resrec.rdata->MaxRDLength = r->resrec.rdlength = RDLength; 5162 else { ReleaseCacheEntity(m, (CacheEntity*)r); r = mDNSNULL; } 5163 } 5164 } 5165 return(r); 5166} 5167 5168mDNSlocal CacheGroup *GetCacheGroup(mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr) 5169{ 5170 mDNSu16 namelen = DomainNameLength(rr->name); 5171 CacheGroup *cg = (CacheGroup*)GetCacheEntity(m, mDNSNULL); 5172 if (!cg) { LogMsg("GetCacheGroup: Failed to allocate memory for %##s", rr->name->c); return(mDNSNULL); } 5173 cg->next = m->rrcache_hash[slot]; 5174 cg->namehash = rr->namehash; 5175 cg->members = mDNSNULL; 5176 cg->rrcache_tail = &cg->members; 5177 if (namelen > sizeof(cg->namestorage)) 5178 cg->name = mDNSPlatformMemAllocate(namelen); 5179 else 5180 cg->name = (domainname*)cg->namestorage; 5181 if (!cg->name) 5182 { 5183 LogMsg("GetCacheGroup: Failed to allocate name storage for %##s", rr->name->c); 5184 ReleaseCacheEntity(m, (CacheEntity*)cg); 5185 return(mDNSNULL); 5186 } 5187 AssignDomainName(cg->name, rr->name); 5188 5189 if (CacheGroupForRecord(m, rr)) LogMsg("GetCacheGroup: Already have CacheGroup for %##s", rr->name->c); 5190 m->rrcache_hash[slot] = cg; 5191 if (CacheGroupForRecord(m, rr) != cg) LogMsg("GetCacheGroup: Not finding CacheGroup for %##s", rr->name->c); 5192 5193 return(cg); 5194} 5195 5196mDNSexport void mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr) 5197{ 5198 mDNS_CheckLock(m); 5199 5200 // Make sure we mark this record as thoroughly expired -- we don't ever want to give 5201 // a positive answer using an expired record (e.g. from an interface that has gone away). 5202 // We don't want to clear CRActiveQuestion here, because that would leave the record subject to 5203 // summary deletion without giving the proper callback to any questions that are monitoring it. 5204 // By setting UnansweredQueries to MaxUnansweredQueries we ensure it won't trigger any further expiration queries. 5205 rr->TimeRcvd = m->timenow - mDNSPlatformOneSecond * 60; 5206 rr->UnansweredQueries = MaxUnansweredQueries; 5207 rr->resrec.rroriginalttl = 0; 5208 SetNextCacheCheckTimeForRecord(m, rr); 5209} 5210 5211mDNSexport mDNSs32 mDNS_TimeNow(const mDNS *const m) 5212{ 5213 mDNSs32 time; 5214 mDNSPlatformLock(m); 5215 if (m->mDNS_busy) 5216 { 5217 LogMsg("mDNS_TimeNow called while holding mDNS lock. This is incorrect. Code protected by lock should just use m->timenow."); 5218 if (!m->timenow) LogMsg("mDNS_TimeNow: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy); 5219 } 5220 5221 if (m->timenow) time = m->timenow; 5222 else time = mDNS_TimeNow_NoLock(m); 5223 mDNSPlatformUnlock(m); 5224 return(time); 5225} 5226 5227// To avoid pointless CPU thrash, we use SetSPSProxyListChanged(X) to record the last interface that 5228// had its Sleep Proxy client list change, and defer to actual BPF reconfiguration to mDNS_Execute(). 5229// (GetNextScheduledEvent() returns "now" when m->SPSProxyListChanged is set) 5230#define SetSPSProxyListChanged(X) do { \ 5231 if (m->SPSProxyListChanged && m->SPSProxyListChanged != (X)) mDNSPlatformUpdateProxyList(m->SPSProxyListChanged); \ 5232 m->SPSProxyListChanged = (X); } while(0) 5233 5234// Called from mDNS_Execute() to expire stale proxy records 5235mDNSlocal void CheckProxyRecords(mDNS *const m, AuthRecord *list) 5236{ 5237 m->CurrentRecord = list; 5238 while (m->CurrentRecord) 5239 { 5240 AuthRecord *rr = m->CurrentRecord; 5241 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering && rr->WakeUp.HMAC.l[0]) 5242 { 5243 // If m->SPSSocket is NULL that means we're not acting as a sleep proxy any more, 5244 // so we need to cease proxying for *all* records we may have, expired or not. 5245 if (m->SPSSocket && m->timenow - rr->TimeExpire < 0) // If proxy record not expired yet, update m->NextScheduledSPS 5246 { 5247 if (m->NextScheduledSPS - rr->TimeExpire > 0) 5248 m->NextScheduledSPS = rr->TimeExpire; 5249 } 5250 else // else proxy record expired, so remove it 5251 { 5252 LogSPS("CheckProxyRecords: Removing %d H-MAC %.6a I-MAC %.6a %d %s", 5253 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, ARDisplayString(m, rr)); 5254 SetSPSProxyListChanged(rr->resrec.InterfaceID); 5255 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 5256 // Don't touch rr after this -- memory may have been free'd 5257 } 5258 } 5259 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 5260 // new records could have been added to the end of the list as a result of that call. 5261 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 5262 m->CurrentRecord = rr->next; 5263 } 5264} 5265 5266mDNSlocal void CheckRmvEventsForLocalRecords(mDNS *const m) 5267{ 5268 while (m->CurrentRecord) 5269 { 5270 AuthRecord *rr = m->CurrentRecord; 5271 if (rr->AnsweredLocalQ && rr->resrec.RecordType == kDNSRecordTypeDeregistering) 5272 { 5273 debugf("CheckRmvEventsForLocalRecords: Generating local RMV events for %s", ARDisplayString(m, rr)); 5274 rr->resrec.RecordType = kDNSRecordTypeShared; 5275 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); 5276 if (m->CurrentRecord == rr) // If rr still exists in list, restore its state now 5277 { 5278 rr->resrec.RecordType = kDNSRecordTypeDeregistering; 5279 rr->AnsweredLocalQ = mDNSfalse; 5280 // SendResponses normally calls CompleteDeregistration after sending goodbyes. 5281 // For LocalOnly records, we don't do that and hence we need to do that here. 5282 if (RRLocalOnly(rr)) CompleteDeregistration(m, rr); 5283 } 5284 } 5285 if (m->CurrentRecord == rr) // If m->CurrentRecord was not auto-advanced, do it ourselves now 5286 m->CurrentRecord = rr->next; 5287 } 5288} 5289 5290mDNSlocal void TimeoutQuestions_internal(mDNS *const m, DNSQuestion* questions, mDNSInterfaceID InterfaceID) 5291{ 5292 if (m->CurrentQuestion) 5293 LogMsg("TimeoutQuestions ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, 5294 DNSTypeName(m->CurrentQuestion->qtype)); 5295 m->CurrentQuestion = questions; 5296 while (m->CurrentQuestion) 5297 { 5298 DNSQuestion *const q = m->CurrentQuestion; 5299 if (q->StopTime) 5300 { 5301 if (!q->TimeoutQuestion) 5302 LogMsg("TimeoutQuestions: ERROR!! TimeoutQuestion not set, but StopTime set for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 5303 5304 if (m->timenow - q->StopTime >= 0) 5305 { 5306 LogInfo("TimeoutQuestions: question %p %##s timed out, time %d", q, q->qname.c, m->timenow - q->StopTime); 5307 q->LOAddressAnswers = 0; // unset since timing out the question 5308 GenerateNegativeResponse(m, InterfaceID, QC_forceresponse); 5309 if (m->CurrentQuestion == q) q->StopTime = 0; 5310 } 5311 else 5312 { 5313 if (m->NextScheduledStopTime - q->StopTime > 0) 5314 m->NextScheduledStopTime = q->StopTime; 5315 } 5316 } 5317 // If m->CurrentQuestion wasn't modified out from under us, advance it now 5318 // We can't do this at the start of the loop because GenerateNegativeResponse 5319 // depends on having m->CurrentQuestion point to the right question 5320 if (m->CurrentQuestion == q) 5321 m->CurrentQuestion = q->next; 5322 } 5323 m->CurrentQuestion = mDNSNULL; 5324} 5325 5326mDNSlocal void TimeoutQuestions(mDNS *const m) 5327{ 5328 m->NextScheduledStopTime = m->timenow + FutureTime; // push reschedule of TimeoutQuestions to way off into the future 5329 TimeoutQuestions_internal(m, m->Questions, mDNSInterface_Any); 5330 TimeoutQuestions_internal(m, m->LocalOnlyQuestions, mDNSInterface_LocalOnly); 5331} 5332 5333mDNSlocal void mDNSCoreFreeProxyRR(mDNS *const m) 5334{ 5335 AuthRecord *rrPtr = m->SPSRRSet, *rrNext = mDNSNULL; 5336 LogSPS("%s : Freeing stored sleep proxy A/AAAA records", __func__); 5337 while (rrPtr) 5338 { 5339 rrNext = rrPtr->next; 5340 mDNSPlatformMemFree(rrPtr); 5341 rrPtr = rrNext; 5342 } 5343 m->SPSRRSet = mDNSNULL; 5344} 5345 5346mDNSexport mDNSs32 mDNS_Execute(mDNS *const m) 5347{ 5348 mDNS_Lock(m); // Must grab lock before trying to read m->timenow 5349 5350 if (m->timenow - m->NextScheduledEvent >= 0) 5351 { 5352 int i; 5353 AuthRecord *head, *tail; 5354 mDNSu32 slot; 5355 AuthGroup *ag; 5356 5357 verbosedebugf("mDNS_Execute"); 5358 5359 if (m->CurrentQuestion) 5360 LogMsg("mDNS_Execute: ERROR m->CurrentQuestion already set: %##s (%s)", 5361 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 5362 5363 if (m->CurrentRecord) 5364 LogMsg("mDNS_Execute: ERROR m->CurrentRecord already set: %s", ARDisplayString(m, m->CurrentRecord)); 5365 5366 // 1. If we're past the probe suppression time, we can clear it 5367 if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0; 5368 5369 // 2. If it's been more than ten seconds since the last probe failure, we can clear the counter 5370 if (m->NumFailedProbes && m->timenow - m->ProbeFailTime >= mDNSPlatformOneSecond * 10) m->NumFailedProbes = 0; 5371 5372 // 3. Purge our cache of stale old records 5373 if (m->rrcache_size && m->timenow - m->NextCacheCheck >= 0) 5374 { 5375 mDNSu32 numchecked = 0; 5376 m->NextCacheCheck = m->timenow + FutureTime; 5377 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) 5378 { 5379 if (m->timenow - m->rrcache_nextcheck[slot] >= 0) 5380 { 5381 CacheGroup **cp = &m->rrcache_hash[slot]; 5382 m->rrcache_nextcheck[slot] = m->timenow + FutureTime; 5383 while (*cp) 5384 { 5385 debugf("m->NextCacheCheck %4d Slot %3d %##s", numchecked, slot, *cp ? (*cp)->name : (domainname*)"\x04NULL"); 5386 numchecked++; 5387 CheckCacheExpiration(m, slot, *cp); 5388 if ((*cp)->members) cp=&(*cp)->next; 5389 else ReleaseCacheGroup(m, cp); 5390 } 5391 } 5392 // Even if we didn't need to actually check this slot yet, still need to 5393 // factor its nextcheck time into our overall NextCacheCheck value 5394 if (m->NextCacheCheck - m->rrcache_nextcheck[slot] > 0) 5395 m->NextCacheCheck = m->rrcache_nextcheck[slot]; 5396 } 5397 debugf("m->NextCacheCheck %4d checked, next in %d", numchecked, m->NextCacheCheck - m->timenow); 5398 } 5399 5400 if (m->timenow - m->NextScheduledSPS >= 0) 5401 { 5402 m->NextScheduledSPS = m->timenow + FutureTime; 5403 CheckProxyRecords(m, m->DuplicateRecords); // Clear m->DuplicateRecords first, then m->ResourceRecords 5404 CheckProxyRecords(m, m->ResourceRecords); 5405 } 5406 5407 SetSPSProxyListChanged(mDNSNULL); // Perform any deferred BPF reconfiguration now 5408 5409 // Check to see if we need to send any keepalives. Do this after we called CheckProxyRecords above 5410 // as records could have expired during that check 5411 if (m->timenow - m->NextScheduledKA >= 0) 5412 { 5413 m->NextScheduledKA = m->timenow + FutureTime; 5414 mDNS_SendKeepalives(m); 5415 } 5416 5417#if BONJOUR_ON_DEMAND 5418 if (m->NextBonjourDisableTime && (m->timenow - m->NextBonjourDisableTime >= 0)) 5419 { 5420 // Schedule immediate network change processing to leave the multicast group 5421 // since the delay time has expired since the previous active registration or query. 5422 m->NetworkChanged = m->timenow; 5423 m->NextBonjourDisableTime = 0; 5424 m->BonjourEnabled = 0; 5425 5426 LogInfo("mDNS_Execute: Scheduled network changed processing to leave multicast group."); 5427 } 5428#endif // BONJOUR_ON_DEMAND 5429 5430 // Clear AnnounceOwner if necessary. (Do this *before* SendQueries() and SendResponses().) 5431 if (m->AnnounceOwner && m->timenow - m->AnnounceOwner >= 0) 5432 { 5433 m->AnnounceOwner = 0; 5434 5435 // This is a good time to reset the delay counter used to prevent spurious conflicts 5436 m->DelayConflictProcessing = 0; 5437 } 5438 5439 if (m->DelaySleep && m->timenow - m->DelaySleep >= 0) 5440 { 5441 m->DelaySleep = 0; 5442 if (m->SleepState == SleepState_Transferring) 5443 { 5444 LogSPS("Re-sleep delay passed; now checking for Sleep Proxy Servers"); 5445 BeginSleepProcessing(m); 5446 } 5447 } 5448 5449 // 4. See if we can answer any of our new local questions from the cache 5450 for (i=0; m->NewQuestions && i<1000; i++) 5451 { 5452 if (m->NewQuestions->DelayAnswering && m->timenow - m->NewQuestions->DelayAnswering < 0) break; 5453 AnswerNewQuestion(m); 5454 } 5455 if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit"); 5456 5457 // Make sure we deliver *all* local RMV events, and clear the corresponding rr->AnsweredLocalQ flags, *before* 5458 // we begin generating *any* new ADD events in the m->NewLocalOnlyQuestions and m->NewLocalRecords loops below. 5459 for (i=0; i<1000 && m->LocalRemoveEvents; i++) 5460 { 5461 m->LocalRemoveEvents = mDNSfalse; 5462 m->CurrentRecord = m->ResourceRecords; 5463 CheckRmvEventsForLocalRecords(m); 5464 // Walk the LocalOnly records and deliver the RMV events 5465 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 5466 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next) 5467 { 5468 m->CurrentRecord = ag->members; 5469 if (m->CurrentRecord) CheckRmvEventsForLocalRecords(m); 5470 } 5471 } 5472 5473 if (i >= 1000) LogMsg("mDNS_Execute: m->LocalRemoveEvents exceeded loop limit"); 5474 5475 for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m); 5476 if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit"); 5477 5478 head = tail = mDNSNULL; 5479 for (i=0; i<1000 && m->NewLocalRecords && m->NewLocalRecords != head; i++) 5480 { 5481 AuthRecord *rr = m->NewLocalRecords; 5482 m->NewLocalRecords = m->NewLocalRecords->next; 5483 if (LocalRecordReady(rr)) 5484 { 5485 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m, rr)); 5486 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue); 5487 } 5488 else if (!rr->next) 5489 { 5490 // If we have just one record that is not ready, we don't have to unlink and 5491 // reinsert. As the NewLocalRecords will be NULL for this case, the loop will 5492 // terminate and set the NewLocalRecords to rr. 5493 debugf("mDNS_Execute: Just one LocalAuthRecord %s, breaking out of the loop early", ARDisplayString(m, rr)); 5494 if (head != mDNSNULL || m->NewLocalRecords != mDNSNULL) 5495 LogMsg("mDNS_Execute: ERROR!!: head %p, NewLocalRecords %p", head, m->NewLocalRecords); 5496 5497 head = rr; 5498 } 5499 else 5500 { 5501 AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records 5502 debugf("mDNS_Execute: Skipping LocalAuthRecord %s", ARDisplayString(m, rr)); 5503 // if this is the first record we are skipping, move to the end of the list. 5504 // if we have already skipped records before, append it at the end. 5505 while (*p && *p != rr) p=&(*p)->next; 5506 if (*p) *p = rr->next; // Cut this record from the list 5507 else { LogMsg("mDNS_Execute: ERROR!! Cannot find record %s in ResourceRecords list", ARDisplayString(m, rr)); break; } 5508 if (!head) 5509 { 5510 while (*p) p=&(*p)->next; 5511 *p = rr; 5512 head = tail = rr; 5513 } 5514 else 5515 { 5516 tail->next = rr; 5517 tail = rr; 5518 } 5519 rr->next = mDNSNULL; 5520 } 5521 } 5522 m->NewLocalRecords = head; 5523 debugf("mDNS_Execute: Setting NewLocalRecords to %s", (head ? ARDisplayString(m, head) : "NULL")); 5524 5525 if (i >= 1000) LogMsg("mDNS_Execute: m->NewLocalRecords exceeded loop limit"); 5526 5527 // Check to see if we have any new LocalOnly/P2P records to examine for delivering 5528 // to our local questions 5529 if (m->NewLocalOnlyRecords) 5530 { 5531 m->NewLocalOnlyRecords = mDNSfalse; 5532 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 5533 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next) 5534 { 5535 for (i=0; i<100 && ag->NewLocalOnlyRecords; i++) 5536 { 5537 AuthRecord *rr = ag->NewLocalOnlyRecords; 5538 ag->NewLocalOnlyRecords = ag->NewLocalOnlyRecords->next; 5539 // LocalOnly records should always be ready as they never probe 5540 if (LocalRecordReady(rr)) 5541 { 5542 debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s", ARDisplayString(m, rr)); 5543 AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue); 5544 } 5545 else LogMsg("mDNS_Execute: LocalOnlyRecord %s not ready", ARDisplayString(m, rr)); 5546 } 5547 // We limit about 100 per AuthGroup that can be serviced at a time 5548 if (i >= 100) LogMsg("mDNS_Execute: ag->NewLocalOnlyRecords exceeded loop limit"); 5549 } 5550 } 5551 5552 // 5. See what packets we need to send 5553 if (m->mDNSPlatformStatus != mStatus_NoError || (m->SleepState == SleepState_Sleeping)) 5554 DiscardDeregistrations(m); 5555 if (m->mDNSPlatformStatus == mStatus_NoError && (m->SuppressSending == 0 || m->timenow - m->SuppressSending >= 0)) 5556 { 5557 // If the platform code is ready, and we're not suppressing packet generation right now 5558 // then send our responses, probes, and questions. 5559 // We check the cache first, because there might be records close to expiring that trigger questions to refresh them. 5560 // We send queries next, because there might be final-stage probes that complete their probing here, causing 5561 // them to advance to announcing state, and we want those to be included in any announcements we send out. 5562 // Finally, we send responses, including the previously mentioned records that just completed probing. 5563 m->SuppressSending = 0; 5564 5565 // 6. Send Query packets. This may cause some probing records to advance to announcing state 5566 if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m); 5567 if (m->timenow - m->NextScheduledQuery >= 0) 5568 { 5569 DNSQuestion *q; 5570 LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second", 5571 m->timenow, m->NextScheduledQuery, m->timenow - m->NextScheduledQuery); 5572 m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond; 5573 for (q = m->Questions; q && q != m->NewQuestions; q=q->next) 5574 if (ActiveQuestion(q) && m->timenow - NextQSendTime(q) >= 0) 5575 LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 5576 } 5577 if (m->timenow - m->NextScheduledProbe >= 0) 5578 { 5579 LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second", 5580 m->timenow, m->NextScheduledProbe, m->timenow - m->NextScheduledProbe); 5581 m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond; 5582 } 5583 5584 // 7. Send Response packets, including probing records just advanced to announcing state 5585 if (m->timenow - m->NextScheduledResponse >= 0) SendResponses(m); 5586 if (m->timenow - m->NextScheduledResponse >= 0) 5587 { 5588 LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second"); 5589 m->NextScheduledResponse = m->timenow + mDNSPlatformOneSecond; 5590 } 5591 } 5592 5593 // Clear RandomDelay values, ready to pick a new different value next time 5594 m->RandomQueryDelay = 0; 5595 m->RandomReconfirmDelay = 0; 5596 5597 // See if any questions (or local-only questions) have timed out 5598 if (m->NextScheduledStopTime && m->timenow - m->NextScheduledStopTime >= 0) TimeoutQuestions(m); 5599#ifndef UNICAST_DISABLED 5600 if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0) UpdateAllSRVRecords(m); 5601 if (m->timenow - m->NextScheduledNATOp >= 0) CheckNATMappings(m); 5602 if (m->timenow - m->NextuDNSEvent >= 0) uDNS_Tasks(m); 5603#endif 5604#if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR 5605 extern void serviceBLE(); 5606 if (m->NextBLEServiceTime && (m->timenow - m->NextBLEServiceTime >= 0)) serviceBLE(); 5607#endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR 5608 } 5609 5610 // Note about multi-threaded systems: 5611 // On a multi-threaded system, some other thread could run right after the mDNS_Unlock(), 5612 // performing mDNS API operations that change our next scheduled event time. 5613 // 5614 // On multi-threaded systems (like the current Windows implementation) that have a single main thread 5615 // calling mDNS_Execute() (and other threads allowed to call mDNS API routines) it is the responsibility 5616 // of the mDNSPlatformUnlock() routine to signal some kind of stateful condition variable that will 5617 // signal whatever blocking primitive the main thread is using, so that it will wake up and execute one 5618 // more iteration of its loop, and immediately call mDNS_Execute() again. The signal has to be stateful 5619 // in the sense that if the main thread has not yet entered its blocking primitive, then as soon as it 5620 // does, the state of the signal will be noticed, causing the blocking primitive to return immediately 5621 // without blocking. This avoids the race condition between the signal from the other thread arriving 5622 // just *before* or just *after* the main thread enters the blocking primitive. 5623 // 5624 // On multi-threaded systems (like the current Mac OS 9 implementation) that are entirely timer-driven, 5625 // with no main mDNS_Execute() thread, it is the responsibility of the mDNSPlatformUnlock() routine to 5626 // set the timer according to the m->NextScheduledEvent value, and then when the timer fires, the timer 5627 // callback function should call mDNS_Execute() (and ignore the return value, which may already be stale 5628 // by the time it gets to the timer callback function). 5629 5630 mDNS_Unlock(m); // Calling mDNS_Unlock is what gives m->NextScheduledEvent its new value 5631 return(m->NextScheduledEvent); 5632} 5633 5634#ifndef UNICAST_DISABLED 5635mDNSlocal void SuspendLLQs(mDNS *m) 5636{ 5637 DNSQuestion *q; 5638 for (q = m->Questions; q; q = q->next) 5639 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->state == LLQ_Established) 5640 { q->ReqLease = 0; sendLLQRefresh(m, q); } 5641} 5642#endif // UNICAST_DISABLED 5643 5644mDNSlocal mDNSBool QuestionHasLocalAnswers(mDNS *const m, DNSQuestion *q) 5645{ 5646 AuthRecord *rr; 5647 AuthGroup *ag; 5648 5649 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); 5650 if (ag) 5651 { 5652 for (rr = ag->members; rr; rr=rr->next) 5653 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME 5654 if (UniqueLocalOnlyRecord(rr) && LocalOnlyRecordAnswersQuestion(rr, q)) 5655 { 5656 LogInfo("QuestionHasLocalAnswers: Question %p %##s (%s) has local answer %s", q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr)); 5657 return mDNStrue; 5658 } 5659 } 5660 return mDNSfalse; 5661} 5662 5663// ActivateUnicastQuery() is called from three places: 5664// 1. When a new question is created 5665// 2. On wake from sleep 5666// 3. When the DNS configuration changes 5667// In case 1 we don't want to mess with our established ThisQInterval and LastQTime (ScheduleImmediately is false) 5668// In cases 2 and 3 we do want to cause the question to be resent immediately (ScheduleImmediately is true) 5669mDNSlocal void ActivateUnicastQuery(mDNS *const m, DNSQuestion *const question, mDNSBool ScheduleImmediately) 5670{ 5671 // For now this AutoTunnel stuff is specific to Mac OS X. 5672 // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer 5673#if APPLE_OSX_mDNSResponder 5674 // Even though BTMM client tunnels are only useful for AAAA queries, we need to treat v4 and v6 queries equally. 5675 // Otherwise we can get the situation where the A query completes really fast (with an NXDOMAIN result) and the 5676 // caller then gives up waiting for the AAAA result while we're still in the process of setting up the tunnel. 5677 // To level the playing field, we block both A and AAAA queries while tunnel setup is in progress, and then 5678 // returns results for both at the same time. If we are looking for the _autotunnel6 record, then skip this logic 5679 // as this would trigger looking up _autotunnel6._autotunnel6 and end up failing the original query. 5680 5681 if (RRTypeIsAddressType(question->qtype) && PrivateQuery(question) && 5682 !SameDomainLabel(question->qname.c, (const mDNSu8 *)"\x0c_autotunnel6")&& question->QuestionCallback != AutoTunnelCallback) 5683 { 5684 question->NoAnswer = NoAnswer_Suspended; 5685 AddNewClientTunnel(question); 5686 return; 5687 } 5688#endif // APPLE_OSX_mDNSResponder 5689 5690 if (!question->DuplicateOf) 5691 { 5692 debugf("ActivateUnicastQuery: %##s %s%s%s", 5693 question->qname.c, DNSTypeName(question->qtype), PrivateQuery(question) ? " (Private)" : "", ScheduleImmediately ? " ScheduleImmediately" : ""); 5694 question->CNAMEReferrals = 0; 5695 if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; } 5696 if (question->LongLived) 5697 { 5698 question->state = LLQ_InitialRequest; 5699 question->id = zeroOpaque64; 5700 question->servPort = zeroIPPort; 5701 if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; } 5702 } 5703 // If the question has local answers, then we don't want answers from outside 5704 if (ScheduleImmediately && !QuestionHasLocalAnswers(m, question)) 5705 { 5706 question->ThisQInterval = InitialQuestionInterval; 5707 question->LastQTime = m->timenow - question->ThisQInterval; 5708 SetNextQueryTime(m, question); 5709 } 5710 } 5711} 5712 5713// Caller should hold the lock 5714mDNSexport void mDNSCoreRestartAddressQueries(mDNS *const m, mDNSBool SearchDomainsChanged, FlushCache flushCacheRecords, 5715 CallbackBeforeStartQuery BeforeStartCallback, void *context) 5716{ 5717 DNSQuestion *q; 5718 DNSQuestion *restart = mDNSNULL; 5719 5720 mDNS_CheckLock(m); 5721 5722 // 1. Flush the cache records 5723 if (flushCacheRecords) flushCacheRecords(m); 5724 5725 // 2. Even though we may have purged the cache records above, before it can generate RMV event 5726 // we are going to stop the question. Hence we need to deliver the RMV event before we 5727 // stop the question. 5728 // 5729 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the 5730 // application callback can potentially stop the current question (detected by CurrentQuestion) or 5731 // *any* other question which could be the next one that we may process here. RestartQuestion 5732 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal 5733 // if the "next" question is stopped while the CurrentQuestion is stopped 5734 5735 if (m->RestartQuestion) 5736 LogMsg("mDNSCoreRestartAddressQueries: ERROR!! m->RestartQuestion already set: %##s (%s)", 5737 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); 5738 5739 m->RestartQuestion = m->Questions; 5740 while (m->RestartQuestion) 5741 { 5742 q = m->RestartQuestion; 5743 m->RestartQuestion = q->next; 5744 // GetZoneData questions are referenced by other questions (original query that started the GetZoneData 5745 // question) through their "nta" pointer. Normally when the original query stops, it stops the 5746 // GetZoneData question and also frees the memory (See CancelGetZoneData). If we stop the GetZoneData 5747 // question followed by the original query that refers to this GetZoneData question, we will end up 5748 // freeing the GetZoneData question and then start the "freed" question at the end. 5749 5750 if (IsGetZoneDataQuestion(q)) 5751 { 5752 DNSQuestion *refq = q->next; 5753 LogInfo("mDNSCoreRestartAddressQueries: Skipping GetZoneDataQuestion %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 5754 // debug stuff, we just try to find the referencing question and don't do much with it 5755 while (refq) 5756 { 5757 if (q == &refq->nta->question) 5758 { 5759 LogInfo("mDNSCoreRestartAddressQueries: Question %p %##s (%s) referring to GetZoneDataQuestion %p, not stopping", refq, refq->qname.c, DNSTypeName(refq->qtype), q); 5760 } 5761 refq = refq->next; 5762 } 5763 continue; 5764 } 5765 5766 // This function is called when /etc/hosts changes and that could affect A, AAAA and CNAME queries 5767 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA && q->qtype != kDNSType_CNAME) continue; 5768 5769 // If the search domains did not change, then we restart all the queries. Otherwise, only 5770 // for queries for which we "might" have appended search domains ("might" because we may 5771 // find results before we apply search domains even though AppendSearchDomains is set to 1) 5772 if (!SearchDomainsChanged || q->AppendSearchDomains) 5773 { 5774 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero 5775 // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before 5776 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers). Let us say that 5777 // /etc/hosts has an A Record for web.apple.com. Any queries for web.apple.com will be answered locally. 5778 // But this can't prevent a CNAME/AAAA query to not to be sent on the wire. When it is sent on the wire, 5779 // it could create cache entries. When we are restarting queries, we can't deliver the cache RMV events 5780 // for the original query using these cache entries as ADDs were never delivered using these cache 5781 // entries and hence this order is needed. 5782 5783 // If the query is suppressed, the RMV events won't be delivered 5784 if (!CacheRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Cache Record RMV events"); continue; } 5785 5786 // SuppressQuery status does not affect questions that are answered using local records 5787 if (!LocalRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Local Record RMV events"); continue; } 5788 5789 LogInfo("mDNSCoreRestartAddressQueries: Stop question %p %##s (%s), AppendSearchDomains %d, qnameOrig %p", q, 5790 q->qname.c, DNSTypeName(q->qtype), q->AppendSearchDomains, q->qnameOrig); 5791 mDNS_StopQuery_internal(m, q); 5792 // Reset state so that it looks like it was in the beginning i.e it should look at /etc/hosts, cache 5793 // and then search domains should be appended. At the beginning, qnameOrig was NULL. 5794 if (q->qnameOrig) 5795 { 5796 LogInfo("mDNSCoreRestartAddressQueries: qnameOrig %##s", q->qnameOrig); 5797 AssignDomainName(&q->qname, q->qnameOrig); 5798 mDNSPlatformMemFree(q->qnameOrig); 5799 q->qnameOrig = mDNSNULL; 5800 q->RetryWithSearchDomains = ApplySearchDomainsFirst(q) ? 1 : 0; 5801 } 5802 q->SearchListIndex = 0; 5803 q->next = restart; 5804 restart = q; 5805 } 5806 } 5807 5808 // 3. Callback before we start the query 5809 if (BeforeStartCallback) BeforeStartCallback(m, context); 5810 5811 // 4. Restart all the stopped queries 5812 while (restart) 5813 { 5814 q = restart; 5815 restart = restart->next; 5816 q->next = mDNSNULL; 5817 LogInfo("mDNSCoreRestartAddressQueries: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 5818 mDNS_StartQuery_internal(m, q); 5819 } 5820} 5821 5822mDNSexport void mDNSCoreRestartQueries(mDNS *const m) 5823{ 5824 DNSQuestion *q; 5825 5826#ifndef UNICAST_DISABLED 5827 // Retrigger all our uDNS questions 5828 if (m->CurrentQuestion) 5829 LogMsg("mDNSCoreRestartQueries: ERROR m->CurrentQuestion already set: %##s (%s)", 5830 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 5831 m->CurrentQuestion = m->Questions; 5832 while (m->CurrentQuestion) 5833 { 5834 q = m->CurrentQuestion; 5835 m->CurrentQuestion = m->CurrentQuestion->next; 5836 if (!mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) ActivateUnicastQuery(m, q, mDNStrue); 5837 } 5838#endif 5839 5840 // Retrigger all our mDNS questions 5841 for (q = m->Questions; q; q=q->next) // Scan our list of questions 5842 mDNSCoreRestartQuestion(m, q); 5843} 5844 5845// restart question if it's multicast and currently active 5846mDNSexport void mDNSCoreRestartQuestion(mDNS *const m, DNSQuestion *q) 5847{ 5848 if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) 5849 { 5850 q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question 5851 q->RequestUnicast = kDefaultRequestUnicastCount; 5852 q->LastQTime = m->timenow - q->ThisQInterval; 5853 q->RecentAnswerPkts = 0; 5854 ExpireDupSuppressInfo(q->DupSuppress, m->timenow); 5855 m->NextScheduledQuery = m->timenow; 5856 } 5857} 5858 5859// restart the probe/announce cycle for multicast record 5860mDNSexport void mDNSCoreRestartRegistration(mDNS *const m, AuthRecord *rr, int announceCount) 5861{ 5862 if (!AuthRecord_uDNS(rr)) 5863 { 5864 if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique; 5865 rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); 5866 5867 if (mDNS_KeepaliveRecord(&rr->resrec)) 5868 { 5869 rr->AnnounceCount = 0; // Do not announce keepalive records 5870 } 5871 else 5872 { 5873 // announceCount < 0 indicates default announce count should be used 5874 if (announceCount < 0) 5875 announceCount = InitialAnnounceCount; 5876 if (rr->AnnounceCount < (mDNSu8)announceCount) 5877 rr->AnnounceCount = (mDNSu8)announceCount; 5878 } 5879 5880 rr->SendNSECNow = mDNSNULL; 5881 InitializeLastAPTime(m, rr); 5882 } 5883} 5884 5885// *************************************************************************** 5886#if COMPILER_LIKES_PRAGMA_MARK 5887#pragma mark - 5888#pragma mark - Power Management (Sleep/Wake) 5889#endif 5890 5891mDNSexport void mDNS_UpdateAllowSleep(mDNS *const m) 5892{ 5893#ifndef IDLESLEEPCONTROL_DISABLED 5894 mDNSBool allowSleep = mDNStrue; 5895 char reason[128]; 5896 5897 reason[0] = 0; 5898 5899 if (m->SystemSleepOnlyIfWakeOnLAN) 5900 { 5901 // Don't sleep if we are a proxy for any services 5902 if (m->ProxyRecords) 5903 { 5904 allowSleep = mDNSfalse; 5905 mDNS_snprintf(reason, sizeof(reason), "sleep proxy for %d records", m->ProxyRecords); 5906 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because we are proxying %d records", m->ProxyRecords); 5907 } 5908 5909 if (allowSleep && mDNSCoreHaveAdvertisedMulticastServices(m)) 5910 { 5911 // Scan the list of active interfaces 5912 NetworkInterfaceInfo *intf; 5913 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 5914 { 5915 if (intf->McastTxRx && !intf->Loopback && !mDNSPlatformInterfaceIsD2D(intf->InterfaceID)) 5916 { 5917 // Disallow sleep if this interface doesn't support NetWake 5918 if (!intf->NetWake) 5919 { 5920 allowSleep = mDNSfalse; 5921 mDNS_snprintf(reason, sizeof(reason), "%s does not support NetWake", intf->ifname); 5922 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s does not support NetWake", intf->ifname); 5923 break; 5924 } 5925 5926 // If the interface can be an in-NIC Proxy, we should check if it can accomodate all the records 5927 // that will be offloaded. If not, we should prevent sleep. 5928 // This check will be possible once the lower layers provide an API to query the space available for offloads on the NIC. 5929#if APPLE_OSX_mDNSResponder 5930 if (!SupportsInNICProxy(intf)) 5931#endif 5932 { 5933 // Disallow sleep if there is no sleep proxy server 5934 const CacheRecord *cr = FindSPSInCache1(m, &intf->NetWakeBrowse, mDNSNULL, mDNSNULL); 5935 if ( cr == mDNSNULL) 5936 { 5937 allowSleep = mDNSfalse; 5938 mDNS_snprintf(reason, sizeof(reason), "No sleep proxy server on %s", intf->ifname); 5939 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s has no sleep proxy server", intf->ifname); 5940 break; 5941 } 5942 else if (m->SPSType != 0) 5943 { 5944 mDNSu32 mymetric = LocalSPSMetric(m); 5945 mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c); 5946 if (metric >= mymetric) 5947 { 5948 allowSleep = mDNSfalse; 5949 mDNS_snprintf(reason, sizeof(reason), "No sleep proxy server with better metric on %s", intf->ifname); 5950 LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s has no sleep proxy server with a better metric", intf->ifname); 5951 break; 5952 } 5953 } 5954 } 5955 } 5956 } 5957 } 5958 } 5959 5960 // Call the platform code to enable/disable sleep 5961 mDNSPlatformSetAllowSleep(allowSleep, reason); 5962#else 5963 (void) m; 5964#endif /* !defined(IDLESLEEPCONTROL_DISABLED) */ 5965} 5966 5967mDNSlocal mDNSBool mDNSUpdateOkToSend(mDNS *const m, AuthRecord *rr, NetworkInterfaceInfo *const intf, mDNSu32 scopeid) 5968{ 5969 // If it is not a uDNS record, check to see if the updateid is zero. "updateid" is cleared when we have 5970 // sent the resource record on all the interfaces. If the update id is not zero, check to see if it is time 5971 // to send. 5972 if (AuthRecord_uDNS(rr) || (rr->AuthFlags & AuthFlagsWakeOnly) || mDNSOpaque16IsZero(rr->updateid) || 5973 m->timenow - (rr->LastAPTime + rr->ThisAPInterval) < 0) 5974 { 5975 return mDNSfalse; 5976 } 5977 5978 // If we have a pending registration for "scopeid", it is ok to send the update on that interface. 5979 // If the scopeid is too big to check for validity, we don't check against updateIntID. When 5980 // we successfully update on all the interfaces (with whatever set in "rr->updateIntID"), we clear 5981 // updateid and we should have returned from above. 5982 // 5983 // Note: scopeid is the same as intf->InterfaceID. It is passed in so that we don't have to call the 5984 // platform function to extract the value from "intf" every time. 5985 5986 if ((scopeid >= (sizeof(rr->updateIntID) * mDNSNBBY) || bit_get_opaque64(rr->updateIntID, scopeid)) && 5987 (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID)) 5988 return mDNStrue; 5989 5990 return mDNSfalse; 5991} 5992 5993mDNSexport void UpdateRMAC(mDNS *const m, void *context) 5994{ 5995 IPAddressMACMapping *addrmap = (IPAddressMACMapping *)context ; 5996 m->CurrentRecord = m->ResourceRecords; 5997 5998 if (!addrmap) 5999 { 6000 LogMsg("UpdateRMAC: Address mapping is NULL"); 6001 return; 6002 } 6003 6004 while (m->CurrentRecord) 6005 { 6006 AuthRecord *rr = m->CurrentRecord; 6007 // If this is a non-sleep proxy keepalive record and the remote IP address matches, update the RData 6008 if (!rr->WakeUp.HMAC.l[0] && mDNS_KeepaliveRecord(&rr->resrec)) 6009 { 6010 mDNSAddr raddr; 6011 getKeepaliveRaddr(m, rr, &raddr); 6012 if (mDNSSameAddress(&raddr, &addrmap->ipaddr)) 6013 { 6014 // Update the MAC address only if it is not a zero MAC address 6015 mDNSEthAddr macAddr; 6016 mDNSu8 *ptr = GetValueForMACAddr((mDNSu8 *)(addrmap->ethaddr), (mDNSu8 *) (addrmap->ethaddr + sizeof(addrmap->ethaddr)), &macAddr); 6017 if (ptr != mDNSNULL && !mDNSEthAddressIsZero(macAddr)) 6018 { 6019 UpdateKeepaliveRData(m, rr, mDNSNULL, mDNStrue, (char *)(addrmap->ethaddr)); 6020 } 6021 } 6022 } 6023 m->CurrentRecord = rr->next; 6024 } 6025 6026 if (addrmap) 6027 mDNSPlatformMemFree(addrmap); 6028 6029} 6030 6031mDNSexport mStatus UpdateKeepaliveRData(mDNS *const m, AuthRecord *rr, NetworkInterfaceInfo *const intf, mDNSBool updateMac, char *ethAddr) 6032{ 6033 mDNSu16 newrdlength; 6034 mDNSAddr laddr = zeroAddr; 6035 mDNSAddr raddr = zeroAddr; 6036 mDNSEthAddr eth = zeroEthAddr; 6037 mDNSIPPort lport = zeroIPPort; 6038 mDNSIPPort rport = zeroIPPort; 6039 mDNSu32 timeout = 0; 6040 mDNSu32 seq = 0; 6041 mDNSu32 ack = 0; 6042 mDNSu16 win = 0; 6043 UTF8str255 txt; 6044 int rdsize; 6045 RData *newrd; 6046 mDNSTCPInfo mti; 6047 mStatus ret; 6048 6049 // Note: If we fail to update the DNS NULL record with additional information in this function, it will be registered 6050 // with the SPS like any other record. SPS will not send keepalives if it does not have additional information. 6051 mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); 6052 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport)) 6053 { 6054 LogMsg("UpdateKeepaliveRData: not a valid record %s for keepalive %#a:%d %#a:%d", ARDisplayString(m, rr), &laddr, lport.NotAnInteger, &raddr, rport.NotAnInteger); 6055 return mStatus_UnknownErr; 6056 } 6057 6058 if (updateMac) 6059 { 6060 if (laddr.type == mDNSAddrType_IPv4) 6061 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d h=%#a d=%#a l=%u r=%u m=%s", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ethAddr); 6062 else 6063 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d H=%#a D=%#a l=%u r=%u m=%s", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ethAddr); 6064 6065 } 6066 else 6067 { 6068 // If this keepalive packet would be sent on a different interface than the current one that we are processing 6069 // now, then we don't update the DNS NULL record. But we do not prevent it from registering with the SPS. When SPS sees 6070 // this DNS NULL record, it does not send any keepalives as it does not have all the information 6071 mDNSPlatformMemZero(&mti, sizeof (mDNSTCPInfo)); 6072 ret = mDNSPlatformRetrieveTCPInfo(&laddr, &lport, &raddr, &rport, &mti); 6073 if (ret != mStatus_NoError) 6074 { 6075 LogMsg("mDNSPlatformRetrieveTCPInfo: mDNSPlatformRetrieveTCPInfo failed %d", ret); 6076 return ret; 6077 } 6078 if ((intf != mDNSNULL) && (mti.IntfId != intf->InterfaceID)) 6079 { 6080 LogInfo("mDNSPlatformRetrieveTCPInfo: InterfaceID mismatch mti.IntfId = %p InterfaceID = %p", mti.IntfId, intf->InterfaceID); 6081 return mStatus_BadParamErr; 6082 } 6083 6084 if (laddr.type == mDNSAddrType_IPv4) 6085 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d h=%#a d=%#a l=%u r=%u m=%.6a s=%u a=%u w=%u", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ð, mti.seq, mti.ack, mti.window); 6086 else 6087 newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d H=%#a D=%#a l=%u r=%u m=%.6a s=%u a=%u w=%u", timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ð, mti.seq, mti.ack, mti.window); 6088 } 6089 6090 // Did we insert a null byte at the end ? 6091 if (newrdlength == (sizeof(txt.c) - 1)) 6092 { 6093 LogMsg("UpdateKeepaliveRData: could not allocate memory %s", ARDisplayString(m, rr)); 6094 return mStatus_NoMemoryErr; 6095 } 6096 6097 // Include the length for the null byte at the end 6098 txt.c[0] = newrdlength + 1; 6099 // Account for the first length byte and the null byte at the end 6100 newrdlength += 2; 6101 6102 rdsize = newrdlength > sizeof(RDataBody) ? newrdlength : sizeof(RDataBody); 6103 newrd = mDNSPlatformMemAllocate(sizeof(RData) - sizeof(RDataBody) + rdsize); 6104 if (!newrd) { LogMsg("UpdateKeepaliveRData: ptr NULL"); return mStatus_NoMemoryErr; } 6105 6106 newrd->MaxRDLength = (mDNSu16) rdsize; 6107 mDNSPlatformMemCopy(&newrd->u, txt.c, newrdlength); 6108 6109 // If we are updating the record for the first time, rdata points to rdatastorage as the rdata memory 6110 // was allocated as part of the AuthRecord itself. We allocate memory when we update the AuthRecord. 6111 // If the resource record has data that we allocated in a previous pass (to update MAC address), 6112 // free that memory here before copying in the new data. 6113 if ( rr->resrec.rdata != &rr->rdatastorage) 6114 { 6115 LogSPS("UpdateKeepaliveRData: Freed allocated memory for keep alive packet: %s ", ARDisplayString(m, rr)); 6116 mDNSPlatformMemFree(rr->resrec.rdata); 6117 } 6118 SetNewRData(&rr->resrec, newrd, newrdlength); // Update our rdata 6119 6120 LogSPS("UpdateKeepaliveRData: successfully updated the record %s", ARDisplayString(m, rr)); 6121 return mStatus_NoError; 6122} 6123 6124mDNSlocal void SendSPSRegistrationForOwner(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id, const OwnerOptData *const owner) 6125{ 6126 const int optspace = DNSOpt_Header_Space + DNSOpt_LeaseData_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC); 6127 const int sps = intf->NextSPSAttempt / 3; 6128 AuthRecord *rr; 6129 mDNSOpaque16 msgid; 6130 mDNSu32 scopeid; 6131 6132 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue); 6133 if (!intf->SPSAddr[sps].type) 6134 { 6135 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond; 6136 if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0) 6137 m->NextScheduledSPRetry = intf->NextSPSAttemptTime; 6138 LogSPS("SendSPSRegistration: %s SPS %d (%d) %##s not yet resolved", intf->ifname, intf->NextSPSAttempt, sps, intf->NetWakeResolve[sps].qname.c); 6139 goto exit; 6140 } 6141 6142 // Mark our mDNS records (not unicast records) for transfer to SPS 6143 if (mDNSOpaque16IsZero(id)) 6144 { 6145 // We may have to register this record over multiple interfaces and we don't want to 6146 // overwrite the id. We send the registration over interface X with id "IDX" and before 6147 // we get a response, we overwrite with id "IDY" for interface Y and we won't accept responses 6148 // for "IDX". Hence, we want to use the same ID across all interfaces. 6149 // 6150 // In the case of sleep proxy server transfering its records when it goes to sleep, the owner 6151 // option check below will set the same ID across the records from the same owner. Records 6152 // with different owner option gets different ID. 6153 msgid = mDNS_NewMessageID(m); 6154 for (rr = m->ResourceRecords; rr; rr=rr->next) 6155 { 6156 if (!(rr->AuthFlags & AuthFlagsWakeOnly) && rr->resrec.RecordType > kDNSRecordTypeDeregistering) 6157 { 6158 if (rr->resrec.InterfaceID == intf->InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name)))) 6159 { 6160 if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner))) 6161 { 6162 rr->SendRNow = mDNSInterfaceMark; // mark it now 6163 // When we are registering on the first interface, rr->updateid is zero in which case 6164 // initialize with the new ID. For subsequent interfaces, we want to use the same ID. 6165 // At the end, all the updates sent across all the interfaces with the same ID. 6166 if (mDNSOpaque16IsZero(rr->updateid)) 6167 rr->updateid = msgid; 6168 else 6169 msgid = rr->updateid; 6170 } 6171 } 6172 } 6173 } 6174 } 6175 else 6176 msgid = id; 6177 6178 while (1) 6179 { 6180 mDNSu8 *p = m->omsg.data; 6181 // To comply with RFC 2782, PutResourceRecord suppresses name compression for SRV records in unicast updates. 6182 // For now we follow that same logic for SPS registrations too. 6183 // If we decide to compress SRV records in SPS registrations in the future, we can achieve that by creating our 6184 // initial DNSMessage with h.flags set to zero, and then update it to UpdateReqFlags right before sending the packet. 6185 InitializeDNSMessage(&m->omsg.h, msgid, UpdateReqFlags); 6186 6187 for (rr = m->ResourceRecords; rr; rr=rr->next) 6188 if (rr->SendRNow || mDNSUpdateOkToSend(m, rr, intf, scopeid)) 6189 { 6190 if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner))) 6191 { 6192 mDNSu8 *newptr; 6193 const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.mDNS_numUpdates ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData) - optspace; 6194 6195 // If we can't update the keepalive record, don't send it 6196 if (mDNS_KeepaliveRecord(&rr->resrec) && (UpdateKeepaliveRData(m, rr, intf, mDNSfalse, mDNSNULL) != mStatus_NoError)) 6197 { 6198 if (scopeid < (sizeof(rr->updateIntID) * mDNSNBBY)) 6199 { 6200 bit_clr_opaque64(rr->updateIntID, scopeid); 6201 } 6202 rr->SendRNow = mDNSNULL; 6203 continue; 6204 } 6205 6206 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) 6207 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the 'unique' bit so PutResourceRecord will set it 6208 newptr = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit); 6209 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear 'unique' bit back to normal state 6210 if (!newptr) 6211 LogSPS("SendSPSRegistration put %s FAILED %d/%d %s", intf->ifname, p - m->omsg.data, limit - m->omsg.data, ARDisplayString(m, rr)); 6212 else 6213 { 6214 LogSPS("SendSPSRegistration put %s 0x%x 0x%x (updateid %d) %s", intf->ifname, rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(m->omsg.h.id), ARDisplayString(m, rr)); 6215 rr->SendRNow = mDNSNULL; 6216 rr->ThisAPInterval = mDNSPlatformOneSecond; 6217 rr->LastAPTime = m->timenow; 6218 // should be initialized above 6219 if (mDNSOpaque16IsZero(rr->updateid)) LogMsg("SendSPSRegistration: ERROR!! rr %s updateid is zero", ARDisplayString(m, rr)); 6220 if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 6221 m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval); 6222 p = newptr; 6223 } 6224 } 6225 } 6226 6227 if (!m->omsg.h.mDNS_numUpdates) break; 6228 else 6229 { 6230 AuthRecord opt; 6231 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 6232 opt.resrec.rrclass = NormalMaxDNSMessageData; 6233 opt.resrec.rdlength = sizeof(rdataOPT) * 2; // Two options in this OPT record 6234 opt.resrec.rdestimate = sizeof(rdataOPT) * 2; 6235 opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; 6236 opt.resrec.rdata->u.opt[0].optlen = DNSOpt_LeaseData_Space - 4; 6237 opt.resrec.rdata->u.opt[0].u.updatelease = DEFAULT_UPDATE_LEASE; 6238 if (!owner->HMAC.l[0]) // If no owner data, 6239 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[1]); // use our own interface information 6240 else // otherwise, use the owner data we were given 6241 { 6242 opt.resrec.rdata->u.opt[1].u.owner = *owner; 6243 opt.resrec.rdata->u.opt[1].opt = kDNSOpt_Owner; 6244 opt.resrec.rdata->u.opt[1].optlen = DNSOpt_Owner_Space(&owner->HMAC, &owner->IMAC) - 4; 6245 } 6246 LogSPS("SendSPSRegistration put %s %s", intf->ifname, ARDisplayString(m, &opt)); 6247 p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); 6248 if (!p) 6249 LogMsg("SendSPSRegistration: Failed to put OPT record (%d updates) %s", m->omsg.h.mDNS_numUpdates, ARDisplayString(m, &opt)); 6250 else 6251 { 6252 mStatus err; 6253 6254 LogSPS("SendSPSRegistration: Sending Update %s %d (%d) id %5d with %d records %d bytes to %#a:%d", intf->ifname, intf->NextSPSAttempt, sps, 6255 mDNSVal16(m->omsg.h.id), m->omsg.h.mDNS_numUpdates, p - m->omsg.data, &intf->SPSAddr[sps], mDNSVal16(intf->SPSPort[sps])); 6256 // if (intf->NextSPSAttempt < 5) m->omsg.h.flags = zeroID; // For simulating packet loss 6257 err = mDNSSendDNSMessage(m, &m->omsg, p, intf->InterfaceID, mDNSNULL, &intf->SPSAddr[sps], intf->SPSPort[sps], mDNSNULL, mDNSNULL, mDNSfalse); 6258 if (err) LogSPS("SendSPSRegistration: mDNSSendDNSMessage err %d", err); 6259 if (err && intf->SPSAddr[sps].type == mDNSAddrType_IPv4 && intf->NetWakeResolve[sps].ThisQInterval == -1) 6260 { 6261 LogSPS("SendSPSRegistration %d %##s failed to send to IPv4 address; will try IPv6 instead", sps, intf->NetWakeResolve[sps].qname.c); 6262 intf->NetWakeResolve[sps].qtype = kDNSType_AAAA; 6263 mDNS_StartQuery_internal(m, &intf->NetWakeResolve[sps]); 6264 return; 6265 } 6266 } 6267 } 6268 } 6269 6270 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond * 10; // If successful, update NextSPSAttemptTime 6271 6272exit: 6273 if (mDNSOpaque16IsZero(id) && intf->NextSPSAttempt < 8) intf->NextSPSAttempt++; 6274} 6275 6276mDNSlocal mDNSBool RecordIsFirstOccurrenceOfOwner(mDNS *const m, const AuthRecord *const rr) 6277{ 6278 AuthRecord *ar; 6279 for (ar = m->ResourceRecords; ar && ar != rr; ar=ar->next) 6280 if (mDNSPlatformMemSame(&rr->WakeUp, &ar->WakeUp, sizeof(rr->WakeUp))) return mDNSfalse; 6281 return mDNStrue; 6282} 6283 6284mDNSlocal void mDNSCoreStoreProxyRR(mDNS *const m, const mDNSInterfaceID InterfaceID, AuthRecord *const rr) 6285{ 6286 AuthRecord *newRR = mDNSPlatformMemAllocate(sizeof(AuthRecord)); 6287 6288 if (newRR == mDNSNULL) 6289 { 6290 LogSPS("%s : could not allocate memory for new resource record", __func__); 6291 return; 6292 } 6293 6294 mDNSPlatformMemZero(newRR, sizeof(AuthRecord)); 6295 mDNS_SetupResourceRecord(newRR, mDNSNULL, InterfaceID, rr->resrec.rrtype, 6296 rr->resrec.rroriginalttl, rr->resrec.RecordType, 6297 rr->ARType, mDNSNULL, mDNSNULL); 6298 6299 AssignDomainName(&newRR->namestorage, &rr->namestorage); 6300 newRR->resrec.rdlength = DomainNameLength(rr->resrec.name); 6301 newRR->resrec.namehash = DomainNameHashValue(newRR->resrec.name); 6302 newRR->resrec.rrclass = rr->resrec.rrclass; 6303 6304 if (rr->resrec.rrtype == kDNSType_A) 6305 { 6306 newRR->resrec.rdata->u.ipv4 = rr->resrec.rdata->u.ipv4; 6307 } 6308 else if (rr->resrec.rrtype == kDNSType_AAAA) 6309 { 6310 newRR->resrec.rdata->u.ipv6 = rr->resrec.rdata->u.ipv6; 6311 } 6312 SetNewRData(&newRR->resrec, mDNSNULL, 0); 6313 6314 // Insert the new node at the head of the list. 6315 newRR->next = m->SPSRRSet; 6316 m->SPSRRSet = newRR; 6317 LogSPS("%s : Storing proxy record : %s ", __func__, ARDisplayString(m, rr)); 6318} 6319 6320// Some records are interface specific and some are not. The ones that are supposed to be registered 6321// on multiple interfaces need to be initialized with all the valid interfaces on which it will be sent. 6322// updateIntID bit field tells us on which interfaces we need to register this record. When we get an 6323// ack from the sleep proxy server, we clear the interface bit. This way, we know when a record completes 6324// registration on all the interfaces 6325mDNSlocal void SPSInitRecordsBeforeUpdate(mDNS *const m, mDNSOpaque64 updateIntID, mDNSBool *WakeOnlyService) 6326{ 6327 AuthRecord *ar; 6328 LogSPS("SPSInitRecordsBeforeUpdate: UpdateIntID 0x%x 0x%x", updateIntID.l[1], updateIntID.l[0]); 6329 6330 *WakeOnlyService = mDNSfalse; 6331 6332 // Before we store the A and AAAA records that we are going to register with the sleep proxy, 6333 // make sure that the old sleep proxy records are removed. 6334 mDNSCoreFreeProxyRR(m); 6335 6336 // For records that are registered only on a specific interface, mark only that bit as it will 6337 // never be registered on any other interface. For others, it should be sent on all interfaces. 6338 for (ar = m->ResourceRecords; ar; ar=ar->next) 6339 { 6340 ar->updateIntID = zeroOpaque64; 6341 ar->updateid = zeroID; 6342 if (AuthRecord_uDNS(ar)) 6343 { 6344 continue; 6345 } 6346 if (ar->AuthFlags & AuthFlagsWakeOnly) 6347 { 6348 if (ar->resrec.RecordType == kDNSRecordTypeShared && ar->RequireGoodbye) 6349 { 6350 ar->ImmedAnswer = mDNSInterfaceMark; 6351 *WakeOnlyService = mDNStrue; 6352 continue; 6353 } 6354 } 6355 if (!ar->resrec.InterfaceID) 6356 { 6357 LogSPS("Setting scopeid (ALL) 0x%x 0x%x for %s", updateIntID.l[1], updateIntID.l[0], ARDisplayString(m, ar)); 6358 ar->updateIntID = updateIntID; 6359 } 6360 else 6361 { 6362 // Filter records that belong to interfaces that we won't register the records on. UpdateIntID captures 6363 // exactly this. 6364 mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, ar->resrec.InterfaceID, mDNStrue); 6365 if ((scopeid < (sizeof(updateIntID) * mDNSNBBY)) && bit_get_opaque64(updateIntID, scopeid)) 6366 { 6367 bit_set_opaque64(ar->updateIntID, scopeid); 6368 LogSPS("SPSInitRecordsBeforeUpdate: Setting scopeid(%d) 0x%x 0x%x for %s", scopeid, ar->updateIntID.l[1], 6369 ar->updateIntID.l[0], ARDisplayString(m, ar)); 6370 } 6371 else 6372 { 6373 LogSPS("SPSInitRecordsBeforeUpdate: scopeid %d beyond range or not valid for SPS registration", scopeid); 6374 } 6375 } 6376 // Store the A and AAAA records that we registered with the sleep proxy. 6377 // We will use this to prevent spurious name conflicts that may occur when we wake up 6378 if (ar->resrec.rrtype == kDNSType_A || ar->resrec.rrtype == kDNSType_AAAA) 6379 { 6380 mDNSCoreStoreProxyRR(m, ar->resrec.InterfaceID, ar); 6381 } 6382 } 6383} 6384 6385mDNSlocal void SendSPSRegistration(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id) 6386{ 6387 AuthRecord *ar; 6388 OwnerOptData owner = zeroOwner; 6389 6390 SendSPSRegistrationForOwner(m, intf, id, &owner); 6391 6392 for (ar = m->ResourceRecords; ar; ar=ar->next) 6393 { 6394 if (!mDNSPlatformMemSame(&owner, &ar->WakeUp, sizeof(owner)) && RecordIsFirstOccurrenceOfOwner(m, ar)) 6395 { 6396 owner = ar->WakeUp; 6397 SendSPSRegistrationForOwner(m, intf, id, &owner); 6398 } 6399 } 6400} 6401 6402// RetrySPSRegistrations is called from SendResponses, with the lock held 6403mDNSlocal void RetrySPSRegistrations(mDNS *const m) 6404{ 6405 AuthRecord *rr; 6406 NetworkInterfaceInfo *intf; 6407 6408 // First make sure none of our interfaces' NextSPSAttemptTimes are inadvertently set to m->timenow + mDNSPlatformOneSecond * 10 6409 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 6410 if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10) 6411 intf->NextSPSAttemptTime++; 6412 6413 // Retry any record registrations that are due 6414 for (rr = m->ResourceRecords; rr; rr=rr->next) 6415 if (!AuthRecord_uDNS(rr) && !mDNSOpaque16IsZero(rr->updateid) && m->timenow - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 6416 { 6417 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 6418 { 6419 // If we still have registrations pending on this interface, send it now 6420 mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue); 6421 if ((scopeid >= (sizeof(rr->updateIntID) * mDNSNBBY) || bit_get_opaque64(rr->updateIntID, scopeid)) && 6422 (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID)) 6423 { 6424 LogSPS("RetrySPSRegistrations: 0x%x 0x%x (updateid %d) %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m, rr)); 6425 SendSPSRegistration(m, intf, rr->updateid); 6426 } 6427 } 6428 } 6429 6430 // For interfaces where we did an SPS registration attempt, increment intf->NextSPSAttempt 6431 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 6432 if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10 && intf->NextSPSAttempt < 8) 6433 intf->NextSPSAttempt++; 6434} 6435 6436mDNSlocal void NetWakeResolve(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 6437{ 6438 NetworkInterfaceInfo *intf = (NetworkInterfaceInfo *)question->QuestionContext; 6439 int sps = (int)(question - intf->NetWakeResolve); 6440 (void)m; // Unused 6441 LogSPS("NetWakeResolve: SPS: %d Add: %d %s", sps, AddRecord, RRDisplayString(m, answer)); 6442 6443 if (!AddRecord) return; // Don't care about REMOVE events 6444 if (answer->rrtype != question->qtype) return; // Don't care about CNAMEs 6445 6446 // if (answer->rrtype == kDNSType_AAAA && sps == 0) return; // To test failing to resolve sleep proxy's address 6447 6448 if (answer->rrtype == kDNSType_SRV) 6449 { 6450 // 1. Got the SRV record; now look up the target host's IP address 6451 mDNS_StopQuery(m, question); 6452 intf->SPSPort[sps] = answer->rdata->u.srv.port; 6453 AssignDomainName(&question->qname, &answer->rdata->u.srv.target); 6454 question->qtype = kDNSType_A; 6455 mDNS_StartQuery(m, question); 6456 } 6457 else if (answer->rrtype == kDNSType_A && answer->rdlength == sizeof(mDNSv4Addr)) 6458 { 6459 // 2. Got an IPv4 address for the target host; record address and initiate an SPS registration if appropriate 6460 mDNS_StopQuery(m, question); 6461 question->ThisQInterval = -1; 6462 intf->SPSAddr[sps].type = mDNSAddrType_IPv4; 6463 intf->SPSAddr[sps].ip.v4 = answer->rdata->u.ipv4; 6464 mDNS_Lock(m); 6465 if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now 6466 mDNS_Unlock(m); 6467 } 6468 else if (answer->rrtype == kDNSType_A && answer->rdlength == 0) 6469 { 6470 // 3. Got negative response -- target host apparently has IPv6 disabled -- so try looking up the target host's IPv4 address(es) instead 6471 mDNS_StopQuery(m, question); 6472 LogSPS("NetWakeResolve: SPS %d %##s has no IPv4 address, will try IPv6 instead", sps, question->qname.c); 6473 question->qtype = kDNSType_AAAA; 6474 mDNS_StartQuery(m, question); 6475 } 6476 else if (answer->rrtype == kDNSType_AAAA && answer->rdlength == sizeof(mDNSv6Addr) && mDNSv6AddressIsLinkLocal(&answer->rdata->u.ipv6)) 6477 { 6478 // 4. Got the target host's IPv6 link-local address; record address and initiate an SPS registration if appropriate 6479 mDNS_StopQuery(m, question); 6480 question->ThisQInterval = -1; 6481 intf->SPSAddr[sps].type = mDNSAddrType_IPv6; 6482 intf->SPSAddr[sps].ip.v6 = answer->rdata->u.ipv6; 6483 mDNS_Lock(m); 6484 if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now 6485 mDNS_Unlock(m); 6486 } 6487} 6488 6489mDNSexport mDNSBool mDNSCoreHaveAdvertisedMulticastServices(mDNS *const m) 6490{ 6491 AuthRecord *rr; 6492 for (rr = m->ResourceRecords; rr; rr=rr->next) 6493 if (mDNS_KeepaliveRecord(&rr->resrec) || (rr->resrec.rrtype == kDNSType_SRV && !AuthRecord_uDNS(rr) && !mDNSSameIPPort(rr->resrec.rdata->u.srv.port, DiscardPort))) 6494 return mDNStrue; 6495 return mDNSfalse; 6496} 6497 6498#define WAKE_ONLY_SERVICE 1 6499#define AC_ONLY_SERVICE 2 6500 6501#ifdef APPLE_OSX_mDNSResponder 6502mDNSlocal void SendGoodbyesForSelectServices(mDNS *const m, mDNSBool *servicePresent, mDNSu32 serviceType) 6503{ 6504 AuthRecord *rr; 6505 *servicePresent = mDNSfalse; 6506 6507 // Mark all the records we need to deregister and send them 6508 for (rr = m->ResourceRecords; rr; rr=rr->next) 6509 { 6510 // If the service type is wake only service and the auth flags match and requires a goodbye 6511 // OR if the service type is AC only and it is not a keepalive record, 6512 // mark the records we need to deregister and send them 6513 if ((serviceType == WAKE_ONLY_SERVICE && (rr->AuthFlags & AuthFlagsWakeOnly) && 6514 rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) || 6515 (serviceType == AC_ONLY_SERVICE && !mDNS_KeepaliveRecord(&rr->resrec))) 6516 { 6517 rr->ImmedAnswer = mDNSInterfaceMark; 6518 *servicePresent = mDNStrue; 6519 } 6520 } 6521} 6522#endif 6523 6524#ifdef APPLE_OSX_mDNSResponder 6525// This function is used only in the case of local NIC proxy. For external 6526// sleep proxy server, we do this in SPSInitRecordsBeforeUpdate when we 6527// walk the resource records. 6528mDNSlocal void SendGoodbyesForWakeOnlyService(mDNS *const m, mDNSBool *WakeOnlyService) 6529{ 6530 return SendGoodbyesForSelectServices(m, WakeOnlyService, WAKE_ONLY_SERVICE); 6531} 6532#endif // APPLE_OSX_mDNSResponder 6533 6534 6535mDNSlocal void SendSleepGoodbyes(mDNS *const m, mDNSBool AllInterfaces, mDNSBool unicast) 6536{ 6537 AuthRecord *rr; 6538 m->SleepState = SleepState_Sleeping; 6539 6540 // If AllInterfaces is not set, the caller has already marked it appropriately 6541 // on which interfaces this should be sent. 6542 if (AllInterfaces) 6543 { 6544 NetworkInterfaceInfo *intf; 6545 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 6546 { 6547 intf->SendGoodbyes = 1; 6548 } 6549 } 6550 if (unicast) 6551 { 6552#ifndef UNICAST_DISABLED 6553 SleepRecordRegistrations(m); // If we have no SPS, need to deregister our uDNS records 6554#endif /* UNICAST_DISABLED */ 6555 } 6556 6557 // Mark all the records we need to deregister and send them 6558 for (rr = m->ResourceRecords; rr; rr=rr->next) 6559 if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) 6560 rr->ImmedAnswer = mDNSInterfaceMark; 6561 SendResponses(m); 6562} 6563 6564/* 6565 * This function attempts to detect if multiple interfaces are on the same subnet. 6566 * It makes this determination based only on the IPv4 Addresses and subnet masks. 6567 * IPv6 link local addresses that are configured by default on all interfaces make 6568 * it hard to make this determination 6569 * 6570 * The 'real' fix for this would be to send out multicast packets over one interface 6571 * and conclude that multiple interfaces are on the same subnet only if these packets 6572 * are seen on other interfaces on the same system 6573 */ 6574mDNSlocal mDNSBool skipSameSubnetRegistration(mDNS *const m, mDNSInterfaceID *regID, mDNSu32 count, mDNSInterfaceID intfid) 6575{ 6576 NetworkInterfaceInfo *intf; 6577 NetworkInterfaceInfo *newIntf; 6578 mDNSu32 i; 6579 6580 for (newIntf = FirstInterfaceForID(m, intfid); newIntf; newIntf = newIntf->next) 6581 { 6582 if ((newIntf->InterfaceID != intfid) || 6583 (newIntf->ip.type != mDNSAddrType_IPv4)) 6584 { 6585 continue; 6586 } 6587 for ( i = 0; i < count; i++) 6588 { 6589 for (intf = FirstInterfaceForID(m, regID[i]); intf; intf = intf->next) 6590 { 6591 if ((intf->InterfaceID != regID[i]) || 6592 (intf->ip.type != mDNSAddrType_IPv4)) 6593 { 6594 continue; 6595 } 6596 if ((intf->ip.ip.v4.NotAnInteger & intf->mask.ip.v4.NotAnInteger) == (newIntf->ip.ip.v4.NotAnInteger & newIntf->mask.ip.v4.NotAnInteger)) 6597 { 6598 LogSPS("%s : Already registered for the same subnet (IPv4) for interface %s", __func__, intf->ifname); 6599 return (mDNStrue); 6600 } 6601 } 6602 } 6603 } 6604 return (mDNSfalse); 6605} 6606 6607mDNSlocal void DoKeepaliveCallbacks(mDNS *m) 6608{ 6609 // Loop through the keepalive records and callback with an error 6610 m->CurrentRecord = m->ResourceRecords; 6611 while (m->CurrentRecord) 6612 { 6613 AuthRecord *const rr = m->CurrentRecord; 6614 if ((mDNS_KeepaliveRecord(&rr->resrec)) && (rr->resrec.RecordType != kDNSRecordTypeDeregistering)) 6615 { 6616 LogSPS("DoKeepaliveCallbacks: Invoking the callback for %s", ARDisplayString(m, rr)); 6617 if (rr->RecordCallback) 6618 rr->RecordCallback(m, rr, mStatus_BadStateErr); 6619 } 6620 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 6621 m->CurrentRecord = rr->next; 6622 } 6623} 6624 6625// BeginSleepProcessing is called, with the lock held, from either mDNS_Execute or mDNSCoreMachineSleep 6626mDNSlocal void BeginSleepProcessing(mDNS *const m) 6627{ 6628 mDNSBool SendGoodbyes = mDNStrue; 6629 mDNSBool WakeOnlyService = mDNSfalse; 6630 mDNSBool invokeKACallback = mDNStrue; 6631 const CacheRecord *sps[3] = { mDNSNULL }; 6632 mDNSOpaque64 updateIntID = zeroOpaque64; 6633 mDNSInterfaceID registeredIntfIDS[128] = { 0 }; 6634 mDNSu32 registeredCount = 0; 6635 int skippedRegistrations = 0; 6636 6637 m->NextScheduledSPRetry = m->timenow; 6638 6639 // Clear out the SCDynamic entry that stores the external SPS information 6640 mDNSPlatformClearSPSData(); 6641 6642 if (!m->SystemWakeOnLANEnabled) LogSPS("BeginSleepProcessing: m->SystemWakeOnLANEnabled is false"); 6643 else if (!mDNSCoreHaveAdvertisedMulticastServices(m)) LogSPS("BeginSleepProcessing: No advertised services"); 6644 else // If we have at least one advertised service 6645 { 6646 NetworkInterfaceInfo *intf; 6647 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 6648 { 6649 // Intialize it to false. These values make sense only when SleepState is set to Sleeping. 6650 intf->SendGoodbyes = 0; 6651 6652 // If it is not multicast capable, we could not have possibly discovered sleep proxy 6653 // servers. 6654 if (!intf->McastTxRx || mDNSPlatformInterfaceIsD2D(intf->InterfaceID)) 6655 { 6656 LogSPS("BeginSleepProcessing: %-6s Ignoring for registrations", intf->ifname); 6657 continue; 6658 } 6659 6660 // If we are not capable of WOMP, then don't register with sleep proxy. 6661 // 6662 // Note: If we are not NetWake capable, we don't browse for the sleep proxy server. 6663 // We might find sleep proxy servers in the cache and start a resolve on them. 6664 // But then if the interface goes away, we won't stop these questions because 6665 // mDNS_DeactivateNetWake_internal assumes that a browse has been started for it 6666 // to stop both the browse and resolve questions. 6667 if (!intf->NetWake) 6668 { 6669 LogSPS("BeginSleepProcessing: %-6s not capable of magic packet wakeup", intf->ifname); 6670 intf->SendGoodbyes = 1; 6671 skippedRegistrations++; 6672 continue; 6673 } 6674 6675 // Check if we have already registered with a sleep proxy for this subnet 6676 if (skipSameSubnetRegistration(m, registeredIntfIDS, registeredCount, intf->InterfaceID)) 6677 { 6678 LogSPS("%s : Skipping sleep proxy registration on %s", __func__, intf->ifname); 6679 continue; 6680 } 6681 6682#if APPLE_OSX_mDNSResponder 6683 else if (SupportsInNICProxy(intf)) 6684 { 6685 mDNSBool keepaliveOnly = mDNSfalse; 6686 if (ActivateLocalProxy(intf, &keepaliveOnly) == mStatus_NoError) 6687 { 6688 SendGoodbyesForWakeOnlyService(m, &WakeOnlyService); 6689 6690 // Send goodbyes for all advertised services if the only record offloaded was the keepalive record. 6691 SendGoodbyes = (keepaliveOnly) ? mDNStrue: mDNSfalse; 6692 invokeKACallback = mDNSfalse; 6693 LogSPS("BeginSleepProcessing: %-6s using local proxy", intf->ifname); 6694 // This will leave m->SleepState set to SleepState_Transferring, 6695 // which is okay because with no outstanding resolves, or updates in flight, 6696 // mDNSCoreReadyForSleep() will conclude correctly that all the updates have already completed 6697 6698 // Setting this flag activates the SleepLimit which delays sleep by 5 seconds and 6699 // will allow the system to deregister any BTMM records. 6700 m->NextScheduledSPRetry = m->timenow + (5 * mDNSPlatformOneSecond); 6701 registeredIntfIDS[registeredCount] = intf->InterfaceID; 6702 registeredCount++; 6703 } 6704 } 6705#endif // APPLE_OSX_mDNSResponder 6706 else 6707 { 6708#if APPLE_OSX_mDNSResponder 6709 // If on battery, do not attempt to offload to external sleep proxies 6710 if (m->SystemWakeOnLANEnabled == mDNS_WakeOnBattery) 6711 { 6712 LogSPS("BegingSleepProcessing: Not connected to AC power - Not registering with an external sleep proxy."); 6713 return; 6714 } 6715#endif // APPLE_OSX_mDNSResponder 6716 FindSPSInCache(m, &intf->NetWakeBrowse, sps); 6717 if (!sps[0]) LogSPS("BeginSleepProcessing: %-6s %#a No Sleep Proxy Server found (Next Browse Q in %d, interval %d)", 6718 intf->ifname, &intf->ip, NextQSendTime(&intf->NetWakeBrowse) - m->timenow, intf->NetWakeBrowse.ThisQInterval); 6719 else 6720 { 6721 int i; 6722 mDNSu32 scopeid; 6723 SendGoodbyes = mDNSfalse; 6724 intf->NextSPSAttempt = 0; 6725 intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond; 6726 6727 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue); 6728 // Now we know for sure that we have to wait for registration to complete on this interface. 6729 if (scopeid < (sizeof(updateIntID) * mDNSNBBY)) 6730 bit_set_opaque64(updateIntID, scopeid); 6731 6732 // Don't need to set m->NextScheduledSPRetry here because we already set "m->NextScheduledSPRetry = m->timenow" above 6733 for (i=0; i<3; i++) 6734 { 6735#if ForceAlerts 6736 if (intf->SPSAddr[i].type) 6737 LogFatalError("BeginSleepProcessing: %s %d intf->SPSAddr[i].type %d", intf->ifname, i, intf->SPSAddr[i].type); 6738 if (intf->NetWakeResolve[i].ThisQInterval >= 0) 6739 LogFatalError("BeginSleepProcessing: %s %d intf->NetWakeResolve[i].ThisQInterval %d", intf->ifname, i, intf->NetWakeResolve[i].ThisQInterval); 6740#endif 6741 intf->SPSAddr[i].type = mDNSAddrType_None; 6742 if (intf->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery(m, &intf->NetWakeResolve[i]); 6743 intf->NetWakeResolve[i].ThisQInterval = -1; 6744 if (sps[i]) 6745 { 6746 LogSPS("BeginSleepProcessing: %-6s Found Sleep Proxy Server %d TTL %d %s", intf->ifname, i, sps[i]->resrec.rroriginalttl, CRDisplayString(m, sps[i])); 6747 mDNS_SetupQuestion(&intf->NetWakeResolve[i], intf->InterfaceID, &sps[i]->resrec.rdata->u.name, kDNSType_SRV, NetWakeResolve, intf); 6748 intf->NetWakeResolve[i].ReturnIntermed = mDNStrue; 6749 mDNS_StartQuery_internal(m, &intf->NetWakeResolve[i]); 6750 6751 // If we are registering with a Sleep Proxy for a new subnet, add it to our list 6752 registeredIntfIDS[registeredCount] = intf->InterfaceID; 6753 registeredCount++; 6754 } 6755 } 6756 } 6757 } 6758 } 6759 } 6760 6761 // If we have at least one interface on which we are registering with an external sleep proxy, 6762 // initialize all the records appropriately. 6763 if (!mDNSOpaque64IsZero(&updateIntID)) 6764 SPSInitRecordsBeforeUpdate(m, updateIntID, &WakeOnlyService); 6765 6766 // Call the applicaitons that registered a keepalive record to inform them that we failed to offload 6767 // the records to a sleep proxy. 6768 if (invokeKACallback) 6769 { 6770 LogSPS("BeginSleepProcessing: Did not register with an in-NIC proxy - invoking the callbacks for KA records"); 6771 DoKeepaliveCallbacks(m); 6772 } 6773 6774 // SendSleepGoodbyes last two arguments control whether we send goodbyes on all 6775 // interfaces and also deregister unicast registrations. 6776 // 6777 // - If there are no sleep proxy servers, then send goodbyes on all interfaces 6778 // for both multicast and unicast. 6779 // 6780 // - If we skipped registrations on some interfaces, then we have already marked 6781 // them appropriately above. We don't need to send goodbyes for unicast as 6782 // we have registered with at least one sleep proxy. 6783 // 6784 // - If we are not planning to send any goodbyes, then check for WakeOnlyServices. 6785 // 6786 // Note: If we are planning to send goodbyes, we mark the record with mDNSInterfaceAny 6787 // and call SendResponses which inturn calls ShouldSendGoodbyesBeforeSleep which looks 6788 // at WakeOnlyServices first. 6789 if (SendGoodbyes) 6790 { 6791 LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server"); 6792 SendSleepGoodbyes(m, mDNStrue, mDNStrue); 6793 } 6794 else if (skippedRegistrations) 6795 { 6796 LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server on all interfaces"); 6797 SendSleepGoodbyes(m, mDNSfalse, mDNSfalse); 6798 } 6799 else if (WakeOnlyService) 6800 { 6801 // If we saw WakeOnly service above, send the goodbyes now. 6802 LogSPS("BeginSleepProcessing: Sending goodbyes for WakeOnlyService"); 6803 SendResponses(m); 6804 } 6805} 6806 6807// Call mDNSCoreMachineSleep(m, mDNStrue) when the machine is about to go to sleep. 6808// Call mDNSCoreMachineSleep(m, mDNSfalse) when the machine is has just woken up. 6809// Normally, the platform support layer below mDNSCore should call this, not the client layer above. 6810mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleep) 6811{ 6812 AuthRecord *rr; 6813 6814 LogSPS("%s (old state %d) at %ld", sleep ? "Sleeping" : "Waking", m->SleepState, m->timenow); 6815 6816 if (sleep && !m->SleepState) // Going to sleep 6817 { 6818 mDNS_Lock(m); 6819 // If we're going to sleep, need to stop advertising that we're a Sleep Proxy Server 6820 if (m->SPSSocket) 6821 { 6822 mDNSu8 oldstate = m->SPSState; 6823 mDNS_DropLockBeforeCallback(); // mDNS_DeregisterService expects to be called without the lock held, so we emulate that here 6824 m->SPSState = 2; 6825#ifndef SPC_DISABLED 6826 if (oldstate == 1) mDNS_DeregisterService(m, &m->SPSRecords); 6827#else 6828 (void)oldstate; 6829#endif 6830 mDNS_ReclaimLockAfterCallback(); 6831 } 6832 6833 m->SleepState = SleepState_Transferring; 6834 if (m->SystemWakeOnLANEnabled && m->DelaySleep) 6835 { 6836 // If we just woke up moments ago, allow ten seconds for networking to stabilize before going back to sleep 6837 LogSPS("mDNSCoreMachineSleep: Re-sleeping immediately after waking; will delay for %d ticks", m->DelaySleep - m->timenow); 6838 m->SleepLimit = NonZeroTime(m->DelaySleep + mDNSPlatformOneSecond * 10); 6839 } 6840 else 6841 { 6842 m->DelaySleep = 0; 6843 m->SleepLimit = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 10); 6844 m->mDNSStats.Sleeps++; 6845 BeginSleepProcessing(m); 6846 } 6847 6848#ifndef UNICAST_DISABLED 6849 SuspendLLQs(m); 6850#endif 6851#if APPLE_OSX_mDNSResponder 6852 RemoveAutoTunnel6Record(m); 6853#endif 6854 LogSPS("mDNSCoreMachineSleep: m->SleepState %d (%s) seq %d", m->SleepState, 6855 m->SleepState == SleepState_Transferring ? "Transferring" : 6856 m->SleepState == SleepState_Sleeping ? "Sleeping" : "?", m->SleepSeqNum); 6857 mDNS_Unlock(m); 6858 } 6859 else if (!sleep) // Waking up 6860 { 6861 mDNSu32 slot; 6862 CacheGroup *cg; 6863 CacheRecord *cr; 6864 NetworkInterfaceInfo *intf; 6865 mDNSs32 currtime, diff; 6866 6867 mDNS_Lock(m); 6868 // Reset SleepLimit back to 0 now that we're awake again. 6869 m->SleepLimit = 0; 6870 6871 // If we were previously sleeping, but now we're not, increment m->SleepSeqNum to indicate that we're entering a new period of wakefulness 6872 if (m->SleepState != SleepState_Awake) 6873 { 6874 m->SleepState = SleepState_Awake; 6875 m->SleepSeqNum++; 6876 // If the machine wakes and then immediately tries to sleep again (e.g. a maintenance wake) 6877 // then we enforce a minimum delay of five seconds before we begin sleep processing. 6878 // This is to allow time for the Ethernet link to come up, DHCP to get an address, mDNS to issue queries, etc., 6879 // before we make our determination of whether there's a Sleep Proxy out there we should register with. 6880 m->DelaySleep = NonZeroTime(m->timenow + kDarkWakeDelaySleep); 6881 } 6882 6883 if (m->SPSState == 3) 6884 { 6885 m->SPSState = 0; 6886 mDNSCoreBeSleepProxyServer_internal(m, m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower, m->SPSFeatureFlags); 6887 } 6888 m->mDNSStats.Wakes++; 6889 m->DelayConflictProcessing = MAX_CONFLICT_PROCESSING_DELAYS; 6890 // ... and the same for NextSPSAttempt 6891 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) intf->NextSPSAttempt = -1; 6892 6893 // Restart unicast and multicast queries 6894 mDNSCoreRestartQueries(m); 6895 6896 // and reactivtate service registrations 6897 m->NextSRVUpdate = NonZeroTime(m->timenow + mDNSPlatformOneSecond); 6898 LogInfo("mDNSCoreMachineSleep waking: NextSRVUpdate in %d %d", m->NextSRVUpdate - m->timenow, m->timenow); 6899 6900 // 2. Re-validate our cache records 6901 currtime = mDNSPlatformUTC(); 6902 6903 diff = currtime - m->TimeSlept; 6904 FORALL_CACHERECORDS(slot, cg, cr) 6905 { 6906 // Temporary fix: For unicast cache records, look at how much time we slept. 6907 // Adjust the RecvTime by the amount of time we slept so that we age the 6908 // cache record appropriately. If it is expired already, purge. If there 6909 // is a network change that happens after the wakeup, we might purge the 6910 // cache anyways and this helps only in the case where there are no network 6911 // changes across sleep/wakeup transition. 6912 // 6913 // Note: If there is a network/DNS server change that already happened and 6914 // these cache entries are already refreshed and we are getting a delayed 6915 // wake up notification, we might adjust the TimeRcvd based on the time slept 6916 // now which can cause the cache to purge pre-maturely. As this is not a very 6917 // common case, this should happen rarely. 6918 if (!cr->resrec.InterfaceID) 6919 { 6920 if (diff > 0) 6921 { 6922 mDNSu32 uTTL = RRUnadjustedTTL(cr->resrec.rroriginalttl); 6923 const mDNSs32 remain = uTTL - (m->timenow - cr->TimeRcvd) / mDNSPlatformOneSecond; 6924 6925 // -if we have slept longer than the remaining TTL, purge and start fresh. 6926 // -if we have been sleeping for a long time, we could reduce TimeRcvd below by 6927 // a sufficiently big value which could cause the value to go into the future 6928 // because of the signed comparison of time. For this to happen, we should have been 6929 // sleeping really long (~24 days). For now, we want to be conservative and flush even 6930 // if we have slept for more than two days. 6931 6932 if (diff >= remain || diff > (2 * 24 * 3600)) 6933 { 6934 LogInfo("mDNSCoreMachineSleep: %s: Purging cache entry SleptTime %d, Remaining TTL %d", 6935 CRDisplayString(m, cr), diff, remain); 6936 mDNS_PurgeCacheResourceRecord(m, cr); 6937 continue; 6938 } 6939 cr->TimeRcvd -= (diff * mDNSPlatformOneSecond); 6940 if (m->timenow - (cr->TimeRcvd + ((mDNSs32)uTTL * mDNSPlatformOneSecond)) >= 0) 6941 { 6942 LogInfo("mDNSCoreMachineSleep: %s: Purging after adjusting the remaining TTL %d by %d seconds", 6943 CRDisplayString(m, cr), remain, diff); 6944 mDNS_PurgeCacheResourceRecord(m, cr); 6945 } 6946 else 6947 { 6948 LogInfo("mDNSCoreMachineSleep: %s: Adjusted the remain ttl %u by %d seconds", CRDisplayString(m, cr), remain, diff); 6949 } 6950 } 6951 } 6952 else 6953 { 6954 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForWake); 6955 } 6956 } 6957 6958 // 3. Retrigger probing and announcing for all our authoritative records 6959 for (rr = m->ResourceRecords; rr; rr=rr->next) 6960 { 6961 if (AuthRecord_uDNS(rr)) 6962 { 6963 ActivateUnicastRegistration(m, rr); 6964 } 6965 else 6966 { 6967 mDNSCoreRestartRegistration(m, rr, -1); 6968 } 6969 } 6970 6971 // 4. Refresh NAT mappings 6972 // We don't want to have to assume that all hardware can necessarily keep accurate 6973 // track of passage of time while asleep, so on wake we refresh our NAT mappings. 6974 // We typically wake up with no interfaces active, so there's no need to rush to try to find our external address. 6975 // But if we do get a network configuration change, mDNSMacOSXNetworkChanged will call uDNS_SetupDNSConfig, which 6976 // will call mDNS_SetPrimaryInterfaceInfo, which will call RecreateNATMappings to refresh them, potentially sooner 6977 // than five seconds from now. 6978 LogInfo("mDNSCoreMachineSleep: recreating NAT mappings in 5 seconds"); 6979 RecreateNATMappings(m, mDNSPlatformOneSecond * 5); 6980 mDNS_Unlock(m); 6981 } 6982} 6983 6984mDNSexport mDNSBool mDNSCoreReadyForSleep(mDNS *m, mDNSs32 now) 6985{ 6986 DNSQuestion *q; 6987 AuthRecord *rr; 6988 NetworkInterfaceInfo *intf; 6989 6990 mDNS_Lock(m); 6991 6992 if (m->DelaySleep) goto notready; 6993 6994 // If we've not hit the sleep limit time, and it's not time for our next retry, we can skip these checks 6995 if (m->SleepLimit - now > 0 && m->NextScheduledSPRetry - now > 0) goto notready; 6996 6997 m->NextScheduledSPRetry = now + 0x40000000UL; 6998 6999 // See if we might need to retransmit any lost Sleep Proxy Registrations 7000 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 7001 if (intf->NextSPSAttempt >= 0) 7002 { 7003 if (now - intf->NextSPSAttemptTime >= 0) 7004 { 7005 LogSPS("mDNSCoreReadyForSleep: retrying for %s SPS %d try %d", 7006 intf->ifname, intf->NextSPSAttempt/3, intf->NextSPSAttempt); 7007 SendSPSRegistration(m, intf, zeroID); 7008 // Don't need to "goto notready" here, because if we do still have record registrations 7009 // that have not been acknowledged yet, we'll catch that in the record list scan below. 7010 } 7011 else 7012 if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0) 7013 m->NextScheduledSPRetry = intf->NextSPSAttemptTime; 7014 } 7015 7016 // Scan list of interfaces, and see if we're still waiting for any sleep proxy resolves to complete 7017 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 7018 { 7019 int sps = (intf->NextSPSAttempt == 0) ? 0 : (intf->NextSPSAttempt-1)/3; 7020 if (intf->NetWakeResolve[sps].ThisQInterval >= 0) 7021 { 7022 LogSPS("mDNSCoreReadyForSleep: waiting for SPS Resolve %s %##s (%s)", 7023 intf->ifname, intf->NetWakeResolve[sps].qname.c, DNSTypeName(intf->NetWakeResolve[sps].qtype)); 7024 goto spsnotready; 7025 } 7026 } 7027 7028 // Scan list of registered records 7029 for (rr = m->ResourceRecords; rr; rr = rr->next) 7030 if (!AuthRecord_uDNS(rr)) 7031 if (!mDNSOpaque64IsZero(&rr->updateIntID)) 7032 { LogSPS("mDNSCoreReadyForSleep: waiting for SPS updateIntID 0x%x 0x%x (updateid %d) %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto spsnotready; } 7033 7034 // Scan list of private LLQs, and make sure they've all completed their handshake with the server 7035 for (q = m->Questions; q; q = q->next) 7036 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->ReqLease == 0 && q->tcp) 7037 { 7038 LogSPS("mDNSCoreReadyForSleep: waiting for LLQ %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 7039 goto notready; 7040 } 7041 7042 // Scan list of registered records 7043 for (rr = m->ResourceRecords; rr; rr = rr->next) 7044 if (AuthRecord_uDNS(rr)) 7045 { 7046 if (rr->state == regState_Refresh && rr->tcp) 7047 { LogSPS("mDNSCoreReadyForSleep: waiting for Record updateIntID 0x%x 0x%x (updateid %d) %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto notready; } 7048 #if APPLE_OSX_mDNSResponder 7049 if (!RecordReadyForSleep(rr)) { LogSPS("mDNSCoreReadyForSleep: waiting for %s", ARDisplayString(m, rr)); goto notready; } 7050 #endif 7051 } 7052 7053 mDNS_Unlock(m); 7054 return mDNStrue; 7055 7056spsnotready: 7057 7058 // If we failed to complete sleep proxy registration within ten seconds, we give up on that 7059 // and allow up to ten seconds more to complete wide-area deregistration instead 7060 if (now - m->SleepLimit >= 0) 7061 { 7062 LogMsg("Failed to register with SPS, now sending goodbyes"); 7063 7064 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) 7065 if (intf->NetWakeBrowse.ThisQInterval >= 0) 7066 { 7067 LogSPS("ReadyForSleep mDNS_DeactivateNetWake %s %##s (%s)", 7068 intf->ifname, intf->NetWakeResolve[0].qname.c, DNSTypeName(intf->NetWakeResolve[0].qtype)); 7069 mDNS_DeactivateNetWake_internal(m, intf); 7070 } 7071 7072 for (rr = m->ResourceRecords; rr; rr = rr->next) 7073 if (!AuthRecord_uDNS(rr)) 7074 if (!mDNSOpaque64IsZero(&rr->updateIntID)) 7075 { 7076 LogSPS("ReadyForSleep clearing updateIntID 0x%x 0x%x (updateid %d) for %s", rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m, rr)); 7077 rr->updateIntID = zeroOpaque64; 7078 } 7079 7080 // We'd really like to allow up to ten seconds more here, 7081 // but if we don't respond to the sleep notification within 30 seconds 7082 // we'll be put back to sleep forcibly without the chance to schedule the next maintenance wake. 7083 // Right now we wait 16 sec after wake for all the interfaces to come up, then we wait up to 10 seconds 7084 // more for SPS resolves and record registrations to complete, which puts us at 26 seconds. 7085 // If we allow just one more second to send our goodbyes, that puts us at 27 seconds. 7086 m->SleepLimit = now + mDNSPlatformOneSecond * 1; 7087 7088 SendSleepGoodbyes(m, mDNStrue, mDNStrue); 7089 } 7090 7091notready: 7092 mDNS_Unlock(m); 7093 return mDNSfalse; 7094} 7095 7096mDNSexport mDNSs32 mDNSCoreIntervalToNextWake(mDNS *const m, mDNSs32 now) 7097{ 7098 AuthRecord *ar; 7099 7100 // Even when we have no wake-on-LAN-capable interfaces, or we failed to find a sleep proxy, or we have other 7101 // failure scenarios, we still want to wake up in at most 120 minutes, to see if the network environment has changed. 7102 // E.g. we might wake up and find no wireless network because the base station got rebooted just at that moment, 7103 // and if that happens we don't want to just give up and go back to sleep and never try again. 7104 mDNSs32 e = now + (120 * 60 * mDNSPlatformOneSecond); // Sleep for at most 120 minutes 7105 7106 NATTraversalInfo *nat; 7107 for (nat = m->NATTraversals; nat; nat=nat->next) 7108 if (nat->Protocol && nat->ExpiryTime && nat->ExpiryTime - now > mDNSPlatformOneSecond*4) 7109 { 7110 mDNSs32 t = nat->ExpiryTime - (nat->ExpiryTime - now) / 10; // Wake up when 90% of the way to the expiry time 7111 if (e - t > 0) e = t; 7112 LogSPS("ComputeWakeTime: %p %s Int %5d Ext %5d Err %d Retry %5d Interval %5d Expire %5d Wake %5d", 7113 nat, nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP", 7114 mDNSVal16(nat->IntPort), mDNSVal16(nat->ExternalPort), nat->Result, 7115 nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0, 7116 nat->retryInterval / mDNSPlatformOneSecond, 7117 nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0, 7118 (t - now) / mDNSPlatformOneSecond); 7119 } 7120 7121 // This loop checks both the time we need to renew wide-area registrations, 7122 // and the time we need to renew Sleep Proxy registrations 7123 for (ar = m->ResourceRecords; ar; ar = ar->next) 7124 if (ar->expire && ar->expire - now > mDNSPlatformOneSecond*4) 7125 { 7126 mDNSs32 t = ar->expire - (ar->expire - now) / 10; // Wake up when 90% of the way to the expiry time 7127 if (e - t > 0) e = t; 7128 LogSPS("ComputeWakeTime: %p Int %7d Next %7d Expire %7d Wake %7d %s", 7129 ar, ar->ThisAPInterval / mDNSPlatformOneSecond, 7130 (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond, 7131 ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0, 7132 (t - now) / mDNSPlatformOneSecond, ARDisplayString(m, ar)); 7133 } 7134 7135 return(e - now); 7136} 7137 7138// *************************************************************************** 7139#if COMPILER_LIKES_PRAGMA_MARK 7140#pragma mark - 7141#pragma mark - Packet Reception Functions 7142#endif 7143 7144#define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo) 7145 7146mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end, 7147 const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, DNSMessage *const response, AuthRecord *ResponseRecords) 7148{ 7149 mDNSu8 *responseptr = response->data; 7150 const mDNSu8 *const limit = response->data + sizeof(response->data); 7151 const mDNSu8 *ptr = query->data; 7152 AuthRecord *rr; 7153 mDNSu32 maxttl = 0x70000000; 7154 int i; 7155 7156 // Initialize the response fields so we can answer the questions 7157 InitializeDNSMessage(&response->h, query->h.id, ResponseFlags); 7158 7159 // *** 7160 // *** 1. Write out the list of questions we are actually going to answer with this packet 7161 // *** 7162 if (LegacyQuery) 7163 { 7164 maxttl = kStaticCacheTTL; 7165 for (i=0; i<query->h.numQuestions; i++) // For each question... 7166 { 7167 DNSQuestion q; 7168 ptr = getQuestion(query, ptr, end, InterfaceID, &q); // get the question... 7169 if (!ptr) return(mDNSNULL); 7170 7171 for (rr=ResponseRecords; rr; rr=rr->NextResponse) // and search our list of proposed answers 7172 { 7173 if (rr->NR_AnswerTo == ptr) // If we're going to generate a record answering this question 7174 { // then put the question in the question section 7175 responseptr = putQuestion(response, responseptr, limit, &q.qname, q.qtype, q.qclass); 7176 if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL); } 7177 break; // break out of the ResponseRecords loop, and go on to the next question 7178 } 7179 } 7180 } 7181 7182 if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL); } 7183 } 7184 7185 // *** 7186 // *** 2. Write Answers 7187 // *** 7188 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 7189 if (rr->NR_AnswerTo) 7190 { 7191 mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAnswers, &rr->resrec, 7192 maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl); 7193 if (p) responseptr = p; 7194 else { debugf("GenerateUnicastResponse: Ran out of space for answers!"); response->h.flags.b[0] |= kDNSFlag0_TC; } 7195 } 7196 7197 // *** 7198 // *** 3. Write Additionals 7199 // *** 7200 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 7201 if (rr->NR_AdditionalTo && !rr->NR_AnswerTo) 7202 { 7203 mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAdditionals, &rr->resrec, 7204 maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl); 7205 if (p) responseptr = p; 7206 else debugf("GenerateUnicastResponse: No more space for additionals"); 7207 } 7208 7209 return(responseptr); 7210} 7211 7212// AuthRecord *our is our Resource Record 7213// CacheRecord *pkt is the Resource Record from the response packet we've witnessed on the network 7214// Returns 0 if there is no conflict 7215// Returns +1 if there was a conflict and we won 7216// Returns -1 if there was a conflict and we lost and have to rename 7217mDNSlocal int CompareRData(const AuthRecord *const our, const CacheRecord *const pkt) 7218{ 7219 mDNSu8 ourdata[256], *ourptr = ourdata, *ourend; 7220 mDNSu8 pktdata[256], *pktptr = pktdata, *pktend; 7221 if (!our) { LogMsg("CompareRData ERROR: our is NULL"); return(+1); } 7222 if (!pkt) { LogMsg("CompareRData ERROR: pkt is NULL"); return(+1); } 7223 7224 ourend = putRData(mDNSNULL, ourdata, ourdata + sizeof(ourdata), &our->resrec); 7225 pktend = putRData(mDNSNULL, pktdata, pktdata + sizeof(pktdata), &pkt->resrec); 7226 while (ourptr < ourend && pktptr < pktend && *ourptr == *pktptr) { ourptr++; pktptr++; } 7227 if (ourptr >= ourend && pktptr >= pktend) return(0); // If data identical, not a conflict 7228 7229 if (ourptr >= ourend) return(-1); // Our data ran out first; We lost 7230 if (pktptr >= pktend) return(+1); // Packet data ran out first; We won 7231 if (*pktptr > *ourptr) return(-1); // Our data is numerically lower; We lost 7232 if (*pktptr < *ourptr) return(+1); // Packet data is numerically lower; We won 7233 7234 LogMsg("CompareRData ERROR: Invalid state"); 7235 return(-1); 7236} 7237 7238// See if we have an authoritative record that's identical to this packet record, 7239// whose canonical DependentOn record is the specified master record. 7240// The DependentOn pointer is typically used for the TXT record of service registrations 7241// It indicates that there is no inherent conflict detection for the TXT record 7242// -- it depends on the SRV record to resolve name conflicts 7243// If we find any identical ResourceRecords in our authoritative list, then follow their DependentOn 7244// pointer chain (if any) to make sure we reach the canonical DependentOn record 7245// If the record has no DependentOn, then just return that record's pointer 7246// Returns NULL if we don't have any local RRs that are identical to the one from the packet 7247mDNSlocal mDNSBool MatchDependentOn(const mDNS *const m, const CacheRecord *const pktrr, const AuthRecord *const master) 7248{ 7249 const AuthRecord *r1; 7250 for (r1 = m->ResourceRecords; r1; r1=r1->next) 7251 { 7252 if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec)) 7253 { 7254 const AuthRecord *r2 = r1; 7255 while (r2->DependentOn) r2 = r2->DependentOn; 7256 if (r2 == master) return(mDNStrue); 7257 } 7258 } 7259 for (r1 = m->DuplicateRecords; r1; r1=r1->next) 7260 { 7261 if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec)) 7262 { 7263 const AuthRecord *r2 = r1; 7264 while (r2->DependentOn) r2 = r2->DependentOn; 7265 if (r2 == master) return(mDNStrue); 7266 } 7267 } 7268 return(mDNSfalse); 7269} 7270 7271// Find the canonical RRSet pointer for this RR received in a packet. 7272// If we find any identical AuthRecord in our authoritative list, then follow its RRSet 7273// pointers (if any) to make sure we return the canonical member of this name/type/class 7274// Returns NULL if we don't have any local RRs that are identical to the one from the packet 7275mDNSlocal const AuthRecord *FindRRSet(const mDNS *const m, const CacheRecord *const pktrr) 7276{ 7277 const AuthRecord *rr; 7278 for (rr = m->ResourceRecords; rr; rr=rr->next) 7279 { 7280 if (IdenticalResourceRecord(&rr->resrec, &pktrr->resrec)) 7281 { 7282 while (rr->RRSet && rr != rr->RRSet) rr = rr->RRSet; 7283 return(rr); 7284 } 7285 } 7286 return(mDNSNULL); 7287} 7288 7289// PacketRRConflict is called when we've received an RR (pktrr) which has the same name 7290// as one of our records (our) but different rdata. 7291// 1. If our record is not a type that's supposed to be unique, we don't care. 7292// 2a. If our record is marked as dependent on some other record for conflict detection, ignore this one. 7293// 2b. If the packet rr exactly matches one of our other RRs, and *that* record's DependentOn pointer 7294// points to our record, ignore this conflict (e.g. the packet record matches one of our 7295// TXT records, and that record is marked as dependent on 'our', its SRV record). 7296// 3. If we have some *other* RR that exactly matches the one from the packet, and that record and our record 7297// are members of the same RRSet, then this is not a conflict. 7298mDNSlocal mDNSBool PacketRRConflict(const mDNS *const m, const AuthRecord *const our, const CacheRecord *const pktrr) 7299{ 7300 // If not supposed to be unique, not a conflict 7301 if (!(our->resrec.RecordType & kDNSRecordTypeUniqueMask)) return(mDNSfalse); 7302 7303 // If a dependent record, not a conflict 7304 if (our->DependentOn || MatchDependentOn(m, pktrr, our)) return(mDNSfalse); 7305 else 7306 { 7307 // If the pktrr matches a member of ourset, not a conflict 7308 const AuthRecord *ourset = our->RRSet ? our->RRSet : our; 7309 const AuthRecord *pktset = FindRRSet(m, pktrr); 7310 if (pktset == ourset) return(mDNSfalse); 7311 7312 // For records we're proxying, where we don't know the full 7313 // relationship between the records, having any matching record 7314 // in our AuthRecords list is sufficient evidence of non-conflict 7315 if (our->WakeUp.HMAC.l[0] && pktset) return(mDNSfalse); 7316 } 7317 7318 // Okay, this is a conflict 7319 return(mDNStrue); 7320} 7321 7322// Note: ResolveSimultaneousProbe calls mDNS_Deregister_internal which can call a user callback, which may change 7323// the record list and/or question list. 7324// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 7325mDNSlocal void ResolveSimultaneousProbe(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end, 7326 DNSQuestion *q, AuthRecord *our) 7327{ 7328 int i; 7329 const mDNSu8 *ptr = LocateAuthorities(query, end); 7330 mDNSBool FoundUpdate = mDNSfalse; 7331 7332 for (i = 0; i < query->h.numAuthorities; i++) 7333 { 7334 ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 7335 if (!ptr) break; 7336 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && ResourceRecordAnswersQuestion(&m->rec.r.resrec, q)) 7337 { 7338 FoundUpdate = mDNStrue; 7339 if (PacketRRConflict(m, our, &m->rec.r)) 7340 { 7341 int result = (int)our->resrec.rrclass - (int)m->rec.r.resrec.rrclass; 7342 if (!result) result = (int)our->resrec.rrtype - (int)m->rec.r.resrec.rrtype; 7343 if (!result) result = CompareRData(our, &m->rec.r); 7344 if (result) 7345 { 7346 const char *const msg = (result < 0) ? "lost:" : (result > 0) ? "won: " : "tie: "; 7347 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); 7348 LogMsg("ResolveSimultaneousProbe: %p Our Record %d %s %08lX %s", our->resrec.InterfaceID, our->ProbeCount, msg, our->resrec.rdatahash, ARDisplayString(m, our)); 7349 } 7350 // 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. 7351 // Instead we pause for one second, to give the other host (if real) a chance to establish its name, and then try probing again. 7352 // If there really is another live host out there with the same name, it will answer our probes and we'll then rename. 7353 if (result < 0) 7354 { 7355 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond); 7356 our->ProbeCount = DefaultProbeCountForTypeUnique; 7357 our->AnnounceCount = InitialAnnounceCount; 7358 InitializeLastAPTime(m, our); 7359 goto exit; 7360 } 7361 } 7362#if 0 7363 else 7364 { 7365 LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s", q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); 7366 LogMsg("ResolveSimultaneousProbe: %p Our Record %d ign: %08lX %s", our->resrec.InterfaceID, our->ProbeCount, our->resrec.rdatahash, ARDisplayString(m, our)); 7367 } 7368#endif 7369 } 7370 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7371 } 7372 if (!FoundUpdate) 7373 LogInfo("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name->c, DNSTypeName(our->resrec.rrtype)); 7374exit: 7375 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7376} 7377 7378mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, const ResourceRecord *const pktrr) 7379{ 7380 CacheGroup *cg = CacheGroupForRecord(m, pktrr); 7381 CacheRecord *rr; 7382 mDNSBool match; 7383 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 7384 { 7385 if (!pktrr->InterfaceID) 7386 { 7387 mDNSu16 id1 = (pktrr->rDNSServer ? pktrr->rDNSServer->resGroupID : 0); 7388 mDNSu16 id2 = (rr->resrec.rDNSServer ? rr->resrec.rDNSServer->resGroupID : 0); 7389 match = (id1 == id2); 7390 } 7391 else match = (pktrr->InterfaceID == rr->resrec.InterfaceID); 7392 7393 if (match && IdenticalSameNameRecord(pktrr, &rr->resrec)) break; 7394 } 7395 return(rr); 7396} 7397mDNSlocal void DeregisterProxyRecord(mDNS *const m, AuthRecord *const rr) 7398{ 7399 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host 7400 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it 7401 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 7402 SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID); 7403} 7404 7405mDNSlocal void ClearKeepaliveProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist, const mDNSInterfaceID InterfaceID) 7406{ 7407 if (m->CurrentRecord) 7408 LogMsg("ClearKeepaliveProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 7409 m->CurrentRecord = thelist; 7410 7411 // Normally, the RDATA of the keepalive record will be different each time and hence we always 7412 // clean up the keepalive record. 7413 while (m->CurrentRecord) 7414 { 7415 AuthRecord *const rr = m->CurrentRecord; 7416 if (InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) 7417 { 7418 if (mDNS_KeepaliveRecord(&m->rec.r.resrec)) 7419 { 7420 LogSPS("ClearKeepaliveProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s", 7421 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); 7422 DeregisterProxyRecord(m, rr); 7423 } 7424 } 7425 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 7426 // new records could have been added to the end of the list as a result of that call. 7427 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 7428 m->CurrentRecord = rr->next; 7429 } 7430} 7431 7432// Called from mDNSCoreReceiveUpdate when we get a sleep proxy registration request, 7433// to check our lists and discard any stale duplicates of this record we already have 7434mDNSlocal void ClearIdenticalProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist) 7435{ 7436 if (m->CurrentRecord) 7437 LogMsg("ClearIdenticalProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 7438 m->CurrentRecord = thelist; 7439 while (m->CurrentRecord) 7440 { 7441 AuthRecord *const rr = m->CurrentRecord; 7442 if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) 7443 if (IdenticalResourceRecord(&rr->resrec, &m->rec.r.resrec)) 7444 { 7445 LogSPS("ClearIdenticalProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s", 7446 m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); 7447 DeregisterProxyRecord(m, rr); 7448 } 7449 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 7450 // new records could have been added to the end of the list as a result of that call. 7451 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 7452 m->CurrentRecord = rr->next; 7453 } 7454} 7455 7456// Called from ProcessQuery when we get an mDNS packet with an owner record in it 7457mDNSlocal void ClearProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist) 7458{ 7459 if (m->CurrentRecord) 7460 LogMsg("ClearProxyRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 7461 m->CurrentRecord = thelist; 7462 while (m->CurrentRecord) 7463 { 7464 AuthRecord *const rr = m->CurrentRecord; 7465 if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) 7466 if (owner->seq != rr->WakeUp.seq || m->timenow - rr->TimeRcvd > mDNSPlatformOneSecond * 60) 7467 { 7468 if (rr->AddressProxy.type == mDNSAddrType_IPv6) 7469 { 7470 // We don't do this here because we know that the host is waking up at this point, so we don't send 7471 // Unsolicited Neighbor Advertisements -- even Neighbor Advertisements agreeing with what the host should be 7472 // saying itself -- because it can cause some IPv6 stacks to falsely conclude that there's an address conflict. 7473 #if MDNS_USE_Unsolicited_Neighbor_Advertisements 7474 LogSPS("NDP Announcement -- Releasing traffic for H-MAC %.6a I-MAC %.6a %s", 7475 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); 7476 SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, &rr->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth); 7477 #endif 7478 } 7479 LogSPS("ClearProxyRecords: Removing %3d AC %2d %02X H-MAC %.6a I-MAC %.6a %d %d %s", 7480 m->ProxyRecords, rr->AnnounceCount, rr->resrec.RecordType, 7481 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); 7482 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) rr->resrec.RecordType = kDNSRecordTypeShared; 7483 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host 7484 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it, since real host is now back and functional 7485 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 7486 SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID); 7487 } 7488 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 7489 // new records could have been added to the end of the list as a result of that call. 7490 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 7491 m->CurrentRecord = rr->next; 7492 } 7493} 7494 7495// ProcessQuery examines a received query to see if we have any answers to give 7496mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end, 7497 const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast, 7498 mDNSBool QueryWasLocalUnicast, DNSMessage *const response) 7499{ 7500 mDNSBool FromLocalSubnet = srcaddr && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); 7501 AuthRecord *ResponseRecords = mDNSNULL; 7502 AuthRecord **nrp = &ResponseRecords; 7503 7504#if POOF_ENABLED 7505 CacheRecord *ExpectedAnswers = mDNSNULL; // Records in our cache we expect to see updated 7506 CacheRecord **eap = &ExpectedAnswers; 7507#endif // POOF_ENABLED 7508 7509 DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet 7510 DNSQuestion **dqp = &DupQuestions; 7511 mDNSs32 delayresponse = 0; 7512 mDNSBool SendLegacyResponse = mDNSfalse; 7513 const mDNSu8 *ptr; 7514 mDNSu8 *responseptr = mDNSNULL; 7515 AuthRecord *rr; 7516 int i; 7517 CacheRecord *McastNSEC3Records = mDNSNULL; 7518 7519 // *** 7520 // *** 1. Look in Additional Section for an OPT record 7521 // *** 7522 ptr = LocateOptRR(query, end, DNSOpt_OwnerData_ID_Space); 7523 if (ptr) 7524 { 7525 ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAdd, &m->rec); 7526 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) 7527 { 7528 const rdataOPT *opt; 7529 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 7530 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently 7531 // delete all our own AuthRecords (which are identified by having zero MAC tags on them). 7532 for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++) 7533 if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0]) 7534 { 7535 ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords); 7536 ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords); 7537 } 7538 } 7539 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7540 } 7541 7542 // 7543 // Look in Authority Section for NSEC3 record 7544 // 7545 7546 mDNSParseNSEC3Records(m, query, end, InterfaceID, &McastNSEC3Records); 7547 7548 // *** 7549 // *** 2. Parse Question Section and mark potential answers 7550 // *** 7551 ptr = query->data; 7552 for (i=0; i<query->h.numQuestions; i++) // For each question... 7553 { 7554 mDNSBool QuestionNeedsMulticastResponse; 7555 int NumAnswersForThisQuestion = 0; 7556 AuthRecord *NSECAnswer = mDNSNULL; 7557 DNSQuestion pktq, *q; 7558 ptr = getQuestion(query, ptr, end, InterfaceID, &pktq); // get the question... 7559 if (!ptr) goto exit; 7560 7561 pktq.AnonInfo = mDNSNULL; 7562 if (McastNSEC3Records) 7563 InitializeAnonInfoForQuestion(m, &McastNSEC3Records, &pktq); 7564 // The only queries that *need* a multicast response are: 7565 // * Queries sent via multicast 7566 // * from port 5353 7567 // * that don't have the kDNSQClass_UnicastResponse bit set 7568 // These queries need multicast responses because other clients will: 7569 // * suppress their own identical questions when they see these questions, and 7570 // * expire their cache records if they don't see the expected responses 7571 // For other queries, we may still choose to send the occasional multicast response anyway, 7572 // to keep our neighbours caches warm, and for ongoing conflict detection. 7573 QuestionNeedsMulticastResponse = QueryWasMulticast && !LegacyQuery && !(pktq.qclass & kDNSQClass_UnicastResponse); 7574 7575 if (pktq.qclass & kDNSQClass_UnicastResponse) 7576 m->mDNSStats.UnicastBitInQueries++; 7577 else 7578 m->mDNSStats.NormalQueries++; 7579 7580 // Clear the UnicastResponse flag -- don't want to confuse the rest of the code that follows later 7581 pktq.qclass &= ~kDNSQClass_UnicastResponse; 7582 7583 // Note: We use the m->CurrentRecord mechanism here because calling ResolveSimultaneousProbe 7584 // can result in user callbacks which may change the record list and/or question list. 7585 // Also note: we just mark potential answer records here, without trying to build the 7586 // "ResponseRecords" list, because we don't want to risk user callbacks deleting records 7587 // from that list while we're in the middle of trying to build it. 7588 if (m->CurrentRecord) 7589 LogMsg("ProcessQuery ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 7590 m->CurrentRecord = m->ResourceRecords; 7591 while (m->CurrentRecord) 7592 { 7593 rr = m->CurrentRecord; 7594 m->CurrentRecord = rr->next; 7595 if (AnyTypeRecordAnswersQuestion(&rr->resrec, &pktq) && (QueryWasMulticast || QueryWasLocalUnicast || rr->AllowRemoteQuery)) 7596 { 7597 m->mDNSStats.MatchingAnswersForQueries++; 7598 if (RRTypeAnswersQuestionType(&rr->resrec, pktq.qtype)) 7599 { 7600 if (rr->resrec.RecordType == kDNSRecordTypeUnique) 7601 ResolveSimultaneousProbe(m, query, end, &pktq, rr); 7602 else if (ResourceRecordIsValidAnswer(rr)) 7603 { 7604 NumAnswersForThisQuestion++; 7605 // As we have verified this question to be part of the same subset, 7606 // set the anonymous data which is needed below when walk the cache 7607 // records to see what answers we should be expecting. The cache records 7608 // may cache only the nsec3RR and not the anonymous data itself. 7609 if (pktq.AnonInfo && rr->resrec.AnonInfo) 7610 SetAnonData(&pktq, &rr->resrec, mDNStrue); 7611 7612 // Note: We should check here if this is a probe-type query, and if so, generate an immediate 7613 // unicast answer back to the source, because timeliness in answering probes is important. 7614 7615 // Notes: 7616 // NR_AnswerTo pointing into query packet means "answer via immediate legacy unicast" (may *also* choose to multicast) 7617 // NR_AnswerTo == NR_AnswerUnicast means "answer via delayed unicast" (to modern querier; may promote to multicast instead) 7618 // NR_AnswerTo == NR_AnswerMulticast means "definitely answer via multicast" (can't downgrade to unicast later) 7619 // If we're not multicasting this record because the kDNSQClass_UnicastResponse bit was set, 7620 // but the multicast querier is not on a matching subnet (e.g. because of overlaid subnets on one link) 7621 // then we'll multicast it anyway (if we unicast, the receiver will ignore it because it has an apparently non-local source) 7622 if (QuestionNeedsMulticastResponse || (!FromLocalSubnet && QueryWasMulticast && !LegacyQuery)) 7623 { 7624 // We only mark this question for sending if it is at least one second since the last time we multicast it 7625 // on this interface. If it is more than a second, or LastMCInterface is different, then we may multicast it. 7626 // This is to guard against the case where someone blasts us with queries as fast as they can. 7627 if ((mDNSu32)(m->timenow - rr->LastMCTime) >= (mDNSu32)mDNSPlatformOneSecond || 7628 (rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID)) 7629 rr->NR_AnswerTo = NR_AnswerMulticast; 7630 } 7631 else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = LegacyQuery ? ptr : NR_AnswerUnicast; 7632 } 7633 } 7634 else if ((rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && ResourceRecordIsValidAnswer(rr)) 7635 { 7636 // If we don't have any answers for this question, but we do own another record with the same name, 7637 // then we'll want to mark it to generate an NSEC record on this interface 7638 if (!NSECAnswer) NSECAnswer = rr; 7639 } 7640 } 7641 } 7642 7643 if (NumAnswersForThisQuestion == 0 && NSECAnswer) 7644 { 7645 NumAnswersForThisQuestion++; 7646 NSECAnswer->SendNSECNow = InterfaceID; 7647 m->NextScheduledResponse = m->timenow; 7648 } 7649 7650 // If we couldn't answer this question, someone else might be able to, 7651 // so use random delay on response to reduce collisions 7652 if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms 7653 7654 if (query->h.flags.b[0] & kDNSFlag0_TC) 7655 m->mDNSStats.KnownAnswerMultiplePkts++; 7656 // We only do the following accelerated cache expiration and duplicate question suppression processing 7657 // for non-truncated multicast queries with multicast responses. 7658 // For any query generating a unicast response we don't do this because we can't assume we will see the response. 7659 // For truncated queries we don't do this because a response we're expecting might be suppressed by a subsequent 7660 // known-answer packet, and when there's packet loss we can't safely assume we'll receive *all* known-answer packets. 7661 if (QuestionNeedsMulticastResponse && !(query->h.flags.b[0] & kDNSFlag0_TC)) 7662 { 7663#if POOF_ENABLED 7664 CacheGroup *cg = CacheGroupForName(m, pktq.qnamehash, &pktq.qname); 7665 CacheRecord *cr; 7666 7667 // Make a list indicating which of our own cache records we expect to see updated as a result of this query 7668 // Note: Records larger than 1K are not habitually multicast, so don't expect those to be updated 7669 for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next) 7670 if (SameNameRecordAnswersQuestion(&cr->resrec, &pktq) && cr->resrec.rdlength <= SmallRecordLimit) 7671 if (!cr->NextInKAList && eap != &cr->NextInKAList) 7672 { 7673 *eap = cr; 7674 eap = &cr->NextInKAList; 7675 } 7676#endif // POOF_ENABLED 7677 7678 // Check if this question is the same as any of mine. 7679 // We only do this for non-truncated queries. Right now it would be too complicated to try 7680 // to keep track of duplicate suppression state between multiple packets, especially when we 7681 // can't guarantee to receive all of the Known Answer packets that go with a particular query. 7682 // For anonymous question, the duplicate suppressesion should happen if the 7683 // question belongs in the same group. As the group is expected to be 7684 // small, we don't do the optimization for now. 7685 if (!pktq.AnonInfo) 7686 { 7687 for (q = m->Questions; q; q=q->next) 7688 if (!q->Target.type && ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4) 7689 if (!q->InterfaceID || q->InterfaceID == InterfaceID) 7690 if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList) 7691 if (q->qtype == pktq.qtype && 7692 q->qclass == pktq.qclass && 7693 q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname)) 7694 { *dqp = q; dqp = &q->NextInDQList; } 7695 } 7696 } 7697 if (pktq.AnonInfo) 7698 { 7699 FreeAnonInfo(pktq.AnonInfo); 7700 } 7701 } 7702 7703 // *** 7704 // *** 3. Now we can safely build the list of marked answers 7705 // *** 7706 for (rr = m->ResourceRecords; rr; rr=rr->next) // Now build our list of potential answers 7707 if (rr->NR_AnswerTo) // If we marked the record... 7708 AddRecordToResponseList(&nrp, rr, mDNSNULL); // ... add it to the list 7709 7710 // *** 7711 // *** 4. Add additional records 7712 // *** 7713 AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID); 7714 7715 // *** 7716 // *** 5. Parse Answer Section and cancel any records disallowed by Known-Answer list 7717 // *** 7718 for (i=0; i<query->h.numAnswers; i++) // For each record in the query's answer section... 7719 { 7720 // Get the record... 7721 CacheRecord *ourcacherr; 7722 ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &m->rec); 7723 if (!ptr) goto exit; 7724 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) 7725 { 7726 // See if this Known-Answer suppresses any of our currently planned answers 7727 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 7728 { 7729 if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&m->rec.r, rr)) 7730 { 7731 m->mDNSStats.KnownAnswerSuppressions++; 7732 rr->NR_AnswerTo = mDNSNULL; 7733 rr->NR_AdditionalTo = mDNSNULL; 7734 } 7735 } 7736 7737 // See if this Known-Answer suppresses any previously scheduled answers (for multi-packet KA suppression) 7738 for (rr=m->ResourceRecords; rr; rr=rr->next) 7739 { 7740 // If we're planning to send this answer on this interface, and only on this interface, then allow KA suppression 7741 if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&m->rec.r, rr)) 7742 { 7743 if (srcaddr->type == mDNSAddrType_IPv4) 7744 { 7745 if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zerov4Addr; 7746 } 7747 else if (srcaddr->type == mDNSAddrType_IPv6) 7748 { 7749 if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr; 7750 } 7751 if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester)) 7752 { 7753 m->mDNSStats.KnownAnswerSuppressions++; 7754 rr->ImmedAnswer = mDNSNULL; 7755 rr->ImmedUnicast = mDNSfalse; 7756 #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 7757 LogMsg("Suppressed after%4d: %s", m->timenow - rr->ImmedAnswerMarkTime, ARDisplayString(m, rr)); 7758 #endif 7759 } 7760 } 7761 } 7762 7763 ourcacherr = FindIdenticalRecordInCache(m, &m->rec.r.resrec); 7764 7765#if POOF_ENABLED 7766 // Having built our ExpectedAnswers list from the questions in this packet, we then remove 7767 // any records that are suppressed by the Known Answer list in this packet. 7768 eap = &ExpectedAnswers; 7769 while (*eap) 7770 { 7771 CacheRecord *cr = *eap; 7772 if (cr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&m->rec.r.resrec, &cr->resrec)) 7773 { *eap = cr->NextInKAList; cr->NextInKAList = mDNSNULL; } 7774 else eap = &cr->NextInKAList; 7775 } 7776#endif // POOF_ENABLED 7777 7778 // See if this Known-Answer is a surprise to us. If so, we shouldn't suppress our own query. 7779 if (!ourcacherr) 7780 { 7781 dqp = &DupQuestions; 7782 while (*dqp) 7783 { 7784 DNSQuestion *q = *dqp; 7785 if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q)) 7786 { *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; } 7787 else dqp = &q->NextInDQList; 7788 } 7789 } 7790 } 7791 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7792 } 7793 7794 // *** 7795 // *** 6. Cancel any additionals that were added because of now-deleted records 7796 // *** 7797 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 7798 if (rr->NR_AdditionalTo && !MustSendRecord(rr->NR_AdditionalTo)) 7799 { rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; } 7800 7801 // *** 7802 // *** 7. Mark the send flags on the records we plan to send 7803 // *** 7804 for (rr=ResponseRecords; rr; rr=rr->NextResponse) 7805 { 7806 if (rr->NR_AnswerTo) 7807 { 7808 mDNSBool SendMulticastResponse = mDNSfalse; // Send modern multicast response 7809 mDNSBool SendUnicastResponse = mDNSfalse; // Send modern unicast response (not legacy unicast response) 7810 7811 // If it's been one TTL/4 since we multicast this, then send a multicast response 7812 // for conflict detection, etc. 7813 if ((mDNSu32)(m->timenow - rr->LastMCTime) >= (mDNSu32)TicksTTL(rr)/4) 7814 { 7815 SendMulticastResponse = mDNStrue; 7816 // If this record was marked for modern (delayed) unicast response, then mark it as promoted to 7817 // multicast response instead (don't want to end up ALSO setting SendUnicastResponse in the check below). 7818 // If this record was marked for legacy unicast response, then we mustn't change the NR_AnswerTo value. 7819 if (rr->NR_AnswerTo == NR_AnswerUnicast) 7820 { 7821 m->mDNSStats.UnicastDemotedToMulticast++; 7822 rr->NR_AnswerTo = NR_AnswerMulticast; 7823 } 7824 } 7825 7826 // If the client insists on a multicast response, then we'd better send one 7827 if (rr->NR_AnswerTo == NR_AnswerMulticast) 7828 { 7829 m->mDNSStats.MulticastResponses++; 7830 SendMulticastResponse = mDNStrue; 7831 } 7832 else if (rr->NR_AnswerTo == NR_AnswerUnicast) 7833 { 7834 m->mDNSStats.UnicastResponses++; 7835 SendUnicastResponse = mDNStrue; 7836 } 7837 else if (rr->NR_AnswerTo) 7838 { 7839 SendLegacyResponse = mDNStrue; 7840 } 7841 7842 if (SendMulticastResponse || SendUnicastResponse) 7843 { 7844#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 7845 rr->ImmedAnswerMarkTime = m->timenow; 7846#endif 7847 m->NextScheduledResponse = m->timenow; 7848 // If we're already planning to send this on another interface, just send it on all interfaces 7849 if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID) 7850 rr->ImmedAnswer = mDNSInterfaceMark; 7851 else 7852 { 7853 rr->ImmedAnswer = InterfaceID; // Record interface to send it on 7854 if (SendUnicastResponse) rr->ImmedUnicast = mDNStrue; 7855 if (srcaddr->type == mDNSAddrType_IPv4) 7856 { 7857 if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4; 7858 else if (!mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = onesIPv4Addr; 7859 } 7860 else if (srcaddr->type == mDNSAddrType_IPv6) 7861 { 7862 if (mDNSIPv6AddressIsZero(rr->v6Requester)) rr->v6Requester = srcaddr->ip.v6; 7863 else if (!mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = onesIPv6Addr; 7864 } 7865 } 7866 } 7867 // If TC flag is set, it means we should expect that additional known answers may be coming in another packet, 7868 // so we allow roughly half a second before deciding to reply (we've observed inter-packet delays of 100-200ms on 802.11) 7869 // else, if record is a shared one, spread responses over 100ms to avoid implosion of simultaneous responses 7870 // else, for a simple unique record reply, we can reply immediately; no need for delay 7871 if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; // Divided by 50 = 400ms 7872 else if (rr->resrec.RecordType == kDNSRecordTypeShared) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms 7873 } 7874 else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == NR_AnswerMulticast) 7875 { 7876 // Since additional records are an optimization anyway, we only ever send them on one interface at a time 7877 // If two clients on different interfaces do queries that invoke the same optional additional answer, 7878 // then the earlier client is out of luck 7879 rr->ImmedAdditional = InterfaceID; 7880 // No need to set m->NextScheduledResponse here 7881 // We'll send these additional records when we send them, or not, as the case may be 7882 } 7883 } 7884 7885 // *** 7886 // *** 8. If we think other machines are likely to answer these questions, set our packet suppression timer 7887 // *** 7888 if (delayresponse && (!m->SuppressSending || (m->SuppressSending - m->timenow) < (delayresponse + 49) / 50)) 7889 { 7890#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 7891 mDNSs32 oldss = m->SuppressSending; 7892 if (oldss && delayresponse) 7893 LogMsg("Current SuppressSending delay%5ld; require%5ld", m->SuppressSending - m->timenow, (delayresponse + 49) / 50); 7894#endif 7895 // Pick a random delay: 7896 // We start with the base delay chosen above (typically either 1 second or 20 seconds), 7897 // and add a random value in the range 0-5 seconds (making 1-6 seconds or 20-25 seconds). 7898 // This is an integer value, with resolution determined by the platform clock rate. 7899 // We then divide that by 50 to get the delay value in ticks. We defer the division until last 7900 // to get better results on platforms with coarse clock granularity (e.g. ten ticks per second). 7901 // The +49 before dividing is to ensure we round up, not down, to ensure that even 7902 // on platforms where the native clock rate is less than fifty ticks per second, 7903 // we still guarantee that the final calculated delay is at least one platform tick. 7904 // We want to make sure we don't ever allow the delay to be zero ticks, 7905 // because if that happens we'll fail the Bonjour Conformance Test. 7906 // Our final computed delay is 20-120ms for normal delayed replies, 7907 // or 400-500ms in the case of multi-packet known-answer lists. 7908 m->SuppressSending = m->timenow + (delayresponse + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*5) + 49) / 50; 7909 if (m->SuppressSending == 0) m->SuppressSending = 1; 7910#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES 7911 if (oldss && delayresponse) 7912 LogMsg("Set SuppressSending to %5ld", m->SuppressSending - m->timenow); 7913#endif 7914 } 7915 7916 // *** 7917 // *** 9. If query is from a legacy client, or from a new client requesting a unicast reply, then generate a unicast response too 7918 // *** 7919 if (SendLegacyResponse) 7920 responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords); 7921 7922exit: 7923 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 7924 7925 // *** 7926 // *** 10. Finally, clear our link chains ready for use next time 7927 // *** 7928 while (ResponseRecords) 7929 { 7930 rr = ResponseRecords; 7931 ResponseRecords = rr->NextResponse; 7932 rr->NextResponse = mDNSNULL; 7933 rr->NR_AnswerTo = mDNSNULL; 7934 rr->NR_AdditionalTo = mDNSNULL; 7935 } 7936 7937#if POOF_ENABLED 7938 while (ExpectedAnswers) 7939 { 7940 CacheRecord *cr = ExpectedAnswers; 7941 ExpectedAnswers = cr->NextInKAList; 7942 cr->NextInKAList = mDNSNULL; 7943 7944 // For non-truncated queries, we can definitively say that we should expect 7945 // to be seeing a response for any records still left in the ExpectedAnswers list 7946 if (!(query->h.flags.b[0] & kDNSFlag0_TC)) 7947 if (cr->UnansweredQueries == 0 || m->timenow - cr->LastUnansweredTime >= mDNSPlatformOneSecond * 3/4) 7948 { 7949 cr->UnansweredQueries++; 7950 cr->LastUnansweredTime = m->timenow; 7951 if (cr->UnansweredQueries > 1) 7952 debugf("ProcessQuery: UnansweredQueries %lu %s", cr->UnansweredQueries, CRDisplayString(m, cr)); 7953 SetNextCacheCheckTimeForRecord(m, cr); 7954 } 7955 7956 // If we've seen multiple unanswered queries for this record, 7957 // then mark it to expire in five seconds if we don't get a response by then. 7958 if (cr->UnansweredQueries >= MaxUnansweredQueries) 7959 { 7960 // Only show debugging message if this record was not about to expire anyway 7961 if (RRExpireTime(cr) - m->timenow > (mDNSs32) kDefaultReconfirmTimeForNoAnswer * 4 / 3 + mDNSPlatformOneSecond) 7962 LogInfo("ProcessQuery: UnansweredQueries %lu interface %lu TTL %lu mDNS_Reconfirm() for %s", 7963 cr->UnansweredQueries, InterfaceID, (RRExpireTime(cr) - m->timenow + mDNSPlatformOneSecond-1) / mDNSPlatformOneSecond, CRDisplayString(m, cr)); 7964 7965 m->mDNSStats.PoofCacheDeletions++; 7966 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 7967 } 7968 } 7969#endif // POOF_ENABLED 7970 7971 while (DupQuestions) 7972 { 7973 DNSQuestion *q = DupQuestions; 7974 DupQuestions = q->NextInDQList; 7975 q->NextInDQList = mDNSNULL; 7976 RecordDupSuppressInfo(q->DupSuppress, m->timenow, InterfaceID, srcaddr->type); 7977 debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s", q->qname.c, DNSTypeName(q->qtype), InterfaceID, 7978 srcaddr->type == mDNSAddrType_IPv4 ? "v4" : "v6"); 7979 } 7980 7981 if (McastNSEC3Records) 7982 { 7983 debugf("ProcessQuery: McastNSEC3Records not used"); 7984 FreeNSECRecords(m, McastNSEC3Records); 7985 } 7986 7987 return(responseptr); 7988} 7989 7990mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, 7991 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, 7992 const mDNSInterfaceID InterfaceID) 7993{ 7994 mDNSu8 *responseend = mDNSNULL; 7995 mDNSBool QueryWasLocalUnicast = srcaddr && dstaddr && 7996 !mDNSAddrIsDNSMulticast(dstaddr) && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); 7997 7998 if (!dstaddr || (!InterfaceID && mDNSAddrIsDNSMulticast(dstaddr))) 7999 { 8000 const char *const reason = !dstaddr ? "Received over TCP connection" : "Multicast, but no InterfaceID"; 8001 LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " 8002 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes (%s)", 8003 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, 8004 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 8005 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 8006 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 8007 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data, reason); 8008 return; 8009 } 8010 8011 verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " 8012 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes", 8013 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, 8014 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 8015 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 8016 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 8017 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data); 8018 8019 responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID, 8020 !mDNSSameIPPort(srcport, MulticastDNSPort), mDNSAddrIsDNSMulticast(dstaddr), QueryWasLocalUnicast, &m->omsg); 8021 8022 if (responseend) // If responseend is non-null, that means we built a unicast response packet 8023 { 8024 debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld", 8025 m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s", 8026 m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s", 8027 m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s", 8028 srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type); 8029 mDNSSendDNSMessage(m, &m->omsg, responseend, InterfaceID, mDNSNULL, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse); 8030 } 8031} 8032 8033#if 0 8034mDNSlocal mDNSBool TrustedSource(const mDNS *const m, const mDNSAddr *const srcaddr) 8035{ 8036 DNSServer *s; 8037 (void)m; // Unused 8038 (void)srcaddr; // Unused 8039 for (s = m->DNSServers; s; s = s->next) 8040 if (mDNSSameAddress(srcaddr, &s->addr)) return(mDNStrue); 8041 return(mDNSfalse); 8042} 8043#endif 8044 8045struct UDPSocket_struct 8046{ 8047 mDNSIPPort port; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port 8048}; 8049 8050mDNSlocal DNSQuestion *ExpectingUnicastResponseForQuestion(const mDNS *const m, const mDNSIPPort port, const mDNSOpaque16 id, const DNSQuestion *const question, mDNSBool tcp) 8051{ 8052 DNSQuestion *q; 8053 for (q = m->Questions; q; q=q->next) 8054 { 8055 if (!tcp && !q->LocalSocket) continue; 8056 if (mDNSSameIPPort(tcp ? q->tcpSrcPort : q->LocalSocket->port, port) && 8057 mDNSSameOpaque16(q->TargetQID, id) && 8058 q->qtype == question->qtype && 8059 q->qclass == question->qclass && 8060 q->qnamehash == question->qnamehash && 8061 SameDomainName(&q->qname, &question->qname)) 8062 return(q); 8063 } 8064 return(mDNSNULL); 8065} 8066 8067// This function is called when we receive a unicast response. This could be the case of a unicast response from the 8068// DNS server or a response to the QU query. Hence, the cache record's InterfaceId can be both NULL or non-NULL (QU case) 8069mDNSlocal DNSQuestion *ExpectingUnicastResponseForRecord(mDNS *const m, 8070 const mDNSAddr *const srcaddr, const mDNSBool SrcLocal, const mDNSIPPort port, const mDNSOpaque16 id, const CacheRecord *const rr, mDNSBool tcp) 8071{ 8072 DNSQuestion *q; 8073 (void)id; 8074 (void)srcaddr; 8075 8076 for (q = m->Questions; q; q=q->next) 8077 { 8078 if (!q->DuplicateOf && ResourceRecordAnswersUnicastResponse(&rr->resrec, q)) 8079 { 8080 if (!mDNSOpaque16IsZero(q->TargetQID)) 8081 { 8082 debugf("ExpectingUnicastResponseForRecord msg->h.id %d q->TargetQID %d for %s", mDNSVal16(id), mDNSVal16(q->TargetQID), CRDisplayString(m, rr)); 8083 8084 if (mDNSSameOpaque16(q->TargetQID, id)) 8085 { 8086 mDNSIPPort srcp; 8087 if (!tcp) 8088 { 8089 srcp = q->LocalSocket ? q->LocalSocket->port : zeroIPPort; 8090 } 8091 else 8092 { 8093 srcp = q->tcpSrcPort; 8094 } 8095 if (mDNSSameIPPort(srcp, port)) return(q); 8096 8097 // if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue); 8098 // if (q->LongLived && mDNSSameAddress(srcaddr, &q->servAddr)) return(mDNStrue); Shouldn't need this now that we have LLQType checking 8099 // if (TrustedSource(m, srcaddr)) return(mDNStrue); 8100 LogInfo("WARNING: Ignoring suspect uDNS response for %##s (%s) [q->Target %#a:%d] from %#a:%d %s", 8101 q->qname.c, DNSTypeName(q->qtype), &q->Target, mDNSVal16(srcp), srcaddr, mDNSVal16(port), CRDisplayString(m, rr)); 8102 return(mDNSNULL); 8103 } 8104 } 8105 else 8106 { 8107 if (SrcLocal && q->ExpectUnicastResp && (mDNSu32)(m->timenow - q->ExpectUnicastResp) < (mDNSu32)(mDNSPlatformOneSecond*2)) 8108 return(q); 8109 } 8110 } 8111 } 8112 return(mDNSNULL); 8113} 8114 8115// Certain data types need more space for in-memory storage than their in-packet rdlength would imply 8116// Currently this applies only to rdata types containing more than one domainname, 8117// or types where the domainname is not the last item in the structure. 8118mDNSlocal mDNSu16 GetRDLengthMem(const ResourceRecord *const rr) 8119{ 8120 switch (rr->rrtype) 8121 { 8122 case kDNSType_SOA: return sizeof(rdataSOA); 8123 case kDNSType_RP: return sizeof(rdataRP); 8124 case kDNSType_PX: return sizeof(rdataPX); 8125 default: return rr->rdlength; 8126 } 8127} 8128 8129mDNSexport CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg, mDNSs32 delay, mDNSBool Add, const mDNSAddr *sourceAddress) 8130{ 8131 CacheRecord *rr = mDNSNULL; 8132 mDNSu16 RDLength = GetRDLengthMem(&m->rec.r.resrec); 8133 8134 if (!m->rec.r.resrec.InterfaceID) debugf("CreateNewCacheEntry %s", CRDisplayString(m, &m->rec.r)); 8135 8136 //if (RDLength > InlineCacheRDSize) 8137 // LogInfo("Rdata len %4d > InlineCacheRDSize %d %s", RDLength, InlineCacheRDSize, CRDisplayString(m, &m->rec.r)); 8138 8139 if (!cg) cg = GetCacheGroup(m, slot, &m->rec.r.resrec); // If we don't have a CacheGroup for this name, make one now 8140 if (cg) rr = GetCacheRecord(m, cg, RDLength); // Make a cache record, being careful not to recycle cg 8141 if (!rr) NoCacheAnswer(m, &m->rec.r); 8142 else 8143 { 8144 RData *saveptr = rr->resrec.rdata; // Save the rr->resrec.rdata pointer 8145 *rr = m->rec.r; // Block copy the CacheRecord object 8146 rr->resrec.rdata = saveptr; // Restore rr->resrec.rdata after the structure assignment 8147 rr->resrec.name = cg->name; // And set rr->resrec.name to point into our CacheGroup header 8148 8149 // We need to add the anonymous info before we call CacheRecordAdd so that 8150 // if it finds a matching question with this record, it bumps up the counters like 8151 // CurrentAnswers etc. Otherwise, when a cache entry gets removed, CacheRecordRmv 8152 // will complain. 8153 if (m->rec.r.resrec.AnonInfo) 8154 { 8155 rr->resrec.AnonInfo = m->rec.r.resrec.AnonInfo; 8156 m->rec.r.resrec.AnonInfo = mDNSNULL; 8157 } 8158 rr->DelayDelivery = delay; 8159 8160 // If this is an oversized record with external storage allocated, copy rdata to external storage 8161 if (rr->resrec.rdata == (RData*)&rr->smallrdatastorage && RDLength > InlineCacheRDSize) 8162 LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s", m->rec.r.resrec.name->c); 8163 else if (rr->resrec.rdata != (RData*)&rr->smallrdatastorage && RDLength <= InlineCacheRDSize) 8164 LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s", m->rec.r.resrec.name->c); 8165 if (RDLength > InlineCacheRDSize) 8166 mDNSPlatformMemCopy(rr->resrec.rdata, m->rec.r.resrec.rdata, sizeofRDataHeader + RDLength); 8167 8168 rr->next = mDNSNULL; // Clear 'next' pointer 8169 rr->nsec = mDNSNULL; 8170 rr->soa = mDNSNULL; 8171 8172 if (sourceAddress) 8173 rr->sourceAddress = *sourceAddress; 8174 8175 if (!rr->resrec.InterfaceID) 8176 { 8177 m->rrcache_totalused_unicast += rr->resrec.rdlength; 8178 if (DNSSECRecordType(rr->resrec.rrtype)) 8179 BumpDNSSECStats(m, kStatsActionIncrement, kStatsTypeMemoryUsage, rr->resrec.rdlength); 8180 } 8181 8182 if (Add) 8183 { 8184 *(cg->rrcache_tail) = rr; // Append this record to tail of cache slot list 8185 cg->rrcache_tail = &(rr->next); // Advance tail pointer 8186 CacheRecordAdd(m, rr); // CacheRecordAdd calls SetNextCacheCheckTimeForRecord(m, rr); for us 8187 } 8188 else 8189 { 8190 // Can't use the "cg->name" if we are not adding to the cache as the 8191 // CacheGroup may be released anytime if it is empty 8192 domainname *name = mDNSPlatformMemAllocate(DomainNameLength(cg->name)); 8193 if (name) 8194 { 8195 AssignDomainName(name, cg->name); 8196 rr->resrec.name = name; 8197 } 8198 else 8199 { 8200 ReleaseCacheRecord(m, rr); 8201 NoCacheAnswer(m, &m->rec.r); 8202 rr = mDNSNULL; 8203 } 8204 } 8205 } 8206 return(rr); 8207} 8208 8209mDNSlocal void RefreshCacheRecord(mDNS *const m, CacheRecord *rr, mDNSu32 ttl) 8210{ 8211 rr->TimeRcvd = m->timenow; 8212 rr->resrec.rroriginalttl = ttl; 8213 rr->UnansweredQueries = 0; 8214 SetNextCacheCheckTimeForRecord(m, rr); 8215} 8216 8217mDNSexport void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease) 8218{ 8219 CacheRecord *rr; 8220 CacheGroup *cg = CacheGroupForName(m, q->qnamehash, &q->qname); 8221 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 8222 if (rr->CRActiveQuestion == q) 8223 { 8224 //LogInfo("GrantCacheExtensions: new lease %d / %s", lease, CRDisplayString(m, rr)); 8225 RefreshCacheRecord(m, rr, lease); 8226 } 8227} 8228 8229mDNSlocal mDNSu32 GetEffectiveTTL(const uDNS_LLQType LLQType, mDNSu32 ttl) // TTL in seconds 8230{ 8231 if (LLQType == uDNS_LLQ_Entire) ttl = kLLQ_DefLease; 8232 else if (LLQType == uDNS_LLQ_Events) 8233 { 8234 // If the TTL is -1 for uDNS LLQ event packet, that means "remove" 8235 if (ttl == 0xFFFFFFFF) ttl = 0; 8236 else ttl = kLLQ_DefLease; 8237 } 8238 else // else not LLQ (standard uDNS response) 8239 { 8240 // The TTL is already capped to a maximum value in GetLargeResourceRecord, but just to be extra safe we 8241 // also do this check here to make sure we can't get overflow below when we add a quarter to the TTL 8242 if (ttl > 0x60000000UL / mDNSPlatformOneSecond) ttl = 0x60000000UL / mDNSPlatformOneSecond; 8243 8244 ttl = RRAdjustTTL(ttl); 8245 8246 // For mDNS, TTL zero means "delete this record" 8247 // For uDNS, TTL zero means: this data is true at this moment, but don't cache it. 8248 // For the sake of network efficiency, we impose a minimum effective TTL of 15 seconds. 8249 // This means that we'll do our 80, 85, 90, 95% queries at 12.00, 12.75, 13.50, 14.25 seconds 8250 // respectively, and then if we get no response, delete the record from the cache at 15 seconds. 8251 // This gives the server up to three seconds to respond between when we send our 80% query at 12 seconds 8252 // and when we delete the record at 15 seconds. Allowing cache lifetimes less than 15 seconds would 8253 // (with the current code) result in the server having even less than three seconds to respond 8254 // before we deleted the record and reported a "remove" event to any active questions. 8255 // Furthermore, with the current code, if we were to allow a TTL of less than 2 seconds 8256 // then things really break (e.g. we end up making a negative cache entry). 8257 // In the future we may want to revisit this and consider properly supporting non-cached (TTL=0) uDNS answers. 8258 if (ttl < 15) ttl = 15; 8259 } 8260 8261 return ttl; 8262} 8263 8264// When the response does not match the question directly, we still want to cache them sometimes. The current response is 8265// in m->rec. 8266mDNSlocal mDNSBool IsResponseAcceptable(mDNS *const m, const CacheRecord *crlist, DNSQuestion *q, mDNSBool *nseclist) 8267{ 8268 CacheRecord *const newcr = &m->rec.r; 8269 ResourceRecord *rr = &newcr->resrec; 8270 const CacheRecord *cr; 8271 8272 *nseclist = mDNSfalse; 8273 for (cr = crlist; cr != (CacheRecord*)1; cr = cr->NextInCFList) 8274 { 8275 domainname *target = GetRRDomainNameTarget(&cr->resrec); 8276 // When we issue a query for A record, the response might contain both a CNAME and A records. Only the CNAME would 8277 // match the question and we already created a cache entry in the previous pass of this loop. Now when we process 8278 // the A record, it does not match the question because the record name here is the CNAME. Hence we try to 8279 // match with the previous records to make it an AcceptableResponse. We have to be careful about setting the 8280 // DNSServer value that we got in the previous pass. This can happen for other record types like SRV also. 8281 8282 if (target && cr->resrec.rdatahash == rr->namehash && SameDomainName(target, rr->name)) 8283 { 8284 LogInfo("IsResponseAcceptable: Found a matching entry for %##s in the CacheFlushRecords %s", rr->name->c, CRDisplayString(m, cr)); 8285 return (mDNStrue); 8286 } 8287 } 8288 8289 // Either the question requires validation or we are validating a response with DNSSEC in which case 8290 // we need to accept the RRSIGs also so that we can validate the response. It is also possible that 8291 // we receive NSECs for our query which does not match the qname and we need to cache in that case 8292 // too. nseclist is set if they have to be cached as part of the negative cache record. 8293 if (q && DNSSECQuestion(q)) 8294 { 8295 mDNSBool same = SameDomainName(&q->qname, rr->name); 8296 if (same && (q->qtype == rr->rrtype || rr->rrtype == kDNSType_CNAME)) 8297 { 8298 LogInfo("IsResponseAcceptable: Accepting, same name and qtype %s, CR %s", DNSTypeName(q->qtype), 8299 CRDisplayString(m, newcr)); 8300 return mDNStrue; 8301 } 8302 // We cache RRSIGS if it covers the question type or NSEC. If it covers a NSEC, 8303 // "nseclist" is set 8304 if (rr->rrtype == kDNSType_RRSIG) 8305 { 8306 RDataBody2 *const rdb = (RDataBody2 *)newcr->smallrdatastorage.data; 8307 rdataRRSig *rrsig = &rdb->rrsig; 8308 mDNSu16 typeCovered = swap16(rrsig->typeCovered); 8309 8310 // Note the ordering. If we are looking up the NSEC record, then the RRSIG's typeCovered 8311 // would match the qtype and they are cached normally as they are not used to prove the 8312 // non-existence of any name. In that case, it is like any other normal dnssec validation 8313 // and hence nseclist should not be set. 8314 8315 if (same && ((typeCovered == q->qtype) || (typeCovered == kDNSType_CNAME))) 8316 { 8317 LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches question type %s", CRDisplayString(m, newcr), 8318 DNSTypeName(q->qtype)); 8319 return mDNStrue; 8320 } 8321 else if (typeCovered == kDNSType_NSEC || typeCovered == kDNSType_NSEC3) 8322 { 8323 LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches %s type (nseclist = 1)", CRDisplayString(m, newcr), DNSTypeName(typeCovered)); 8324 *nseclist = mDNStrue; 8325 return mDNStrue; 8326 } 8327 else if (typeCovered == kDNSType_SOA) 8328 { 8329 LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches SOA type (nseclist = 1)", CRDisplayString(m, newcr)); 8330 *nseclist = mDNStrue; 8331 return mDNStrue; 8332 } 8333 else return mDNSfalse; 8334 } 8335 if (rr->rrtype == kDNSType_NSEC) 8336 { 8337 if (!UNICAST_NSEC(rr)) 8338 { 8339 LogMsg("IsResponseAcceptable: ERROR!! Not a unicast NSEC %s", CRDisplayString(m, newcr)); 8340 return mDNSfalse; 8341 } 8342 LogInfo("IsResponseAcceptable: Accepting NSEC %s (nseclist = 1)", CRDisplayString(m, newcr)); 8343 *nseclist = mDNStrue; 8344 return mDNStrue; 8345 } 8346 if (rr->rrtype == kDNSType_SOA) 8347 { 8348 LogInfo("IsResponseAcceptable: Accepting SOA %s (nseclist = 1)", CRDisplayString(m, newcr)); 8349 *nseclist = mDNStrue; 8350 return mDNStrue; 8351 } 8352 else if (rr->rrtype == kDNSType_NSEC3) 8353 { 8354 LogInfo("IsResponseAcceptable: Accepting NSEC3 %s (nseclist = 1)", CRDisplayString(m, newcr)); 8355 *nseclist = mDNStrue; 8356 return mDNStrue; 8357 } 8358 } 8359 return mDNSfalse; 8360} 8361 8362mDNSlocal void FreeNSECRecords(mDNS *const m, CacheRecord *NSECRecords) 8363{ 8364 CacheRecord *rp, *next; 8365 8366 for (rp = NSECRecords; rp; rp = next) 8367 { 8368 next = rp->next; 8369 ReleaseCacheRecord(m, rp); 8370 } 8371} 8372 8373// If we received zero DNSSEC records even when the DO/EDNS0 bit was set, we need to provide this 8374// information to ValidatingResponse question to indicate the DNSSEC status to the application 8375mDNSlocal void mDNSCoreReceiveNoDNSSECAnswers(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *dstaddr, 8376 mDNSIPPort dstport, const mDNSInterfaceID InterfaceID) 8377{ 8378 int i; 8379 const mDNSu8 *ptr = response->data; 8380 8381 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) 8382 { 8383 DNSQuestion pktq; 8384 DNSQuestion *qptr = mDNSNULL; 8385 ptr = getQuestion(response, ptr, end, InterfaceID, &pktq); 8386 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &pktq, !dstaddr)) && 8387 qptr->ValidatingResponse) 8388 { 8389 DNSQuestion *next, *q; 8390 8391 if (qptr->DuplicateOf) 8392 LogMsg("mDNSCoreReceiveNoDNSSECAnswers: ERROR!! qptr %##s (%s) Duplicate question matching response", qptr->qname.c, DNSTypeName(qptr->qtype)); 8393 8394 // Be careful to call the callback for duplicate questions first and then the original 8395 // question. If we called the callback on the original question, it could stop and 8396 // a duplicate question would become the original question. 8397 mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls 8398 for (q = qptr->next ; q && q != m->NewQuestions; q = next) 8399 { 8400 next = q->next; 8401 if (q->DuplicateOf == qptr) 8402 { 8403 if (q->ValidatingResponse) 8404 LogInfo("mDNSCoreReceiveNoDNSSECAnswers: qptr %##s (%s) Duplicate question found", q->qname.c, DNSTypeName(q->qtype)); 8405 else 8406 LogMsg("mDNSCoreReceiveNoDNSSECAnswers: ERROR!! qptr %##s (%s) Duplicate question not ValidatingResponse", q->qname.c, DNSTypeName(q->qtype)); 8407 if (q->QuestionCallback) 8408 q->QuestionCallback(m, q, mDNSNULL, QC_nodnssec); 8409 } 8410 } 8411 if (qptr->QuestionCallback) 8412 qptr->QuestionCallback(m, qptr, mDNSNULL, QC_nodnssec); 8413 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 8414 } 8415 } 8416} 8417 8418mDNSlocal void mDNSCoreReceiveNoUnicastAnswers(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *dstaddr, 8419 mDNSIPPort dstport, const mDNSInterfaceID InterfaceID, uDNS_LLQType LLQType, mDNSu8 rcode, CacheRecord *NSECRecords) 8420{ 8421 int i; 8422 const mDNSu8 *ptr = response->data; 8423 CacheRecord *SOARecord = mDNSNULL; 8424 8425 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) 8426 { 8427 DNSQuestion q; 8428 DNSQuestion *qptr = mDNSNULL; 8429 ptr = getQuestion(response, ptr, end, InterfaceID, &q); 8430 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr))) 8431 { 8432 CacheRecord *rr, *neg = mDNSNULL; 8433 CacheGroup *cg = CacheGroupForName(m, q.qnamehash, &q.qname); 8434 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 8435 if (SameNameRecordAnswersQuestion(&rr->resrec, qptr)) 8436 { 8437 // 1. If we got a fresh answer to this query, then don't need to generate a negative entry 8438 if (RRExpireTime(rr) - m->timenow > 0) break; 8439 // 2. If we already had a negative entry, keep track of it so we can resurrect it instead of creating a new one 8440 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) neg = rr; 8441 } 8442 // When we're doing parallel unicast and multicast queries for dot-local names (for supporting Microsoft 8443 // Active Directory sites) we don't want to waste memory making negative cache entries for all the unicast answers. 8444 // Otherwise we just fill up our cache with negative entries for just about every single multicast name we ever look up 8445 // (since the Microsoft Active Directory server is going to assert that pretty much every single multicast name doesn't exist). 8446 // This is not only a waste of memory, but there's also the problem of those negative entries confusing us later -- e.g. we 8447 // suppress sending our mDNS query packet because we think we already have a valid (negative) answer to that query in our cache. 8448 // The one exception is that we *DO* want to make a negative cache entry for "local. SOA", for the (common) case where we're 8449 // *not* on a Microsoft Active Directory network, and there is no authoritative server for "local". Note that this is not 8450 // in conflict with the mDNS spec, because that spec says, "Multicast DNS Zones have no SOA record," so it's okay to cache 8451 // negative answers for "local. SOA" from a uDNS server, because the mDNS spec already says that such records do not exist :-) 8452 // 8453 // By suppressing negative responses, it might take longer to timeout a .local question as it might be expecting a 8454 // response e.g., we deliver a positive "A" response and suppress negative "AAAA" response and the upper layer may 8455 // be waiting longer to get the AAAA response before returning the "A" response to the application. To handle this 8456 // case without creating the negative cache entries, we generate a negative response and let the layer above us 8457 // do the appropriate thing. This negative response is also needed for appending new search domains. 8458 if (!InterfaceID && q.qtype != kDNSType_SOA && IsLocalDomain(&q.qname)) 8459 { 8460 if (!rr) 8461 { 8462 LogInfo("mDNSCoreReceiveNoUnicastAnswers: Generate negative response for %##s (%s)", q.qname.c, DNSTypeName(q.qtype)); 8463 m->CurrentQuestion = qptr; 8464 // We are not creating a cache record in this case, we need to pass back 8465 // the error we got so that the proxy code can return the right one to 8466 // the application 8467 if (qptr->ProxyQuestion) 8468 qptr->responseFlags = response->h.flags; 8469 GenerateNegativeResponse(m, mDNSInterface_Any, QC_forceresponse); 8470 m->CurrentQuestion = mDNSNULL; 8471 } 8472 else 8473 { 8474 LogInfo("mDNSCoreReceiveNoUnicastAnswers: Skipping check and not creating a negative cache entry for %##s (%s)", q.qname.c, DNSTypeName(q.qtype)); 8475 } 8476 } 8477 else 8478 { 8479 if (!rr) 8480 { 8481 // We start off assuming a negative caching TTL of 60 seconds 8482 // but then look to see if we can find an SOA authority record to tell us a better value we should be using 8483 mDNSu32 negttl = 60; 8484 int repeat = 0; 8485 const domainname *name = &q.qname; 8486 mDNSu32 hash = q.qnamehash; 8487 8488 // Special case for our special Microsoft Active Directory "local SOA" check. 8489 // Some cheap home gateways don't include an SOA record in the authority section when 8490 // they send negative responses, so we don't know how long to cache the negative result. 8491 // Because we don't want to keep hitting the root name servers with our query to find 8492 // if we're on a network using Microsoft Active Directory using "local" as a private 8493 // internal top-level domain, we make sure to cache the negative result for at least one day. 8494 if (q.qtype == kDNSType_SOA && SameDomainName(&q.qname, &localdomain)) negttl = 60 * 60 * 24; 8495 8496 // If we're going to make (or update) a negative entry, then look for the appropriate TTL from the SOA record 8497 if (response->h.numAuthorities && (ptr = LocateAuthorities(response, end)) != mDNSNULL) 8498 { 8499 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 8500 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_SOA) 8501 { 8502 CacheGroup *cgSOA = CacheGroupForRecord(m, &m->rec.r.resrec); 8503 const rdataSOA *const soa = (const rdataSOA *)m->rec.r.resrec.rdata->u.data; 8504 mDNSu32 ttl_s = soa->min; 8505 // We use the lesser of the SOA.MIN field and the SOA record's TTL, *except* 8506 // for the SOA record for ".", where the record is reported as non-cacheable 8507 // (TTL zero) for some reason, so in this case we just take the SOA record's TTL as-is 8508 if (ttl_s > m->rec.r.resrec.rroriginalttl && m->rec.r.resrec.name->c[0]) 8509 ttl_s = m->rec.r.resrec.rroriginalttl; 8510 if (negttl < ttl_s) negttl = ttl_s; 8511 8512 // Create the SOA record as we may have to return this to the questions 8513 // that we are acting as a proxy for currently or in the future. 8514 SOARecord = CreateNewCacheEntry(m, HashSlotFromNameHash(m->rec.r.resrec.namehash), cgSOA, 1, mDNSfalse, mDNSNULL); 8515 8516 // Special check for SOA queries: If we queried for a.b.c.d.com, and got no answer, 8517 // with an Authority Section SOA record for d.com, then this is a hint that the authority 8518 // is d.com, and consequently SOA records b.c.d.com and c.d.com don't exist either. 8519 // To do this we set the repeat count so the while loop below will make a series of negative cache entries for us 8520 // 8521 // For ProxyQuestions, we don't do this as we need to create additional SOA records to cache them 8522 // along with the negative cache record. For simplicity, we don't create the additional records. 8523 if (!qptr->ProxyQuestion && q.qtype == kDNSType_SOA) 8524 { 8525 int qcount = CountLabels(&q.qname); 8526 int scount = CountLabels(m->rec.r.resrec.name); 8527 if (qcount - 1 > scount) 8528 if (SameDomainName(SkipLeadingLabels(&q.qname, qcount - scount), m->rec.r.resrec.name)) 8529 repeat = qcount - 1 - scount; 8530 } 8531 } 8532 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 8533 } 8534 8535 // If we already had a negative entry in the cache, then we double our existing negative TTL. This is to avoid 8536 // the case where the record doesn't exist (e.g. particularly for things like our lb._dns-sd._udp.<domain> query), 8537 // and the server returns no SOA record (or an SOA record with a small MIN TTL) so we assume a TTL 8538 // of 60 seconds, and we end up polling the server every minute for a record that doesn't exist. 8539 // With this fix in place, when this happens, we double the effective TTL each time (up to one hour), 8540 // so that we back off our polling rate and don't keep hitting the server continually. 8541 if (neg) 8542 { 8543 if (negttl < neg->resrec.rroriginalttl * 2) 8544 negttl = neg->resrec.rroriginalttl * 2; 8545 if (negttl > 3600) 8546 negttl = 3600; 8547 } 8548 8549 negttl = GetEffectiveTTL(LLQType, negttl); // Add 25% grace period if necessary 8550 8551 // If we already had a negative cache entry just update it, else make one or more new negative cache entries. 8552 if (neg) 8553 { 8554 LogInfo("mDNSCoreReceiveNoUnicastAnswers: Renewing negative TTL from %d to %d %s", neg->resrec.rroriginalttl, negttl, CRDisplayString(m, neg)); 8555 RefreshCacheRecord(m, neg, negttl); 8556 // When we created the cache for the first time and answered the question, the question's 8557 // interval was set to MaxQuestionInterval. If the cache is about to expire and we are resending 8558 // the queries, the interval should still be at MaxQuestionInterval. If the query is being 8559 // restarted (setting it to InitialQuestionInterval) for other reasons e.g., wakeup, 8560 // we should reset its question interval here to MaxQuestionInterval. 8561 ResetQuestionState(m, qptr); 8562 if (DNSSECQuestion(qptr)) 8563 neg->CRDNSSECQuestion = 1; 8564 // Update the NSEC records again. 8565 // TBD: Need to purge and revalidate if the cached NSECS and the new set are not same. 8566 if (NSECRecords) 8567 { 8568 if (!AddNSECSForCacheRecord(m, NSECRecords, neg, rcode)) 8569 { 8570 // We might just have an SOA record for zones that are not signed and hence don't log 8571 // this as an error 8572 LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord failed to add NSEC for negcr %s during refresh", CRDisplayString(m, neg)); 8573 FreeNSECRecords(m, NSECRecords); 8574 neg->CRDNSSECQuestion = 0; 8575 } 8576 NSECRecords = mDNSNULL; 8577 } 8578 if (SOARecord) 8579 { 8580 if (neg->soa) 8581 ReleaseCacheRecord(m, neg->soa); 8582 neg->soa = SOARecord; 8583 SOARecord = mDNSNULL; 8584 } 8585 } 8586 else while (1) 8587 { 8588 CacheRecord *negcr; 8589 debugf("mDNSCoreReceiveNoUnicastAnswers making negative cache entry TTL %d for %##s (%s)", negttl, name->c, DNSTypeName(q.qtype)); 8590 MakeNegativeCacheRecord(m, &m->rec.r, name, hash, q.qtype, q.qclass, negttl, mDNSInterface_Any, qptr->qDNSServer); 8591 m->rec.r.responseFlags = response->h.flags; 8592 // We create SOA records above which might create new cache groups. Earlier 8593 // in the function we looked up the cache group for the name and it could have 8594 // been NULL. If we pass NULL cg to new cache entries that we create below, 8595 // it will create additional cache groups for the same name. To avoid that, 8596 // look up the cache group again to re-initialize cg again. 8597 cg = CacheGroupForName(m, hash, name); 8598 if (NSECRecords && DNSSECQuestion(qptr)) 8599 { 8600 // Create the cache entry with delay and then add the NSEC records 8601 // to it and add it immediately. 8602 negcr = CreateNewCacheEntry(m, HashSlotFromNameHash(hash), cg, 1, mDNStrue, mDNSNULL); 8603 if (negcr) 8604 { 8605 negcr->CRDNSSECQuestion = 0; 8606 if (!AddNSECSForCacheRecord(m, NSECRecords, negcr, rcode)) 8607 { 8608 LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord failed to add NSEC for negcr %s", 8609 CRDisplayString(m, negcr)); 8610 FreeNSECRecords(m, NSECRecords); 8611 } 8612 else 8613 { 8614 negcr->CRDNSSECQuestion = 1; 8615 LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord added neg NSEC for %s", CRDisplayString(m, negcr)); 8616 } 8617 NSECRecords = mDNSNULL; 8618 negcr->DelayDelivery = 0; 8619 CacheRecordDeferredAdd(m, negcr); 8620 } 8621 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 8622 break; 8623 } 8624 else 8625 { 8626 // Need to add with a delay so that we can tag the SOA record 8627 negcr = CreateNewCacheEntry(m, HashSlotFromNameHash(hash), cg, 1, mDNStrue, mDNSNULL); 8628 if (negcr) 8629 { 8630 negcr->CRDNSSECQuestion = 0; 8631 if (DNSSECQuestion(qptr)) 8632 negcr->CRDNSSECQuestion = 1; 8633 negcr->DelayDelivery = 0; 8634 8635 if (SOARecord) 8636 { 8637 if (negcr->soa) 8638 ReleaseCacheRecord(m, negcr->soa); 8639 negcr->soa = SOARecord; 8640 SOARecord = mDNSNULL; 8641 } 8642 CacheRecordDeferredAdd(m, negcr); 8643 } 8644 } 8645 m->rec.r.responseFlags = zeroID; 8646 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 8647 if (!repeat) break; 8648 repeat--; 8649 name = (const domainname *)(name->c + 1 + name->c[0]); 8650 hash = DomainNameHashValue(name); 8651 } 8652 } 8653 } 8654 } 8655 } 8656 if (NSECRecords) { LogInfo("mDNSCoreReceiveNoUnicastAnswers: NSECRecords not used"); FreeNSECRecords(m, NSECRecords); } 8657 if (SOARecord) { LogInfo("mDNSCoreReceiveNoUnicastAnswers: SOARecord not used"); ReleaseCacheRecord(m, SOARecord); } 8658} 8659 8660mDNSlocal void mDNSCorePrintStoredProxyRecords(mDNS *const m) 8661{ 8662 AuthRecord *rrPtr = mDNSNULL; 8663 LogSPS("Stored Proxy records :"); 8664 for (rrPtr = m->SPSRRSet; rrPtr; rrPtr = rrPtr->next) 8665 { 8666 LogSPS("%s", ARDisplayString(m, rrPtr)); 8667 } 8668} 8669 8670mDNSlocal mDNSBool mDNSCoreRegisteredProxyRecord(mDNS *const m, AuthRecord *rr) 8671{ 8672 AuthRecord *rrPtr = mDNSNULL; 8673 8674 for (rrPtr = m->SPSRRSet; rrPtr; rrPtr = rrPtr->next) 8675 { 8676 if (IdenticalResourceRecord(&rrPtr->resrec, &rr->resrec)) 8677 { 8678 LogSPS("mDNSCoreRegisteredProxyRecord: Ignoring packet registered with sleep proxy : %s ", ARDisplayString(m, rr)); 8679 return mDNStrue; 8680 } 8681 } 8682 mDNSCorePrintStoredProxyRecords(m); 8683 return mDNSfalse; 8684} 8685 8686mDNSlocal CacheRecord* mDNSCoreReceiveCacheCheck(mDNS *const m, const DNSMessage *const response, uDNS_LLQType LLQType, 8687 const mDNSu32 slot, CacheGroup *cg, DNSQuestion *unicastQuestion, CacheRecord ***cfp, CacheRecord **NSECCachePtr, 8688 mDNSInterfaceID InterfaceID) 8689{ 8690 CacheRecord *rr; 8691 CacheRecord **cflocal = *cfp; 8692 8693 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 8694 { 8695 mDNSBool match; 8696 // Resource record received via unicast, the resGroupID should match ? 8697 if (!InterfaceID) 8698 { 8699 mDNSu16 id1 = (rr->resrec.rDNSServer ? rr->resrec.rDNSServer->resGroupID : 0); 8700 mDNSu16 id2 = (m->rec.r.resrec.rDNSServer ? m->rec.r.resrec.rDNSServer->resGroupID : 0); 8701 match = (id1 == id2); 8702 } 8703 else 8704 match = (rr->resrec.InterfaceID == InterfaceID); 8705 // If we found this exact resource record, refresh its TTL 8706 if (match && IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec)) 8707 { 8708 if (m->rec.r.resrec.rdlength > InlineCacheRDSize) 8709 verbosedebugf("mDNSCoreReceiveCacheCheck: Found record size %5d interface %p already in cache: %s", 8710 m->rec.r.resrec.rdlength, InterfaceID, CRDisplayString(m, &m->rec.r)); 8711 8712 if (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) 8713 { 8714 // If this packet record has the kDNSClass_UniqueRRSet flag set, then add it to our cache flushing list 8715 if (rr->NextInCFList == mDNSNULL && *cfp != &rr->NextInCFList && LLQType != uDNS_LLQ_Events) 8716 { 8717 *cflocal = rr; 8718 cflocal = &rr->NextInCFList; 8719 *cflocal = (CacheRecord*)1; 8720 *cfp = &rr->NextInCFList; 8721 } 8722 8723 // If this packet record is marked unique, and our previous cached copy was not, then fix it 8724 if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)) 8725 { 8726 DNSQuestion *q; 8727 for (q = m->Questions; q; q=q->next) 8728 { 8729 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 8730 q->UniqueAnswers++; 8731 } 8732 rr->resrec.RecordType = m->rec.r.resrec.RecordType; 8733 } 8734 } 8735 8736 if (!SameRDataBody(&m->rec.r.resrec, &rr->resrec.rdata->u, SameDomainNameCS)) 8737 { 8738 // If the rdata of the packet record differs in name capitalization from the record in our cache 8739 // then mDNSPlatformMemSame will detect this. In this case, throw the old record away, so that clients get 8740 // a 'remove' event for the record with the old capitalization, and then an 'add' event for the new one. 8741 // <rdar://problem/4015377> mDNS -F returns the same domain multiple times with different casing 8742 rr->resrec.rroriginalttl = 0; 8743 rr->TimeRcvd = m->timenow; 8744 rr->UnansweredQueries = MaxUnansweredQueries; 8745 SetNextCacheCheckTimeForRecord(m, rr); 8746 LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change old: %s", CRDisplayString(m, rr)); 8747 LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change new: %s", CRDisplayString(m, &m->rec.r)); 8748 LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change in %d slot %3d in %d %d", 8749 NextCacheCheckEvent(rr) - m->timenow, slot, m->rrcache_nextcheck[slot] - m->timenow, m->NextCacheCheck - m->timenow); 8750 // DO NOT break out here -- we want to continue as if we never found it 8751 } 8752 else if (!IdenticalAnonInfo(m->rec.r.resrec.AnonInfo, rr->resrec.AnonInfo)) 8753 { 8754 // If the NSEC3 record changed, a few possibilities 8755 // 8756 // 1) the peer reinitialized e.g., after network change and still part of the 8757 // same set. 8758 // 2) the peer went to a different set but we did not see the goodbyes. If we just 8759 // update the nsec3 record, it would be incorrect. Flush the cache so that we 8760 // can deliver a RMV followed by ADD. 8761 // 3) if the peer is ourselves and we see the goodbye when moving to a different set 8762 // and so we flush the cache and create a new cache record with the new set information. 8763 // Now we move back to the original set. In this case, we can't just update the 8764 // NSEC3 record alone. We need to flush so that we can deliver an RMV followed by ADD 8765 // when we create the new cache entry. 8766 // 8767 // Note: For case (1), we could avoid flushing the cache but we can't tell the difference 8768 // from the other cases. 8769 rr->resrec.rroriginalttl = 0; 8770 rr->TimeRcvd = m->timenow; 8771 rr->UnansweredQueries = MaxUnansweredQueries; 8772 SetNextCacheCheckTimeForRecord(m, rr); 8773 LogInfo("mDNSCoreReceiveCacheCheck: AnonInfo changed for %s", CRDisplayString(m, rr)); 8774 // DO NOT break out here -- we want to continue as if we never found it. When we return 8775 // from this function, we will create a new cache entry with the new NSEC3 record 8776 } 8777 else if (m->rec.r.resrec.rroriginalttl > 0) 8778 { 8779 DNSQuestion *q; 8780 8781 m->mDNSStats.CacheRefreshed++; 8782 8783 if (rr->resrec.rroriginalttl == 0) debugf("uDNS rescuing %s", CRDisplayString(m, rr)); 8784 RefreshCacheRecord(m, rr, m->rec.r.resrec.rroriginalttl); 8785 rr->responseFlags = response->h.flags; 8786 8787 // If we may have NSEC records returned with the answer (which we don't know yet as it 8788 // has not been processed), we need to cache them along with the first cache 8789 // record in the list that answers the question so that it can be used for validation 8790 // later. The "type" check below is to make sure that we cache on the cache record 8791 // that would answer the question. It is possible that we might cache additional things 8792 // e.g., MX question might cache A records also, and we want to cache the NSEC on 8793 // the record that answers the question. 8794 if (response->h.numAnswers && unicastQuestion && unicastQuestion->qtype == rr->resrec.rrtype 8795 && !(*NSECCachePtr)) 8796 { 8797 LogInfo("mDNSCoreReceiveCacheCheck: rescuing RR %s", CRDisplayString(m, rr)); 8798 *NSECCachePtr = rr; 8799 } 8800 // We have to reset the question interval to MaxQuestionInterval so that we don't keep 8801 // polling the network once we get a valid response back. For the first time when a new 8802 // cache entry is created, AnswerCurrentQuestionWithResourceRecord does that. 8803 // Subsequently, if we reissue questions from within the mDNSResponder e.g., DNS server 8804 // configuration changed, without flushing the cache, we reset the question interval here. 8805 // Currently, we do this for for both multicast and unicast questions as long as the record 8806 // type is unique. For unicast, resource record is always unique and for multicast it is 8807 // true for records like A etc. but not for PTR. 8808 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) 8809 { 8810 for (q = m->Questions; q; q=q->next) 8811 { 8812 if (!q->DuplicateOf && !q->LongLived && 8813 ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) 8814 { 8815 ResetQuestionState(m, q); 8816 debugf("mDNSCoreReceiveCacheCheck: Set MaxQuestionInterval for %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 8817 break; // Why break here? Aren't there other questions we might want to look at?-- SC July 2010 8818 } 8819 } 8820 } 8821 break; 8822 } 8823 else 8824 { 8825 // If the packet TTL is zero, that means we're deleting this record. 8826 // To give other hosts on the network a chance to protest, we push the deletion 8827 // out one second into the future. Also, we set UnansweredQueries to MaxUnansweredQueries. 8828 // Otherwise, we'll do final queries for this record at 80% and 90% of its apparent 8829 // lifetime (800ms and 900ms from now) which is a pointless waste of network bandwidth. 8830 // If record's current expiry time is more than a second from now, we set it to expire in one second. 8831 // If the record is already going to expire in less than one second anyway, we leave it alone -- 8832 // we don't want to let the goodbye packet *extend* the record's lifetime in our cache. 8833 debugf("DE for %s", CRDisplayString(m, rr)); 8834 if (RRExpireTime(rr) - m->timenow > mDNSPlatformOneSecond) 8835 { 8836 rr->resrec.rroriginalttl = 1; 8837 rr->TimeRcvd = m->timenow; 8838 rr->UnansweredQueries = MaxUnansweredQueries; 8839 SetNextCacheCheckTimeForRecord(m, rr); 8840 } 8841 break; 8842 } 8843 } 8844 } 8845 return rr; 8846} 8847 8848mDNSlocal void mDNSParseNSEC3Records(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, 8849 const mDNSInterfaceID InterfaceID, CacheRecord **NSEC3Records) 8850{ 8851 const mDNSu8 *ptr; 8852 CacheRecord *rr; 8853 int i; 8854 8855 if (!response->h.numAuthorities) 8856 return; 8857 ptr = LocateAuthorities(response, end); 8858 if (!ptr) 8859 { 8860 LogInfo("mDNSParseNSEC3Records: ERROR can't locate authorities"); 8861 return; 8862 } 8863 for (i = 0; i < response->h.numAuthorities && ptr && ptr < end; i++) 8864 { 8865 CacheGroup *cg; 8866 8867 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 8868 if (!ptr || m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative || m->rec.r.resrec.rrtype != kDNSType_NSEC3) 8869 { 8870 debugf("mDNSParseNSEC3Records: ptr %p, Record %s, ignoring", ptr, CRDisplayString(m, &m->rec.r)); 8871 m->rec.r.resrec.RecordType = 0; 8872 continue; 8873 } 8874 cg = CacheGroupForRecord(m, &m->rec.r.resrec); 8875 // Create the cache entry but don't add it to the cache it. We need 8876 // to cache this along with the main cache record. 8877 rr = CreateNewCacheEntry(m, HashSlotFromNameHash(m->rec.r.resrec.namehash), cg, 0, mDNSfalse, mDNSNULL); 8878 if (rr) 8879 { 8880 debugf("mDNSParseNSEC3Records: %s", CRDisplayString(m, rr)); 8881 *NSEC3Records = rr; 8882 NSEC3Records = &rr->next; 8883 } 8884 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 8885 } 8886} 8887 8888mDNSlocal void mDNSCoreResetRecord(mDNS *const m) 8889{ 8890 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 8891 if (m->rec.r.resrec.AnonInfo) 8892 { 8893 FreeAnonInfo(m->rec.r.resrec.AnonInfo); 8894 m->rec.r.resrec.AnonInfo = mDNSNULL; 8895 } 8896} 8897 8898// Note: mDNSCoreReceiveResponse calls mDNS_Deregister_internal which can call a user callback, which may change 8899// the record list and/or question list. 8900// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 8901// InterfaceID non-NULL tells us the interface this multicast response was received on 8902// InterfaceID NULL tells us this was a unicast response 8903// dstaddr NULL tells us we received this over an outgoing TCP connection we made 8904mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m, 8905 const DNSMessage *const response, const mDNSu8 *end, 8906 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, 8907 const mDNSInterfaceID InterfaceID) 8908{ 8909 int i; 8910 mDNSBool ResponseMCast = dstaddr && mDNSAddrIsDNSMulticast(dstaddr); 8911 mDNSBool ResponseSrcLocal = !srcaddr || mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); 8912 DNSQuestion *llqMatch = mDNSNULL; 8913 DNSQuestion *unicastQuestion = mDNSNULL; 8914 uDNS_LLQType LLQType = uDNS_recvLLQResponse(m, response, end, srcaddr, srcport, &llqMatch); 8915 8916 // "(CacheRecord*)1" is a special (non-zero) end-of-list marker 8917 // We use this non-zero marker so that records in our CacheFlushRecords list will always have NextInCFList 8918 // set non-zero, and that tells GetCacheEntity() that they're not, at this moment, eligible for recycling. 8919 CacheRecord *CacheFlushRecords = (CacheRecord*)1; 8920 CacheRecord **cfp = &CacheFlushRecords; 8921 CacheRecord *NSECRecords = mDNSNULL; 8922 CacheRecord *NSECCachePtr = mDNSNULL; 8923 CacheRecord **nsecp = &NSECRecords; 8924 CacheRecord *McastNSEC3Records = mDNSNULL; 8925 mDNSBool nseclist; 8926 mDNSu8 rcode = '\0'; 8927 mDNSBool rrsigsCreated = mDNSfalse; 8928 mDNSBool DNSSECQuestion = mDNSfalse; 8929 NetworkInterfaceInfo *llintf = FirstIPv4LLInterfaceForID(m, InterfaceID); 8930 mDNSBool recordAcceptedInResponse = mDNSfalse; // Set if a record is accepted from a unicast mDNS response that answers an existing question. 8931 8932 // All records in a DNS response packet are treated as equally valid statements of truth. If we want 8933 // to guard against spoof responses, then the only credible protection against that is cryptographic 8934 // security, e.g. DNSSEC., not worrying about which section in the spoof packet contained the record. 8935 int firstauthority = response->h.numAnswers; 8936 int firstadditional = firstauthority + response->h.numAuthorities; 8937 int totalrecords = firstadditional + response->h.numAdditionals; 8938 const mDNSu8 *ptr = response->data; 8939 DNSServer *uDNSServer = mDNSNULL; 8940 8941 debugf("Received Response from %#-15a addressed to %#-15a on %p with " 8942 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes LLQType %d", 8943 srcaddr, dstaddr, InterfaceID, 8944 response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,", 8945 response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,", 8946 response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,", 8947 response->h.numAdditionals, response->h.numAdditionals == 1 ? " " : "s", end - response->data, LLQType); 8948 8949#if AWD_METRICS 8950 if (mDNSSameIPPort(srcport, UnicastDNSPort)) 8951 { 8952 MetricsUpdateDNSResponseSize((mDNSu32)(end - (mDNSu8 *)response)); 8953 } 8954#endif 8955 8956 // According to RFC 2181 <http://www.ietf.org/rfc/rfc2181.txt> 8957 // When a DNS client receives a reply with TC 8958 // set, it should ignore that response, and query again, using a 8959 // mechanism, such as a TCP connection, that will permit larger replies. 8960 // It feels wrong to be throwing away data after the network went to all the trouble of delivering it to us, but 8961 // delivering some records of the RRSet first and then the remainder a couple of milliseconds later was causing 8962 // failures in our Microsoft Active Directory client, which expects to get the entire set of answers at once. 8963 // <rdar://problem/6690034> Can't bind to Active Directory 8964 // In addition, if the client immediately canceled its query after getting the initial partial response, then we'll 8965 // abort our TCP connection, and not complete the operation, and end up with an incomplete RRSet in our cache. 8966 // Next time there's a query for this RRSet we'll see answers in our cache, and assume we have the whole RRSet already, 8967 // and not even do the TCP query. 8968 // Accordingly, if we get a uDNS reply with kDNSFlag0_TC set, we bail out and wait for the TCP response containing the entire RRSet. 8969 if (!InterfaceID && (response->h.flags.b[0] & kDNSFlag0_TC)) return; 8970 8971 if (LLQType == uDNS_LLQ_Ignore) return; 8972 8973 // 1. We ignore questions (if any) in mDNS response packets 8974 // 2. If this is an LLQ response, we handle it much the same 8975 // 3. If we get a uDNS UDP response with the TC (truncated) bit set, then we can't treat this 8976 // answer as being the authoritative complete RRSet, and respond by deleting all other 8977 // matching cache records that don't appear in this packet. 8978 // Otherwise, this is a authoritative uDNS answer, so arrange for any stale records to be purged 8979 if (ResponseMCast || LLQType == uDNS_LLQ_Events || (response->h.flags.b[0] & kDNSFlag0_TC)) 8980 ptr = LocateAnswers(response, end); 8981 // Otherwise, for one-shot queries, any answers in our cache that are not also contained 8982 // in this response packet are immediately deemed to be invalid. 8983 else 8984 { 8985 mDNSBool failure, returnEarly; 8986 rcode = (mDNSu8)(response->h.flags.b[1] & kDNSFlag1_RC_Mask); 8987 failure = !(rcode == kDNSFlag1_RC_NoErr || rcode == kDNSFlag1_RC_NXDomain || rcode == kDNSFlag1_RC_NotAuth); 8988 returnEarly = mDNSfalse; 8989 // We could possibly combine this with the similar loop at the end of this function -- 8990 // instead of tagging cache records here and then rescuing them if we find them in the answer section, 8991 // we could instead use the "m->PktNum" mechanism to tag each cache record with the packet number in 8992 // which it was received (or refreshed), and then at the end if we find any cache records which 8993 // answer questions in this packet's question section, but which aren't tagged with this packet's 8994 // packet number, then we deduce they are old and delete them 8995 for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) 8996 { 8997 DNSQuestion q, *qptr = mDNSNULL; 8998 ptr = getQuestion(response, ptr, end, InterfaceID, &q); 8999 if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr))) 9000 { 9001 if (!failure) 9002 { 9003 CacheRecord *rr; 9004 // Remember the unicast question that we found, which we use to make caching 9005 // decisions later on in this function 9006 CacheGroup *cg = CacheGroupForName(m, q.qnamehash, &q.qname); 9007 if (!mDNSOpaque16IsZero(response->h.id)) 9008 { 9009 unicastQuestion = qptr; 9010 if (qptr->qDNSServer && DNSSECQuestion(qptr)) 9011 { 9012 LogInfo("mDNSCoreReceiveResponse: Setting aware for %##s (%s) on %#a", qptr->qname.c, 9013 DNSTypeName(qptr->qtype), &qptr->qDNSServer->addr); 9014 qptr->qDNSServer->DNSSECAware = mDNStrue; 9015 qptr->qDNSServer->req_DO = mDNStrue; 9016 } 9017 if (qptr->ValidatingResponse) 9018 DNSSECQuestion = mDNStrue; 9019 } 9020 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 9021 if (SameNameRecordAnswersQuestion(&rr->resrec, qptr)) 9022 { 9023 debugf("uDNS marking %p %##s (%s) %p %s", q.InterfaceID, q.qname.c, DNSTypeName(q.qtype), 9024 rr->resrec.InterfaceID, CRDisplayString(m, rr)); 9025 // Don't want to disturb rroriginalttl here, because code below might need it for the exponential backoff doubling algorithm 9026 rr->TimeRcvd = m->timenow - TicksTTL(rr) - 1; 9027 rr->UnansweredQueries = MaxUnansweredQueries; 9028 rr->CRDNSSECQuestion = 0; 9029 if (unicastQuestion && DNSSECQuestion(unicastQuestion)) 9030 { 9031 LogInfo("mDNSCoreReceiveResponse: CRDNSSECQuestion set for record %s, question %##s (%s)", CRDisplayString(m, rr), 9032 unicastQuestion->qname.c, DNSTypeName(unicastQuestion->qtype)); 9033 rr->CRDNSSECQuestion = 1; 9034 } 9035 } 9036 } 9037 else 9038 { 9039 if (qptr) 9040 { 9041 // If we recv any error from the DNSServer for a DNSSEC Query and if we know that the server 9042 // is not DNSSEC aware, stop doing DNSSEC for that DNSServer. Note that by setting the 9043 // req_DO to false here, the next retransmission for this question will turn off validation 9044 // and hence retransmit without the EDNS0/DOK option. 9045 if (DNSSECOptionalQuestion(qptr) && qptr->qDNSServer && !qptr->qDNSServer->DNSSECAware) 9046 { 9047 LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to DNSSEC Query %##s (%s), clear DO flag", 9048 qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype)); 9049 qptr->qDNSServer->req_DO = mDNSfalse; 9050 } 9051 // For Unicast DNS Queries, penalize the DNSServer 9052 else 9053 { 9054 LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to query %##s (%s)", 9055 qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype)); 9056 PenalizeDNSServer(m, qptr, response->h.flags); 9057 } 9058 } 9059 returnEarly = mDNStrue; 9060 } 9061 } 9062 } 9063 if (returnEarly) 9064 { 9065 LogInfo("Ignoring %2d Answer%s %2d Authorit%s %2d Additional%s", 9066 response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,", 9067 response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,", 9068 response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s"); 9069 // not goto exit because we won't have any CacheFlushRecords and we do not want to 9070 // generate negative cache entries (we want to query the next server) 9071 return; 9072 } 9073 if (unicastQuestion && DNSSECQuestion(unicastQuestion)) 9074 { 9075 BumpDNSSECStats(m, kStatsActionSet, kStatsTypeMsgSize, (end - response->data)); 9076 } 9077 } 9078 9079 // Parse the NSEC3 records from the Authority section before we process 9080 // the Answer section so that we can cache them along with the proper 9081 // cache records we create. 9082 if (mDNSOpaque16IsZero(response->h.id)) 9083 mDNSParseNSEC3Records(m, response, end, InterfaceID, &McastNSEC3Records); 9084 9085 for (i = 0; i < totalrecords && ptr && ptr < end; i++) 9086 { 9087 // All responses sent via LL multicast are acceptable for caching 9088 // All responses received over our outbound TCP connections are acceptable for caching 9089 // We accept all records in a unicast response to a multicast query once we find one that 9090 // answers an active question. 9091 mDNSBool AcceptableResponse = ResponseMCast || !dstaddr || LLQType || recordAcceptedInResponse; 9092 // (Note that just because we are willing to cache something, that doesn't necessarily make it a trustworthy answer 9093 // to any specific question -- any code reading records from the cache needs to make that determination for itself.) 9094 9095 const mDNSu8 RecordType = 9096 (i < firstauthority ) ? (mDNSu8)kDNSRecordTypePacketAns : 9097 (i < firstadditional) ? (mDNSu8)kDNSRecordTypePacketAuth : (mDNSu8)kDNSRecordTypePacketAdd; 9098 ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &m->rec); 9099 if (!ptr) goto exit; // Break out of the loop and clean up our CacheFlushRecords list before exiting 9100 9101 if (m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative) 9102 { 9103 mDNSCoreResetRecord(m); 9104 continue; 9105 } 9106 9107 // We have already parsed the NSEC3 records and cached them approrpriately for 9108 // multicast responses. 9109 if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype == kDNSType_NSEC3) 9110 { 9111 mDNSCoreResetRecord(m); 9112 continue; 9113 } 9114 // Don't want to cache OPT or TSIG pseudo-RRs 9115 if (m->rec.r.resrec.rrtype == kDNSType_TSIG) 9116 { 9117 mDNSCoreResetRecord(m); 9118 continue; 9119 } 9120 if (m->rec.r.resrec.rrtype == kDNSType_OPT) 9121 { 9122 const rdataOPT *opt; 9123 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 9124 // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently 9125 // delete all our own AuthRecords (which are identified by having zero MAC tags on them). 9126 for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++) 9127 if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0]) 9128 { 9129 ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords); 9130 ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords); 9131 } 9132 mDNSCoreResetRecord(m); 9133 continue; 9134 } 9135 // if a CNAME record points to itself, then don't add it to the cache 9136 if ((m->rec.r.resrec.rrtype == kDNSType_CNAME) && SameDomainName(m->rec.r.resrec.name, &m->rec.r.resrec.rdata->u.name)) 9137 { 9138 LogInfo("mDNSCoreReceiveResponse: CNAME loop domain name %##s", m->rec.r.resrec.name->c); 9139 mDNSCoreResetRecord(m); 9140 continue; 9141 } 9142 9143 // When we receive uDNS LLQ responses, we assume a long cache lifetime -- 9144 // In the case of active LLQs, we'll get remove events when the records actually do go away 9145 // In the case of polling LLQs, we assume the record remains valid until the next poll 9146 if (!mDNSOpaque16IsZero(response->h.id)) 9147 m->rec.r.resrec.rroriginalttl = GetEffectiveTTL(LLQType, m->rec.r.resrec.rroriginalttl); 9148 9149 // If response was not sent via LL multicast, 9150 // then see if it answers a recent query of ours, which would also make it acceptable for caching. 9151 if (!ResponseMCast) 9152 { 9153 if (LLQType) 9154 { 9155 // For Long Lived queries that are both sent over UDP and Private TCP, LLQType is set. 9156 // Even though it is AcceptableResponse, we need a matching DNSServer pointer for the 9157 // queries to get ADD/RMV events. To lookup the question, we can't use 9158 // ExpectingUnicastResponseForRecord as the port numbers don't match. uDNS_recvLLQRespose 9159 // has already matched the question using the 64 bit Id in the packet and we use that here. 9160 9161 if (llqMatch != mDNSNULL) m->rec.r.resrec.rDNSServer = uDNSServer = llqMatch->qDNSServer; 9162 9163 // If this is a DNSSEC question that is also LongLived, don't accept records from the 9164 // Additional/Authority section blindly. We need to go through IsAcceptableResponse below 9165 // so that NSEC/NSEC3 record are cached in the nseclist if we accept them. This can happen 9166 // for both negative responses and wildcard expanded positive responses as both of come 9167 // back with NSEC/NSEC3s. 9168 if (unicastQuestion && DNSSECQuestion(unicastQuestion)) 9169 AcceptableResponse = mDNSfalse; 9170 } 9171 else if (!AcceptableResponse || !dstaddr) 9172 { 9173 // For responses that come over TCP (Responses that can't fit within UDP) or TLS (Private queries 9174 // that are not long lived e.g., AAAA lookup in a Private domain), it is indicated by !dstaddr. 9175 // Even though it is AcceptableResponse, we still need a DNSServer pointer for the resource records that 9176 // we create. 9177 9178 DNSQuestion *q = ExpectingUnicastResponseForRecord(m, srcaddr, ResponseSrcLocal, dstport, response->h.id, &m->rec.r, !dstaddr); 9179 9180 // Initialize the DNS server on the resource record which will now filter what questions we answer with 9181 // this record. 9182 // 9183 // We could potentially lookup the DNS server based on the source address, but that may not work always 9184 // and that's why ExpectingUnicastResponseForRecord does not try to verify whether the response came 9185 // from the DNS server that queried. We follow the same logic here. If we can find a matching quetion based 9186 // on the "id" and "source port", then this response answers the question and assume the response 9187 // came from the same DNS server that we sent the query to. 9188 9189 if (q != mDNSNULL) 9190 { 9191 AcceptableResponse = mDNStrue; 9192 if (!InterfaceID) 9193 { 9194 debugf("mDNSCoreReceiveResponse: InterfaceID %p %##s (%s)", q->InterfaceID, q->qname.c, DNSTypeName(q->qtype)); 9195 m->rec.r.resrec.rDNSServer = uDNSServer = q->qDNSServer; 9196 } 9197 else 9198 { 9199 // Accept all remaining records in this unicast response to an mDNS query. 9200 recordAcceptedInResponse = mDNStrue; 9201 LogInfo("mDNSCoreReceiveResponse: Accepting response for query: %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 9202 } 9203 } 9204 else 9205 { 9206 // If we can't find a matching question, we need to see whether we have seen records earlier that matched 9207 // the question. The code below does that. So, make this record unacceptable for now 9208 if (!InterfaceID) 9209 { 9210 debugf("mDNSCoreReceiveResponse: Can't find question for record name %##s", m->rec.r.resrec.name->c); 9211 AcceptableResponse = mDNSfalse; 9212 } 9213 } 9214 } 9215 } 9216 else if (llintf && llintf->IgnoreIPv4LL && m->rec.r.resrec.rrtype == kDNSType_A) 9217 { 9218 // There are some routers (rare, thankfully) that generate bogus ARP responses for 9219 // any IPv4 address they don���t recognize, including RFC 3927 IPv4 link-local addresses. 9220 // To work with these broken routers, client devices need to blacklist these broken 9221 // routers and ignore their bogus ARP responses. Some devices implement a technique 9222 // such as the one described in US Patent 7436783, which lets clients detect and 9223 // ignore these broken routers: <https://www.google.com/patents/US7436783> 9224 9225 // OS X and iOS do not implement this defensive mechanism, instead taking a simpler 9226 // approach of just detecting these broken routers and completely disabling IPv4 9227 // link-local communication on interfaces where a broken router is detected. 9228 // OS X and iOS set the IFEF_ARPLL interface flag on interfaces 9229 // that are deemed ���safe��� for IPv4 link-local communication; 9230 // the flag is cleared on interfaces where a broken router is detected. 9231 9232 // OS X and iOS will not even try to communicate with an IPv4 9233 // link-local destination on an interface without the IFEF_ARPLL flag set. 9234 // This can cause some badly written applications to freeze for a long time if they 9235 // attempt to connect to an IPv4 link-local destination address and then wait for 9236 // that connection attempt to time out before trying other candidate addresses. 9237 9238 // To mask this client bug, we suppress acceptance of IPv4 link-local address 9239 // records on interfaces where we know the OS will be unwilling even to attempt 9240 // communication with those IPv4 link-local destination addresses. 9241 // <rdar://problem/9400639> kSuppress IPv4LL answers on interfaces without IFEF_ARPLL 9242 9243 const CacheRecord *const rr = &m->rec.r; 9244 const RDataBody2 *const rdb = (RDataBody2 *)rr->smallrdatastorage.data; 9245 if (mDNSv4AddressIsLinkLocal(&rdb->ipv4)) 9246 { 9247 LogInfo("mDNSResponder: Dropping LinkLocal packet %s", CRDisplayString(m, &m->rec.r)); 9248 mDNSCoreResetRecord(m); 9249 continue; 9250 } 9251 } 9252 9253 // 1. Check that this packet resource record does not conflict with any of ours 9254 if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype != kDNSType_NSEC) 9255 { 9256 if (m->CurrentRecord) 9257 LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 9258 m->CurrentRecord = m->ResourceRecords; 9259 while (m->CurrentRecord) 9260 { 9261 AuthRecord *rr = m->CurrentRecord; 9262 m->CurrentRecord = rr->next; 9263 // We accept all multicast responses, and unicast responses resulting from queries we issued 9264 // For other unicast responses, this code accepts them only for responses with an 9265 // (apparently) local source address that pertain to a record of our own that's in probing state 9266 if (!AcceptableResponse && !(ResponseSrcLocal && rr->resrec.RecordType == kDNSRecordTypeUnique)) continue; 9267 9268 if (PacketRRMatchesSignature(&m->rec.r, rr)) // If interface, name, type (if shared record) and class match... 9269 { 9270 // ... check to see if type and rdata are identical 9271 if (IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec)) 9272 { 9273 // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us 9274 if (m->rec.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState) 9275 { 9276 // If we were planning to send on this -- and only this -- interface, then we don't need to any more 9277 if (rr->ImmedAnswer == InterfaceID) { rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse; } 9278 } 9279 else 9280 { 9281 if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; } 9282 else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; } 9283 } 9284 } 9285 // else, the packet RR has different type or different rdata -- check to see if this is a conflict 9286 else if (m->rec.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &m->rec.r)) 9287 { 9288 LogInfo("mDNSCoreReceiveResponse: Pkt Record: %08lX %s", m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); 9289 LogInfo("mDNSCoreReceiveResponse: Our Record: %08lX %s", rr->resrec.rdatahash, ARDisplayString(m, rr)); 9290 9291 // If this record is marked DependentOn another record for conflict detection purposes, 9292 // then *that* record has to be bumped back to probing state to resolve the conflict 9293 if (rr->DependentOn) 9294 { 9295 while (rr->DependentOn) rr = rr->DependentOn; 9296 LogInfo("mDNSCoreReceiveResponse: Dep Record: %08lX %s", rr->resrec.rdatahash, ARDisplayString(m, rr)); 9297 } 9298 9299 // If we've just whacked this record's ProbeCount, don't need to do it again 9300 if (rr->ProbeCount > DefaultProbeCountForTypeUnique) 9301 LogInfo("mDNSCoreReceiveResponse: Already reset to Probing: %s", ARDisplayString(m, rr)); 9302 else if (rr->ProbeCount == DefaultProbeCountForTypeUnique) 9303 LogInfo("mDNSCoreReceiveResponse: Ignoring response received before we even began probing: %s", ARDisplayString(m, rr)); 9304 else 9305 { 9306 LogMsg("mDNSCoreReceiveResponse: Received from %#a:%d %s", srcaddr, mDNSVal16(srcport), CRDisplayString(m, &m->rec.r)); 9307 // If we'd previously verified this record, put it back to probing state and try again 9308 if (rr->resrec.RecordType == kDNSRecordTypeVerified) 9309 { 9310 LogMsg("mDNSCoreReceiveResponse: Resetting to Probing: %s", ARDisplayString(m, rr)); 9311 rr->resrec.RecordType = kDNSRecordTypeUnique; 9312 // We set ProbeCount to one more than the usual value so we know we've already touched this record. 9313 // This is because our single probe for "example-name.local" could yield a response with (say) two A records and 9314 // three AAAA records in it, and we don't want to call RecordProbeFailure() five times and count that as five conflicts. 9315 // This special value is recognised and reset to DefaultProbeCountForTypeUnique in SendQueries(). 9316 rr->ProbeCount = DefaultProbeCountForTypeUnique + 1; 9317 rr->AnnounceCount = InitialAnnounceCount; 9318 InitializeLastAPTime(m, rr); 9319 RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate 9320 } 9321 // If we're probing for this record, we just failed 9322 else if (rr->resrec.RecordType == kDNSRecordTypeUnique) 9323 { 9324 // At this point in the code, we're probing for uniqueness. 9325 // We've sent at least one probe (rr->ProbeCount < DefaultProbeCountForTypeUnique) 9326 // but we haven't completed probing yet (rr->resrec.RecordType == kDNSRecordTypeUnique). 9327 // Before we call deregister, check if this is a packet we registered with the sleep proxy. 9328 if (!mDNSCoreRegisteredProxyRecord(m, rr)) 9329 { 9330 // This may be a conflict due to stale packets on the network. Delay probing by a second. 9331 // If there are conflicts after 3 such attempts, then it is a true conflict. 9332 if (m->DelayConflictProcessing) 9333 { 9334 m->DelayConflictProcessing--; 9335 LogMsg("Possible spurious conflict for %s. Attempt %d at suppressing probes for one second", 9336 ARDisplayString(m, rr), (MAX_CONFLICT_PROCESSING_DELAYS - m->DelayConflictProcessing)); 9337 rr->ProbeCount = DefaultProbeCountForTypeUnique + 1; 9338 rr->AnnounceCount = InitialAnnounceCount; 9339 m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond); 9340 InitializeLastAPTime(m, rr); 9341 RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate 9342 } 9343 else 9344 { 9345 LogMsg("mDNSCoreReceiveResponse: ProbeCount %d; will deregister %s", rr->ProbeCount, ARDisplayString(m, rr)); 9346 m->mDNSStats.NameConflicts++; 9347#if APPLE_OSX_mDNSResponder 9348 // See if this record was also registered with any D2D plugins. 9349 D2D_stop_advertising_record(rr); 9350#endif 9351 mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); 9352 } 9353 9354 } 9355 } 9356 // We assumed this record must be unique, but we were wrong. (e.g. There are two mDNSResponders on the 9357 // same machine giving different answers for the reverse mapping record, or there are two machines on the 9358 // network using the same IP address.) This is simply a misconfiguration, and there's nothing we can do 9359 // to fix it -- e.g. it's not our job to be trying to change the machine's IP address. We just discard our 9360 // record to avoid continued conflicts (as we do for a conflict on our Unique records) and get on with life. 9361 else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique) 9362 { 9363 LogMsg("mDNSCoreReceiveResponse: Unexpected conflict discarding %s", ARDisplayString(m, rr)); 9364 m->mDNSStats.KnownUniqueNameConflicts++; 9365#if APPLE_OSX_mDNSResponder 9366 D2D_stop_advertising_record(rr); 9367#endif 9368 mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); 9369 } 9370 else 9371 LogMsg("mDNSCoreReceiveResponse: Unexpected record type %X %s", rr->resrec.RecordType, ARDisplayString(m, rr)); 9372 } 9373 } 9374 // Else, matching signature, different type or rdata, but not a considered a conflict. 9375 // If the packet record has the cache-flush bit set, then we check to see if we 9376 // have any record(s) of the same type that we should re-assert to rescue them 9377 // (see note about "multi-homing and bridged networks" at the end of this function). 9378 else if (m->rec.r.resrec.rrtype == rr->resrec.rrtype) 9379 if ((m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (mDNSu32)(m->timenow - rr->LastMCTime) > (mDNSu32)mDNSPlatformOneSecond/2) 9380 { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; } 9381 } 9382 } 9383 } 9384 9385 nseclist = mDNSfalse; 9386 if (!AcceptableResponse) 9387 { 9388 AcceptableResponse = IsResponseAcceptable(m, CacheFlushRecords, unicastQuestion, &nseclist); 9389 if (AcceptableResponse) m->rec.r.resrec.rDNSServer = uDNSServer; 9390 } 9391 9392 // 2. See if we want to add this packet resource record to our cache 9393 // We only try to cache answers if we have a cache to put them in 9394 // Also, we ignore any apparent attempts at cache poisoning unicast to us that do not answer any outstanding active query 9395 if (!AcceptableResponse) LogInfo("mDNSCoreReceiveResponse ignoring %s", CRDisplayString(m, &m->rec.r)); 9396 if (m->rrcache_size && AcceptableResponse) 9397 { 9398 const mDNSu32 slot = HashSlotFromNameHash(m->rec.r.resrec.namehash); 9399 CacheGroup *cg = CacheGroupForRecord(m, &m->rec.r.resrec); 9400 CacheRecord *rr = mDNSNULL; 9401 9402 if (McastNSEC3Records) 9403 InitializeAnonInfoForCR(m, &McastNSEC3Records, &m->rec.r); 9404 9405 // 2a. Check if this packet resource record is already in our cache. 9406 // 9407 // If this record should go in the nseclist, don't look in the cache for updating it. 9408 // They are supposed to be cached under the "nsec" field of the cache record for 9409 // validation. Just create the cache record. 9410 if (!nseclist) 9411 { 9412 rr = mDNSCoreReceiveCacheCheck(m, response, LLQType, slot, cg, unicastQuestion, &cfp, &NSECCachePtr, InterfaceID); 9413 } 9414 9415 // If packet resource record not in our cache, add it now 9416 // (unless it is just a deletion of a record we never had, in which case we don't care) 9417 if (!rr && m->rec.r.resrec.rroriginalttl > 0) 9418 { 9419 const mDNSBool AddToCFList = (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (LLQType != uDNS_LLQ_Events); 9420 mDNSs32 delay; 9421 9422 if (AddToCFList) 9423 delay = NonZeroTime(m->timenow + mDNSPlatformOneSecond); 9424 else 9425 delay = CheckForSoonToExpireRecords(m, m->rec.r.resrec.name, m->rec.r.resrec.namehash, mDNSNULL); 9426 9427 // If unique, assume we may have to delay delivery of this 'add' event. 9428 // Below, where we walk the CacheFlushRecords list, we either call CacheRecordDeferredAdd() 9429 // to immediately to generate answer callbacks, or we call ScheduleNextCacheCheckTime() 9430 // to schedule an mDNS_Execute task at the appropriate time. 9431 rr = CreateNewCacheEntry(m, slot, cg, delay, !nseclist, srcaddr); 9432 if (rr) 9433 { 9434 rr->responseFlags = response->h.flags; 9435 // If we are not creating signatures, then we need to inform DNSSEC so that 9436 // it does not wait forever. Don't do this if we got NSEC records 9437 // as it indicates that this name does not exist. 9438 if (rr->resrec.rrtype == kDNSType_RRSIG && !nseclist) 9439 { 9440 rrsigsCreated = mDNStrue; 9441 } 9442 // Remember whether we created a cache record in response to a DNSSEC question. 9443 // This helps DNSSEC code not to reissue the question to fetch the DNSSEC records. 9444 rr->CRDNSSECQuestion = 0; 9445 if (unicastQuestion && DNSSECQuestion(unicastQuestion)) 9446 { 9447 LogInfo("mDNSCoreReceiveResponse: CRDNSSECQuestion set for new record %s, question %##s (%s)", CRDisplayString(m, rr), 9448 unicastQuestion->qname.c, DNSTypeName(unicastQuestion->qtype)); 9449 rr->CRDNSSECQuestion = 1; 9450 } 9451 // NSEC/NSEC3 records and its signatures are cached with the negative cache entry 9452 // which we should be creating below. It is also needed in the wildcard 9453 // expanded answer case and in that case it is cached along with the answer. 9454 if (nseclist) 9455 { 9456 rr->TimeRcvd = m->timenow; 9457 *nsecp = rr; 9458 nsecp = &rr->next; 9459 } 9460 else if (AddToCFList) 9461 { 9462 *cfp = rr; 9463 cfp = &rr->NextInCFList; 9464 *cfp = (CacheRecord*)1; 9465 } 9466 else if (rr->DelayDelivery) 9467 { 9468 ScheduleNextCacheCheckTime(m, slot, rr->DelayDelivery); 9469 } 9470 } 9471 } 9472 else 9473 { 9474 if (rr && rr->resrec.AnonInfo && m->rec.r.resrec.AnonInfo) 9475 { 9476 CopyAnonInfoForCR(m, rr, &m->rec.r); 9477 } 9478 } 9479 } 9480 mDNSCoreResetRecord(m); 9481 } 9482 9483exit: 9484 mDNSCoreResetRecord(m); 9485 9486 // If we've just received one or more records with their cache flush bits set, 9487 // then scan that cache slot to see if there are any old stale records we need to flush 9488 while (CacheFlushRecords != (CacheRecord*)1) 9489 { 9490 CacheRecord *r1 = CacheFlushRecords, *r2; 9491 const mDNSu32 slot = HashSlotFromNameHash(r1->resrec.namehash); 9492 const CacheGroup *cg = CacheGroupForRecord(m, &r1->resrec); 9493 CacheFlushRecords = CacheFlushRecords->NextInCFList; 9494 r1->NextInCFList = mDNSNULL; 9495 9496 // Look for records in the cache with the same signature as this new one with the cache flush 9497 // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL 9498 // (as required by DNS semantics) or (b) if they're old, mark them for deletion in one second. 9499 // We make these TTL adjustments *only* for records that still have *more* than one second 9500 // remaining to live. Otherwise, a record that we tagged for deletion half a second ago 9501 // (and now has half a second remaining) could inadvertently get its life extended, by either 9502 // (a) if we got an explicit goodbye packet half a second ago, the record would be considered 9503 // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet, 9504 // or (b) otherwise, the record would not be fully resurrected, but would be reset to expire 9505 // in one second, thereby inadvertently delaying its actual expiration, instead of hastening it. 9506 // If this were to happen repeatedly, the record's expiration could be deferred indefinitely. 9507 // To avoid this, we need to ensure that the cache flushing operation will only act to 9508 // *decrease* a record's remaining lifetime, never *increase* it. 9509 for (r2 = cg ? cg->members : mDNSNULL; r2; r2=r2->next) 9510 { 9511 mDNSu16 id1; 9512 mDNSu16 id2; 9513 if (!r1->resrec.InterfaceID) 9514 { 9515 id1 = (r1->resrec.rDNSServer ? r1->resrec.rDNSServer->resGroupID : 0); 9516 id2 = (r2->resrec.rDNSServer ? r2->resrec.rDNSServer->resGroupID : 0); 9517 } 9518 else 9519 { 9520 id1 = id2 = 0; 9521 } 9522 // When we receive new RRSIGs e.g., for DNSKEY record, we should not flush the old 9523 // RRSIGS e.g., for TXT record. To do so, we need to look at the typeCovered field of 9524 // the new RRSIG that we received. Process only if the typeCovered matches. 9525 if ((r1->resrec.rrtype == r2->resrec.rrtype) && (r1->resrec.rrtype == kDNSType_RRSIG)) 9526 { 9527 rdataRRSig *rrsig1 = (rdataRRSig *)(((RDataBody2 *)(r1->resrec.rdata->u.data))->data); 9528 rdataRRSig *rrsig2 = (rdataRRSig *)(((RDataBody2 *)(r2->resrec.rdata->u.data))->data); 9529 if (swap16(rrsig1->typeCovered) != swap16(rrsig2->typeCovered)) 9530 { 9531 debugf("mDNSCoreReceiveResponse: Received RRSIG typeCovered %s, found %s, not processing", 9532 DNSTypeName(swap16(rrsig1->typeCovered)), DNSTypeName(swap16(rrsig2->typeCovered))); 9533 continue; 9534 } 9535 } 9536 9537 // For Unicast (null InterfaceID) the resolver IDs should also match 9538 if ((r1->resrec.InterfaceID == r2->resrec.InterfaceID) && 9539 (r1->resrec.InterfaceID || (id1 == id2)) && 9540 r1->resrec.rrtype == r2->resrec.rrtype && 9541 r1->resrec.rrclass == r2->resrec.rrclass) 9542 { 9543 // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics) 9544 // else, if record is old, mark it to be flushed 9545 if (m->timenow - r2->TimeRcvd < mDNSPlatformOneSecond && RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond) 9546 { 9547 // If we find mismatched TTLs in an RRSet, correct them. 9548 // We only do this for records with a TTL of 2 or higher. It's possible to have a 9549 // goodbye announcement with the cache flush bit set (or a case-change on record rdata, 9550 // which we treat as a goodbye followed by an addition) and in that case it would be 9551 // inappropriate to synchronize all the other records to a TTL of 0 (or 1). 9552 9553 // We suppress the message for the specific case of correcting from 240 to 60 for type TXT, 9554 // because certain early Bonjour devices are known to have this specific mismatch, and 9555 // there's no point filling syslog with messages about something we already know about. 9556 // We also don't log this for uDNS responses, since a caching name server is obliged 9557 // to give us an aged TTL to correct for how long it has held the record, 9558 // so our received TTLs are expected to vary in that case 9559 9560 // We also suppress log message in the case of SRV records that are received 9561 // with a TTL of 4500 that are already cached with a TTL of 120 seconds, since 9562 // this behavior was observed for a number of discoveryd based AppleTV's in iOS 8 9563 // GM builds. 9564 if (r2->resrec.rroriginalttl != r1->resrec.rroriginalttl && r1->resrec.rroriginalttl > 1) 9565 { 9566 if (!(r2->resrec.rroriginalttl == 240 && r1->resrec.rroriginalttl == 60 && r2->resrec.rrtype == kDNSType_TXT) && 9567 !(r2->resrec.rroriginalttl == 120 && r1->resrec.rroriginalttl == 4500 && r2->resrec.rrtype == kDNSType_SRV) && 9568 mDNSOpaque16IsZero(response->h.id)) 9569 LogInfo("Correcting TTL from %4d to %4d for %s", 9570 r2->resrec.rroriginalttl, r1->resrec.rroriginalttl, CRDisplayString(m, r2)); 9571 r2->resrec.rroriginalttl = r1->resrec.rroriginalttl; 9572 } 9573 r2->TimeRcvd = m->timenow; 9574 } 9575 else // else, if record is old, mark it to be flushed 9576 { 9577 verbosedebugf("Cache flush new %p age %d expire in %d %s", r1, m->timenow - r1->TimeRcvd, RRExpireTime(r1) - m->timenow, CRDisplayString(m, r1)); 9578 verbosedebugf("Cache flush old %p age %d expire in %d %s", r2, m->timenow - r2->TimeRcvd, RRExpireTime(r2) - m->timenow, CRDisplayString(m, r2)); 9579 // We set stale records to expire in one second. 9580 // This gives the owner a chance to rescue it if necessary. 9581 // This is important in the case of multi-homing and bridged networks: 9582 // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be 9583 // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit 9584 // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet 9585 // will promptly delete their cached copies of the (still valid) Ethernet IP address record. 9586 // By delaying the deletion by one second, we give X a change to notice that this bridging has 9587 // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches. 9588 9589 // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary 9590 // final expiration queries for this record. 9591 9592 // If a record is deleted twice, first with an explicit DE record, then a second time by virtue of the cache 9593 // flush bit on the new record replacing it, then we allow the record to be deleted immediately, without the usual 9594 // one-second grace period. This improves responsiveness for mDNS_Update(), as used for things like iChat status updates. 9595 // <rdar://problem/5636422> Updating TXT records is too slow 9596 // We check for "rroriginalttl == 1" because we want to include records tagged by the "packet TTL is zero" check above, 9597 // which sets rroriginalttl to 1, but not records tagged by the rdata case-change check, which sets rroriginalttl to 0. 9598 if (r2->TimeRcvd == m->timenow && r2->resrec.rroriginalttl == 1 && r2->UnansweredQueries == MaxUnansweredQueries) 9599 { 9600 LogInfo("Cache flush for DE record %s", CRDisplayString(m, r2)); 9601 r2->resrec.rroriginalttl = 0; 9602 } 9603 else if (RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond) 9604 { 9605 // We only set a record to expire in one second if it currently has *more* than a second to live 9606 // If it's already due to expire in a second or less, we just leave it alone 9607 r2->resrec.rroriginalttl = 1; 9608 r2->UnansweredQueries = MaxUnansweredQueries; 9609 r2->TimeRcvd = m->timenow - 1; 9610 // We use (m->timenow - 1) instead of m->timenow, because we use that to identify records 9611 // that we marked for deletion via an explicit DE record 9612 } 9613 } 9614 SetNextCacheCheckTimeForRecord(m, r2); 9615 } 9616 } 9617 9618 if (r1->DelayDelivery) // If we were planning to delay delivery of this record, see if we still need to 9619 { 9620 // If we had a unicast question for this response with at least one positive answer and we 9621 // have NSECRecords, it is most likely a wildcard expanded answer. Cache the NSEC and its 9622 // signatures along with the cache record which will be used for validation later. If 9623 // we rescued a few records earlier in this function, then NSECCachePtr would be set. In that 9624 // use that instead. 9625 if (response->h.numAnswers && unicastQuestion && NSECRecords) 9626 { 9627 if (!NSECCachePtr) 9628 { 9629 LogInfo("mDNSCoreReceiveResponse: Updating NSECCachePtr to %s", CRDisplayString(m, r1)); 9630 NSECCachePtr = r1; 9631 } 9632 // Note: We need to do this before we call CacheRecordDeferredAdd as this 9633 // might start the verification process which needs these NSEC records 9634 if (!AddNSECSForCacheRecord(m, NSECRecords, NSECCachePtr, rcode)) 9635 { 9636 LogInfo("mDNSCoreReceiveResponse: AddNSECSForCacheRecord failed to add NSEC for %s", CRDisplayString(m, NSECCachePtr)); 9637 FreeNSECRecords(m, NSECRecords); 9638 } 9639 NSECRecords = mDNSNULL; 9640 NSECCachePtr = mDNSNULL; 9641 } 9642 r1->DelayDelivery = CheckForSoonToExpireRecords(m, r1->resrec.name, r1->resrec.namehash, mDNSNULL); 9643 // If no longer delaying, deliver answer now, else schedule delivery for the appropriate time 9644 if (!r1->DelayDelivery) CacheRecordDeferredAdd(m, r1); 9645 else ScheduleNextCacheCheckTime(m, slot, r1->DelayDelivery); 9646 } 9647 } 9648 9649 // If we have not consumed the NSEC records yet e.g., just refreshing the cache, 9650 // update them now for future validations. 9651 if (NSECRecords && NSECCachePtr) 9652 { 9653 LogInfo("mDNSCoreReceieveResponse: Updating NSEC records in %s", CRDisplayString(m, NSECCachePtr)); 9654 if (!AddNSECSForCacheRecord(m, NSECRecords, NSECCachePtr, rcode)) 9655 { 9656 LogInfo("mDNSCoreReceiveResponse: AddNSECSForCacheRecord failed to add NSEC for %s", CRDisplayString(m, NSECCachePtr)); 9657 FreeNSECRecords(m, NSECRecords); 9658 } 9659 NSECRecords = mDNSNULL; 9660 NSECCachePtr = mDNSNULL; 9661 } 9662 9663 // If there is at least one answer and we did not create RRSIGs and there was a 9664 // ValidatingResponse question waiting for this response, give a hint that no RRSIGs 9665 // were created. We don't need to give a hint: 9666 // 9667 // - if we have no answers, the mDNSCoreReceiveNoUnicastAnswers below should 9668 // generate a negative response 9669 // 9670 // - if we have NSECRecords, it means we might have a potential proof for 9671 // non-existence of name that we are looking for 9672 // 9673 if (response->h.numAnswers && !rrsigsCreated && DNSSECQuestion && !NSECRecords) 9674 mDNSCoreReceiveNoDNSSECAnswers(m, response, end, dstaddr, dstport, InterfaceID); 9675 9676 // See if we need to generate negative cache entries for unanswered unicast questions 9677 mDNSCoreReceiveNoUnicastAnswers(m, response, end, dstaddr, dstport, InterfaceID, LLQType, rcode, NSECRecords); 9678 9679 if (McastNSEC3Records) 9680 { 9681 debugf("mDNSCoreReceiveResponse: McastNSEC3Records not used"); 9682 FreeNSECRecords(m, McastNSEC3Records); 9683 } 9684} 9685 9686// ScheduleWakeup causes all proxy records with WakeUp.HMAC matching mDNSEthAddr 'e' to be deregistered, causing 9687// multiple wakeup magic packets to be sent if appropriate, and all records to be ultimately freed after a few seconds. 9688// ScheduleWakeup is called on mDNS record conflicts, ARP conflicts, NDP conflicts, or reception of trigger traffic 9689// that warrants waking the sleeping host. 9690// ScheduleWakeup must be called with the lock held (ScheduleWakeupForList uses mDNS_Deregister_internal) 9691 9692mDNSlocal void ScheduleWakeupForList(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e, AuthRecord *const thelist) 9693{ 9694 // We need to use the m->CurrentRecord mechanism here when dealing with DuplicateRecords list as 9695 // mDNS_Deregister_internal deregisters duplicate records immediately as they are not used 9696 // to send wakeups or goodbyes. See the comment in that function for more details. To keep it 9697 // simple, we use the same mechanism for both lists. 9698 if (!e->l[0]) 9699 { 9700 LogMsg("ScheduleWakeupForList ERROR: Target HMAC is zero"); 9701 return; 9702 } 9703 m->CurrentRecord = thelist; 9704 while (m->CurrentRecord) 9705 { 9706 AuthRecord *const rr = m->CurrentRecord; 9707 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && mDNSSameEthAddress(&rr->WakeUp.HMAC, e)) 9708 { 9709 LogInfo("ScheduleWakeupForList: Scheduling wakeup packets for %s", ARDisplayString(m, rr)); 9710 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 9711 } 9712 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 9713 m->CurrentRecord = rr->next; 9714 } 9715} 9716 9717mDNSlocal void ScheduleWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e) 9718{ 9719 if (!e->l[0]) { LogMsg("ScheduleWakeup ERROR: Target HMAC is zero"); return; } 9720 ScheduleWakeupForList(m, InterfaceID, e, m->DuplicateRecords); 9721 ScheduleWakeupForList(m, InterfaceID, e, m->ResourceRecords); 9722} 9723 9724mDNSlocal void SPSRecordCallback(mDNS *const m, AuthRecord *const ar, mStatus result) 9725{ 9726 if (result && result != mStatus_MemFree) 9727 LogInfo("SPS Callback %d %s", result, ARDisplayString(m, ar)); 9728 9729 if (result == mStatus_NameConflict) 9730 { 9731 mDNS_Lock(m); 9732 LogMsg("%-7s Conflicting mDNS -- waking %.6a %s", InterfaceNameForID(m, ar->resrec.InterfaceID), &ar->WakeUp.HMAC, ARDisplayString(m, ar)); 9733 if (ar->WakeUp.HMAC.l[0]) 9734 { 9735 SendWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.IMAC, &ar->WakeUp.password, mDNSfalse); // Send one wakeup magic packet 9736 ScheduleWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.HMAC); // Schedule all other records with the same owner to be woken 9737 } 9738 mDNS_Unlock(m); 9739 } 9740 9741 if (result == mStatus_NameConflict || result == mStatus_MemFree) 9742 { 9743 m->ProxyRecords--; 9744 mDNSPlatformMemFree(ar); 9745 mDNS_UpdateAllowSleep(m); 9746 } 9747} 9748 9749mDNSlocal mDNSu8 *GetValueForMACAddr(mDNSu8 *ptr, mDNSu8 *limit, mDNSEthAddr *eth) 9750{ 9751 int i; 9752 mDNSs8 hval = 0; 9753 int colons = 0; 9754 mDNSu8 val = 0; 9755 9756 for (i = 0; ptr < limit && *ptr != ' ' && i < 17; i++, ptr++) 9757 { 9758 hval = HexVal(*ptr); 9759 if (hval != -1) 9760 { 9761 val <<= 4; 9762 val |= hval; 9763 } 9764 else if (*ptr == ':') 9765 { 9766 if (colons >=5) 9767 { 9768 LogMsg("GetValueForMACAddr: Address malformed colons %d val %d", colons, val); 9769 return mDNSNULL; 9770 } 9771 eth->b[colons] = val; 9772 colons++; 9773 val = 0; 9774 } 9775 } 9776 if (colons != 5) 9777 { 9778 LogMsg("GetValueForMACAddr: Address malformed colons %d", colons); 9779 return mDNSNULL; 9780 } 9781 eth->b[colons] = val; 9782 return ptr; 9783} 9784 9785mDNSlocal mDNSu8 *GetValueForIPv6Addr(mDNSu8 *ptr, mDNSu8 *limit, mDNSv6Addr *v6) 9786{ 9787 int hval; 9788 int value; 9789 int numBytes; 9790 int digitsProcessed; 9791 int zeroFillStart; 9792 int numColons; 9793 mDNSu8 v6addr[16]; 9794 9795 // RFC 3513: Section 2.2 specifies IPv6 presentation format. The following parsing 9796 // handles both (1) and (2) and does not handle embedded IPv4 addresses. 9797 // 9798 // First forms a address in "v6addr", then expands to fill the zeroes in and returns 9799 // the result in "v6" 9800 9801 numColons = numBytes = value = digitsProcessed = zeroFillStart = 0; 9802 while (ptr < limit && *ptr != ' ') 9803 { 9804 hval = HexVal(*ptr); 9805 if (hval != -1) 9806 { 9807 value <<= 4; 9808 value |= hval; 9809 digitsProcessed = 1; 9810 } 9811 else if (*ptr == ':') 9812 { 9813 if (!digitsProcessed) 9814 { 9815 // If we have already seen a "::", we should not see one more. Handle the special 9816 // case of "::" 9817 if (numColons) 9818 { 9819 // if we never filled any bytes and the next character is space (we have reached the end) 9820 // we are done 9821 if (!numBytes && (ptr + 1) < limit && *(ptr + 1) == ' ') 9822 { 9823 mDNSPlatformMemZero(v6->b, 16); 9824 return ptr + 1; 9825 } 9826 LogMsg("GetValueForIPv6Addr: zeroFillStart non-zero %d", zeroFillStart); 9827 return mDNSNULL; 9828 } 9829 9830 // We processed "::". We need to fill zeroes later. For now, mark the 9831 // point where we will start filling zeroes from. 9832 zeroFillStart = numBytes; 9833 numColons++; 9834 } 9835 else if ((ptr + 1) < limit && *(ptr + 1) == ' ') 9836 { 9837 // We have a trailing ":" i.e., no more characters after ":" 9838 LogMsg("GetValueForIPv6Addr: Trailing colon"); 9839 return mDNSNULL; 9840 } 9841 else 9842 { 9843 // For a fully expanded IPv6 address, we fill the 14th and 15th byte outside of this while 9844 // loop below as there is no ":" at the end. Hence, the last two bytes that can possibly 9845 // filled here is 12 and 13. 9846 if (numBytes > 13) { LogMsg("GetValueForIPv6Addr:1: numBytes is %d", numBytes); return mDNSNULL; } 9847 9848 v6addr[numBytes++] = (mDNSu8) ((value >> 8) & 0xFF); 9849 v6addr[numBytes++] = (mDNSu8) (value & 0xFF); 9850 digitsProcessed = value = 0; 9851 9852 // Make sure that we did not fill the 13th and 14th byte above 9853 if (numBytes > 14) { LogMsg("GetValueForIPv6Addr:2: numBytes is %d", numBytes); return mDNSNULL; } 9854 } 9855 } 9856 ptr++; 9857 } 9858 9859 // We should be processing the last set of bytes following the last ":" here 9860 if (!digitsProcessed) 9861 { 9862 LogMsg("GetValueForIPv6Addr: no trailing bytes after colon, numBytes is %d", numBytes); 9863 return mDNSNULL; 9864 } 9865 9866 if (numBytes > 14) { LogMsg("GetValueForIPv6Addr:3: numBytes is %d", numBytes); return mDNSNULL; } 9867 v6addr[numBytes++] = (mDNSu8) ((value >> 8) & 0xFF); 9868 v6addr[numBytes++] = (mDNSu8) (value & 0xFF); 9869 9870 if (zeroFillStart) 9871 { 9872 int i, j, n; 9873 for (i = 0; i < zeroFillStart; i++) 9874 v6->b[i] = v6addr[i]; 9875 for (j = i, n = 0; n < 16 - numBytes; j++, n++) 9876 v6->b[j] = 0; 9877 for (; j < 16; i++, j++) 9878 v6->b[j] = v6addr[i]; 9879 } 9880 else if (numBytes == 16) 9881 mDNSPlatformMemCopy(v6->b, v6addr, 16); 9882 else 9883 { 9884 LogMsg("GetValueForIPv6addr: Not enough bytes for IPv6 address, numBytes is %d", numBytes); 9885 return mDNSNULL; 9886 } 9887 return ptr; 9888} 9889 9890mDNSlocal mDNSu8 *GetValueForIPv4Addr(mDNSu8 *ptr, mDNSu8 *limit, mDNSv4Addr *v4) 9891{ 9892 mDNSu32 val; 9893 int dots = 0; 9894 val = 0; 9895 9896 for ( ; ptr < limit && *ptr != ' '; ptr++) 9897 { 9898 if (*ptr >= '0' && *ptr <= '9') 9899 val = val * 10 + *ptr - '0'; 9900 else if (*ptr == '.') 9901 { 9902 if (val > 255 || dots >= 3) 9903 { 9904 LogMsg("GetValueForIPv4Addr: something wrong ptr(%p) %c, limit %p, dots %d", ptr, *ptr, limit, dots); 9905 return mDNSNULL; 9906 } 9907 v4->b[dots++] = val; 9908 val = 0; 9909 } 9910 else 9911 { 9912 // We have a zero at the end and if we reached that, then we are done. 9913 if (*ptr == 0 && ptr == limit - 1 && dots == 3) 9914 { 9915 v4->b[dots] = val; 9916 return ptr + 1; 9917 } 9918 else { LogMsg("GetValueForIPv4Addr: something wrong ptr(%p) %c, limit %p, dots %d", ptr, *ptr, limit, dots); return mDNSNULL; } 9919 } 9920 } 9921 if (dots != 3) { LogMsg("GetValueForIPv4Addr: Address malformed dots %d", dots); return mDNSNULL; } 9922 v4->b[dots] = val; 9923 return ptr; 9924} 9925 9926mDNSlocal mDNSu8 *GetValueForKeepalive(mDNSu8 *ptr, mDNSu8 *limit, mDNSu32 *value) 9927{ 9928 mDNSu32 val; 9929 9930 val = 0; 9931 for ( ; ptr < limit && *ptr != ' '; ptr++) 9932 { 9933 if (*ptr < '0' || *ptr > '9') 9934 { 9935 // We have a zero at the end and if we reached that, then we are done. 9936 if (*ptr == 0 && ptr == limit - 1) 9937 { 9938 *value = val; 9939 return ptr + 1; 9940 } 9941 else { LogMsg("GetValueForKeepalive: *ptr %d, ptr %p, limit %p, ptr +1 %d", *ptr, ptr, limit, *(ptr + 1)); return mDNSNULL; } 9942 } 9943 val = val * 10 + *ptr - '0'; 9944 } 9945 *value = val; 9946 return ptr; 9947} 9948 9949mDNSexport mDNSBool mDNSValidKeepAliveRecord(AuthRecord *rr) 9950{ 9951 mDNSAddr laddr, raddr; 9952 mDNSEthAddr eth; 9953 mDNSIPPort lport, rport; 9954 mDNSu32 timeout, seq, ack; 9955 mDNSu16 win; 9956 9957 if (!mDNS_KeepaliveRecord(&rr->resrec)) 9958 { 9959 return mDNSfalse; 9960 } 9961 9962 timeout = seq = ack = 0; 9963 win = 0; 9964 laddr = raddr = zeroAddr; 9965 lport = rport = zeroIPPort; 9966 eth = zeroEthAddr; 9967 9968 mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); 9969 9970 if (mDNSAddressIsZero(&laddr) || mDNSIPPortIsZero(lport) || 9971 mDNSAddressIsZero(&raddr) || mDNSIPPortIsZero(rport) || 9972 mDNSEthAddressIsZero(eth)) 9973 { 9974 return mDNSfalse; 9975 } 9976 9977 return mDNStrue; 9978} 9979 9980 9981mDNSlocal void mDNS_ExtractKeepaliveInfo(AuthRecord *ar, mDNSu32 *timeout, mDNSAddr *laddr, mDNSAddr *raddr, mDNSEthAddr *eth, mDNSu32 *seq, 9982 mDNSu32 *ack, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu16 *win) 9983{ 9984 if (ar->resrec.rrtype != kDNSType_NULL) 9985 return; 9986 9987 if (mDNS_KeepaliveRecord(&ar->resrec)) 9988 { 9989 int len = ar->resrec.rdlength; 9990 mDNSu8 *ptr = &ar->resrec.rdata->u.txt.c[1]; 9991 mDNSu8 *limit = ptr + len - 1; // Exclude the first byte that is the length 9992 mDNSu32 value = 0; 9993 9994 while (ptr < limit) 9995 { 9996 mDNSu8 param = *ptr; 9997 ptr += 2; // Skip the letter and the "=" 9998 if (param == 'h') 9999 { 10000 laddr->type = mDNSAddrType_IPv4; 10001 ptr = GetValueForIPv4Addr(ptr, limit, &laddr->ip.v4); 10002 } 10003 else if (param == 'd') 10004 { 10005 raddr->type = mDNSAddrType_IPv4; 10006 ptr = GetValueForIPv4Addr(ptr, limit, &raddr->ip.v4); 10007 } 10008 else if (param == 'H') 10009 { 10010 laddr->type = mDNSAddrType_IPv6; 10011 ptr = GetValueForIPv6Addr(ptr, limit, &laddr->ip.v6); 10012 } 10013 else if (param == 'D') 10014 { 10015 raddr->type = mDNSAddrType_IPv6; 10016 ptr = GetValueForIPv6Addr(ptr, limit, &raddr->ip.v6); 10017 } 10018 else if (param == 'm') 10019 { 10020 ptr = GetValueForMACAddr(ptr, limit, eth); 10021 } 10022 else 10023 { 10024 ptr = GetValueForKeepalive(ptr, limit, &value); 10025 } 10026 if (!ptr) { LogMsg("mDNS_ExtractKeepaliveInfo: Cannot parse\n"); return; } 10027 10028 // Extract everything in network order so that it is easy for sending a keepalive and also 10029 // for matching incoming TCP packets 10030 switch (param) 10031 { 10032 case 't': 10033 *timeout = value; 10034 //if (*timeout < 120) *timeout = 120; 10035 break; 10036 case 'h': 10037 case 'H': 10038 case 'd': 10039 case 'D': 10040 case 'm': 10041 case 'i': 10042 case 'c': 10043 break; 10044 case 'l': 10045 lport->NotAnInteger = swap16((mDNSu16)value); 10046 break; 10047 case 'r': 10048 rport->NotAnInteger = swap16((mDNSu16)value); 10049 break; 10050 case 's': 10051 *seq = swap32(value); 10052 break; 10053 case 'a': 10054 *ack = swap32(value); 10055 break; 10056 case 'w': 10057 *win = swap16((mDNSu16)value); 10058 break; 10059 default: 10060 LogMsg("mDNS_ExtractKeepaliveInfo: unknown value %c\n", param); 10061 ptr = limit; 10062 break; 10063 } 10064 ptr++; // skip the space 10065 } 10066 } 10067} 10068 10069// Matches the proxied auth records to the incoming TCP packet and returns the match and its sequence and ack in "rseq" and "rack" so that 10070// the clients need not retrieve this information from the auth record again. 10071mDNSlocal AuthRecord* mDNS_MatchKeepaliveInfo(mDNS *const m, const mDNSAddr* pladdr, const mDNSAddr* praddr, const mDNSIPPort plport, 10072 const mDNSIPPort prport, mDNSu32 *rseq, mDNSu32 *rack) 10073{ 10074 AuthRecord *ar; 10075 mDNSAddr laddr, raddr; 10076 mDNSEthAddr eth; 10077 mDNSIPPort lport, rport; 10078 mDNSu32 timeout, seq, ack; 10079 mDNSu16 win; 10080 10081 for (ar = m->ResourceRecords; ar; ar=ar->next) 10082 { 10083 timeout = seq = ack = 0; 10084 win = 0; 10085 laddr = raddr = zeroAddr; 10086 lport = rport = zeroIPPort; 10087 10088 if (!ar->WakeUp.HMAC.l[0]) continue; 10089 10090 mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); 10091 10092 // Did we parse correctly ? 10093 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win) 10094 { 10095 debugf("mDNS_MatchKeepaliveInfo: not a valid record %s for keepalive", ARDisplayString(m, ar)); 10096 continue; 10097 } 10098 10099 debugf("mDNS_MatchKeepaliveInfo: laddr %#a pladdr %#a, raddr %#a praddr %#a, lport %d plport %d, rport %d prport %d", 10100 &laddr, pladdr, &raddr, praddr, mDNSVal16(lport), mDNSVal16(plport), mDNSVal16(rport), mDNSVal16(prport)); 10101 10102 // Does it match the incoming TCP packet ? 10103 if (mDNSSameAddress(&laddr, pladdr) && mDNSSameAddress(&raddr, praddr) && mDNSSameIPPort(lport, plport) && mDNSSameIPPort(rport, prport)) 10104 { 10105 // returning in network order 10106 *rseq = seq; 10107 *rack = ack; 10108 return ar; 10109 } 10110 } 10111 return mDNSNULL; 10112} 10113 10114mDNSlocal void mDNS_SendKeepalives(mDNS *const m) 10115{ 10116 AuthRecord *ar; 10117 10118 for (ar = m->ResourceRecords; ar; ar=ar->next) 10119 { 10120 mDNSu32 timeout, seq, ack; 10121 mDNSu16 win; 10122 mDNSAddr laddr, raddr; 10123 mDNSEthAddr eth; 10124 mDNSIPPort lport, rport; 10125 10126 timeout = seq = ack = 0; 10127 win = 0; 10128 10129 laddr = raddr = zeroAddr; 10130 lport = rport = zeroIPPort; 10131 10132 if (!ar->WakeUp.HMAC.l[0]) continue; 10133 10134 mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); 10135 10136 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win) 10137 { 10138 debugf("mDNS_SendKeepalives: not a valid record %s for keepalive", ARDisplayString(m, ar)); 10139 continue; 10140 } 10141 LogMsg("mDNS_SendKeepalives: laddr %#a raddr %#a lport %d rport %d", &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport)); 10142 10143 // When we receive a proxy update, we set KATimeExpire to zero so that we always send a keepalive 10144 // immediately (to detect any potential problems). After that we always set it to a non-zero value. 10145 if (!ar->KATimeExpire || (m->timenow - ar->KATimeExpire >= 0)) 10146 { 10147 mDNSPlatformSendKeepalive(&laddr, &raddr, &lport, &rport, seq, ack, win); 10148 ar->KATimeExpire = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); 10149 } 10150 if (m->NextScheduledKA - ar->KATimeExpire > 0) 10151 m->NextScheduledKA = ar->KATimeExpire; 10152 } 10153} 10154 10155mDNSlocal void mDNS_SendKeepaliveACK(mDNS *const m, AuthRecord *ar) 10156{ 10157 mDNSu32 timeout, seq, ack, seqInc; 10158 mDNSu16 win; 10159 mDNSAddr laddr, raddr; 10160 mDNSEthAddr eth; 10161 mDNSIPPort lport, rport; 10162 mDNSu8 *ptr; 10163 10164 if (ar == mDNSNULL) 10165 { 10166 LogInfo("mDNS_SendKeepalivesACK: AuthRecord is NULL"); 10167 return; 10168 } 10169 10170 timeout = seq = ack = 0; 10171 win = 0; 10172 10173 laddr = raddr = zeroAddr; 10174 lport = rport = zeroIPPort; 10175 10176 mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); 10177 10178 if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win) 10179 { 10180 LogInfo("mDNS_SendKeepaliveACK: not a valid record %s for keepalive", ARDisplayString(m, ar)); 10181 return; 10182 } 10183 10184 // To send a keepalive ACK, we need to add one to the sequence number from the keepalive 10185 // record, which is the TCP connection's "next" sequence number minus one. Otherwise, the 10186 // keepalive ACK also ends up being a keepalive probe. Also, seq is in network byte order, so 10187 // it's converted to host byte order before incrementing it by one. 10188 ptr = (mDNSu8 *)&seq; 10189 seqInc = (mDNSu32)((ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3]) + 1; 10190 ptr[0] = (mDNSu8)((seqInc >> 24) & 0xFF); 10191 ptr[1] = (mDNSu8)((seqInc >> 16) & 0xFF); 10192 ptr[2] = (mDNSu8)((seqInc >> 8) & 0xFF); 10193 ptr[3] = (mDNSu8)((seqInc ) & 0xFF); 10194 LogMsg("mDNS_SendKeepaliveACK: laddr %#a raddr %#a lport %d rport %d", &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport)); 10195 mDNSPlatformSendKeepalive(&laddr, &raddr, &lport, &rport, seq, ack, win); 10196} 10197 10198mDNSlocal void mDNSCoreReceiveUpdate(mDNS *const m, 10199 const DNSMessage *const msg, const mDNSu8 *end, 10200 const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, 10201 const mDNSInterfaceID InterfaceID) 10202{ 10203 int i; 10204 AuthRecord opt; 10205 mDNSu8 *p = m->omsg.data; 10206 OwnerOptData owner = zeroOwner; // Need to zero this, so we'll know if this Update packet was missing its Owner option 10207 mDNSu32 updatelease = 0; 10208 const mDNSu8 *ptr; 10209 10210 LogSPS("Received Update from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " 10211 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes", 10212 srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, 10213 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 10214 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 10215 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 10216 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s", end - msg->data); 10217 10218 if (!InterfaceID || !m->SPSSocket || !mDNSSameIPPort(dstport, m->SPSSocket->port)) return; 10219 10220 if (mDNS_PacketLoggingEnabled) 10221 DumpPacket(m, mStatus_NoError, mDNSfalse, "UDP", srcaddr, srcport, dstaddr, dstport, msg, end); 10222 10223 ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space + DNSOpt_OwnerData_ID_Space); 10224 if (ptr) 10225 { 10226 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); 10227 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) 10228 { 10229 const rdataOPT *o; 10230 const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; 10231 for (o = &m->rec.r.resrec.rdata->u.opt[0]; o < e; o++) 10232 { 10233 if (o->opt == kDNSOpt_Lease) updatelease = o->u.updatelease; 10234 else if (o->opt == kDNSOpt_Owner && o->u.owner.vers == 0) owner = o->u.owner; 10235 } 10236 } 10237 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 10238 } 10239 10240 InitializeDNSMessage(&m->omsg.h, msg->h.id, UpdateRespFlags); 10241 10242 if (!updatelease || !owner.HMAC.l[0]) 10243 { 10244 static int msgs = 0; 10245 if (msgs < 100) 10246 { 10247 msgs++; 10248 LogMsg("Refusing sleep proxy registration from %#a:%d:%s%s", srcaddr, mDNSVal16(srcport), 10249 !updatelease ? " No lease" : "", !owner.HMAC.l[0] ? " No owner" : ""); 10250 } 10251 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_FormErr; 10252 } 10253 else if (m->ProxyRecords + msg->h.mDNS_numUpdates > MAX_PROXY_RECORDS) 10254 { 10255 static int msgs = 0; 10256 if (msgs < 100) 10257 { 10258 msgs++; 10259 LogMsg("Refusing sleep proxy registration from %#a:%d: Too many records %d + %d = %d > %d", srcaddr, mDNSVal16(srcport), 10260 m->ProxyRecords, msg->h.mDNS_numUpdates, m->ProxyRecords + msg->h.mDNS_numUpdates, MAX_PROXY_RECORDS); 10261 } 10262 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused; 10263 } 10264 else 10265 { 10266 LogSPS("Received Update for H-MAC %.6a I-MAC %.6a Password %.6a seq %d", &owner.HMAC, &owner.IMAC, &owner.password, owner.seq); 10267 10268 if (updatelease > 24 * 60 * 60) 10269 updatelease = 24 * 60 * 60; 10270 10271 if (updatelease > 0x40000000UL / mDNSPlatformOneSecond) 10272 updatelease = 0x40000000UL / mDNSPlatformOneSecond; 10273 10274 ptr = LocateAuthorities(msg, end); 10275 10276 // Clear any stale TCP keepalive records that may exist 10277 ClearKeepaliveProxyRecords(m, &owner, m->DuplicateRecords, InterfaceID); 10278 ClearKeepaliveProxyRecords(m, &owner, m->ResourceRecords, InterfaceID); 10279 10280 for (i = 0; i < msg->h.mDNS_numUpdates && ptr && ptr < end; i++) 10281 { 10282 ptr = GetLargeResourceRecord(m, msg, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); 10283 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) 10284 { 10285 mDNSu16 RDLengthMem = GetRDLengthMem(&m->rec.r.resrec); 10286 AuthRecord *ar = mDNSPlatformMemAllocate(sizeof(AuthRecord) - sizeof(RDataBody) + RDLengthMem); 10287 if (!ar) 10288 { 10289 m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused; 10290 break; 10291 } 10292 else 10293 { 10294 mDNSu8 RecordType = m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask ? kDNSRecordTypeUnique : kDNSRecordTypeShared; 10295 m->rec.r.resrec.rrclass &= ~kDNSClass_UniqueRRSet; 10296 // All stale keepalive records have been flushed prior to this loop. 10297 if (!mDNS_KeepaliveRecord(&m->rec.r.resrec)) 10298 { 10299 ClearIdenticalProxyRecords(m, &owner, m->DuplicateRecords); // Make sure we don't have any old stale duplicates of this record 10300 ClearIdenticalProxyRecords(m, &owner, m->ResourceRecords); 10301 } 10302 mDNS_SetupResourceRecord(ar, mDNSNULL, InterfaceID, m->rec.r.resrec.rrtype, m->rec.r.resrec.rroriginalttl, RecordType, AuthRecordAny, SPSRecordCallback, ar); 10303 AssignDomainName(&ar->namestorage, m->rec.r.resrec.name); 10304 ar->resrec.rdlength = GetRDLength(&m->rec.r.resrec, mDNSfalse); 10305 ar->resrec.rdata->MaxRDLength = RDLengthMem; 10306 mDNSPlatformMemCopy(ar->resrec.rdata->u.data, m->rec.r.resrec.rdata->u.data, RDLengthMem); 10307 ar->ForceMCast = mDNStrue; 10308 ar->WakeUp = owner; 10309 if (m->rec.r.resrec.rrtype == kDNSType_PTR) 10310 { 10311 mDNSs32 t = ReverseMapDomainType(m->rec.r.resrec.name); 10312 if (t == mDNSAddrType_IPv4) GetIPv4FromName(&ar->AddressProxy, m->rec.r.resrec.name); 10313 else if (t == mDNSAddrType_IPv6) GetIPv6FromName(&ar->AddressProxy, m->rec.r.resrec.name); 10314 debugf("mDNSCoreReceiveUpdate: PTR %d %d %#a %s", t, ar->AddressProxy.type, &ar->AddressProxy, ARDisplayString(m, ar)); 10315 if (ar->AddressProxy.type) SetSPSProxyListChanged(InterfaceID); 10316 } 10317 ar->TimeRcvd = m->timenow; 10318 ar->TimeExpire = m->timenow + updatelease * mDNSPlatformOneSecond; 10319 if (m->NextScheduledSPS - ar->TimeExpire > 0) 10320 m->NextScheduledSPS = ar->TimeExpire; 10321 ar->KATimeExpire = 0; 10322 mDNS_Register_internal(m, ar); 10323 10324 m->ProxyRecords++; 10325 mDNS_UpdateAllowSleep(m); 10326 LogSPS("SPS Registered %4d %X %s", m->ProxyRecords, RecordType, ARDisplayString(m,ar)); 10327 } 10328 } 10329 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 10330 } 10331 10332 if (m->omsg.h.flags.b[1] & kDNSFlag1_RC_Mask) 10333 { 10334 LogMsg("Refusing sleep proxy registration from %#a:%d: Out of memory", srcaddr, mDNSVal16(srcport)); 10335 ClearProxyRecords(m, &owner, m->DuplicateRecords); 10336 ClearProxyRecords(m, &owner, m->ResourceRecords); 10337 } 10338 else 10339 { 10340 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 10341 opt.resrec.rrclass = NormalMaxDNSMessageData; 10342 opt.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record 10343 opt.resrec.rdestimate = sizeof(rdataOPT); 10344 opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; 10345 opt.resrec.rdata->u.opt[0].u.updatelease = updatelease; 10346 p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); 10347 } 10348 } 10349 10350 if (p) mDNSSendDNSMessage(m, &m->omsg, p, InterfaceID, m->SPSSocket, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse); 10351 mDNS_SendKeepalives(m); 10352} 10353 10354mDNSlocal mDNSu32 mDNSGenerateOwnerOptForInterface(mDNS *const m, const mDNSInterfaceID InterfaceID, DNSMessage *msg) 10355{ 10356 mDNSu8 *ptr = msg->data; 10357 mDNSu8 *end = mDNSNULL; 10358 mDNSu32 length = 0; 10359 AuthRecord opt; 10360 NetworkInterfaceInfo *intf; 10361 10362 mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 10363 opt.resrec.rrclass = NormalMaxDNSMessageData; 10364 opt.resrec.rdlength = sizeof(rdataOPT); 10365 opt.resrec.rdestimate = sizeof(rdataOPT); 10366 10367 intf = FirstInterfaceForID(m, InterfaceID); 10368 SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); 10369 10370 LogSPS("Generated OPT record : %s", ARDisplayString(m, &opt)); 10371 end = PutResourceRecord(msg, ptr, &msg->h.numAdditionals, &opt.resrec); 10372 if (end != mDNSNULL) 10373 { 10374 // Put all the integer values in IETF byte-order (MSB first, LSB second) 10375 SwapDNSHeaderBytes(msg); 10376 length = (end - msg->data); 10377 } 10378 else 10379 LogSPS("mDNSGenerateOwnerOptForInterface: Failed to generate owner OPT record"); 10380 10381 return length; 10382} 10383 10384// Note that this routine is called both for Sleep Proxy Registrations, and for Standard Dynamic 10385// DNS registrations, but (currently) only has to handle the Sleep Proxy Registration reply case, 10386// and should ignore Standard Dynamic DNS registration replies, because those are handled elsewhere. 10387// Really, both should be unified and handled in one place. 10388mDNSlocal void mDNSCoreReceiveUpdateR(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *end, const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID) 10389{ 10390 if (InterfaceID) 10391 { 10392 mDNSu32 pktlease = 0, spsupdates = 0; 10393 const mDNSBool gotlease = GetPktLease(m, msg, end, &pktlease); 10394 const mDNSu32 updatelease = gotlease ? pktlease : 60 * 60; // If SPS fails to indicate lease time, assume one hour 10395 if (gotlease) LogSPS("DNS Update response contains lease option granting %4d seconds, updateid %d, InterfaceID %p", updatelease, mDNSVal16(msg->h.id), InterfaceID); 10396 10397 if (m->CurrentRecord) 10398 LogMsg("mDNSCoreReceiveUpdateR ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 10399 m->CurrentRecord = m->ResourceRecords; 10400 while (m->CurrentRecord) 10401 { 10402 AuthRecord *const rr = m->CurrentRecord; 10403 if (rr->resrec.InterfaceID == InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name)))) 10404 if (mDNSSameOpaque16(rr->updateid, msg->h.id)) 10405 { 10406 // We successfully completed this record's registration on this "InterfaceID". Clear that bit. 10407 // Clear the updateid when we are done sending on all interfaces. 10408 mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, InterfaceID, mDNStrue); 10409 if (scopeid < (sizeof(rr->updateIntID) * mDNSNBBY)) 10410 bit_clr_opaque64(rr->updateIntID, scopeid); 10411 if (mDNSOpaque64IsZero(&rr->updateIntID)) 10412 rr->updateid = zeroID; 10413 rr->expire = NonZeroTime(m->timenow + updatelease * mDNSPlatformOneSecond); 10414 spsupdates++; 10415 LogSPS("Sleep Proxy %s record %2d %5d 0x%x 0x%x (%d) %s", rr->WakeUp.HMAC.l[0] ? "transferred" : "registered", spsupdates, updatelease, rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); 10416 if (rr->WakeUp.HMAC.l[0]) 10417 { 10418 rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host 10419 rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it 10420 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 10421 } 10422 } 10423 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 10424 // new records could have been added to the end of the list as a result of that call. 10425 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 10426 m->CurrentRecord = rr->next; 10427 } 10428 if (spsupdates) // Only do this dynamic store stuff if this was, in fact, a Sleep Proxy Update response 10429 { 10430 char *ifname; 10431 mDNSAddr spsaddr; 10432 DNSMessage optMsg; 10433 int length; 10434 // Update the dynamic store with the IP Address and MAC address of the sleep proxy 10435 ifname = InterfaceNameForID(m, InterfaceID); 10436 mDNSPlatformMemCopy(&spsaddr, srcaddr, sizeof (mDNSAddr)); 10437 mDNSPlatformStoreSPSMACAddr(&spsaddr, ifname); 10438 10439 // Store the Owner OPT record for this interface. 10440 // Configd may use the OPT record if it detects a conflict with the BSP when the system wakes up 10441 InitializeDNSMessage(&optMsg.h, zeroID, ResponseFlags); 10442 length = mDNSGenerateOwnerOptForInterface(m, InterfaceID, &optMsg); 10443 if (length != 0) 10444 { 10445 length += sizeof(DNSMessageHeader); 10446 mDNSPlatformStoreOwnerOptRecord(ifname, &optMsg, length); 10447 } 10448 } 10449 } 10450 // If we were waiting to go to sleep, then this SPS registration or wide-area record deletion 10451 // may have been the thing we were waiting for, so schedule another check to see if we can sleep now. 10452 if (m->SleepLimit) m->NextScheduledSPRetry = m->timenow; 10453} 10454 10455mDNSexport void MakeNegativeCacheRecord(mDNS *const m, CacheRecord *const cr, 10456 const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds, mDNSInterfaceID InterfaceID, DNSServer *dnsserver) 10457{ 10458 if (cr == &m->rec.r && m->rec.r.resrec.RecordType) 10459 LogFatalError("MakeNegativeCacheRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r)); 10460 10461 // Create empty resource record 10462 cr->resrec.RecordType = kDNSRecordTypePacketNegative; 10463 cr->resrec.InterfaceID = InterfaceID; 10464 cr->resrec.rDNSServer = dnsserver; 10465 cr->resrec.name = name; // Will be updated to point to cg->name when we call CreateNewCacheEntry 10466 cr->resrec.rrtype = rrtype; 10467 cr->resrec.rrclass = rrclass; 10468 cr->resrec.rroriginalttl = ttl_seconds; 10469 cr->resrec.rdlength = 0; 10470 cr->resrec.rdestimate = 0; 10471 cr->resrec.namehash = namehash; 10472 cr->resrec.rdatahash = 0; 10473 cr->resrec.rdata = (RData*)&cr->smallrdatastorage; 10474 cr->resrec.rdata->MaxRDLength = 0; 10475 10476 cr->NextInKAList = mDNSNULL; 10477 cr->TimeRcvd = m->timenow; 10478 cr->DelayDelivery = 0; 10479 cr->NextRequiredQuery = m->timenow; 10480 cr->LastUsed = m->timenow; 10481 cr->CRActiveQuestion = mDNSNULL; 10482 cr->UnansweredQueries = 0; 10483 cr->LastUnansweredTime = 0; 10484 cr->NextInCFList = mDNSNULL; 10485 cr->nsec = mDNSNULL; 10486 cr->soa = mDNSNULL; 10487 cr->CRDNSSECQuestion = 0; 10488 // Initialize to the basic one and the caller can set it to more 10489 // specific based on the response if any 10490 cr->responseFlags = ResponseFlags; 10491} 10492 10493mDNSexport void mDNSCoreReceive(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end, 10494 const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, const mDNSIPPort dstport, 10495 const mDNSInterfaceID InterfaceID) 10496{ 10497 mDNSInterfaceID ifid = InterfaceID; 10498 const mDNSu8 *const pkt = (mDNSu8 *)msg; 10499 const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery; 10500 const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery; 10501 const mDNSu8 UpdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_Update; 10502 const mDNSu8 UpdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update; 10503 mDNSu8 QR_OP; 10504 mDNSu8 *ptr = mDNSNULL; 10505 mDNSBool TLS = (dstaddr == (mDNSAddr *)1); // For debug logs: dstaddr = 0 means TCP; dstaddr = 1 means TLS 10506 if (TLS) dstaddr = mDNSNULL; 10507 10508#ifndef UNICAST_DISABLED 10509 if (mDNSSameAddress(srcaddr, &m->Router)) 10510 { 10511#ifdef _LEGACY_NAT_TRAVERSAL_ 10512 if (mDNSSameIPPort(srcport, SSDPPort) || (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port))) 10513 { 10514 mDNS_Lock(m); 10515 LNT_ConfigureRouterInfo(m, InterfaceID, (mDNSu8 *)msg, (mDNSu16)(end - pkt)); 10516 mDNS_Unlock(m); 10517 return; 10518 } 10519#endif 10520 if (mDNSSameIPPort(srcport, NATPMPPort)) 10521 { 10522 mDNS_Lock(m); 10523 uDNS_ReceiveNATPacket(m, InterfaceID, (mDNSu8 *)msg, (mDNSu16)(end - pkt)); 10524 mDNS_Unlock(m); 10525 return; 10526 } 10527 } 10528#ifdef _LEGACY_NAT_TRAVERSAL_ 10529 else if (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port)) { debugf("Ignoring SSDP response from %#a:%d", srcaddr, mDNSVal16(srcport)); return; } 10530#endif 10531 10532#endif 10533 if ((unsigned)(end - pkt) < sizeof(DNSMessageHeader)) 10534 { 10535 LogMsg("DNS Message from %#a:%d to %#a:%d length %d too short", srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), (int)(end - pkt)); 10536 return; 10537 } 10538 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask); 10539 // Read the integer parts which are in IETF byte-order (MSB first, LSB second) 10540 ptr = (mDNSu8 *)&msg->h.numQuestions; 10541 msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); 10542 msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); 10543 msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]); 10544 msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]); 10545 10546 if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; } 10547 10548 // We use zero addresses and all-ones addresses at various places in the code to indicate special values like "no address" 10549 // If we accept and try to process a packet with zero or all-ones source address, that could really mess things up 10550 if (srcaddr && !mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; } 10551 10552 mDNS_Lock(m); 10553 m->PktNum++; 10554 if (mDNSOpaque16IsZero(msg->h.id)) 10555 { 10556 m->MPktNum++; 10557#if APPLE_OSX_mDNSResponder 10558 // Track the number of multicast packets received from a source outside our subnet. 10559 // Check the destination address to avoid accounting for spurious packets that 10560 // comes in with message id zero. 10561 if (!mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr) && dstaddr && 10562 mDNSAddressIsAllDNSLinkGroup(dstaddr)) 10563 { 10564 m->RemoteSubnet++; 10565 } 10566#endif // #if APPLE_OSX_mDNSResponder 10567 } 10568 10569#ifndef UNICAST_DISABLED 10570 if (!dstaddr || (!mDNSAddressIsAllDNSLinkGroup(dstaddr) && (QR_OP == StdR || QR_OP == UpdR))) 10571 if (!mDNSOpaque16IsZero(msg->h.id)) // uDNS_ReceiveMsg only needs to get real uDNS responses, not "QU" mDNS responses 10572 { 10573 ifid = mDNSInterface_Any; 10574 if (mDNS_PacketLoggingEnabled) 10575 DumpPacket(m, mStatus_NoError, mDNSfalse, TLS ? "TLS" : !dstaddr ? "TCP" : "UDP", srcaddr, srcport, dstaddr, dstport, msg, end); 10576 uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport); 10577 // Note: mDNSCore also needs to get access to received unicast responses 10578 } 10579#endif 10580 if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid); 10581 else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid); 10582 else if (QR_OP == UpdQ) mDNSCoreReceiveUpdate (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID); 10583 else if (QR_OP == UpdR) mDNSCoreReceiveUpdateR (m, msg, end, srcaddr, InterfaceID); 10584 else 10585 { 10586 if (mDNS_LoggingEnabled) 10587 { 10588 static int msgCount = 0; 10589 if (msgCount < 1000) { 10590 int i = 0; 10591 msgCount++; 10592 LogInfo("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d length %d on %p (ignored)", 10593 msg->h.flags.b[0], msg->h.flags.b[1], srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), (int)(end - pkt), InterfaceID); 10594 while (i < (int)(end - pkt)) 10595 { 10596 char buffer[128]; 10597 char *p = buffer + mDNS_snprintf(buffer, sizeof(buffer), "%04X", i); 10598 do if (i < (int)(end - pkt)) p += mDNS_snprintf(p, sizeof(buffer), " %02X", pkt[i]);while (++i & 15); 10599 LogInfo("%s", buffer); 10600 } 10601 } 10602 } 10603 } 10604 // Packet reception often causes a change to the task list: 10605 // 1. Inbound queries can cause us to need to send responses 10606 // 2. Conflicing response packets received from other hosts can cause us to need to send defensive responses 10607 // 3. Other hosts announcing deletion of shared records can cause us to need to re-assert those records 10608 // 4. Response packets that answer questions may cause our client to issue new questions 10609 mDNS_Unlock(m); 10610} 10611 10612// *************************************************************************** 10613#if COMPILER_LIKES_PRAGMA_MARK 10614#pragma mark - 10615#pragma mark - Searcher Functions 10616#endif 10617 10618// Targets are considered the same if both queries are untargeted, or 10619// if both are targeted to the same address+port 10620// (If Target address is zero, TargetPort is undefined) 10621#define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \ 10622 (mDNSSameAddress(& (A)->Target, & (B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort))) 10623 10624// SameQuestionKind is true if *both* questions are either multicast or unicast 10625// TargetQID is used for this determination. 10626#define SameQuestionKind(A,B) ((mDNSOpaque16IsZero(A) && mDNSOpaque16IsZero(B)) || \ 10627 ((!mDNSOpaque16IsZero(A)) && (!mDNSOpaque16IsZero(B)))) 10628 10629// Note: We explicitly disallow making a public query be a duplicate of a private one. This is to avoid the 10630// circular deadlock where a client does a query for something like "dns-sd -Q _dns-query-tls._tcp.company.com SRV" 10631// and we have a key for company.com, so we try to locate the private query server for company.com, which necessarily entails 10632// doing a standard DNS query for the _dns-query-tls._tcp SRV record for company.com. If we make the latter (public) query 10633// a duplicate of the former (private) query, then it will block forever waiting for an answer that will never come. 10634// 10635// We keep SuppressUnusable questions separate so that we can return a quick response to them and not get blocked behind 10636// the queries that are not marked SuppressUnusable. But if the query is not suppressed, they are treated the same as 10637// non-SuppressUnusable questions. This should be fine as the goal of SuppressUnusable is to return quickly only if it 10638// is suppressed. If it is not suppressed, we do try all the DNS servers for valid answers like any other question. 10639// The main reason for this design is that cache entries point to a *single* question and that question is responsible 10640// for keeping the cache fresh as long as it is active. Having multiple active question for a single cache entry 10641// breaks this design principle. 10642// 10643 10644// If IsLLQ(Q) is true, it means the question is both: 10645// (a) long-lived and 10646// (b) being performed by a unicast DNS long-lived query (either full LLQ, or polling) 10647// for multicast questions, we don't want to treat LongLived as anything special 10648#define IsLLQ(Q) ((Q)->LongLived && !mDNSOpaque16IsZero((Q)->TargetQID)) 10649#define IsAWDLIncluded(Q) (((Q)->flags & kDNSServiceFlagsIncludeAWDL) != 0) 10650 10651mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question) 10652{ 10653 DNSQuestion *q; 10654 // Note: A question can only be marked as a duplicate of one that occurs *earlier* in the list. 10655 // This prevents circular references, where two questions are each marked as a duplicate of the other. 10656 // Accordingly, we break out of the loop when we get to 'question', because there's no point searching 10657 // further in the list. 10658 for (q = m->Questions; q && q != question; q=q->next) // Scan our list for another question 10659 if (q->InterfaceID == question->InterfaceID && // with the same InterfaceID, 10660 SameQTarget(q, question) && // and same unicast/multicast target settings 10661 q->qtype == question->qtype && // type, 10662 q->qclass == question->qclass && // class, 10663 IsLLQ(q) == IsLLQ(question) && // and long-lived status matches 10664 (!q->AuthInfo || question->AuthInfo) && // to avoid deadlock, don't make public query dup of a private one 10665 (q->AnonInfo == question->AnonInfo) && // Anonymous query not a dup of normal query 10666 (q->SuppressQuery == question->SuppressQuery) && // Questions that are suppressed/not suppressed 10667 (q->ValidationRequired == question->ValidationRequired) && // Questions that require DNSSEC validation 10668 (q->ValidatingResponse == question->ValidatingResponse) && // Questions that are validating responses using DNSSEC 10669 (q->DisallowPID == question->DisallowPID) && // Disallowing a PID should not affect a PID that is allowed 10670 (q->BrowseThreshold == question->BrowseThreshold) && // browse thresholds must match 10671 q->qnamehash == question->qnamehash && 10672 (IsAWDLIncluded(q) == IsAWDLIncluded(question)) && // Inclusion of AWDL interface must match 10673 SameQuestionKind(q->TargetQID, question->TargetQID) && // mDNS or uDNS must match 10674 SameDomainName(&q->qname, &question->qname)) // and name 10675 return(q); 10676 return(mDNSNULL); 10677} 10678 10679// This is called after a question is deleted, in case other identical questions were being suppressed as duplicates 10680mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, DNSQuestion *const question) 10681{ 10682 DNSQuestion *q; 10683 DNSQuestion *first = mDNSNULL; 10684 10685 // This is referring to some other question as duplicate. No other question can refer to this 10686 // question as a duplicate. 10687 if (question->DuplicateOf) 10688 { 10689 LogInfo("UpdateQuestionDuplicates: question %p %##s (%s) duplicate of %p %##s (%s)", 10690 question, question->qname.c, DNSTypeName(question->qtype), 10691 question->DuplicateOf, question->DuplicateOf->qname.c, DNSTypeName(question->DuplicateOf->qtype)); 10692 return; 10693 } 10694 10695 for (q = m->Questions; q; q=q->next) // Scan our list of questions 10696 if (q->DuplicateOf == question) // To see if any questions were referencing this as their duplicate 10697 { 10698 q->DuplicateOf = first; 10699 if (!first) 10700 { 10701 first = q; 10702 // If q used to be a duplicate, but now is not, 10703 // then inherit the state from the question that's going away 10704 q->LastQTime = question->LastQTime; 10705 q->ThisQInterval = question->ThisQInterval; 10706 q->ExpectUnicastResp = question->ExpectUnicastResp; 10707 q->LastAnswerPktNum = question->LastAnswerPktNum; 10708 q->RecentAnswerPkts = question->RecentAnswerPkts; 10709 q->RequestUnicast = question->RequestUnicast; 10710 q->LastQTxTime = question->LastQTxTime; 10711 q->CNAMEReferrals = question->CNAMEReferrals; 10712 q->nta = question->nta; 10713 q->servAddr = question->servAddr; 10714 q->servPort = question->servPort; 10715 q->qDNSServer = question->qDNSServer; 10716 q->validDNSServers = question->validDNSServers; 10717 q->unansweredQueries = question->unansweredQueries; 10718 q->noServerResponse = question->noServerResponse; 10719 q->triedAllServersOnce = question->triedAllServersOnce; 10720 10721 q->TargetQID = question->TargetQID; 10722 q->LocalSocket = question->LocalSocket; 10723 // No need to close old q->LocalSocket first -- duplicate questions can't have their own sockets 10724 10725 q->state = question->state; 10726 // q->tcp = question->tcp; 10727 q->ReqLease = question->ReqLease; 10728 q->expire = question->expire; 10729 q->ntries = question->ntries; 10730 q->id = question->id; 10731 10732 question->LocalSocket = mDNSNULL; 10733 question->nta = mDNSNULL; // If we've got a GetZoneData in progress, transfer it to the newly active question 10734 // question->tcp = mDNSNULL; 10735 10736 if (q->LocalSocket) 10737 debugf("UpdateQuestionDuplicates transferred LocalSocket pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 10738 10739 if (q->nta) 10740 { 10741 LogInfo("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 10742 q->nta->ZoneDataContext = q; 10743 } 10744 10745 // Need to work out how to safely transfer this state too -- appropriate context pointers need to be updated or the code will crash 10746 if (question->tcp) LogInfo("UpdateQuestionDuplicates did not transfer tcp pointer"); 10747 10748 if (question->state == LLQ_Established) 10749 { 10750 LogInfo("UpdateQuestionDuplicates transferred LLQ state for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 10751 question->state = 0; // Must zero question->state, or mDNS_StopQuery_internal will clean up and cancel our LLQ from the server 10752 } 10753 10754 SetNextQueryTime(m,q); 10755 } 10756 } 10757} 10758 10759mDNSexport McastResolver *mDNS_AddMcastResolver(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, mDNSu32 timeout) 10760{ 10761 McastResolver **p = &m->McastResolvers; 10762 McastResolver *tmp = mDNSNULL; 10763 10764 if (!d) d = (const domainname *)""; 10765 10766 LogInfo("mDNS_AddMcastResolver: Adding %##s, InterfaceID %p, timeout %u", d->c, interface, timeout); 10767 10768 mDNS_CheckLock(m); 10769 10770 while (*p) // Check if we already have this {interface, domain} tuple registered 10771 { 10772 if ((*p)->interface == interface && SameDomainName(&(*p)->domain, d)) 10773 { 10774 if (!((*p)->flags & McastResolver_FlagDelete)) LogMsg("Note: Mcast Resolver domain %##s (%p) registered more than once", d->c, interface); 10775 (*p)->flags &= ~McastResolver_FlagDelete; 10776 tmp = *p; 10777 *p = tmp->next; 10778 tmp->next = mDNSNULL; 10779 } 10780 else 10781 p=&(*p)->next; 10782 } 10783 10784 if (tmp) *p = tmp; // move to end of list, to ensure ordering from platform layer 10785 else 10786 { 10787 // allocate, add to list 10788 *p = mDNSPlatformMemAllocate(sizeof(**p)); 10789 if (!*p) LogMsg("mDNS_AddMcastResolver: ERROR!! - malloc"); 10790 else 10791 { 10792 (*p)->interface = interface; 10793 (*p)->flags = McastResolver_FlagNew; 10794 (*p)->timeout = timeout; 10795 AssignDomainName(&(*p)->domain, d); 10796 (*p)->next = mDNSNULL; 10797 } 10798 } 10799 return(*p); 10800} 10801 10802mDNSinline mDNSs32 PenaltyTimeForServer(mDNS *m, DNSServer *server) 10803{ 10804 mDNSs32 ptime = 0; 10805 if (server->penaltyTime != 0) 10806 { 10807 ptime = server->penaltyTime - m->timenow; 10808 if (ptime < 0) 10809 { 10810 // This should always be a positive value between 0 and DNSSERVER_PENALTY_TIME 10811 // If it does not get reset in ResetDNSServerPenalties for some reason, we do it 10812 // here 10813 LogMsg("PenaltyTimeForServer: PenaltyTime negative %d, (server penaltyTime %d, timenow %d) resetting the penalty", 10814 ptime, server->penaltyTime, m->timenow); 10815 server->penaltyTime = 0; 10816 ptime = 0; 10817 } 10818 } 10819 return ptime; 10820} 10821 10822//Checks to see whether the newname is a better match for the name, given the best one we have 10823//seen so far (given in bestcount). 10824//Returns -1 if the newname is not a better match 10825//Returns 0 if the newname is the same as the old match 10826//Returns 1 if the newname is a better match 10827mDNSlocal int BetterMatchForName(const domainname *name, int namecount, const domainname *newname, int newcount, 10828 int bestcount) 10829{ 10830 // If the name contains fewer labels than the new server's domain or the new name 10831 // contains fewer labels than the current best, then it can't possibly be a better match 10832 if (namecount < newcount || newcount < bestcount) return -1; 10833 10834 // If there is no match, return -1 and the caller will skip this newname for 10835 // selection 10836 // 10837 // If we find a match and the number of labels is the same as bestcount, then 10838 // we return 0 so that the caller can do additional logic to pick one of 10839 // the best based on some other factors e.g., penaltyTime 10840 // 10841 // If we find a match and the number of labels is more than bestcount, then we 10842 // return 1 so that the caller can pick this over the old one. 10843 // 10844 // Note: newcount can either be equal or greater than bestcount beause of the 10845 // check above. 10846 10847 if (SameDomainName(SkipLeadingLabels(name, namecount - newcount), newname)) 10848 return bestcount == newcount ? 0 : 1; 10849 else 10850 return -1; 10851} 10852 10853// Normally, we have McastResolvers for .local, in-addr.arpa and ip6.arpa. But there 10854// can be queries that can forced to multicast (ForceMCast) even though they don't end in these 10855// names. In that case, we give a default timeout of 5 seconds 10856#define DEFAULT_MCAST_TIMEOUT 5 10857mDNSlocal mDNSu32 GetTimeoutForMcastQuestion(mDNS *m, DNSQuestion *question) 10858{ 10859 McastResolver *curmatch = mDNSNULL; 10860 int bestmatchlen = -1, namecount = CountLabels(&question->qname); 10861 McastResolver *curr; 10862 int bettermatch, currcount; 10863 for (curr = m->McastResolvers; curr; curr = curr->next) 10864 { 10865 currcount = CountLabels(&curr->domain); 10866 bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen); 10867 // Take the first best match. If there are multiple equally good matches (bettermatch = 0), we take 10868 // the timeout value from the first one 10869 if (bettermatch == 1) 10870 { 10871 curmatch = curr; 10872 bestmatchlen = currcount; 10873 } 10874 } 10875 LogInfo("GetTimeoutForMcastQuestion: question %##s curmatch %p, Timeout %d", question->qname.c, curmatch, 10876 curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT); 10877 return ( curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT); 10878} 10879 10880// Returns true if it is a Domain Enumeration Query 10881mDNSexport mDNSBool DomainEnumQuery(const domainname *qname) 10882{ 10883 const mDNSu8 *mDNS_DEQLabels[] = { (const mDNSu8 *)"\001b", (const mDNSu8 *)"\002db", (const mDNSu8 *)"\002lb", 10884 (const mDNSu8 *)"\001r", (const mDNSu8 *)"\002dr", (const mDNSu8 *)mDNSNULL, }; 10885 const domainname *d = qname; 10886 const mDNSu8 *label; 10887 int i = 0; 10888 10889 // We need at least 3 labels (DEQ prefix) + one more label to make a meaningful DE query 10890 if (CountLabels(qname) < 4) { debugf("DomainEnumQuery: question %##s, not enough labels", qname->c); return mDNSfalse; } 10891 10892 label = (const mDNSu8 *)d; 10893 while (mDNS_DEQLabels[i] != (const mDNSu8 *)mDNSNULL) 10894 { 10895 if (SameDomainLabel(mDNS_DEQLabels[i], label)) {debugf("DomainEnumQuery: DEQ %##s, label1 match", qname->c); break;} 10896 i++; 10897 } 10898 if (mDNS_DEQLabels[i] == (const mDNSu8 *)mDNSNULL) 10899 { 10900 debugf("DomainEnumQuery: Not a DEQ %##s, label1 mismatch", qname->c); 10901 return mDNSfalse; 10902 } 10903 debugf("DomainEnumQuery: DEQ %##s, label1 match", qname->c); 10904 10905 // CountLabels already verified the number of labels 10906 d = (const domainname *)(d->c + 1 + d->c[0]); // Second Label 10907 label = (const mDNSu8 *)d; 10908 if (!SameDomainLabel(label, (const mDNSu8 *)"\007_dns-sd")) 10909 { 10910 debugf("DomainEnumQuery: Not a DEQ %##s, label2 mismatch", qname->c); 10911 return(mDNSfalse); 10912 } 10913 debugf("DomainEnumQuery: DEQ %##s, label2 match", qname->c); 10914 10915 d = (const domainname *)(d->c + 1 + d->c[0]); // Third Label 10916 label = (const mDNSu8 *)d; 10917 if (!SameDomainLabel(label, (const mDNSu8 *)"\004_udp")) 10918 { 10919 debugf("DomainEnumQuery: Not a DEQ %##s, label3 mismatch", qname->c); 10920 return(mDNSfalse); 10921 } 10922 debugf("DomainEnumQuery: DEQ %##s, label3 match", qname->c); 10923 10924 debugf("DomainEnumQuery: Question %##s is a Domain Enumeration query", qname->c); 10925 10926 return mDNStrue; 10927} 10928 10929// Note: InterfaceID is the InterfaceID of the question 10930mDNSlocal mDNSBool DNSServerMatch(DNSServer *d, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID) 10931{ 10932 // 1) Unscoped questions (NULL InterfaceID) should consider *only* unscoped DNSServers ( DNSServer 10933 // with "scoped" set to kScopeNone) 10934 // 10935 // 2) Scoped questions (non-NULL InterfaceID) should consider *only* scoped DNSServers (DNSServer 10936 // with "scoped" set to kScopeInterfaceId) and their InterfaceIDs should match. 10937 // 10938 // 3) Scoped questions (non-zero ServiceID) should consider *only* scoped DNSServers (DNSServer 10939 // with "scoped" set to kScopeServiceID) and their ServiceIDs should match. 10940 // 10941 // The first condition in the "if" statement checks to see if both the question and the DNSServer are 10942 // unscoped. The question is unscoped only if InterfaceID is zero and ServiceID is -1. 10943 // 10944 // If the first condition fails, following are the possible cases (the notes below are using 10945 // InterfaceID for discussion and the same holds good for ServiceID): 10946 // 10947 // - DNSServer is not scoped, InterfaceID is not NULL - we should skip the current DNSServer entry 10948 // as scoped questions should not pick non-scoped DNSServer entry (Refer to (2) above). 10949 // 10950 // - DNSServer is scoped, InterfaceID is NULL - we should skip the current DNSServer entry as 10951 // unscoped question should not match scoped DNSServer (Refer to (1) above). The InterfaceID check 10952 // would fail in this case. 10953 // 10954 // - DNSServer is scoped and InterfaceID is not NULL - the InterfaceID of the question and the DNSServer 10955 // should match (Refer to (2) above). 10956 // 10957 // Note: mDNSInterface_Unicast is used only by .local unicast questions and are treated as unscoped. 10958 // If a question is scoped both to InterfaceID and ServiceID, the question will be scoped to InterfaceID. 10959 10960 if (((d->scoped == kScopeNone) && ((!InterfaceID && ServiceID == -1) || InterfaceID == mDNSInterface_Unicast)) || 10961 ((d->scoped == kScopeInterfaceID) && d->interface == InterfaceID) || 10962 ((d->scoped == kScopeServiceID) && d->serviceID == ServiceID)) 10963 { 10964 return mDNStrue; 10965 } 10966 return mDNSfalse; 10967} 10968 10969// Sets all the Valid DNS servers for a question 10970mDNSexport mDNSu32 SetValidDNSServers(mDNS *m, DNSQuestion *question) 10971{ 10972 int bestmatchlen = -1, namecount = CountLabels(&question->qname); 10973 DNSServer *curr; 10974 int bettermatch, currcount; 10975 int index = 0; 10976 mDNSu32 timeout = 0; 10977 mDNSBool DEQuery; 10978 10979 question->validDNSServers = zeroOpaque128; 10980 DEQuery = DomainEnumQuery(&question->qname); 10981 for (curr = m->DNSServers; curr; curr = curr->next) 10982 { 10983 debugf("SetValidDNSServers: Parsing DNS server Address %#a (Domain %##s), Scope: %d", &curr->addr, curr->domain.c, curr->scoped); 10984 // skip servers that will soon be deleted 10985 if (curr->flags & DNSServer_FlagDelete) 10986 { 10987 debugf("SetValidDNSServers: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index, &curr->addr, curr->domain.c, curr->scoped); 10988 continue; 10989 } 10990 10991 // This happens normally when you unplug the interface where we reset the interfaceID to mDNSInterface_Any for all 10992 // the DNS servers whose scope match the interfaceID. Few seconds later, we also receive the updated DNS configuration. 10993 // But any questions that has mDNSInterface_Any scope that are started/restarted before we receive the update 10994 // (e.g., CheckSuppressUnusableQuestions is called when interfaces are deregistered with the core) should not 10995 // match the scoped entries by mistake. 10996 // 10997 // Note: DNS configuration change will help pick the new dns servers but currently it does not affect the timeout 10998 10999 // Skip DNSServers that are InterfaceID Scoped but have no valid interfaceid set OR DNSServers that are ServiceID Scoped but have no valid serviceid set 11000 if ((curr->scoped == kScopeInterfaceID && curr->interface == mDNSInterface_Any) || (curr->scoped == kScopeServiceID && curr->serviceID <= 0)) 11001 { 11002 LogInfo("SetValidDNSServers: ScopeType[%d] Skipping DNS server %#a (Domain %##s) Interface:[%p] Serviceid:[%d]", curr->scoped, &curr->addr, curr->domain.c, curr->interface, curr->serviceID); 11003 continue; 11004 } 11005 11006 currcount = CountLabels(&curr->domain); 11007 if ((!curr->cellIntf || (!DEQuery && !(question->flags & kDNSServiceFlagsDenyCellular))) && 11008 (!curr->isExpensive || !(question->flags & kDNSServiceFlagsDenyExpensive)) && 11009 DNSServerMatch(curr, question->InterfaceID, question->ServiceID)) 11010 { 11011 bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen); 11012 11013 // If we found a better match (bettermatch == 1) then clear all the bits 11014 // corresponding to the old DNSServers that we have may set before and start fresh. 11015 // If we find an equal match, then include that DNSServer also by setting the corresponding 11016 // bit 11017 if ((bettermatch == 1) || (bettermatch == 0)) 11018 { 11019 bestmatchlen = currcount; 11020 if (bettermatch) 11021 { 11022 debugf("SetValidDNSServers: Resetting all the bits"); 11023 question->validDNSServers = zeroOpaque128; 11024 timeout = 0; 11025 } 11026 debugf("SetValidDNSServers: question %##s Setting the bit for DNS server Address %#a (Domain %##s), Scoped:%d index %d," 11027 " Timeout %d, interface %p", question->qname.c, &curr->addr, curr->domain.c, curr->scoped, index, curr->timeout, 11028 curr->interface); 11029 timeout += curr->timeout; 11030 if (DEQuery) 11031 debugf("DomainEnumQuery: Question %##s, DNSServer %#a, cell %d", question->qname.c, &curr->addr, curr->cellIntf); 11032 bit_set_opaque128(question->validDNSServers, index); 11033 } 11034 } 11035 index++; 11036 } 11037 question->noServerResponse = 0; 11038 11039 debugf("SetValidDNSServers: ValidDNSServer bits 0x%x%x%x%x for question %p %##s (%s)", 11040 question->validDNSServers.l[3], question->validDNSServers.l[2], question->validDNSServers.l[1], question->validDNSServers.l[0], question, question->qname.c, DNSTypeName(question->qtype)); 11041 // If there are no matching resolvers, then use the default timeout value. 11042 // For ProxyQuestion, shorten the timeout so that dig does not timeout on us in case of no response. 11043 return ((question->ProxyQuestion || question->ValidatingResponse) ? DEFAULT_UDNSSEC_TIMEOUT : timeout ? timeout : DEFAULT_UDNS_TIMEOUT); 11044} 11045 11046// Get the Best server that matches a name. If you find penalized servers, look for the one 11047// that will come out of the penalty box soon 11048mDNSlocal DNSServer *GetBestServer(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID, mDNSOpaque128 validBits, 11049 int *selected, mDNSBool nameMatch) 11050{ 11051 DNSServer *curmatch = mDNSNULL; 11052 int bestmatchlen = -1, namecount = name ? CountLabels(name) : 0; 11053 DNSServer *curr; 11054 mDNSs32 bestPenaltyTime, currPenaltyTime; 11055 int bettermatch, currcount; 11056 int index = 0; 11057 int currindex = -1; 11058 11059 debugf("GetBestServer: ValidDNSServer bits 0x%x%x", validBits.l[1], validBits.l[0]); 11060 bestPenaltyTime = DNSSERVER_PENALTY_TIME + 1; 11061 for (curr = m->DNSServers; curr; curr = curr->next) 11062 { 11063 // skip servers that will soon be deleted 11064 if (curr->flags & DNSServer_FlagDelete) 11065 { 11066 debugf("GetBestServer: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d", index, &curr->addr, curr->domain.c, curr->scoped); 11067 continue; 11068 } 11069 11070 // Check if this is a valid DNSServer 11071 if (!bit_get_opaque64(validBits, index)) 11072 { 11073 debugf("GetBestServer: continuing for index %d", index); 11074 index++; 11075 continue; 11076 } 11077 11078 currcount = CountLabels(&curr->domain); 11079 currPenaltyTime = PenaltyTimeForServer(m, curr); 11080 11081 debugf("GetBestServer: Address %#a (Domain %##s), PenaltyTime(abs) %d, PenaltyTime(rel) %d", 11082 &curr->addr, curr->domain.c, curr->penaltyTime, currPenaltyTime); 11083 11084 // If there are multiple best servers for a given question, we will pick the first one 11085 // if none of them are penalized. If some of them are penalized in that list, we pick 11086 // the least penalized one. BetterMatchForName walks through all best matches and 11087 // "currPenaltyTime < bestPenaltyTime" check lets us either pick the first best server 11088 // in the list when there are no penalized servers and least one among them 11089 // when there are some penalized servers. 11090 11091 if (DNSServerMatch(curr, InterfaceID, ServiceID)) 11092 { 11093 11094 // If we know that all the names are already equally good matches, then skip calling BetterMatchForName. 11095 // This happens when we initially walk all the DNS servers and set the validity bit on the question. 11096 // Actually we just need PenaltyTime match, but for the sake of readability we just skip the expensive 11097 // part and still do some redundant steps e.g., InterfaceID match 11098 11099 if (nameMatch) 11100 bettermatch = BetterMatchForName(name, namecount, &curr->domain, currcount, bestmatchlen); 11101 else 11102 bettermatch = 0; 11103 11104 // If we found a better match (bettermatch == 1) then we don't need to 11105 // compare penalty times. But if we found an equal match, then we compare 11106 // the penalty times to pick a better match 11107 11108 if ((bettermatch == 1) || ((bettermatch == 0) && currPenaltyTime < bestPenaltyTime)) 11109 { 11110 currindex = index; 11111 curmatch = curr; 11112 bestmatchlen = currcount; 11113 bestPenaltyTime = currPenaltyTime; 11114 } 11115 } 11116 index++; 11117 } 11118 if (selected) *selected = currindex; 11119 return curmatch; 11120} 11121 11122// Look up a DNS Server, matching by name and InterfaceID 11123mDNSlocal DNSServer *GetServerForName(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID) 11124{ 11125 DNSServer *curmatch = mDNSNULL; 11126 char *ifname = mDNSNULL; // for logging purposes only 11127 mDNSOpaque128 allValid; 11128 11129 if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly)) 11130 InterfaceID = mDNSNULL; 11131 11132 if (InterfaceID) ifname = InterfaceNameForID(m, InterfaceID); 11133 11134 // By passing in all ones, we make sure that every DNS server is considered 11135 allValid.l[0] = allValid.l[1] = allValid.l[2] = allValid.l[3] = 0xFFFFFFFF; 11136 11137 curmatch = GetBestServer(m, name, InterfaceID, ServiceID, allValid, mDNSNULL, mDNStrue); 11138 11139 if (curmatch != mDNSNULL) 11140 LogInfo("GetServerForName: DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s", &curmatch->addr, 11141 mDNSVal16(curmatch->port), (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None", 11142 InterfaceID, name); 11143 else 11144 LogInfo("GetServerForName: no DNS server (Scope %s:%p) found for name %##s", ifname ? ifname : "None", InterfaceID, name); 11145 11146 return(curmatch); 11147} 11148 11149// Look up a DNS Server for a question within its valid DNSServer bits 11150mDNSexport DNSServer *GetServerForQuestion(mDNS *m, DNSQuestion *question) 11151{ 11152 DNSServer *curmatch = mDNSNULL; 11153 char *ifname = mDNSNULL; // for logging purposes only 11154 mDNSInterfaceID InterfaceID = question->InterfaceID; 11155 const domainname *name = &question->qname; 11156 int currindex; 11157 11158 if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly)) 11159 InterfaceID = mDNSNULL; 11160 11161 if (InterfaceID) 11162 ifname = InterfaceNameForID(m, InterfaceID); 11163 11164 if (!mDNSOpaque128IsZero(&question->validDNSServers)) 11165 { 11166 curmatch = GetBestServer(m, name, InterfaceID, question->ServiceID, question->validDNSServers, &currindex, mDNSfalse); 11167 if (currindex != -1) 11168 bit_clr_opaque128(question->validDNSServers, currindex); 11169 } 11170 11171 if (curmatch != mDNSNULL) 11172 { 11173 LogInfo("GetServerForQuestion: %p DNS server (%p) %#a:%d (Penalty Time Left %d) (Scope %s:%p:%d) found for name %##s (%s)", 11174 question, curmatch, &curmatch->addr, mDNSVal16(curmatch->port), 11175 (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None", 11176 InterfaceID, question->ServiceID, name, DNSTypeName(question->qtype)); 11177 } 11178 else 11179 { 11180 LogInfo("GetServerForQuestion: %p no DNS server (Scope %s:%p:%d) found for name %##s (%s)", 11181 question, ifname ? ifname : "None", InterfaceID, question->ServiceID, name, DNSTypeName(question->qtype)); 11182 } 11183 11184 return(curmatch); 11185} 11186 11187 11188#define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \ 11189 (mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort))) 11190 11191// Called in normal client context (lock not held) 11192mDNSlocal void LLQNATCallback(mDNS *m, NATTraversalInfo *n) 11193{ 11194 DNSQuestion *q; 11195 mDNS_Lock(m); 11196 LogInfo("LLQNATCallback external address:port %.4a:%u, NAT result %d", &n->ExternalAddress, mDNSVal16(n->ExternalPort), n->Result); 11197 n->clientContext = mDNSNULL; // we received at least one callback since starting this NAT-T 11198 for (q = m->Questions; q; q=q->next) 11199 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) 11200 startLLQHandshake(m, q); // If ExternalPort is zero, will do StartLLQPolling instead 11201#if APPLE_OSX_mDNSResponder 11202 UpdateAutoTunnelDomainStatuses(m); 11203#endif 11204 mDNS_Unlock(m); 11205} 11206 11207mDNSlocal mDNSBool IsPrivateDomain(mDNS *const m, DNSQuestion *q) 11208{ 11209 DomainAuthInfo *AuthInfo; 11210 // Skip Private domains as we have special addresses to get the hosts in the Private domain 11211 AuthInfo = GetAuthInfoForName_internal(m, &q->qname); 11212 if (AuthInfo && !AuthInfo->deltime && AuthInfo->AutoTunnel) 11213 { 11214 debugf("IsPrivateDomain: %##s true", q->qname.c); 11215 return mDNStrue; 11216 } 11217 else 11218 { 11219 debugf("IsPrivateDomain: %##s false", q->qname.c); 11220 return mDNSfalse; 11221 } 11222} 11223 11224// This function takes the DNSServer as a separate argument because sometimes the 11225// caller has not yet assigned the DNSServer, but wants to evaluate the SuppressQuery 11226// status before switching to it. 11227mDNSlocal mDNSBool ShouldSuppressUnicastQuery(mDNS *const m, DNSQuestion *q, DNSServer *d) 11228{ 11229 // Some callers don't check for the qtype 11230 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA) 11231 { 11232 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type", q->qname.c, DNSTypeName(q->qtype)); 11233 return mDNSfalse; 11234 } 11235 11236 // Private domains are exempted irrespective of what the DNSServer says 11237 if (IsPrivateDomain(m, q)) 11238 { 11239 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, Private Domain", q->qname.c, DNSTypeName(q->qtype)); 11240 return mDNSfalse; 11241 } 11242 11243 if (!d) 11244 { 11245 LogInfo("ShouldSuppressUnicastQuery: Query suppressed for %##s, qtype %s, as the DNS server is NULL", q->qname.c, DNSTypeName(q->qtype)); 11246 return mDNStrue; 11247 } 11248 11249 // Check if the DNS Configuration allows A/AAAA queries to be sent 11250 if ((q->qtype == kDNSType_A) && (d->req_A)) 11251 { 11252 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, DNSServer %##s %#a:%d allows A queries", q->qname.c, 11253 DNSTypeName(q->qtype), d->domain.c, &d->addr, mDNSVal16(d->port)); 11254 return mDNSfalse; 11255 } 11256 if ((q->qtype == kDNSType_AAAA) && (d->req_AAAA)) 11257 { 11258 LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, DNSServer %##s %#a:%d allows AAAA queries", q->qname.c, 11259 DNSTypeName(q->qtype), d->domain.c, &d->addr, mDNSVal16(d->port)); 11260 return mDNSfalse; 11261 } 11262#if USE_DNS64 11263 if (DNS64IsQueryingARecord(q->dns64.state)) 11264 { 11265 LogInfo("ShouldSuppressUnicastQuery: DNS64 query not suppressed for %##s, qtype %s", q->qname.c, DNSTypeName(q->qtype)); 11266 return mDNSfalse; 11267 } 11268#endif 11269 11270 LogInfo("ShouldSuppressUnicastQuery: Query suppressed for %##s, qtype %s, since DNS Configuration does not allow (req_A is %s and req_AAAA is %s)", 11271 q->qname.c, DNSTypeName(q->qtype), d->req_A ? "true" : "false", d->req_AAAA ? "true" : "false"); 11272 11273 return mDNStrue; 11274} 11275 11276mDNSlocal mDNSBool ShouldSuppressDotLocalQuery(mDNS *const m, DNSQuestion *q) 11277{ 11278 NetworkInterfaceInfo *intf; 11279 AuthRecord *rr; 11280 mDNSBool ret; 11281 11282 // Check to see if there is at least one interface other than loopback and don't suppress 11283 // .local questions if you find one. If we have at least one interface, it means that 11284 // we can send unicast queries for the .local name and we don't want to suppress 11285 // multicast in that case as upper layers don't know how to handle if we return a 11286 // negative response for multicast followed by a positive response for unicast. 11287 // 11288 // Note: we used to check for multicast capable interfaces instead of just any interface 11289 // present. That did not work in the case where we have a valid interface for unicast 11290 // but not multicast capable e.g., cellular, as we ended up delivering a negative response 11291 // first and the upper layer did not wait for the positive response that came later. 11292 for (intf = m->HostInterfaces; intf; intf = intf->next) 11293 { 11294 if (intf->InterfaceActive && !intf->Loopback) 11295 { 11296 LogInfo("ShouldSuppressDotLocalQuery: Found interface %s, not suppressing", intf->ifname); 11297 return mDNSfalse; 11298 } 11299 } 11300 11301 // 1. If we find a LocalOnly or P2P record answering this question, then don't suppress it. 11302 // Set m->CurrentQuestion as it is required by AnswerQuestionWithLORecord. 11303 m->CurrentQuestion = q; 11304 ret = AnswerQuestionWithLORecord(m, q, mDNStrue); 11305 m->CurrentQuestion = mDNSNULL; 11306 11307 if (ret) 11308 { 11309 LogInfo("ShouldSuppressDotLocalQuery: Found LocalOnly record for %##s (%s), not suppressing", q->qname.c, 11310 DNSTypeName(q->qtype)); 11311 return mDNSfalse; 11312 } 11313 11314 // 2. If we find a local AuthRecord answering this question, then don't suppress it. 11315 for (rr = m->ResourceRecords; rr; rr = rr->next) 11316 { 11317 if (ResourceRecordAnswersQuestion(&rr->resrec, q)) 11318 { 11319 LogInfo("ShouldSuppressDotLocalQuery: Found resource record %s for %##s (%s) not suppressing", ARDisplayString(m, rr), 11320 q->qname.c, DNSTypeName(q->qtype)); 11321 return mDNSfalse; 11322 } 11323 } 11324 return mDNStrue; 11325} 11326 11327mDNSlocal mDNSBool ShouldSuppressQuery(mDNS *const m, DNSQuestion *q) 11328{ 11329 if (q->InterfaceID == mDNSInterface_LocalOnly) 11330 { 11331 LogInfo("ShouldSuppressQuery: LocalOnly query not suppressed for %##s, qtype %s", q->qname.c, DNSTypeName(q->qtype)); 11332 return mDNSfalse; 11333 } 11334 11335 if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA) 11336 { 11337 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type", q->qname.c, DNSTypeName(q->qtype)); 11338 return mDNSfalse; 11339 } 11340 11341 // We still want the ability to be able to listen to the local services and hence 11342 // don't fail .local query if we have local records that can potentially answer 11343 // the question. 11344 if (q->InterfaceID != mDNSInterface_Unicast && IsLocalDomain(&q->qname)) 11345 { 11346 if (!ShouldSuppressDotLocalQuery(m, q)) 11347 { 11348 LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local question", q->qname.c, DNSTypeName(q->qtype)); 11349 return mDNSfalse; 11350 } 11351 else 11352 { 11353 LogInfo("ShouldSuppressQuery: Query suppressed for %##s, qtype %s, Local question", q->qname.c, DNSTypeName(q->qtype)); 11354 return mDNStrue; 11355 } 11356 } 11357 11358 return (ShouldSuppressUnicastQuery(m, q, q->qDNSServer)); 11359} 11360 11361mDNSlocal void CacheRecordRmvEventsForCurrentQuestion(mDNS *const m, DNSQuestion *q) 11362{ 11363 CacheRecord *rr; 11364 CacheGroup *cg; 11365 11366 cg = CacheGroupForName(m, q->qnamehash, &q->qname); 11367 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 11368 { 11369 // Don't deliver RMV events for negative records 11370 if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) 11371 { 11372 LogInfo("CacheRecordRmvEventsForCurrentQuestion: CacheRecord %s Suppressing RMV events for question %p %##s (%s), CRActiveQuestion %p, CurrentAnswers %d", 11373 CRDisplayString(m, rr), q, q->qname.c, DNSTypeName(q->qtype), rr->CRActiveQuestion, q->CurrentAnswers); 11374 continue; 11375 } 11376 11377 if (SameNameRecordAnswersQuestion(&rr->resrec, q)) 11378 { 11379 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Calling AnswerCurrentQuestionWithResourceRecord (RMV) for question %##s using resource record %s LocalAnswers %d", 11380 q->qname.c, CRDisplayString(m, rr), q->LOAddressAnswers); 11381 11382 q->CurrentAnswers--; 11383 if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--; 11384 if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--; 11385 11386 if (rr->CRActiveQuestion == q) 11387 { 11388 DNSQuestion *qptr; 11389 // If this was the active question for this cache entry, it was the one that was 11390 // responsible for keeping the cache entry fresh when the cache entry was reaching 11391 // its expiry. We need to handover the responsibility to someone else. Otherwise, 11392 // when the cache entry is about to expire, we won't find an active question 11393 // (pointed by CRActiveQuestion) to refresh the cache. 11394 for (qptr = m->Questions; qptr; qptr=qptr->next) 11395 if (qptr != q && ActiveQuestion(qptr) && ResourceRecordAnswersQuestion(&rr->resrec, qptr)) 11396 break; 11397 11398 if (qptr) 11399 LogInfo("CacheRecordRmvEventsForCurrentQuestion: Updating CRActiveQuestion to %p for cache record %s, " 11400 "Original question CurrentAnswers %d, new question CurrentAnswers %d, SuppressUnusable %d, SuppressQuery %d", 11401 qptr, CRDisplayString(m,rr), q->CurrentAnswers, qptr->CurrentAnswers, qptr->SuppressUnusable, qptr->SuppressQuery); 11402 11403 rr->CRActiveQuestion = qptr; // Question used to be active; new value may or may not be null 11404 if (!qptr) m->rrcache_active--; // If no longer active, decrement rrcache_active count 11405 } 11406 AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv); 11407 if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here 11408 } 11409 } 11410} 11411 11412mDNSlocal mDNSBool IsQuestionNew(mDNS *const m, DNSQuestion *question) 11413{ 11414 DNSQuestion *q; 11415 for (q = m->NewQuestions; q; q = q->next) 11416 if (q == question) return mDNStrue; 11417 return mDNSfalse; 11418} 11419 11420mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q) 11421{ 11422 AuthRecord *rr; 11423 AuthGroup *ag; 11424 11425 if (m->CurrentQuestion) 11426 LogMsg("LocalRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)", 11427 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 11428 11429 if (IsQuestionNew(m, q)) 11430 { 11431 LogInfo("LocalRecordRmvEventsForQuestion: New Question %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 11432 return mDNStrue; 11433 } 11434 m->CurrentQuestion = q; 11435 ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); 11436 if (ag) 11437 { 11438 for (rr = ag->members; rr; rr=rr->next) 11439 // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME 11440 if (UniqueLocalOnlyRecord(rr) && LocalOnlyRecordAnswersQuestion(rr, q)) 11441 { 11442 LogInfo("LocalRecordRmvEventsForQuestion: Delivering possible Rmv events with record %s", 11443 ARDisplayString(m, rr)); 11444 if (q->CurrentAnswers <= 0 || q->LOAddressAnswers <= 0) 11445 { 11446 LogMsg("LocalRecordRmvEventsForQuestion: ERROR!! CurrentAnswers or LOAddressAnswers is zero %p %##s" 11447 " (%s) CurrentAnswers %d, LOAddressAnswers %d", q, q->qname.c, DNSTypeName(q->qtype), 11448 q->CurrentAnswers, q->LOAddressAnswers); 11449 continue; 11450 } 11451 AnswerLocalQuestionWithLocalAuthRecord(m, rr, QC_rmv); // MUST NOT dereference q again 11452 if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; } 11453 } 11454 } 11455 m->CurrentQuestion = mDNSNULL; 11456 return mDNStrue; 11457} 11458 11459// Returns false if the question got deleted while delivering the RMV events 11460// The caller should handle the case 11461mDNSexport mDNSBool CacheRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q) 11462{ 11463 if (m->CurrentQuestion) 11464 LogMsg("CacheRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)", 11465 m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 11466 11467 // If it is a new question, we have not delivered any ADD events yet. So, don't deliver RMV events. 11468 // If this question was answered using local auth records, then you can't deliver RMVs using cache 11469 if (!IsQuestionNew(m, q) && !q->LOAddressAnswers) 11470 { 11471 m->CurrentQuestion = q; 11472 CacheRecordRmvEventsForCurrentQuestion(m, q); 11473 if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; } 11474 m->CurrentQuestion = mDNSNULL; 11475 } 11476 else { LogInfo("CacheRecordRmvEventsForQuestion: Question %p %##s (%s) is a new question", q, q->qname.c, DNSTypeName(q->qtype)); } 11477 return mDNStrue; 11478} 11479 11480mDNSlocal void SuppressStatusChanged(mDNS *const m, DNSQuestion *q, DNSQuestion **restart) 11481{ 11482 // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero 11483 // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before 11484 // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers) 11485 if (q->SuppressQuery) 11486 { 11487 q->SuppressQuery = mDNSfalse; 11488 if (!CacheRecordRmvEventsForQuestion(m, q)) 11489 { 11490 LogInfo("SuppressStatusChanged: Question deleted while delivering RMV events from cache"); 11491 return; 11492 } 11493 q->SuppressQuery = mDNStrue; 11494 } 11495 11496 // SuppressUnusable does not affect questions that are answered from the local records (/etc/hosts) 11497 // and SuppressQuery status does not mean anything for these questions. As we are going to stop the 11498 // question below, we need to deliver the RMV events so that the ADDs that will be delivered during 11499 // the restart will not be a duplicate ADD 11500 if (!LocalRecordRmvEventsForQuestion(m, q)) 11501 { 11502 LogInfo("SuppressStatusChanged: Question deleted while delivering RMV events from Local AuthRecords"); 11503 return; 11504 } 11505 11506 // There are two cases here. 11507 // 11508 // 1. Previously it was suppressed and now it is not suppressed, restart the question so 11509 // that it will start as a new question. Note that we can't just call ActivateUnicastQuery 11510 // because when we get the response, if we had entries in the cache already, it will not answer 11511 // this question if the cache entry did not change. Hence, we need to restart 11512 // the query so that it can be answered from the cache. 11513 // 11514 // 2. Previously it was not suppressed and now it is suppressed. We need to restart the questions 11515 // so that we redo the duplicate checks in mDNS_StartQuery_internal. A SuppressUnusable question 11516 // is a duplicate of non-SuppressUnusable question if it is not suppressed (SuppressQuery is false). 11517 // A SuppressUnusable question is not a duplicate of non-SuppressUnusable question if it is suppressed 11518 // (SuppressQuery is true). The reason for this is that when a question is suppressed, we want an 11519 // immediate response and not want to be blocked behind a question that is querying DNS servers. When 11520 // the question is not suppressed, we don't want two active questions sending packets on the wire. 11521 // This affects both efficiency and also the current design where there is only one active question 11522 // pointed to from a cache entry. 11523 // 11524 // We restart queries in a two step process by first calling stop and build a temporary list which we 11525 // will restart at the end. The main reason for the two step process is to handle duplicate questions. 11526 // If there are duplicate questions, calling stop inherits the values from another question on the list (which 11527 // will soon become the real question) including q->ThisQInterval which might be zero if it was 11528 // suppressed before. At the end when we have restarted all questions, none of them is active as each 11529 // inherits from one another and we need to reactivate one of the questions here which is a little hacky. 11530 // 11531 // It is much cleaner and less error prone to build a list of questions and restart at the end. 11532 11533 LogInfo("SuppressStatusChanged: Stop question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 11534 mDNS_StopQuery_internal(m, q); 11535 q->next = *restart; 11536 *restart = q; 11537} 11538 11539// The caller should hold the lock 11540mDNSexport void CheckSuppressUnusableQuestions(mDNS *const m) 11541{ 11542 DNSQuestion *q; 11543 DNSQuestion *restart = mDNSNULL; 11544 11545 // We look through all questions including new questions. During network change events, 11546 // we potentially restart questions here in this function that ends up as new questions, 11547 // which may be suppressed at this instance. Before it is handled we get another network 11548 // event that changes the status e.g., address becomes available. If we did not process 11549 // new questions, we would never change its SuppressQuery status. 11550 // 11551 // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the 11552 // application callback can potentially stop the current question (detected by CurrentQuestion) or 11553 // *any* other question which could be the next one that we may process here. RestartQuestion 11554 // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal 11555 // if the "next" question is stopped while the CurrentQuestion is stopped 11556 if (m->RestartQuestion) 11557 LogMsg("CheckSuppressUnusableQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)", 11558 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); 11559 m->RestartQuestion = m->Questions; 11560 while (m->RestartQuestion) 11561 { 11562 q = m->RestartQuestion; 11563 m->RestartQuestion = q->next; 11564 if (q->SuppressUnusable) 11565 { 11566 mDNSBool old = q->SuppressQuery; 11567 q->SuppressQuery = ShouldSuppressQuery(m, q); 11568 if (q->SuppressQuery != old) 11569 { 11570 // Previously it was not suppressed, Generate RMV events for the ADDs that we might have delivered before 11571 // followed by a negative cache response. Temporarily turn off suppression so that 11572 // AnswerCurrentQuestionWithResourceRecord can answer the question 11573 SuppressStatusChanged(m, q, &restart); 11574 } 11575 } 11576 } 11577 while (restart) 11578 { 11579 q = restart; 11580 restart = restart->next; 11581 q->next = mDNSNULL; 11582 LogInfo("CheckSuppressUnusableQuestions: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 11583 mDNS_StartQuery_internal(m, q); 11584 } 11585} 11586 11587mDNSlocal void RestartUnicastQuestions(mDNS *const m) 11588{ 11589 DNSQuestion *q; 11590 DNSQuestion *restart = mDNSNULL; 11591 11592 if (m->RestartQuestion) 11593 LogMsg("RestartUnicastQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)", 11594 m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); 11595 m->RestartQuestion = m->Questions; 11596 while (m->RestartQuestion) 11597 { 11598 q = m->RestartQuestion; 11599 m->RestartQuestion = q->next; 11600 if (q->Restart) 11601 { 11602 if (mDNSOpaque16IsZero(q->TargetQID)) 11603 LogMsg("RestartUnicastQuestions: ERROR!! Restart set for multicast question %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 11604 11605 q->Restart = 0; 11606 SuppressStatusChanged(m, q, &restart); 11607 } 11608 } 11609 while (restart) 11610 { 11611 q = restart; 11612 restart = restart->next; 11613 q->next = mDNSNULL; 11614 LogInfo("RestartUnicastQuestions: Start question %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 11615 mDNS_StartQuery_internal(m, q); 11616 } 11617} 11618 11619 11620// ValidateParameters() is called by mDNS_StartQuery_internal() to check the client parameters of 11621// DNS Question that are already set by the client before calling mDNS_StartQuery() 11622mDNSlocal mStatus ValidateParameters(mDNS *const m, DNSQuestion *const question) 11623{ 11624 11625 if (question->Target.type && !ValidQuestionTarget(question)) 11626 { 11627 LogMsg("ValidateParameters: Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery? for question %##s)", 11628 question->Target.type, mDNSVal16(question->TargetPort), question->qname.c); 11629 question->Target.type = mDNSAddrType_None; 11630 } 11631 11632 // If no question->Target specified, clear TargetPort 11633 if (!question->Target.type) 11634 question->TargetPort = zeroIPPort; 11635 11636 if (!ValidateDomainName(&question->qname)) 11637 { 11638 LogMsg("ValidateParameters: Attempt to start query with invalid qname %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 11639 return(mStatus_Invalid); 11640 } 11641 11642 // If this question is referencing a specific interface, verify it exists 11643 if (question->InterfaceID && !LocalOnlyOrP2PInterface(question->InterfaceID) && question->InterfaceID != mDNSInterface_Unicast) 11644 { 11645 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, question->InterfaceID); 11646 if (!intf) 11647 LogInfo("ValidateParameters: Note: InterfaceID %d for question %##s (%s) not currently found in active interface list", 11648 IID(question->InterfaceID), question->qname.c, DNSTypeName(question->qtype)); 11649 } 11650 11651 return(mStatus_NoError); 11652} 11653 11654// InitDNSConfig() is called by InitCommonState() to initialize the DNS configuration of the Question. 11655// These are a subset of the internal uDNS fields. Must be done before ShouldSuppressQuery() & mDNS_PurgeForQuestion() 11656mDNSlocal void InitDNSConfig(mDNS *const m, DNSQuestion *const question) 11657{ 11658 // First reset all DNS Configuration 11659 question->qDNSServer = mDNSNULL; 11660 question->validDNSServers = zeroOpaque128; 11661 question->triedAllServersOnce = 0; 11662 question->noServerResponse = 0; 11663 question->StopTime = (question->TimeoutQuestion) ? question->StopTime : 0; 11664#if AWD_METRICS 11665 mDNSPlatformMemZero(&question->metrics, sizeof(question->metrics)); 11666#endif 11667 11668 // Need not initialize the DNS Configuration for Local Only OR P2P Questions when timeout not specified 11669 if (LocalOnlyOrP2PInterface(question->InterfaceID) && !question->TimeoutQuestion) 11670 return; 11671 // Proceed to initialize DNS Configuration (some are set in SetValidDNSServers()) 11672 if (!mDNSOpaque16IsZero(question->TargetQID)) 11673 { 11674 mDNSu32 timeout = SetValidDNSServers(m, question); 11675 // We set the timeout value the first time mDNS_StartQuery_internal is called for a question. 11676 // So if a question is restarted when a network change occurs, the StopTime is not reset. 11677 // Note that we set the timeout for all questions. If this turns out to be a duplicate, 11678 // it gets a full timeout value even if the original question times out earlier. 11679 if (question->TimeoutQuestion && !question->StopTime) 11680 { 11681 question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); 11682 LogInfo("InitDNSConfig: Setting StopTime on the uDNS question %p %##s (%s)", question, question->qname.c, DNSTypeName(question->qtype)); 11683 } 11684 11685 question->qDNSServer = GetServerForQuestion(m, question); 11686 LogInfo("InitDNSConfig: question %p %##s (%s) Timeout %d, DNS Server %#a:%d", 11687 question, question->qname.c, DNSTypeName(question->qtype), timeout, 11688 question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, 11689 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort)); 11690 } 11691 else if (question->TimeoutQuestion && !question->StopTime) 11692 { 11693 // If the question is to be timed out and its a multicast, local-only or P2P case, 11694 // then set it's stop time. 11695 mDNSu32 timeout = LocalOnlyOrP2PInterface(question->InterfaceID) ? 11696 DEFAULT_LO_OR_P2P_TIMEOUT : GetTimeoutForMcastQuestion(m, question); 11697 question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); 11698 LogInfo("InitDNSConfig: Setting StopTime on question %p %##s (%s)", question, question->qname.c, DNSTypeName(question->qtype)); 11699 } 11700 // Set StopTime here since it is a part of DNS Configuration 11701 if (question->StopTime) 11702 SetNextQueryStopTime(m, question); 11703 // Don't call SetNextQueryTime() if a LocalOnly OR P2P Question since those questions 11704 // will never be transmitted on the wire. 11705 if (!(LocalOnlyOrP2PInterface(question->InterfaceID))) 11706 SetNextQueryTime(m,question); 11707} 11708 11709// InitCommonState() is called by mDNS_StartQuery_internal() to initialize the common(uDNS/mDNS) internal 11710// state fields of the DNS Question. These are independent of the Client layer. 11711mDNSlocal mDNSBool InitCommonState(mDNS *const m, DNSQuestion *const question) 11712{ 11713 mDNSBool purge; 11714 int i; 11715 mDNSBool isBlocked = mDNSfalse; 11716 11717 // Note: In the case where we already have the answer to this question in our cache, that may be all the client 11718 // wanted, and they may immediately cancel their question. In this case, sending an actual query on the wire would 11719 // be a waste. For that reason, we schedule our first query to go out in half a second (InitialQuestionInterval). 11720 // If AnswerNewQuestion() finds that we have *no* relevant answers currently in our cache, then it will accelerate 11721 // that to go out immediately. 11722 question->next = mDNSNULL; 11723 // ThisQInterval should be initialized before any memory allocations occur. If malloc 11724 // debugging is turned on within mDNSResponder (see mDNSDebug.h for details) it validates 11725 // the question list to check if ThisQInterval is negative which means the question has been 11726 // stopped and can't be on the list. The question is already on the list and ThisQInterval 11727 // can be negative if the caller just stopped it and starting it again. Hence, it always has to 11728 // be initialized. CheckForSoonToExpireRecords below prints the cache records when logging is 11729 // turned ON which can allocate memory e.g., base64 encoding, in the case of DNSSEC. 11730 question->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question 11731 question->qnamehash = DomainNameHashValue(&question->qname); 11732 question->DelayAnswering = CheckForSoonToExpireRecords(m, &question->qname, question->qnamehash, &purge); 11733 question->LastQTime = m->timenow; 11734 question->ExpectUnicastResp = 0; 11735 question->LastAnswerPktNum = m->PktNum; 11736 question->RecentAnswerPkts = 0; 11737 question->CurrentAnswers = 0; 11738 11739#if APPLE_OSX_mDNSResponder 11740 11741// Initial browse threshold used by Finder. 11742#define mDNSFinderBrowseThreshold 20 11743 11744 // Set the threshold at which we move to a passive browse state, 11745 // not actively sending queries. 11746 if (question->flags & kDNSServiceFlagsThresholdOne) 11747 question->BrowseThreshold = 1; 11748 else if (question->flags & kDNSServiceFlagsThresholdFinder) 11749 question->BrowseThreshold = mDNSFinderBrowseThreshold; 11750 else 11751 question->BrowseThreshold = 0; 11752 11753#else // APPLE_OSX_mDNSResponder 11754 question->BrowseThreshold = 0; 11755#endif // APPLE_OSX_mDNSResponder 11756 question->CachedAnswerNeedsUpdate = mDNSfalse; 11757 11758 question->LargeAnswers = 0; 11759 question->UniqueAnswers = 0; 11760 question->LOAddressAnswers = 0; 11761 question->FlappingInterface1 = mDNSNULL; 11762 question->FlappingInterface2 = mDNSNULL; 11763 11764 // if kDNSServiceFlagsServiceIndex flag is SET by the client, then do NOT call mDNSPlatformGetDNSRoutePolicy() 11765 // since we would already have the question->ServiceID in that case. 11766 if (!(question->flags & kDNSServiceFlagsServiceIndex)) 11767 { 11768#if APPLE_OSX_mDNSResponder 11769 mDNSPlatformGetDNSRoutePolicy(question, &isBlocked); 11770#else 11771 question->ServiceID = -1; 11772#endif 11773 } 11774 else 11775 LogInfo("InitCommonState: Query for %##s (%s), PID[%d], EUID[%d], ServiceID[%d] is already set by client", question->qname.c, 11776 DNSTypeName(question->qtype), question->pid, question->euid, question->ServiceID); 11777 11778 InitDNSConfig(m, question); 11779 11780 question->AuthInfo = GetAuthInfoForQuestion(m, question); 11781 question->SuppressQuery = 0; 11782 if (question->SuppressUnusable) 11783 question->SuppressQuery = ShouldSuppressQuery(m, question); 11784 11785 // If ServiceID is 0 or the policy disallows making DNS requests, 11786 // set DisallowPID 11787 question->DisallowPID = (question->ServiceID == 0 || isBlocked); 11788 if (question->DisallowPID) 11789 LogInfo("InitCommonState: Query suppressed for %##s (%s), PID %d/ServiceID %d not allowed", question->qname.c, 11790 DNSTypeName(question->qtype), question->pid, question->ServiceID); 11791 11792 question->NextInDQList = mDNSNULL; 11793 question->SendQNow = mDNSNULL; 11794 question->SendOnAll = mDNSfalse; 11795 question->RequestUnicast = kDefaultRequestUnicastCount; 11796 11797#if APPLE_OSX_mDNSResponder 11798 // Set the QU bit in the first query for the following options. 11799 if ((question->flags & kDNSServiceFlagsUnicastResponse) || (question->flags & kDNSServiceFlagsThresholdFinder)) 11800 { 11801 question->RequestUnicast = SET_QU_IN_FIRST_QUERY; 11802 LogInfo("InitCommonState: setting RequestUnicast = %d for %##s (%s)", question->RequestUnicast, question->qname.c, 11803 DNSTypeName(question->qtype)); 11804 } 11805#endif // APPLE_OSX_mDNSResponder 11806 11807 question->LastQTxTime = m->timenow; 11808 question->CNAMEReferrals = 0; 11809 11810 question->WakeOnResolveCount = 0; 11811 if (question->WakeOnResolve) 11812 { 11813 question->WakeOnResolveCount = InitialWakeOnResolveCount; 11814 purge = mDNStrue; 11815 } 11816 11817 for (i=0; i<DupSuppressInfoSize; i++) 11818 question->DupSuppress[i].InterfaceID = mDNSNULL; 11819 11820 question->Restart = 0; 11821 11822 debugf("InitCommonState: Question %##s (%s) Interface %p Now %d Send in %d Answer in %d (%p) %s (%p)", 11823 question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, m->timenow, 11824 NextQSendTime(question) - m->timenow, 11825 question->DelayAnswering ? question->DelayAnswering - m->timenow : 0, 11826 question, question->DuplicateOf ? "duplicate of" : "not duplicate", question->DuplicateOf); 11827 11828 if (question->DelayAnswering) 11829 LogInfo("InitCommonState: Delaying answering for %d ticks while cache stabilizes for %##s (%s)", 11830 question->DelayAnswering - m->timenow, question->qname.c, DNSTypeName(question->qtype)); 11831 11832 return(purge); 11833} 11834 11835// Excludes the DNS Config fields which are already handled by InitDNSConfig() 11836mDNSlocal void InitWABState(DNSQuestion *const question) 11837{ 11838 // We'll create our question->LocalSocket on demand, if needed. 11839 // We won't need one for duplicate questions, or from questions answered immediately out of the cache. 11840 // We also don't need one for LLQs because (when we're using NAT) we want them all to share a single 11841 // NAT mapping for receiving inbound add/remove events. 11842 question->LocalSocket = mDNSNULL; 11843 question->unansweredQueries = 0; 11844 question->nta = mDNSNULL; 11845 question->servAddr = zeroAddr; 11846 question->servPort = zeroIPPort; 11847 question->tcp = mDNSNULL; 11848 question->NoAnswer = NoAnswer_Normal; 11849} 11850 11851mDNSlocal void InitLLQNATState(mDNS *const m) 11852{ 11853 // If we don't have our NAT mapping active, start it now 11854 if (!m->LLQNAT.clientCallback) 11855 { 11856 m->LLQNAT.Protocol = NATOp_MapUDP; 11857 m->LLQNAT.IntPort = m->UnicastPort4; 11858 m->LLQNAT.RequestedPort = m->UnicastPort4; 11859 m->LLQNAT.clientCallback = LLQNATCallback; 11860 m->LLQNAT.clientContext = (void*)1; // Means LLQ NAT Traversal just started 11861 mDNS_StartNATOperation_internal(m, &m->LLQNAT); 11862 } 11863} 11864 11865mDNSlocal void InitLLQState(DNSQuestion *const question) 11866{ 11867 question->state = LLQ_InitialRequest; 11868 question->ReqLease = 0; 11869 question->expire = 0; 11870 question->ntries = 0; 11871 question->id = zeroOpaque64; 11872} 11873 11874#ifdef DNS_PUSH_ENABLED 11875mDNSlocal void InitDNSPNState(DNSQuestion *const question) 11876{ 11877 question->dnsPushState = DNSPUSH_INIT; 11878} 11879#endif // DNS_PUSH_ENABLED 11880 11881// InitDNSSECProxyState() is called by mDNS_StartQuery_internal() to initialize 11882// DNSSEC & DNS Proxy fields of the DNS Question. 11883mDNSlocal void InitDNSSECProxyState(mDNS *const m, DNSQuestion *const question) 11884{ 11885 (void) m; 11886 11887 // DNS server selection affects DNSSEC. Turn off validation if req_DO is not set 11888 // or the request is going over cellular interface. 11889 // 11890 // Note: This needs to be done here before we call FindDuplicateQuestion as it looks 11891 // at ValidationRequired setting also. 11892 if (question->qDNSServer) 11893 { 11894 if (question->qDNSServer->cellIntf) 11895 { 11896 debugf("InitDNSSECProxyState: Turning off validation for %##s (%s); going over cell", question->qname.c, DNSTypeName(question->qtype)); 11897 question->ValidationRequired = mDNSfalse; 11898 } 11899 if (DNSSECOptionalQuestion(question) && !(question->qDNSServer->req_DO)) 11900 { 11901 LogInfo("InitDNSSECProxyState: Turning off validation for %##s (%s); req_DO false", 11902 question->qname.c, DNSTypeName(question->qtype)); 11903 question->ValidationRequired = DNSSEC_VALIDATION_NONE; 11904 } 11905 } 11906 question->ValidationState = (question->ValidationRequired ? DNSSECValRequired : DNSSECValNotRequired); 11907 question->ValidationStatus = 0; 11908 question->responseFlags = zeroID; 11909} 11910 11911// Once the question is completely initialized including the duplicate logic, this function 11912// is called to finalize the unicast question which requires flushing the cache if needed, 11913// activating the query etc. 11914mDNSlocal void FinalizeUnicastQuestion(mDNS *const m, DNSQuestion *question, mDNSBool purge) 11915{ 11916 // Ensure DNS related info of duplicate question is same as the orig question 11917 if (question->DuplicateOf) 11918 { 11919 question->validDNSServers = question->DuplicateOf->validDNSServers; 11920 // If current(dup) question has DNS Server assigned but the original question has no DNS Server assigned to it, 11921 // then we log a line as it could indicate an issue 11922 if (question->DuplicateOf->qDNSServer == mDNSNULL) 11923 { 11924 if (question->qDNSServer) 11925 LogInfo("FinalizeUnicastQuestion: Current(dup) question %p has DNSServer(%#a:%d) but original question(%p) has no DNS Server! %##s (%s)", 11926 question, question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, 11927 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort), 11928 question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype)); 11929 } 11930 question->qDNSServer = question->DuplicateOf->qDNSServer; 11931 LogInfo("FinalizeUnicastQuestion: Duplicate question %p (%p) %##s (%s), DNS Server %#a:%d", 11932 question, question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype), 11933 question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, 11934 mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort)); 11935 } 11936 11937 ActivateUnicastQuery(m, question, mDNSfalse); 11938 11939 // If purge was set above, flush the cache. Need to do this after we set the 11940 // DNS server on the question 11941 if (purge) 11942 { 11943 question->DelayAnswering = 0; 11944 mDNS_PurgeForQuestion(m, question); 11945 } 11946 else if (!question->DuplicateOf && DNSSECQuestion(question)) 11947 { 11948 // For DNSSEC questions, we need to have the RRSIGs also for verification. 11949 CheckForDNSSECRecords(m, question); 11950 } 11951 if (question->LongLived) 11952 { 11953 // Unlike other initializations, InitLLQNATState should be done after 11954 // we determine that it is a unicast question. LongLived is set for 11955 // both multicast and unicast browse questions but we should initialize 11956 // the LLQ NAT state only for unicast. Otherwise we will unnecessarily 11957 // start the NAT traversal that is not needed. 11958 InitLLQNATState(m); 11959#if APPLE_OSX_mDNSResponder 11960 UpdateAutoTunnelDomainStatuses(m); 11961#endif 11962 } 11963} 11964 11965mDNSexport mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question) 11966{ 11967 DNSQuestion **q; 11968 mStatus vStatus; 11969 mDNSBool purge; 11970 11971 // First check for cache space (can't do queries if there is no cache space allocated) 11972 if (m->rrcache_size == 0) 11973 return(mStatus_NoCache); 11974 11975 vStatus = ValidateParameters(m, question); 11976 if (vStatus) 11977 return(vStatus); 11978 11979#ifdef USE_LIBIDN 11980 // If the TLD includes high-ascii bytes, assume it will need to be converted to Punycode. 11981 // (In the future the root name servers may answer UTF-8 queries directly, but for now they do not.) 11982 if (IsHighASCIILabel(LastLabel(&question->qname))) 11983 { 11984 domainname newname; 11985 if (PerformNextPunycodeConversion(question, &newname)) 11986 AssignDomainName(&question->qname, &newname); 11987 } 11988#endif // USE_LIBIDN 11989 11990 question->TargetQID = 11991#ifndef UNICAST_DISABLED 11992 (question->Target.type || Question_uDNS(question)) ? mDNS_NewMessageID(m) : 11993#endif // UNICAST_DISABLED 11994 zeroID; 11995 debugf("mDNS_StartQuery_internal: %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 11996 11997 // Note: It important that new questions are appended at the *end* of the list, not prepended at the start 11998 q = &m->Questions; 11999 if (LocalOnlyOrP2PInterface(question->InterfaceID)) 12000 q = &m->LocalOnlyQuestions; 12001 while (*q && *q != question) 12002 q=&(*q)->next; 12003 12004 if (*q) 12005 { 12006 LogMsg("mDNS_StartQuery_internal: Error! Tried to add a question %##s (%s) %p that's already in the active list", 12007 question->qname.c, DNSTypeName(question->qtype), question); 12008 return(mStatus_AlreadyRegistered); 12009 } 12010 *q = question; 12011 12012 // Intialize the question. The only ordering constraint we have today is that 12013 // InitDNSSECProxyState should be called after the DNS server is selected (in 12014 // InitCommonState -> InitDNSConfig) as DNS server selection affects DNSSEC 12015 // validation. 12016 12017 purge = InitCommonState(m, question); 12018 InitWABState(question); 12019 InitLLQState(question); 12020#ifdef DNS_PUSH_ENABLED 12021 InitDNSPNState(question); 12022#endif // DNS_PUSH_ENABLED 12023 InitDNSSECProxyState(m, question); 12024 12025 // FindDuplicateQuestion should be called last after all the intialization 12026 // as the duplicate logic could be potentially based on any field in the 12027 // question. 12028 question->DuplicateOf = FindDuplicateQuestion(m, question); 12029 if (question->DuplicateOf) 12030 question->AuthInfo = question->DuplicateOf->AuthInfo; 12031 12032 if (LocalOnlyOrP2PInterface(question->InterfaceID)) 12033 { 12034 if (!m->NewLocalOnlyQuestions) 12035 m->NewLocalOnlyQuestions = question; 12036 } 12037 else 12038 { 12039 if (!m->NewQuestions) 12040 m->NewQuestions = question; 12041 12042 // If the question's id is non-zero, then it's Wide Area 12043 // MUST NOT do this Wide Area setup until near the end of 12044 // mDNS_StartQuery_internal -- this code may itself issue queries (e.g. SOA, 12045 // NS, etc.) and if we haven't finished setting up our own question and setting 12046 // m->NewQuestions if necessary then we could end up recursively re-entering 12047 // this routine with the question list data structures in an inconsistent state. 12048 if (!mDNSOpaque16IsZero(question->TargetQID)) 12049 { 12050 FinalizeUnicastQuestion(m, question, purge); 12051 } 12052 else 12053 { 12054#if BONJOUR_ON_DEMAND 12055 m->NumAllInterfaceQuestions++; 12056 LogInfo("mDNS_StartQuery_internal: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %##s (%s)", 12057 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, question->qname.c, DNSTypeName(question->qtype)); 12058 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) 12059 { 12060 m->NextBonjourDisableTime = 0; 12061 if (m->BonjourEnabled == 0) 12062 { 12063 // Enable Bonjour immediately by scheduling network changed processing where 12064 // we will join the multicast group on each active interface. 12065 m->BonjourEnabled = 1; 12066 m->NetworkChanged = m->timenow; 12067 } 12068 } 12069#endif // BONJOUR_ON_DEMAND 12070 if (purge) 12071 { 12072 LogInfo("mDNS_StartQuery_internal: Purging for %##s", question->qname.c); 12073 mDNS_PurgeForQuestion(m, question); 12074 } 12075 } 12076 } 12077 12078 return(mStatus_NoError); 12079} 12080 12081// CancelGetZoneData is an internal routine (i.e. must be called with the lock already held) 12082mDNSexport void CancelGetZoneData(mDNS *const m, ZoneData *nta) 12083{ 12084 debugf("CancelGetZoneData %##s (%s)", nta->question.qname.c, DNSTypeName(nta->question.qtype)); 12085 // This function may be called anytime to free the zone information.The question may or may not have stopped. 12086 // If it was already stopped, mDNS_StopQuery_internal would have set q->ThisQInterval to -1 and should not 12087 // call it again 12088 if (nta->question.ThisQInterval != -1) 12089 { 12090 mDNS_StopQuery_internal(m, &nta->question); 12091 if (nta->question.ThisQInterval != -1) 12092 LogMsg("CancelGetZoneData: Question %##s (%s) ThisQInterval %d not -1", nta->question.qname.c, DNSTypeName(nta->question.qtype), nta->question.ThisQInterval); 12093 } 12094 mDNSPlatformMemFree(nta); 12095} 12096 12097mDNSexport mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question) 12098{ 12099 CacheGroup *cg = CacheGroupForName(m, question->qnamehash, &question->qname); 12100 CacheRecord *rr; 12101 DNSQuestion **qp = &m->Questions; 12102 12103 //LogInfo("mDNS_StopQuery_internal %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 12104 12105 if (LocalOnlyOrP2PInterface(question->InterfaceID)) 12106 qp = &m->LocalOnlyQuestions; 12107 while (*qp && *qp != question) qp=&(*qp)->next; 12108 if (*qp) *qp = (*qp)->next; 12109 else 12110 { 12111#if !ForceAlerts 12112 if (question->ThisQInterval >= 0) // Only log error message if the query was supposed to be active 12113#endif 12114 LogFatalError("mDNS_StopQuery_internal: Question %##s (%s) not found in active list", question->qname.c, DNSTypeName(question->qtype)); 12115 return(mStatus_BadReferenceErr); 12116 } 12117 12118#if BONJOUR_ON_DEMAND 12119 if (!LocalOnlyOrP2PInterface(question->InterfaceID) && mDNSOpaque16IsZero(question->TargetQID)) 12120 { 12121 if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) 12122 m->NextBonjourDisableTime = NonZeroTime(m->timenow + (BONJOUR_DISABLE_DELAY * mDNSPlatformOneSecond)); 12123 m->NumAllInterfaceQuestions--; 12124 LogInfo("mDNS_StopQuery_internal: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %##s (%s)", 12125 m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, question->qname.c, DNSTypeName(question->qtype)); 12126 } 12127#endif // BONJOUR_ON_DEMAND 12128 12129#if AWD_METRICS 12130 if (Question_uDNS(question) && !question->metrics.answered && (question->metrics.querySendCount > 0)) 12131 { 12132 const domainname * queryName; 12133 mDNSBool isForCell; 12134 mDNSu32 durationMs; 12135 12136 queryName = question->metrics.originalQName ? question->metrics.originalQName : &question->qname; 12137 isForCell = (question->qDNSServer && question->qDNSServer->cellIntf); 12138 durationMs = ((m->timenow - question->metrics.firstQueryTime) * 1000) / mDNSPlatformOneSecond; 12139 MetricsUpdateDNSQueryStats(queryName, question->qtype, mDNSNULL, question->metrics.querySendCount, durationMs, isForCell); 12140 } 12141#endif 12142 // Take care to cut question from list *before* calling UpdateQuestionDuplicates 12143 UpdateQuestionDuplicates(m, question); 12144 // But don't trash ThisQInterval until afterwards. 12145 question->ThisQInterval = -1; 12146 12147 // If there are any cache records referencing this as their active question, then see if there is any 12148 // other question that is also referencing them, else their CRActiveQuestion needs to get set to NULL. 12149 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 12150 { 12151 if (rr->CRActiveQuestion == question) 12152 { 12153 DNSQuestion *q; 12154 DNSQuestion *replacement = mDNSNULL; 12155 // If we find an active question that is answered by this cached record, use it as the cache record's 12156 // CRActiveQuestion replacement. If there are no such questions, but there's at least one unsuppressed inactive 12157 // question that is answered by this cache record, then use an inactive one to not forgo generating RMV events 12158 // via CacheRecordRmv() when the cache record expires. 12159 for (q = m->Questions; q && (q != m->NewQuestions); q = q->next) 12160 { 12161 if (!q->DuplicateOf && !QuerySuppressed(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) 12162 { 12163 if (q->ThisQInterval > 0) 12164 { 12165 replacement = q; 12166 break; 12167 } 12168 else if (!replacement) 12169 { 12170 replacement = q; 12171 } 12172 } 12173 } 12174 if (replacement) 12175 debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s, Original question CurrentAnswers %d, new question " 12176 "CurrentAnswers %d, SuppressQuery %d", replacement, CRDisplayString(m,rr), question->CurrentAnswers, replacement->CurrentAnswers, replacement->SuppressQuery); 12177 rr->CRActiveQuestion = replacement; // Question used to be active; new value may or may not be null 12178 if (!replacement) m->rrcache_active--; // If no longer active, decrement rrcache_active count 12179 } 12180 } 12181 12182 // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv() is about to look at, 12183 // bump its pointer forward one question. 12184 if (m->CurrentQuestion == question) 12185 { 12186 debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)", 12187 question->qname.c, DNSTypeName(question->qtype)); 12188 m->CurrentQuestion = question->next; 12189 } 12190 12191 if (m->NewQuestions == question) 12192 { 12193 debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)", 12194 question->qname.c, DNSTypeName(question->qtype)); 12195 m->NewQuestions = question->next; 12196 } 12197 12198 if (m->NewLocalOnlyQuestions == question) m->NewLocalOnlyQuestions = question->next; 12199 12200 if (m->RestartQuestion == question) 12201 { 12202 LogMsg("mDNS_StopQuery_internal: Just deleted the current restart question: %##s (%s)", 12203 question->qname.c, DNSTypeName(question->qtype)); 12204 m->RestartQuestion = question->next; 12205 } 12206 12207 if (m->ValidationQuestion == question) 12208 { 12209 LogInfo("mDNS_StopQuery_internal: Just deleted the current Validation question: %##s (%s)", 12210 question->qname.c, DNSTypeName(question->qtype)); 12211 m->ValidationQuestion = question->next; 12212 } 12213 12214 // Take care not to trash question->next until *after* we've updated m->CurrentQuestion and m->NewQuestions 12215 question->next = mDNSNULL; 12216 12217 // LogMsg("mDNS_StopQuery_internal: Question %##s (%s) removed", question->qname.c, DNSTypeName(question->qtype)); 12218 12219 // And finally, cancel any associated GetZoneData operation that's still running. 12220 // Must not do this until last, because there's a good chance the GetZoneData question is the next in the list, 12221 // so if we delete it earlier in this routine, we could find that our "question->next" pointer above is already 12222 // invalid before we even use it. By making sure that we update m->CurrentQuestion and m->NewQuestions if necessary 12223 // *first*, then they're all ready to be updated a second time if necessary when we cancel our GetZoneData query. 12224 if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; } 12225 if (question->LocalSocket) { mDNSPlatformUDPClose(question->LocalSocket); question->LocalSocket = mDNSNULL; } 12226 if (!mDNSOpaque16IsZero(question->TargetQID) && question->LongLived) 12227 { 12228 // Scan our list to see if any more wide-area LLQs remain. If not, stop our NAT Traversal. 12229 DNSQuestion *q; 12230 for (q = m->Questions; q; q=q->next) 12231 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) break; 12232 if (!q) 12233 { 12234 if (!m->LLQNAT.clientCallback) // Should never happen, but just in case... 12235 { 12236 LogMsg("mDNS_StopQuery ERROR LLQNAT.clientCallback NULL"); 12237 } 12238 else 12239 { 12240 LogInfo("Stopping LLQNAT"); 12241 mDNS_StopNATOperation_internal(m, &m->LLQNAT); 12242 m->LLQNAT.clientCallback = mDNSNULL; // Means LLQ NAT Traversal not running 12243 } 12244 } 12245 12246 // If necessary, tell server it can delete this LLQ state 12247 if (question->state == LLQ_Established) 12248 { 12249 question->ReqLease = 0; 12250 sendLLQRefresh(m, question); 12251 // If we need need to make a TCP connection to cancel the LLQ, that's going to take a little while. 12252 // We clear the tcp->question backpointer so that when the TCP connection completes, it doesn't 12253 // crash trying to access our cancelled question, but we don't cancel the TCP operation itself -- 12254 // we let that run out its natural course and complete asynchronously. 12255 if (question->tcp) 12256 { 12257 question->tcp->question = mDNSNULL; 12258 question->tcp = mDNSNULL; 12259 } 12260 } 12261#ifdef DNS_PUSH_ENABLED 12262 else if (question->dnsPushState == DNSPUSH_ESTABLISHED) 12263 { 12264 if (question->tcp) 12265 { 12266 UnSubscribeToDNSPushNotificationServer(m, q); 12267 question->tcp->question = mDNSNULL; 12268 question->tcp = mDNSNULL; 12269 } 12270 } 12271#endif // DNS_PUSH_ENABLED 12272#if APPLE_OSX_mDNSResponder 12273 UpdateAutoTunnelDomainStatuses(m); 12274#endif 12275 } 12276 // wait until we send the refresh above which needs the nta 12277 if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; } 12278 12279 if (question->ValidationRequired && question->DNSSECAuthInfo) 12280 { 12281 LogInfo("mDNS_StopQuery_internal: freeing DNSSECAuthInfo %##s", question->qname.c); 12282 question->DAIFreeCallback(m, question->DNSSECAuthInfo); 12283 question->DNSSECAuthInfo = mDNSNULL; 12284 } 12285 if (question->AnonInfo) 12286 { 12287 FreeAnonInfo(question->AnonInfo); 12288 question->AnonInfo = mDNSNULL; 12289 } 12290#if AWD_METRICS 12291 if (question->metrics.originalQName) 12292 { 12293 mDNSPlatformMemFree(question->metrics.originalQName); 12294 question->metrics.originalQName = mDNSNULL; 12295 } 12296#endif 12297 12298#if USE_DNS64 12299 DNS64ResetState(question); 12300#endif 12301 12302 return(mStatus_NoError); 12303} 12304 12305mDNSexport mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question) 12306{ 12307 mStatus status; 12308 mDNS_Lock(m); 12309 status = mDNS_StartQuery_internal(m, question); 12310 mDNS_Unlock(m); 12311 return(status); 12312} 12313 12314mDNSexport mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question) 12315{ 12316 mStatus status; 12317 mDNS_Lock(m); 12318 status = mDNS_StopQuery_internal(m, question); 12319 mDNS_Unlock(m); 12320 return(status); 12321} 12322 12323// Note that mDNS_StopQueryWithRemoves() does not currently implement the full generality of the other APIs 12324// Specifically, question callbacks invoked as a result of this call cannot themselves make API calls. 12325// We invoke the callback without using mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback 12326// specifically to catch and report if the client callback does try to make API calls 12327mDNSexport mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question) 12328{ 12329 mStatus status; 12330 DNSQuestion *qq; 12331 mDNS_Lock(m); 12332 12333 // Check if question is new -- don't want to give remove events for a question we haven't even answered yet 12334 for (qq = m->NewQuestions; qq; qq=qq->next) if (qq == question) break; 12335 12336 status = mDNS_StopQuery_internal(m, question); 12337 if (status == mStatus_NoError && !qq) 12338 { 12339 const CacheRecord *rr; 12340 CacheGroup *const cg = CacheGroupForName(m, question->qnamehash, &question->qname); 12341 LogInfo("Generating terminal removes for %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); 12342 for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) 12343 if (rr->resrec.RecordType != kDNSRecordTypePacketNegative && SameNameRecordAnswersQuestion(&rr->resrec, question)) 12344 { 12345 // Don't use mDNS_DropLockBeforeCallback() here, since we don't allow API calls 12346 if (question->QuestionCallback) 12347 question->QuestionCallback(m, question, &rr->resrec, mDNSfalse); 12348 } 12349 } 12350 mDNS_Unlock(m); 12351 return(status); 12352} 12353 12354mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const cr) 12355{ 12356 mStatus status; 12357 mDNS_Lock(m); 12358 status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 12359 if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0); 12360 mDNS_Unlock(m); 12361 return(status); 12362} 12363 12364mDNSexport mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr) 12365{ 12366 mStatus status = mStatus_BadReferenceErr; 12367 CacheRecord *cr; 12368 mDNS_Lock(m); 12369 cr = FindIdenticalRecordInCache(m, rr); 12370 debugf("mDNS_ReconfirmByValue: %p %s", cr, RRDisplayString(m, rr)); 12371 if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 12372 if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0); 12373 mDNS_Unlock(m); 12374 return(status); 12375} 12376 12377mDNSlocal mStatus mDNS_StartBrowse_internal(mDNS *const m, DNSQuestion *const question, 12378 const domainname *const srv, const domainname *const domain, 12379 const mDNSu8 *anondata, const mDNSInterfaceID InterfaceID, mDNSu32 flags, 12380 mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass, 12381 mDNSQuestionCallback *Callback, void *Context) 12382{ 12383 question->InterfaceID = InterfaceID; 12384 question->flags = flags; 12385 question->Target = zeroAddr; 12386 question->qtype = kDNSType_PTR; 12387 question->qclass = kDNSClass_IN; 12388 question->LongLived = mDNStrue; 12389 question->ExpectUnique = mDNSfalse; 12390 question->ForceMCast = ForceMCast; 12391 question->ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0; 12392 question->SuppressUnusable = mDNSfalse; 12393 question->SearchListIndex = 0; 12394 question->AppendSearchDomains = 0; 12395 question->RetryWithSearchDomains = mDNSfalse; 12396 question->TimeoutQuestion = 0; 12397 question->WakeOnResolve = 0; 12398 question->UseBackgroundTrafficClass = useBackgroundTrafficClass; 12399 question->ValidationRequired = 0; 12400 question->ValidatingResponse = 0; 12401 question->ProxyQuestion = 0; 12402 question->qnameOrig = mDNSNULL; 12403 question->AnonInfo = mDNSNULL; 12404 question->QuestionCallback = Callback; 12405 question->QuestionContext = Context; 12406 12407 if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) 12408 return(mStatus_BadParamErr); 12409 12410 if (anondata) 12411 { 12412 question->AnonInfo = AllocateAnonInfo(&question->qname, anondata, mDNSPlatformStrLen(anondata), mDNSNULL); 12413 if (!question->AnonInfo) 12414 return(mStatus_BadParamErr); 12415 } 12416 12417 return(mDNS_StartQuery_internal(m, question)); 12418} 12419 12420mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question, 12421 const domainname *const srv, const domainname *const domain, 12422 const mDNSu8 *anondata, const mDNSInterfaceID InterfaceID, mDNSu32 flags, 12423 mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass, 12424 mDNSQuestionCallback *Callback, void *Context) 12425{ 12426 mStatus status; 12427 mDNS_Lock(m); 12428 status = mDNS_StartBrowse_internal(m, question, srv, domain, anondata, InterfaceID, flags, ForceMCast, useBackgroundTrafficClass, Callback, Context); 12429 mDNS_Unlock(m); 12430 return(status); 12431} 12432 12433 12434mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom, 12435 const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context) 12436{ 12437 question->InterfaceID = InterfaceID; 12438 question->flags = 0; 12439 question->Target = zeroAddr; 12440 question->qtype = kDNSType_PTR; 12441 question->qclass = kDNSClass_IN; 12442 question->LongLived = mDNSfalse; 12443 question->ExpectUnique = mDNSfalse; 12444 question->ForceMCast = mDNSfalse; 12445 question->ReturnIntermed = mDNSfalse; 12446 question->SuppressUnusable = mDNSfalse; 12447 question->SearchListIndex = 0; 12448 question->AppendSearchDomains = 0; 12449 question->RetryWithSearchDomains = mDNSfalse; 12450 question->TimeoutQuestion = 0; 12451 question->WakeOnResolve = 0; 12452 question->UseBackgroundTrafficClass = mDNSfalse; 12453 question->ValidationRequired = 0; 12454 question->ValidatingResponse = 0; 12455 question->ProxyQuestion = 0; 12456 question->qnameOrig = mDNSNULL; 12457 question->AnonInfo = mDNSNULL; 12458 question->pid = mDNSPlatformGetPID(); 12459 question->euid = 0; 12460 question->QuestionCallback = Callback; 12461 question->QuestionContext = Context; 12462 if (DomainType > mDNS_DomainTypeMax) return(mStatus_BadParamErr); 12463 if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr); 12464 if (!dom) dom = &localdomain; 12465 if (!AppendDomainName(&question->qname, dom)) return(mStatus_BadParamErr); 12466 return(mDNS_StartQuery(m, question)); 12467} 12468 12469// *************************************************************************** 12470#if COMPILER_LIKES_PRAGMA_MARK 12471#pragma mark - 12472#pragma mark - Responder Functions 12473#endif 12474 12475mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr) 12476{ 12477 mStatus status; 12478 mDNS_Lock(m); 12479 status = mDNS_Register_internal(m, rr); 12480 mDNS_Unlock(m); 12481 return(status); 12482} 12483 12484mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl, 12485 const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback) 12486{ 12487 if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata)) 12488 { 12489 LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(&rr->resrec, &newrdata->u, m->MsgBuffer)); 12490 return(mStatus_Invalid); 12491 } 12492 12493 mDNS_Lock(m); 12494 12495 // If TTL is unspecified, leave TTL unchanged 12496 if (newttl == 0) newttl = rr->resrec.rroriginalttl; 12497 12498 // If we already have an update queued up which has not gone through yet, give the client a chance to free that memory 12499 if (rr->NewRData) 12500 { 12501 RData *n = rr->NewRData; 12502 rr->NewRData = mDNSNULL; // Clear the NewRData pointer ... 12503 if (rr->UpdateCallback) 12504 rr->UpdateCallback(m, rr, n, rr->newrdlength); // ...and let the client free this memory, if necessary 12505 } 12506 12507 rr->NewRData = newrdata; 12508 rr->newrdlength = newrdlength; 12509 rr->UpdateCallback = Callback; 12510 12511#ifndef UNICAST_DISABLED 12512 if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P && !IsLocalDomain(rr->resrec.name)) 12513 { 12514 mStatus status = uDNS_UpdateRecord(m, rr); 12515 // The caller frees the memory on error, don't retain stale pointers 12516 if (status != mStatus_NoError) { rr->NewRData = mDNSNULL; rr->newrdlength = 0; } 12517 mDNS_Unlock(m); 12518 return(status); 12519 } 12520#endif 12521 12522 if (RRLocalOnly(rr) || (rr->resrec.rroriginalttl == newttl && 12523 rr->resrec.rdlength == newrdlength && mDNSPlatformMemSame(rr->resrec.rdata->u.data, newrdata->u.data, newrdlength))) 12524 CompleteRDataUpdate(m, rr); 12525 else 12526 { 12527 rr->AnnounceCount = InitialAnnounceCount; 12528 InitializeLastAPTime(m, rr); 12529 while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr); 12530 if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--; 12531 if (!rr->NextUpdateCredit) rr->NextUpdateCredit = NonZeroTime(m->timenow + kUpdateCreditRefreshInterval); 12532 if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1); 12533 if (rr->UpdateCredits <= 5) 12534 { 12535 mDNSu32 delay = 6 - rr->UpdateCredits; // Delay 1 second, then 2, then 3, etc. up to 6 seconds maximum 12536 if (!rr->UpdateBlocked) rr->UpdateBlocked = NonZeroTime(m->timenow + (mDNSs32)delay * mDNSPlatformOneSecond); 12537 rr->ThisAPInterval *= 4; 12538 rr->LastAPTime = rr->UpdateBlocked - rr->ThisAPInterval; 12539 LogMsg("Excessive update rate for %##s; delaying announcement by %ld second%s", 12540 rr->resrec.name->c, delay, delay > 1 ? "s" : ""); 12541 } 12542 rr->resrec.rroriginalttl = newttl; 12543 } 12544 12545 mDNS_Unlock(m); 12546 return(mStatus_NoError); 12547} 12548 12549// Note: mDNS_Deregister calls mDNS_Deregister_internal which can call a user callback, which may change 12550// the record list and/or question list. 12551// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 12552mDNSexport mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr) 12553{ 12554 mStatus status; 12555 mDNS_Lock(m); 12556 status = mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); 12557 mDNS_Unlock(m); 12558 return(status); 12559} 12560 12561// Circular reference: AdvertiseInterface references mDNS_HostNameCallback, which calls mDNS_SetFQDN, which call AdvertiseInterface 12562mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result); 12563 12564mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m) 12565{ 12566 NetworkInterfaceInfo *intf; 12567 for (intf = m->HostInterfaces; intf; intf = intf->next) 12568 if (intf->Advertise) break; 12569 return(intf); 12570} 12571 12572// The parameter "set" here refers to the set of AuthRecords used to advertise this interface. 12573// (It's a set of records, not a set of interfaces.) 12574mDNSlocal void AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set) 12575{ 12576 char buffer[MAX_REVERSE_MAPPING_NAME]; 12577 NetworkInterfaceInfo *primary; 12578 mDNSu8 recordType; 12579 12580 if (m->AutoTargetServices == 0) 12581 { 12582 LogInfo("AdvertiseInterface: Returning due to AutoTargetServices zero for %s", set->ifname); 12583 return; 12584 } 12585 12586 primary = FindFirstAdvertisedInterface(m); 12587 if (!primary) primary = set; // If no existing advertised interface, this new NetworkInterfaceInfo becomes our new primary 12588 // We should never have primary be NULL, because even if there is 12589 // no other interface yet, we should always find ourself in the list. 12590 12591 // If interface is marked as a direct link, we can assume the address record is unique 12592 // and does not need to go through the probe phase of the probe/announce packet sequence. 12593 recordType = (set->DirectLink ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique); 12594 12595 if (set->DirectLink) 12596 LogInfo("AdvertiseInterface: Marking address record as kDNSRecordTypeKnownUnique for %s", set->ifname); 12597 12598 // Send dynamic update for non-linklocal IPv4 Addresses 12599 mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kHostNameTTL, recordType, AuthRecordAny, mDNS_HostNameCallback, set); 12600 mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 12601 mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kHostNameTTL, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 12602 12603#if ANSWER_REMOTE_HOSTNAME_QUERIES 12604 set->RR_A.AllowRemoteQuery = mDNStrue; 12605 set->RR_PTR.AllowRemoteQuery = mDNStrue; 12606 set->RR_HINFO.AllowRemoteQuery = mDNStrue; 12607#endif 12608 // 1. Set up Address record to map from host name ("foo.local.") to IP address 12609 // 2. Set up reverse-lookup PTR record to map from our address back to our host name 12610 AssignDomainName(&set->RR_A.namestorage, &m->MulticastHostname); 12611 if (set->ip.type == mDNSAddrType_IPv4) 12612 { 12613 set->RR_A.resrec.rrtype = kDNSType_A; 12614 set->RR_A.resrec.rdata->u.ipv4 = set->ip.ip.v4; 12615 // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code 12616 mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.", 12617 set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]); 12618 } 12619 else if (set->ip.type == mDNSAddrType_IPv6) 12620 { 12621 int i; 12622 set->RR_A.resrec.rrtype = kDNSType_AAAA; 12623 set->RR_A.resrec.rdata->u.ipv6 = set->ip.ip.v6; 12624 for (i = 0; i < 16; i++) 12625 { 12626 static const char hexValues[] = "0123456789ABCDEF"; 12627 buffer[i * 4 ] = hexValues[set->ip.ip.v6.b[15 - i] & 0x0F]; 12628 buffer[i * 4 + 1] = '.'; 12629 buffer[i * 4 + 2] = hexValues[set->ip.ip.v6.b[15 - i] >> 4]; 12630 buffer[i * 4 + 3] = '.'; 12631 } 12632 mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa."); 12633 } 12634 12635 MakeDomainNameFromDNSNameString(&set->RR_PTR.namestorage, buffer); 12636 set->RR_PTR.AutoTarget = Target_AutoHost; // Tell mDNS that the target of this PTR is to be kept in sync with our host name 12637 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 12638 12639 set->RR_A.RRSet = &primary->RR_A; // May refer to self 12640 12641 mDNS_Register_internal(m, &set->RR_A); 12642 mDNS_Register_internal(m, &set->RR_PTR); 12643 12644#if APPLE_OSX_mDNSResponder 12645 // must be after the mDNS_Register_internal() calls so that records have complete rdata fields, etc 12646 D2D_start_advertising_interface(set); 12647#endif // APPLE_OSX_mDNSResponder 12648 12649 if (!NO_HINFO && m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254) 12650 { 12651 mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data; 12652 AssignDomainName(&set->RR_HINFO.namestorage, &m->MulticastHostname); 12653 set->RR_HINFO.DependentOn = &set->RR_A; 12654 mDNSPlatformMemCopy(p, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]); 12655 p += 1 + (int)p[0]; 12656 mDNSPlatformMemCopy(p, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]); 12657 mDNS_Register_internal(m, &set->RR_HINFO); 12658 } 12659 else 12660 { 12661 debugf("Not creating HINFO record: platform support layer provided no information"); 12662 set->RR_HINFO.resrec.RecordType = kDNSRecordTypeUnregistered; 12663 } 12664} 12665 12666mDNSlocal void DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set) 12667{ 12668 if (m->AutoTargetServices == 0) 12669 { 12670 LogInfo("DeadvertiseInterface: Returning due to AutoTargetServices zero for %s", set->ifname); 12671 return; 12672 } 12673 12674#if APPLE_OSX_mDNSResponder 12675 D2D_stop_advertising_interface(set); 12676#endif // APPLE_OSX_mDNSResponder 12677 12678 // Unregister these records. 12679 // When doing the mDNS_Exit processing, we first call DeadvertiseInterface for each interface, so by the time the platform 12680 // support layer gets to call mDNS_DeregisterInterface, the address and PTR records have already been deregistered for it. 12681 // Also, in the event of a name conflict, one or more of our records will have been forcibly deregistered. 12682 // To avoid unnecessary and misleading warning messages, we check the RecordType before calling mDNS_Deregister_internal(). 12683 if (set->RR_A .resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_A, mDNS_Dereg_normal); 12684 if (set->RR_PTR .resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_PTR, mDNS_Dereg_normal); 12685 if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal); 12686} 12687 12688mDNSlocal void AdvertiseAllInterfaceRecords(mDNS *const m) 12689{ 12690 NetworkInterfaceInfo *intf; 12691 for (intf = m->HostInterfaces; intf; intf = intf->next) 12692 { 12693 if (intf->Advertise) 12694 { 12695 LogInfo("AdvertiseInterface: Advertising for ifname %s", intf->ifname); 12696 AdvertiseInterface(m, intf); 12697 } 12698 } 12699} 12700 12701mDNSlocal void DeadvertiseAllInterfaceRecords(mDNS *const m) 12702{ 12703 NetworkInterfaceInfo *intf; 12704 for (intf = m->HostInterfaces; intf; intf = intf->next) 12705 { 12706 if (intf->Advertise) 12707 { 12708 LogInfo("DeadvertiseInterface: Deadvertising for ifname %s", intf->ifname); 12709 DeadvertiseInterface(m, intf); 12710 } 12711 } 12712} 12713 12714// Change target host name for record. 12715mDNSlocal void UpdateTargetHostName(mDNS *const m, AuthRecord *const rr) 12716{ 12717#if APPLE_OSX_mDNSResponder 12718 // If this record was also registered with any D2D plugins, stop advertising 12719 // the version with the old host name. 12720 D2D_stop_advertising_record(rr); 12721#endif 12722 12723 SetTargetToHostName(m, rr); 12724 12725#if APPLE_OSX_mDNSResponder 12726 // Advertise the record with the updated host name with the D2D plugins if appropriate. 12727 D2D_start_advertising_record(rr); 12728#endif 12729} 12730 12731mDNSexport void mDNS_SetFQDN(mDNS *const m) 12732{ 12733 domainname newmname; 12734 AuthRecord *rr; 12735 newmname.c[0] = 0; 12736 12737 if (!AppendDomainLabel(&newmname, &m->hostlabel)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; } 12738 if (!AppendLiteralLabelString(&newmname, "local")) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; } 12739 12740 mDNS_Lock(m); 12741 12742 if (SameDomainNameCS(&m->MulticastHostname, &newmname)) debugf("mDNS_SetFQDN - hostname unchanged"); 12743 else 12744 { 12745 AssignDomainName(&m->MulticastHostname, &newmname); 12746 DeadvertiseAllInterfaceRecords(m); 12747 AdvertiseAllInterfaceRecords(m); 12748 } 12749 12750 // 3. Make sure that any AutoTarget SRV records (and the like) get updated 12751 for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->AutoTarget) UpdateTargetHostName(m, rr); 12752 for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->AutoTarget) UpdateTargetHostName(m, rr); 12753 12754 mDNS_Unlock(m); 12755} 12756 12757mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 12758{ 12759 (void)rr; // Unused parameter 12760 12761 #if MDNS_DEBUGMSGS 12762 { 12763 char *msg = "Unknown result"; 12764 if (result == mStatus_NoError) msg = "Name registered"; 12765 else if (result == mStatus_NameConflict) msg = "Name conflict"; 12766 debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result); 12767 } 12768 #endif 12769 12770 if (result == mStatus_NoError) 12771 { 12772 // Notify the client that the host name is successfully registered 12773 if (m->MainCallback) 12774 m->MainCallback(m, mStatus_NoError); 12775 } 12776 else if (result == mStatus_NameConflict) 12777 { 12778 domainlabel oldlabel = m->hostlabel; 12779 12780 // 1. First give the client callback a chance to pick a new name 12781 if (m->MainCallback) 12782 m->MainCallback(m, mStatus_NameConflict); 12783 12784 // 2. If the client callback didn't do it, add (or increment) an index ourselves 12785 // This needs to be case-INSENSITIVE compare, because we need to know that the name has been changed so as to 12786 // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again. 12787 if (SameDomainLabel(m->hostlabel.c, oldlabel.c)) 12788 IncrementLabelSuffix(&m->hostlabel, mDNSfalse); 12789 12790 // 3. Generate the FQDNs from the hostlabel, 12791 // and make sure all SRV records, etc., are updated to reference our new hostname 12792 mDNS_SetFQDN(m); 12793 LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead", oldlabel.c, m->hostlabel.c); 12794 } 12795 else if (result == mStatus_MemFree) 12796 { 12797 // .local hostnames do not require goodbyes - we ignore the MemFree (which is sent directly by 12798 // mDNS_Deregister_internal), and allow the caller to deallocate immediately following mDNS_DeadvertiseInterface 12799 debugf("mDNS_HostNameCallback: MemFree (ignored)"); 12800 } 12801 else 12802 LogMsg("mDNS_HostNameCallback: Unknown error %d for registration of record %s", result, rr->resrec.name->c); 12803} 12804 12805mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active) 12806{ 12807 NetworkInterfaceInfo *intf; 12808 active->IPv4Available = mDNSfalse; 12809 active->IPv6Available = mDNSfalse; 12810 for (intf = m->HostInterfaces; intf; intf = intf->next) 12811 if (intf->InterfaceID == active->InterfaceID) 12812 { 12813 if (intf->ip.type == mDNSAddrType_IPv4 && intf->McastTxRx) active->IPv4Available = mDNStrue; 12814 if (intf->ip.type == mDNSAddrType_IPv6 && intf->McastTxRx) active->IPv6Available = mDNStrue; 12815 } 12816} 12817 12818mDNSlocal void RestartRecordGetZoneData(mDNS * const m) 12819{ 12820 AuthRecord *rr; 12821 LogInfo("RestartRecordGetZoneData: ResourceRecords"); 12822 for (rr = m->ResourceRecords; rr; rr=rr->next) 12823 if (AuthRecord_uDNS(rr) && rr->state != regState_NoTarget) 12824 { 12825 debugf("RestartRecordGetZoneData: StartGetZoneData for %##s", rr->resrec.name->c); 12826 // Zero out the updateid so that if we have a pending response from the server, it won't 12827 // be accepted as a valid response. If we accept the response, we might free the new "nta" 12828 if (rr->nta) { rr->updateid = zeroID; CancelGetZoneData(m, rr->nta); } 12829 rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationGotZoneData, rr); 12830 } 12831} 12832 12833mDNSlocal void InitializeNetWakeState(mDNS *const m, NetworkInterfaceInfo *set) 12834{ 12835 int i; 12836 // We initialize ThisQInterval to -1 indicating that the question has not been started 12837 // yet. If the question (browse) is started later during interface registration, it will 12838 // be stopped during interface deregistration. We can't sanity check to see if the 12839 // question has been stopped or not before initializing it to -1 because we need to 12840 // initialize it to -1 the very first time. 12841 12842 set->NetWakeBrowse.ThisQInterval = -1; 12843 for (i=0; i<3; i++) 12844 { 12845 set->NetWakeResolve[i].ThisQInterval = -1; 12846 set->SPSAddr[i].type = mDNSAddrType_None; 12847 } 12848 set->NextSPSAttempt = -1; 12849 set->NextSPSAttemptTime = m->timenow; 12850} 12851 12852mDNSexport void mDNS_ActivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set) 12853{ 12854 NetworkInterfaceInfo *p = m->HostInterfaces; 12855 while (p && p != set) p=p->next; 12856 if (!p) { LogMsg("mDNS_ActivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set); return; } 12857 12858 if (set->InterfaceActive) 12859 { 12860 LogSPS("ActivateNetWake for %s (%#a)", set->ifname, &set->ip); 12861 mDNS_StartBrowse_internal(m, &set->NetWakeBrowse, &SleepProxyServiceType, &localdomain, mDNSNULL, set->InterfaceID, 0, mDNSfalse, mDNSfalse, m->SPSBrowseCallback, set); 12862 } 12863} 12864 12865mDNSexport void mDNS_DeactivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set) 12866{ 12867 NetworkInterfaceInfo *p = m->HostInterfaces; 12868 while (p && p != set) p=p->next; 12869 if (!p) { LogMsg("mDNS_DeactivateNetWake_internal: NetworkInterfaceInfo %p not found in active list", set); return; } 12870 12871 // Note: We start the browse only if the interface is NetWake capable and we use this to 12872 // stop the resolves also. Hence, the resolves should not be started without the browse 12873 // being started i.e, resolves should not happen unless NetWake capable which is 12874 // guaranteed by BeginSleepProcessing. 12875 if (set->NetWakeBrowse.ThisQInterval >= 0) 12876 { 12877 int i; 12878 LogSPS("DeactivateNetWake for %s (%#a)", set->ifname, &set->ip); 12879 12880 // Stop our browse and resolve operations 12881 mDNS_StopQuery_internal(m, &set->NetWakeBrowse); 12882 for (i=0; i<3; i++) if (set->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery_internal(m, &set->NetWakeResolve[i]); 12883 12884 // Make special call to the browse callback to let it know it can to remove all records for this interface 12885 if (m->SPSBrowseCallback) 12886 { 12887 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 12888 m->SPSBrowseCallback(m, &set->NetWakeBrowse, mDNSNULL, mDNSfalse); 12889 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 12890 } 12891 12892 // Reset our variables back to initial state, so we're ready for when NetWake is turned back on 12893 // (includes resetting NetWakeBrowse.ThisQInterval back to -1) 12894 InitializeNetWakeState(m, set); 12895 } 12896} 12897 12898mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set, InterfaceActivationSpeed activationSpeed) 12899{ 12900 AuthRecord *rr; 12901 mDNSBool FirstOfType = mDNStrue; 12902 NetworkInterfaceInfo **p = &m->HostInterfaces; 12903 12904 if (!set->InterfaceID) 12905 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID", &set->ip); return(mStatus_Invalid); } 12906 12907 if (!mDNSAddressIsValidNonZero(&set->mask)) 12908 { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a", &set->ip, &set->mask); return(mStatus_Invalid); } 12909 12910 mDNS_Lock(m); 12911 12912 // Assume this interface will be active now, unless we find a duplicate already in the list 12913 set->InterfaceActive = mDNStrue; 12914 set->IPv4Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx); 12915 set->IPv6Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx); 12916 12917 InitializeNetWakeState(m, set); 12918 12919 // Scan list to see if this InterfaceID is already represented 12920 while (*p) 12921 { 12922 if (*p == set) 12923 { 12924 LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo that's already in the list"); 12925 mDNS_Unlock(m); 12926 return(mStatus_AlreadyRegistered); 12927 } 12928 12929 if ((*p)->InterfaceID == set->InterfaceID) 12930 { 12931 // This InterfaceID already represented by a different interface in the list, so mark this instance inactive for now 12932 set->InterfaceActive = mDNSfalse; 12933 if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse; 12934 if (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx) (*p)->IPv4Available = mDNStrue; 12935 if (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx) (*p)->IPv6Available = mDNStrue; 12936 } 12937 12938 p=&(*p)->next; 12939 } 12940 12941 set->next = mDNSNULL; 12942 *p = set; 12943 12944 if (set->Advertise) 12945 AdvertiseInterface(m, set); 12946 12947 LogInfo("mDNS_RegisterInterface: InterfaceID %d %s (%#a) %s", 12948 IID(set->InterfaceID), set->ifname, &set->ip, 12949 set->InterfaceActive ? 12950 "not represented in list; marking active and retriggering queries" : 12951 "already represented in list; marking inactive for now"); 12952 12953 if (set->NetWake) mDNS_ActivateNetWake_internal(m, set); 12954 12955 // In early versions of OS X the IPv6 address remains on an interface even when the interface is turned off, 12956 // giving the false impression that there's an active representative of this interface when there really isn't. 12957 // Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records, 12958 // even if we believe that we previously had an active representative of this interface. 12959 if (set->McastTxRx && (FirstOfType || set->InterfaceActive)) 12960 { 12961 DNSQuestion *q; 12962 // Normally, after an interface comes up, we pause half a second before beginning probing. 12963 // This is to guard against cases where there's rapid interface changes, where we could be confused by 12964 // seeing packets we ourselves sent just moments ago (perhaps when this interface had a different address) 12965 // which are then echoed back after a short delay by some Ethernet switches and some 802.11 base stations. 12966 // We don't want to do a probe, and then see a stale echo of an announcement we ourselves sent, 12967 // and think it's a conflicting answer to our probe. 12968 // In the case of a flapping interface, we pause for five seconds, and reduce the announcement count to one packet. 12969 mDNSs32 probedelay; 12970 mDNSu8 numannounce; 12971 switch (activationSpeed) 12972 { 12973 case FastActivation: 12974 probedelay = (mDNSs32)0; 12975 numannounce = InitialAnnounceCount; 12976 LogMsg("mDNS_RegisterInterface: Using fast activation for DirectLink interface %s (%#a)", set->ifname, &set->ip); 12977 break; 12978 12979 case SlowActivation: 12980 probedelay = mDNSPlatformOneSecond * 5; 12981 numannounce = (mDNSu8)1; 12982 LogMsg("mDNS_RegisterInterface: Frequent transitions for interface %s (%#a), doing slow activation", set->ifname, &set->ip); 12983 m->mDNSStats.InterfaceUpFlap++; 12984 break; 12985 12986 case NormalActivation: 12987 default: 12988 probedelay = mDNSPlatformOneSecond / 2; 12989 numannounce = InitialAnnounceCount; 12990 break; 12991 } 12992 12993 LogInfo("mDNS_RegisterInterface: %s (%#a) probedelay %d", set->ifname, &set->ip, probedelay); 12994 12995 // No probe or sending suppression on DirectLink type interfaces. 12996 if (activationSpeed == FastActivation) 12997 { 12998 m->SuppressSending = 0; 12999 m->SuppressProbes = 0; 13000 } 13001 else 13002 { 13003 // Use a small amount of randomness: 13004 // In the case of a network administrator turning on an Ethernet hub so that all the 13005 // connected machines establish link at exactly the same time, we don't want them all 13006 // to go and hit the network with identical queries at exactly the same moment. 13007 // We set a random delay of up to InitialQuestionInterval (1/3 second). 13008 // We must *never* set m->SuppressSending to more than that (or set it repeatedly in a way 13009 // that causes mDNSResponder to remain in a prolonged state of SuppressSending, because 13010 // suppressing packet sending for more than about 1/3 second can cause protocol correctness 13011 // to start to break down (e.g. we don't answer probes fast enough, and get name conflicts). 13012 // See <rdar://problem/4073853> mDNS: m->SuppressSending set too enthusiastically 13013 if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval); 13014 13015 if (m->SuppressProbes == 0 || 13016 m->SuppressProbes - NonZeroTime(m->timenow + probedelay) < 0) 13017 m->SuppressProbes = NonZeroTime(m->timenow + probedelay); 13018 } 13019 13020 // Include OWNER option in packets for 60 seconds after connecting to the network. Setting 13021 // it here also handles the wake up case as the network link comes UP after waking causing 13022 // us to reconnect to the network. If we do this as part of the wake up code, it is possible 13023 // that the network link comes UP after 60 seconds and we never set the OWNER option 13024 m->AnnounceOwner = NonZeroTime(m->timenow + 60 * mDNSPlatformOneSecond); 13025 LogInfo("mDNS_RegisterInterface: Setting AnnounceOwner"); 13026 13027 m->mDNSStats.InterfaceUp++; 13028 for (q = m->Questions; q; q=q->next) // Scan our list of questions 13029 { 13030 if (mDNSOpaque16IsZero(q->TargetQID)) 13031 { 13032 if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) // If non-specific Q, or Q on this specific interface, 13033 { // then reactivate this question 13034 // If flapping, delay between first and second queries is nine seconds instead of one second 13035 mDNSBool dodelay = (activationSpeed == SlowActivation) && (q->FlappingInterface1 == set->InterfaceID || q->FlappingInterface2 == set->InterfaceID); 13036 mDNSs32 initial = dodelay ? InitialQuestionInterval * QuestionIntervalStep2 : InitialQuestionInterval; 13037 mDNSs32 qdelay = dodelay ? kDefaultQueryDelayTimeForFlappingInterface : 0; 13038 if (dodelay) LogInfo("No cache records expired for %##s (%s); delaying questions by %d seconds", q->qname.c, DNSTypeName(q->qtype), qdelay); 13039 13040 if (!q->ThisQInterval || q->ThisQInterval > initial) 13041 { 13042 q->ThisQInterval = initial; 13043 q->RequestUnicast = kDefaultRequestUnicastCount; 13044 } 13045 q->LastQTime = m->timenow - q->ThisQInterval + qdelay; 13046 q->RecentAnswerPkts = 0; 13047 // Change the salt 13048 ReInitAnonInfo(&q->AnonInfo, &q->qname); 13049 SetNextQueryTime(m,q); 13050 } 13051 } 13052 } 13053 13054 // For all our non-specific authoritative resource records (and any dormant records specific to this interface) 13055 // we now need them to re-probe if necessary, and then re-announce. 13056 for (rr = m->ResourceRecords; rr; rr=rr->next) 13057 { 13058 if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID) 13059 { 13060 // Change the salt 13061 ReInitAnonInfo(&rr->resrec.AnonInfo, rr->resrec.name); 13062 mDNSCoreRestartRegistration(m, rr, numannounce); 13063 } 13064 } 13065#if APPLE_OSX_mDNSResponder && !TARGET_OS_IPHONE 13066 DNSSECProbe(m); 13067#endif 13068 } 13069 13070 RestartRecordGetZoneData(m); 13071 13072 mDNS_UpdateAllowSleep(m); 13073 13074 mDNS_Unlock(m); 13075 return(mStatus_NoError); 13076} 13077 13078// Note: mDNS_DeregisterInterface calls mDNS_Deregister_internal which can call a user callback, which may change 13079// the record list and/or question list. 13080// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 13081mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, InterfaceActivationSpeed activationSpeed) 13082{ 13083 NetworkInterfaceInfo **p = &m->HostInterfaces; 13084 mDNSBool revalidate = mDNSfalse; 13085 NetworkInterfaceInfo *primary; 13086 NetworkInterfaceInfo *intf; 13087 AuthRecord *A; 13088 13089 mDNS_Lock(m); 13090 13091 // Find this record in our list 13092 while (*p && *p != set) p=&(*p)->next; 13093 if (!*p) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list"); mDNS_Unlock(m); return; } 13094 13095 mDNS_DeactivateNetWake_internal(m, set); 13096 13097 // Unlink this record from our list 13098 *p = (*p)->next; 13099 set->next = mDNSNULL; 13100 13101 if (!set->InterfaceActive) 13102 { 13103 // If this interface not the active member of its set, update the v4/v6Available flags for the active member 13104 for (intf = m->HostInterfaces; intf; intf = intf->next) 13105 if (intf->InterfaceActive && intf->InterfaceID == set->InterfaceID) 13106 UpdateInterfaceProtocols(m, intf); 13107 } 13108 else 13109 { 13110 intf = FirstInterfaceForID(m, set->InterfaceID); 13111 if (intf) 13112 { 13113 LogInfo("mDNS_DeregisterInterface: Another representative of InterfaceID %d %s (%#a) exists;" 13114 " making it active", IID(set->InterfaceID), set->ifname, &set->ip); 13115 if (intf->InterfaceActive) 13116 LogMsg("mDNS_DeregisterInterface: ERROR intf->InterfaceActive already set for %s (%#a)", set->ifname, &set->ip); 13117 intf->InterfaceActive = mDNStrue; 13118 UpdateInterfaceProtocols(m, intf); 13119 13120 if (intf->NetWake) mDNS_ActivateNetWake_internal(m, intf); 13121 13122 // See if another representative *of the same type* exists. If not, we mave have gone from 13123 // dual-stack to v6-only (or v4-only) so we need to reconfirm which records are still valid. 13124 for (intf = m->HostInterfaces; intf; intf = intf->next) 13125 if (intf->InterfaceID == set->InterfaceID && intf->ip.type == set->ip.type) 13126 break; 13127 if (!intf) revalidate = mDNStrue; 13128 } 13129 else 13130 { 13131 mDNSu32 slot; 13132 CacheGroup *cg; 13133 CacheRecord *rr; 13134 DNSQuestion *q; 13135 13136 LogInfo("mDNS_DeregisterInterface: Last representative of InterfaceID %d %s (%#a) deregistered;" 13137 " marking questions etc. dormant", IID(set->InterfaceID), set->ifname, &set->ip); 13138 13139 m->mDNSStats.InterfaceDown++; 13140 13141 if (set->McastTxRx && (activationSpeed == SlowActivation)) 13142 { 13143 LogMsg("mDNS_DeregisterInterface: Frequent transitions for interface %s (%#a)", set->ifname, &set->ip); 13144 m->mDNSStats.InterfaceDownFlap++; 13145 } 13146 13147 // 1. Deactivate any questions specific to this interface, and tag appropriate questions 13148 // so that mDNS_RegisterInterface() knows how swiftly it needs to reactivate them 13149 for (q = m->Questions; q; q=q->next) 13150 { 13151 if (q->InterfaceID == set->InterfaceID) q->ThisQInterval = 0; 13152 if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) 13153 { 13154 q->FlappingInterface2 = q->FlappingInterface1; 13155 q->FlappingInterface1 = set->InterfaceID; // Keep history of the last two interfaces to go away 13156 } 13157 } 13158 13159 // 2. Flush any cache records received on this interface 13160 revalidate = mDNSfalse; // Don't revalidate if we're flushing the records 13161 FORALL_CACHERECORDS(slot, cg, rr) 13162 { 13163 if (rr->resrec.InterfaceID == set->InterfaceID) 13164 { 13165 // If this interface is deemed flapping, 13166 // postpone deleting the cache records in case the interface comes back again 13167 if (set->McastTxRx && (activationSpeed == SlowActivation)) 13168 { 13169 // For a flapping interface we want these records to go away after 13170 // kDefaultReconfirmTimeForFlappingInterface seconds if they are not reconfirmed. 13171 mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface); 13172 // We set UnansweredQueries = MaxUnansweredQueries so we don't waste time doing any queries for them -- 13173 // if the interface does come back, any relevant questions will be reactivated anyway 13174 rr->UnansweredQueries = MaxUnansweredQueries; 13175 } 13176 else 13177 { 13178 mDNS_PurgeCacheResourceRecord(m, rr); 13179 } 13180 } 13181 } 13182 } 13183 } 13184 13185 // If we still have address records referring to this one, update them. 13186 // This is safe, because this NetworkInterfaceInfo has already been unlinked from the list, 13187 // so the call to FindFirstAdvertisedInterface() won���t accidentally find it. 13188 primary = FindFirstAdvertisedInterface(m); 13189 A = primary ? &primary->RR_A : mDNSNULL; 13190 for (intf = m->HostInterfaces; intf; intf = intf->next) 13191 if (intf->RR_A.RRSet == &set->RR_A) 13192 intf->RR_A.RRSet = A; 13193 13194 // If we were advertising on this interface, deregister those address and reverse-lookup records now 13195 if (set->Advertise) DeadvertiseInterface(m, set); 13196 13197 // If we have any cache records received on this interface that went away, then re-verify them. 13198 // In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off, 13199 // giving the false impression that there's an active representative of this interface when there really isn't. 13200 // Don't need to do this when shutting down, because *all* interfaces are about to go away 13201 if (revalidate && !m->ShutdownTime) 13202 { 13203 mDNSu32 slot; 13204 CacheGroup *cg; 13205 CacheRecord *rr; 13206 FORALL_CACHERECORDS(slot, cg, rr) 13207 if (rr->resrec.InterfaceID == set->InterfaceID) 13208 mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface); 13209 } 13210 13211 mDNS_UpdateAllowSleep(m); 13212 13213 mDNS_Unlock(m); 13214} 13215 13216mDNSlocal void SetAnonInfoSRS(ServiceRecordSet *sr, int NumSubTypes) 13217{ 13218 int i, len; 13219 13220 if (!sr->AnonData) 13221 return; 13222 13223 len = mDNSPlatformStrLen(sr->AnonData); 13224 if (sr->RR_PTR.resrec.AnonInfo) 13225 { 13226 LogMsg("SetAnonInfoSRS: Freeing AnonInfo for PTR record %##s, should have been freed already", sr->RR_PTR.resrec.name->c); 13227 FreeAnonInfo(sr->RR_PTR.resrec.AnonInfo); 13228 } 13229 sr->RR_PTR.resrec.AnonInfo = AllocateAnonInfo(sr->RR_PTR.resrec.name, sr->AnonData, len, mDNSNULL); 13230 for (i=0; i<NumSubTypes; i++) 13231 { 13232 if (sr->SubTypes[i].resrec.AnonInfo) 13233 { 13234 LogMsg("SetAnonInfoSRS: Freeing AnonInfo for subtype record %##s, should have been freed already", sr->SubTypes[i].resrec.name->c); 13235 FreeAnonInfo(sr->SubTypes[i].resrec.AnonInfo); 13236 } 13237 sr->SubTypes[i].resrec.AnonInfo = AllocateAnonInfo(sr->SubTypes[i].resrec.name, sr->AnonData, len, mDNSNULL); 13238 } 13239} 13240 13241mDNSlocal void ResetAnonInfoSRS(ServiceRecordSet *sr, int NumSubTypes) 13242{ 13243 int i; 13244 13245 if (!sr->AnonData) 13246 return; 13247 if (sr->RR_PTR.resrec.AnonInfo) 13248 { 13249 FreeAnonInfo(sr->RR_PTR.resrec.AnonInfo); 13250 sr->RR_PTR.resrec.AnonInfo = mDNSNULL; 13251 } 13252 for (i=0; i<NumSubTypes; i++) 13253 { 13254 if (sr->SubTypes[i].resrec.AnonInfo) 13255 { 13256 FreeAnonInfo(sr->SubTypes[i].resrec.AnonInfo); 13257 sr->SubTypes[i].resrec.AnonInfo = mDNSNULL; 13258 } 13259 } 13260} 13261 13262mDNSlocal void ServiceCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 13263{ 13264 ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext; 13265 (void)m; // Unused parameter 13266 13267 #if MDNS_DEBUGMSGS 13268 { 13269 char *msg = "Unknown result"; 13270 if (result == mStatus_NoError) msg = "Name Registered"; 13271 else if (result == mStatus_NameConflict) msg = "Name Conflict"; 13272 else if (result == mStatus_MemFree) msg = "Memory Free"; 13273 debugf("ServiceCallback: %##s (%s) %s (%d)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result); 13274 } 13275 #endif 13276 13277 // Only pass on the NoError acknowledgement for the SRV record (when it finishes probing) 13278 if (result == mStatus_NoError && rr != &sr->RR_SRV) return; 13279 13280 // If we got a name conflict on either SRV or TXT, forcibly deregister this service, and record that we did that 13281 if (result == mStatus_NameConflict) 13282 { 13283 sr->Conflict = mDNStrue; // Record that this service set had a conflict 13284 mDNS_DeregisterService(m, sr); // Unlink the records from our list 13285 return; 13286 } 13287 13288 if (result == mStatus_MemFree) 13289 { 13290 // If the SRV/TXT/PTR records, or the _services._dns-sd._udp record, or any of the subtype PTR records, 13291 // are still in the process of deregistering, don't pass on the NameConflict/MemFree message until 13292 // every record is finished cleaning up. 13293 mDNSu32 i; 13294 ExtraResourceRecord *e = sr->Extras; 13295 13296 if (sr->RR_SRV.resrec.RecordType != kDNSRecordTypeUnregistered) return; 13297 if (sr->RR_TXT.resrec.RecordType != kDNSRecordTypeUnregistered) return; 13298 if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return; 13299 if (sr->RR_ADV.resrec.RecordType != kDNSRecordTypeUnregistered) return; 13300 for (i=0; i<sr->NumSubTypes; i++) if (sr->SubTypes[i].resrec.RecordType != kDNSRecordTypeUnregistered) return; 13301 13302 while (e) 13303 { 13304 if (e->r.resrec.RecordType != kDNSRecordTypeUnregistered) return; 13305 e = e->next; 13306 } 13307 ResetAnonInfoSRS(sr, sr->NumSubTypes); 13308 13309 // If this ServiceRecordSet was forcibly deregistered, and now its memory is ready for reuse, 13310 // then we can now report the NameConflict to the client 13311 if (sr->Conflict) result = mStatus_NameConflict; 13312 13313 } 13314 13315 LogInfo("ServiceCallback: All records %s for %##s", (result == mStatus_MemFree ? "Unregistered" : "Registered"), sr->RR_PTR.resrec.name->c); 13316 // CAUTION: MUST NOT do anything more with sr after calling sr->Callback(), because the client's callback 13317 // function is allowed to do anything, including deregistering this service and freeing its memory. 13318 if (sr->ServiceCallback) 13319 sr->ServiceCallback(m, sr, result); 13320} 13321 13322mDNSlocal void NSSCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 13323{ 13324 ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext; 13325 if (sr->ServiceCallback) 13326 sr->ServiceCallback(m, sr, result); 13327} 13328 13329 13330// Derive AuthRecType from the kDNSServiceFlags* values. 13331mDNSlocal AuthRecType setAuthRecType(mDNSInterfaceID InterfaceID, mDNSu32 flags) 13332{ 13333 AuthRecType artype; 13334 13335 if (InterfaceID == mDNSInterface_LocalOnly) 13336 artype = AuthRecordLocalOnly; 13337 else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE) 13338 artype = AuthRecordP2P; 13339 else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P) 13340 && (flags & kDNSServiceFlagsIncludeAWDL)) 13341 artype = AuthRecordAnyIncludeAWDLandP2P; 13342 else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P)) 13343 artype = AuthRecordAnyIncludeP2P; 13344 else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeAWDL)) 13345 artype = AuthRecordAnyIncludeAWDL; 13346 else 13347 artype = AuthRecordAny; 13348 13349 return artype; 13350} 13351 13352// Used to derive the original D2D specific flags specified by the client in the registration 13353// when we don't have access to the original flag (kDNSServiceFlags*) values. 13354mDNSexport mDNSu32 deriveD2DFlagsFromAuthRecType(AuthRecType authRecType) 13355{ 13356 mDNSu32 flags = 0; 13357 if ((authRecType == AuthRecordAnyIncludeP2P) || (authRecType == AuthRecordAnyIncludeAWDLandP2P)) 13358 flags |= kDNSServiceFlagsIncludeP2P; 13359 else if ((authRecType == AuthRecordAnyIncludeAWDL) || (authRecType == AuthRecordAnyIncludeAWDLandP2P)) 13360 flags |= kDNSServiceFlagsIncludeAWDL; 13361 return flags; 13362} 13363 13364// Note: 13365// Name is first label of domain name (any dots in the name are actual dots, not label separators) 13366// Type is service type (e.g. "_ipp._tcp.") 13367// Domain is fully qualified domain name (i.e. ending with a null label) 13368// We always register a TXT, even if it is empty (so that clients are not 13369// left waiting forever looking for a nonexistent record.) 13370// If the host parameter is mDNSNULL or the root domain (ASCII NUL), 13371// then the default host name (m->MulticastHostname) is automatically used 13372// If the optional target host parameter is set, then the storage it points to must remain valid for the lifetime of the service registration 13373mDNSexport mStatus mDNS_RegisterService(mDNS *const m, ServiceRecordSet *sr, 13374 const domainlabel *const name, const domainname *const type, const domainname *const domain, 13375 const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen, 13376 AuthRecord *SubTypes, mDNSu32 NumSubTypes, 13377 mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context, mDNSu32 flags) 13378{ 13379 mStatus err; 13380 mDNSu32 i; 13381 mDNSu32 hostTTL; 13382 AuthRecType artype; 13383 mDNSu8 recordType = (flags & kDNSServiceFlagsKnownUnique) ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique; 13384 13385 sr->ServiceCallback = Callback; 13386 sr->ServiceContext = Context; 13387 sr->Conflict = mDNSfalse; 13388 13389 sr->Extras = mDNSNULL; 13390 sr->NumSubTypes = NumSubTypes; 13391 sr->SubTypes = SubTypes; 13392 sr->flags = flags; 13393 13394 artype = setAuthRecType(InterfaceID, flags); 13395 13396 // Initialize the AuthRecord objects to sane values 13397 // Need to initialize everything correctly *before* making the decision whether to do a RegisterNoSuchService and bail out 13398 mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeAdvisory, artype, ServiceCallback, sr); 13399 mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr); 13400 13401 if (flags & kDNSServiceFlagsWakeOnlyService) 13402 { 13403 sr->RR_PTR.AuthFlags = AuthFlagsWakeOnly; 13404 } 13405 13406 if (SameDomainName(type, (const domainname *) "\x4" "_ubd" "\x4" "_tcp")) 13407 hostTTL = kHostNameSmallTTL; 13408 else 13409 hostTTL = kHostNameTTL; 13410 13411 mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, hostTTL, recordType, artype, ServiceCallback, sr); 13412 mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kStandardTTL, recordType, artype, ServiceCallback, sr); 13413 13414 // If port number is zero, that means the client is really trying to do a RegisterNoSuchService 13415 if (mDNSIPPortIsZero(port)) 13416 return(mDNS_RegisterNoSuchService(m, &sr->RR_SRV, name, type, domain, mDNSNULL, InterfaceID, NSSCallback, sr, flags)); 13417 13418 // If the caller is registering an oversized TXT record, 13419 // it is the caller's responsibility to allocate a ServiceRecordSet structure that is large enough for it 13420 if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen) 13421 sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen; 13422 13423 // Set up the record names 13424 // For now we only create an advisory record for the main type, not for subtypes 13425 // We need to gain some operational experience before we decide if there's a need to create them for subtypes too 13426 if (ConstructServiceName(&sr->RR_ADV.namestorage, (const domainlabel*)"\x09_services", (const domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL) 13427 return(mStatus_BadParamErr); 13428 if (ConstructServiceName(&sr->RR_PTR.namestorage, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr); 13429 if (ConstructServiceName(&sr->RR_SRV.namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr); 13430 AssignDomainName(&sr->RR_TXT.namestorage, sr->RR_SRV.resrec.name); 13431 13432 // 1. Set up the ADV record rdata to advertise our service type 13433 AssignDomainName(&sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name); 13434 13435 // 2. Set up the PTR record rdata to point to our service name 13436 // We set up two additionals, so when a client asks for this PTR we automatically send the SRV and the TXT too 13437 // Note: uDNS registration code assumes that Additional1 points to the SRV record 13438 AssignDomainName(&sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name); 13439 sr->RR_PTR.Additional1 = &sr->RR_SRV; 13440 sr->RR_PTR.Additional2 = &sr->RR_TXT; 13441 13442 // 2a. Set up any subtype PTRs to point to our service name 13443 // If the client is using subtypes, it is the client's responsibility to have 13444 // already set the first label of the record name to the subtype being registered 13445 for (i=0; i<NumSubTypes; i++) 13446 { 13447 domainname st; 13448 AssignDomainName(&st, sr->SubTypes[i].resrec.name); 13449 st.c[1+st.c[0]] = 0; // Only want the first label, not the whole FQDN (particularly for mDNS_RenameAndReregisterService()) 13450 AppendDomainName(&st, type); 13451 mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr); 13452 if (ConstructServiceName(&sr->SubTypes[i].namestorage, mDNSNULL, &st, domain) == mDNSNULL) return(mStatus_BadParamErr); 13453 AssignDomainName(&sr->SubTypes[i].resrec.rdata->u.name, &sr->RR_SRV.namestorage); 13454 sr->SubTypes[i].Additional1 = &sr->RR_SRV; 13455 sr->SubTypes[i].Additional2 = &sr->RR_TXT; 13456 } 13457 13458 SetAnonInfoSRS(sr, NumSubTypes); 13459 13460 // 3. Set up the SRV record rdata. 13461 sr->RR_SRV.resrec.rdata->u.srv.priority = 0; 13462 sr->RR_SRV.resrec.rdata->u.srv.weight = 0; 13463 sr->RR_SRV.resrec.rdata->u.srv.port = port; 13464 13465 // Setting AutoTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name 13466 if (host && host->c[0]) AssignDomainName(&sr->RR_SRV.resrec.rdata->u.srv.target, host); 13467 else { sr->RR_SRV.AutoTarget = Target_AutoHost; sr->RR_SRV.resrec.rdata->u.srv.target.c[0] = '\0'; } 13468 13469 // 4. Set up the TXT record rdata, 13470 // and set DependentOn because we're depending on the SRV record to find and resolve conflicts for us 13471 // Note: uDNS registration code assumes that DependentOn points to the SRV record 13472 if (txtinfo == mDNSNULL) sr->RR_TXT.resrec.rdlength = 0; 13473 else if (txtinfo != sr->RR_TXT.resrec.rdata->u.txt.c) 13474 { 13475 sr->RR_TXT.resrec.rdlength = txtlen; 13476 if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr); 13477 mDNSPlatformMemCopy(sr->RR_TXT.resrec.rdata->u.txt.c, txtinfo, txtlen); 13478 } 13479 sr->RR_TXT.DependentOn = &sr->RR_SRV; 13480 13481 mDNS_Lock(m); 13482 // It is important that we register SRV first. uDNS assumes that SRV is registered first so 13483 // that if the SRV cannot find a target, rest of the records that belong to this service 13484 // will not be activated. 13485 err = mDNS_Register_internal(m, &sr->RR_SRV); 13486 // If we can't register the SRV record due to errors, bail out. It has not been inserted in 13487 // any list and hence no need to deregister. We could probably do similar checks for other 13488 // records below and bail out. For now, this seems to be sufficient to address rdar://9304275 13489 if (err) 13490 { 13491 mDNS_Unlock(m); 13492 return err; 13493 } 13494 if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT); 13495 // We register the RR_PTR last, because we want to be sure that in the event of a forced call to 13496 // mDNS_StartExit, the RR_PTR will be the last one to be forcibly deregistered, since that is what triggers 13497 // the mStatus_MemFree callback to ServiceCallback, which in turn passes on the mStatus_MemFree back to 13498 // the client callback, which is then at liberty to free the ServiceRecordSet memory at will. We need to 13499 // make sure we've deregistered all our records and done any other necessary cleanup before that happens. 13500 if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV); 13501 for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]); 13502 if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR); 13503 13504 mDNS_Unlock(m); 13505 13506 if (err) mDNS_DeregisterService(m, sr); 13507 return(err); 13508} 13509 13510mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr, 13511 ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl, mDNSu32 flags) 13512{ 13513 ExtraResourceRecord **e; 13514 mStatus status; 13515 AuthRecType artype; 13516 mDNSInterfaceID InterfaceID = sr->RR_PTR.resrec.InterfaceID; 13517 ResourceRecord *rr; 13518 13519 artype = setAuthRecType(InterfaceID, flags); 13520 13521 extra->next = mDNSNULL; 13522 mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID, 13523 extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, artype, ServiceCallback, sr); 13524 AssignDomainName(&extra->r.namestorage, sr->RR_SRV.resrec.name); 13525 13526 mDNS_Lock(m); 13527 rr = mDNSNULL; 13528 if (extra->r.resrec.rrtype == kDNSType_TXT) 13529 { 13530 if (sr->RR_TXT.resrec.RecordType & kDNSRecordTypeUniqueMask) rr = &sr->RR_TXT.resrec; 13531 } 13532 else if (extra->r.resrec.rrtype == kDNSType_SRV) 13533 { 13534 if (sr->RR_SRV.resrec.RecordType & kDNSRecordTypeUniqueMask) rr = &sr->RR_SRV.resrec; 13535 } 13536 13537 if (!rr) 13538 { 13539 ExtraResourceRecord *srExtra; 13540 13541 for (srExtra = sr->Extras; srExtra; srExtra = srExtra->next) 13542 { 13543 if ((srExtra->r.resrec.rrtype == extra->r.resrec.rrtype) && (srExtra->r.resrec.RecordType & kDNSRecordTypeUniqueMask)) 13544 { 13545 rr = &srExtra->r.resrec; 13546 break; 13547 } 13548 } 13549 } 13550 13551 if (rr && (extra->r.resrec.rroriginalttl != rr->rroriginalttl)) 13552 { 13553 LogMsg("mDNS_AddRecordToService: Correcting TTL from %4d to %4d for %s", 13554 extra->r.resrec.rroriginalttl, rr->rroriginalttl, RRDisplayString(m, &extra->r.resrec)); 13555 extra->r.resrec.rroriginalttl = rr->rroriginalttl; 13556 } 13557 13558 e = &sr->Extras; 13559 while (*e) e = &(*e)->next; 13560 13561 extra->r.DependentOn = &sr->RR_SRV; 13562 13563 debugf("mDNS_AddRecordToService adding record to %##s %s %d", 13564 extra->r.resrec.name->c, DNSTypeName(extra->r.resrec.rrtype), extra->r.resrec.rdlength); 13565 13566 status = mDNS_Register_internal(m, &extra->r); 13567 if (status == mStatus_NoError) *e = extra; 13568 13569 mDNS_Unlock(m); 13570 return(status); 13571} 13572 13573mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra, 13574 mDNSRecordCallback MemFreeCallback, void *Context) 13575{ 13576 ExtraResourceRecord **e; 13577 mStatus status; 13578 13579 mDNS_Lock(m); 13580 e = &sr->Extras; 13581 while (*e && *e != extra) e = &(*e)->next; 13582 if (!*e) 13583 { 13584 debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra->r.resrec.name->c); 13585 status = mStatus_BadReferenceErr; 13586 } 13587 else 13588 { 13589 debugf("mDNS_RemoveRecordFromService removing record from %##s", extra->r.resrec.name->c); 13590 extra->r.RecordCallback = MemFreeCallback; 13591 extra->r.RecordContext = Context; 13592 *e = (*e)->next; 13593 status = mDNS_Deregister_internal(m, &extra->r, mDNS_Dereg_normal); 13594 } 13595 mDNS_Unlock(m); 13596 return(status); 13597} 13598 13599mDNSexport mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname) 13600{ 13601 // Note: Don't need to use mDNS_Lock(m) here, because this code is just using public routines 13602 // mDNS_RegisterService() and mDNS_AddRecordToService(), which do the right locking internally. 13603 domainlabel name1, name2; 13604 domainname type, domain; 13605 const domainname *host = sr->RR_SRV.AutoTarget ? mDNSNULL : &sr->RR_SRV.resrec.rdata->u.srv.target; 13606 ExtraResourceRecord *extras = sr->Extras; 13607 mStatus err; 13608 13609 DeconstructServiceName(sr->RR_SRV.resrec.name, &name1, &type, &domain); 13610 if (!newname) 13611 { 13612 name2 = name1; 13613 IncrementLabelSuffix(&name2, mDNStrue); 13614 newname = &name2; 13615 } 13616 13617 if (SameDomainName(&domain, &localdomain)) 13618 debugf("%##s service renamed from \"%#s\" to \"%#s\"", type.c, name1.c, newname->c); 13619 else debugf("%##s service (domain %##s) renamed from \"%#s\" to \"%#s\"",type.c, domain.c, name1.c, newname->c); 13620 13621 err = mDNS_RegisterService(m, sr, newname, &type, &domain, 13622 host, sr->RR_SRV.resrec.rdata->u.srv.port, sr->RR_TXT.resrec.rdata->u.txt.c, sr->RR_TXT.resrec.rdlength, 13623 sr->SubTypes, sr->NumSubTypes, 13624 sr->RR_PTR.resrec.InterfaceID, sr->ServiceCallback, sr->ServiceContext, sr->flags); 13625 13626 // mDNS_RegisterService() just reset sr->Extras to NULL. 13627 // Fortunately we already grabbed ourselves a copy of this pointer (above), so we can now run 13628 // through the old list of extra records, and re-add them to our freshly created service registration 13629 while (!err && extras) 13630 { 13631 ExtraResourceRecord *e = extras; 13632 extras = extras->next; 13633 err = mDNS_AddRecordToService(m, sr, e, e->r.resrec.rdata, e->r.resrec.rroriginalttl, 0); 13634 } 13635 13636 return(err); 13637} 13638 13639// Note: mDNS_DeregisterService calls mDNS_Deregister_internal which can call a user callback, 13640// which may change the record list and/or question list. 13641// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. 13642mDNSexport mStatus mDNS_DeregisterService_drt(mDNS *const m, ServiceRecordSet *sr, mDNS_Dereg_type drt) 13643{ 13644 // If port number is zero, that means this was actually registered using mDNS_RegisterNoSuchService() 13645 if (mDNSIPPortIsZero(sr->RR_SRV.resrec.rdata->u.srv.port)) return(mDNS_DeregisterNoSuchService(m, &sr->RR_SRV)); 13646 13647 if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered) 13648 { 13649 debugf("Service set for %##s already deregistered", sr->RR_SRV.resrec.name->c); 13650 return(mStatus_BadReferenceErr); 13651 } 13652 else if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeDeregistering) 13653 { 13654 LogInfo("Service set for %##s already in the process of deregistering", sr->RR_SRV.resrec.name->c); 13655 // Avoid race condition: 13656 // If a service gets a conflict, then we set the Conflict flag to tell us to generate 13657 // an mStatus_NameConflict message when we get the mStatus_MemFree for our PTR record. 13658 // If the client happens to deregister the service in the middle of that process, then 13659 // we clear the flag back to the normal state, so that we deliver a plain mStatus_MemFree 13660 // instead of incorrectly promoting it to mStatus_NameConflict. 13661 // This race condition is exposed particularly when the conformance test generates 13662 // a whole batch of simultaneous conflicts across a range of services all advertised 13663 // using the same system default name, and if we don't take this precaution then 13664 // we end up incrementing m->nicelabel multiple times instead of just once. 13665 // <rdar://problem/4060169> Bug when auto-renaming Computer Name after name collision 13666 sr->Conflict = mDNSfalse; 13667 return(mStatus_NoError); 13668 } 13669 else 13670 { 13671 mDNSu32 i; 13672 mStatus status; 13673 ExtraResourceRecord *e; 13674 mDNS_Lock(m); 13675 e = sr->Extras; 13676 13677 // We use mDNS_Dereg_repeat because, in the event of a collision, some or all of the 13678 // SRV, TXT, or Extra records could have already been automatically deregistered, and that's okay 13679 mDNS_Deregister_internal(m, &sr->RR_SRV, mDNS_Dereg_repeat); 13680 mDNS_Deregister_internal(m, &sr->RR_TXT, mDNS_Dereg_repeat); 13681 13682 mDNS_Deregister_internal(m, &sr->RR_ADV, drt); 13683 13684 // We deregister all of the extra records, but we leave the sr->Extras list intact 13685 // in case the client wants to do a RenameAndReregister and reinstate the registration 13686 while (e) 13687 { 13688 mDNS_Deregister_internal(m, &e->r, mDNS_Dereg_repeat); 13689 e = e->next; 13690 } 13691 13692 for (i=0; i<sr->NumSubTypes; i++) 13693 mDNS_Deregister_internal(m, &sr->SubTypes[i], drt); 13694 13695 status = mDNS_Deregister_internal(m, &sr->RR_PTR, drt); 13696 mDNS_Unlock(m); 13697 return(status); 13698 } 13699} 13700 13701// Create a registration that asserts that no such service exists with this name. 13702// This can be useful where there is a given function is available through several protocols. 13703// For example, a printer called "Stuart's Printer" may implement printing via the "pdl-datastream" and "IPP" 13704// protocols, but not via "LPR". In this case it would be prudent for the printer to assert the non-existence of an 13705// "LPR" service called "Stuart's Printer". Without this precaution, another printer than offers only "LPR" printing 13706// could inadvertently advertise its service under the same name "Stuart's Printer", which might be confusing for users. 13707mDNSexport mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr, 13708 const domainlabel *const name, const domainname *const type, const domainname *const domain, 13709 const domainname *const host, 13710 const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context, mDNSu32 flags) 13711{ 13712 AuthRecType artype; 13713 13714 artype = setAuthRecType(InterfaceID, flags); 13715 13716 mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kHostNameTTL, kDNSRecordTypeUnique, artype, Callback, Context); 13717 if (ConstructServiceName(&rr->namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr); 13718 rr->resrec.rdata->u.srv.priority = 0; 13719 rr->resrec.rdata->u.srv.weight = 0; 13720 rr->resrec.rdata->u.srv.port = zeroIPPort; 13721 if (host && host->c[0]) AssignDomainName(&rr->resrec.rdata->u.srv.target, host); 13722 else rr->AutoTarget = Target_AutoHost; 13723 return(mDNS_Register(m, rr)); 13724} 13725 13726mDNSexport mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr, 13727 mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname) 13728{ 13729 AuthRecType artype; 13730 13731 if (InterfaceID == mDNSInterface_LocalOnly) 13732 artype = AuthRecordLocalOnly; 13733 else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE) 13734 artype = AuthRecordP2P; 13735 else 13736 artype = AuthRecordAny; 13737 mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, mDNSNULL, mDNSNULL); 13738 if (!MakeDomainNameFromDNSNameString(&rr->namestorage, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr); 13739 if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr); 13740 return(mDNS_Register(m, rr)); 13741} 13742 13743mDNSlocal mDNSBool mDNS_IdUsedInResourceRecordsList(mDNS * const m, mDNSOpaque16 id) 13744{ 13745 AuthRecord *r; 13746 for (r = m->ResourceRecords; r; r=r->next) if (mDNSSameOpaque16(id, r->updateid)) return mDNStrue; 13747 return mDNSfalse; 13748} 13749 13750mDNSlocal mDNSBool mDNS_IdUsedInQuestionsList(mDNS * const m, mDNSOpaque16 id) 13751{ 13752 DNSQuestion *q; 13753 for (q = m->Questions; q; q=q->next) if (mDNSSameOpaque16(id, q->TargetQID)) return mDNStrue; 13754 return mDNSfalse; 13755} 13756 13757mDNSexport mDNSOpaque16 mDNS_NewMessageID(mDNS * const m) 13758{ 13759 mDNSOpaque16 id; 13760 int i; 13761 13762 for (i=0; i<10; i++) 13763 { 13764 id = mDNSOpaque16fromIntVal(1 + (mDNSu16)mDNSRandom(0xFFFE)); 13765 if (!mDNS_IdUsedInResourceRecordsList(m, id) && !mDNS_IdUsedInQuestionsList(m, id)) break; 13766 } 13767 13768 debugf("mDNS_NewMessageID: %5d", mDNSVal16(id)); 13769 13770 return id; 13771} 13772 13773// *************************************************************************** 13774#if COMPILER_LIKES_PRAGMA_MARK 13775#pragma mark - 13776#pragma mark - Sleep Proxy Server 13777#endif 13778 13779mDNSlocal void RestartARPProbing(mDNS *const m, AuthRecord *const rr) 13780{ 13781 // If we see an ARP from a machine we think is sleeping, then either 13782 // (i) the machine has woken, or 13783 // (ii) it's just a stray old packet from before the machine slept 13784 // To handle the second case, we reset ProbeCount, so we'll suppress our own answers for a while, to avoid 13785 // generating ARP conflicts with a waking machine, and set rr->LastAPTime so we'll start probing again in 10 seconds. 13786 // If the machine has just woken then we'll discard our records when we see the first new mDNS probe from that machine. 13787 // If it was a stray old packet, then after 10 seconds we'll probe again and then start answering ARPs again. In this case we *do* 13788 // need to send new ARP Announcements, because the owner's ARP broadcasts will have updated neighboring ARP caches, so we need to 13789 // re-assert our (temporary) ownership of that IP address in order to receive subsequent packets addressed to that IPv4 address. 13790 13791 rr->resrec.RecordType = kDNSRecordTypeUnique; 13792 rr->ProbeCount = DefaultProbeCountForTypeUnique; 13793 rr->ProbeRestartCount++; 13794 13795 // If we haven't started announcing yet (and we're not already in ten-second-delay mode) the machine is probably 13796 // still going to sleep, so we just reset rr->ProbeCount so we'll continue probing until it stops responding. 13797 // If we *have* started announcing, the machine is probably in the process of waking back up, so in that case 13798 // we're more cautious and we wait ten seconds before probing it again. We do this because while waking from 13799 // sleep, some network interfaces tend to lose or delay inbound packets, and without this delay, if the waking machine 13800 // didn't answer our three probes within three seconds then we'd announce and cause it an unnecessary address conflict. 13801 if (rr->AnnounceCount == InitialAnnounceCount && m->timenow - rr->LastAPTime >= 0) 13802 InitializeLastAPTime(m, rr); 13803 else 13804 { 13805 rr->AnnounceCount = InitialAnnounceCount; 13806 rr->ThisAPInterval = mDNSPlatformOneSecond; 13807 rr->LastAPTime = m->timenow + mDNSPlatformOneSecond * 9; // Send first packet at rr->LastAPTime + rr->ThisAPInterval, i.e. 10 seconds from now 13808 SetNextAnnounceProbeTime(m, rr); 13809 } 13810} 13811 13812mDNSlocal void mDNSCoreReceiveRawARP(mDNS *const m, const ARP_EthIP *const arp, const mDNSInterfaceID InterfaceID) 13813{ 13814 static const mDNSOpaque16 ARP_op_request = { { 0, 1 } }; 13815 AuthRecord *rr; 13816 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 13817 if (!intf) return; 13818 13819 mDNS_Lock(m); 13820 13821 // Pass 1: 13822 // Process ARP Requests and Probes (but not Announcements), and generate an ARP Reply if necessary. 13823 // We also process ARPs from our own kernel (and 'answer' them by injecting a local ARP table entry) 13824 // We ignore ARP Announcements here -- Announcements are not questions, they're assertions, so we don't need to answer them. 13825 // The times we might need to react to an ARP Announcement are: 13826 // (i) as an indication that the host in question has not gone to sleep yet (so we should delay beginning to proxy for it) or 13827 // (ii) if it's a conflicting Announcement from another host 13828 // -- and we check for these in Pass 2 below. 13829 if (mDNSSameOpaque16(arp->op, ARP_op_request) && !mDNSSameIPv4Address(arp->spa, arp->tpa)) 13830 { 13831 for (rr = m->ResourceRecords; rr; rr=rr->next) 13832 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && 13833 rr->AddressProxy.type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->AddressProxy.ip.v4, arp->tpa)) 13834 { 13835 static const char msg1[] = "ARP Req from owner -- re-probing"; 13836 static const char msg2[] = "Ignoring ARP Request from "; 13837 static const char msg3[] = "Creating Local ARP Cache entry "; 13838 static const char msg4[] = "Answering ARP Request from "; 13839 const char *const msg = mDNSSameEthAddress(&arp->sha, &rr->WakeUp.IMAC) ? msg1 : 13840 (rr->AnnounceCount == InitialAnnounceCount) ? msg2 : 13841 mDNSSameEthAddress(&arp->sha, &intf->MAC) ? msg3 : msg4; 13842 LogMsg("Arp %-7s %s %.6a %.4a for %.4a -- H-MAC %.6a I-MAC %.6a %s", 13843 intf->ifname, msg, arp->sha.b, arp->spa.b, arp->tpa.b, 13844 &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 13845 if (msg == msg1) 13846 { 13847 if ( rr->ProbeRestartCount < MAX_PROBE_RESTARTS) 13848 RestartARPProbing(m, rr); 13849 else 13850 LogSPS("Reached maximum number of restarts for probing - %s", ARDisplayString(m,rr)); 13851 } 13852 else if (msg == msg3) 13853 { 13854 mDNSPlatformSetLocalAddressCacheEntry(&rr->AddressProxy, &rr->WakeUp.IMAC, InterfaceID); 13855 } 13856 else if (msg == msg4) 13857 { 13858 SendARP(m, 2, rr, (mDNSv4Addr *)arp->tpa.b, &arp->sha, (mDNSv4Addr *)arp->spa.b, &arp->sha); 13859 } 13860 } 13861 } 13862 13863 // Pass 2: 13864 // For all types of ARP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding. 13865 // (Strictly speaking we're only checking Announcement/Request/Reply packets, since ARP Probes have zero Sender IP address, 13866 // so by definition (and by design) they can never conflict with any real (i.e. non-zero) IP address). 13867 // We ignore ARPs we sent ourselves (Sender MAC address is our MAC address) because our own proxy ARPs do not constitute a conflict that we need to handle. 13868 // If we see an apparently conflicting ARP, we check the sender hardware address: 13869 // If the sender hardware address is the original owner this is benign, so we just suppress our own proxy answering for a while longer. 13870 // If the sender hardware address is *not* the original owner, then this is a conflict, and we need to wake the sleeping machine to handle it. 13871 if (mDNSSameEthAddress(&arp->sha, &intf->MAC)) 13872 debugf("ARP from self for %.4a", arp->tpa.b); 13873 else 13874 { 13875 if (!mDNSSameIPv4Address(arp->spa, zerov4Addr)) 13876 for (rr = m->ResourceRecords; rr; rr=rr->next) 13877 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && 13878 rr->AddressProxy.type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->AddressProxy.ip.v4, arp->spa) && (rr->ProbeRestartCount < MAX_PROBE_RESTARTS)) 13879 { 13880 if (mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC)) 13881 { 13882 LogMsg("%-7s ARP from %.6a %.4a for %.4a -- Invalid H-MAC %.6a I-MAC %.6a %s", intf->ifname, 13883 arp->sha.b, arp->spa.b, arp->tpa.b, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 13884 } 13885 else 13886 { 13887 RestartARPProbing(m, rr); 13888 if (mDNSSameEthAddress(&arp->sha, &rr->WakeUp.IMAC)) 13889 { 13890 LogMsg("%-7s ARP %s from owner %.6a %.4a for %-15.4a -- re-starting probing for %s", intf->ifname, 13891 mDNSSameIPv4Address(arp->spa, arp->tpa) ? "Announcement " : mDNSSameOpaque16(arp->op, ARP_op_request) ? "Request " : "Response ", 13892 arp->sha.b, arp->spa.b, arp->tpa.b, ARDisplayString(m, rr)); 13893 } 13894 else 13895 { 13896 LogMsg("%-7s Conflicting ARP from %.6a %.4a for %.4a -- waking H-MAC %.6a I-MAC %.6a %s", intf->ifname, 13897 arp->sha.b, arp->spa.b, arp->tpa.b, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 13898 ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC); 13899 } 13900 } 13901 } 13902 } 13903 13904 mDNS_Unlock(m); 13905} 13906 13907/* 13908 // Option 1 is Source Link Layer Address Option 13909 // Option 2 is Target Link Layer Address Option 13910 mDNSlocal const mDNSEthAddr *GetLinkLayerAddressOption(const IPv6NDP *const ndp, const mDNSu8 *const end, mDNSu8 op) 13911 { 13912 const mDNSu8 *options = (mDNSu8 *)(ndp+1); 13913 while (options < end) 13914 { 13915 debugf("NDP Option %02X len %2d %d", options[0], options[1], end - options); 13916 if (options[0] == op && options[1] == 1) return (const mDNSEthAddr*)(options+2); 13917 options += options[1] * 8; 13918 } 13919 return mDNSNULL; 13920 } 13921 */ 13922 13923mDNSlocal void mDNSCoreReceiveRawND(mDNS *const m, const mDNSEthAddr *const sha, const mDNSv6Addr *spa, 13924 const IPv6NDP *const ndp, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID) 13925{ 13926 AuthRecord *rr; 13927 NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); 13928 if (!intf) return; 13929 13930 mDNS_Lock(m); 13931 13932 // Pass 1: Process Neighbor Solicitations, and generate a Neighbor Advertisement if necessary. 13933 if (ndp->type == NDP_Sol) 13934 { 13935 //const mDNSEthAddr *const sha = GetLinkLayerAddressOption(ndp, end, NDP_SrcLL); 13936 (void)end; 13937 for (rr = m->ResourceRecords; rr; rr=rr->next) 13938 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && 13939 rr->AddressProxy.type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->AddressProxy.ip.v6, ndp->target)) 13940 { 13941 static const char msg1[] = "NDP Req from owner -- re-probing"; 13942 static const char msg2[] = "Ignoring NDP Request from "; 13943 static const char msg3[] = "Creating Local NDP Cache entry "; 13944 static const char msg4[] = "Answering NDP Request from "; 13945 static const char msg5[] = "Answering NDP Probe from "; 13946 const char *const msg = sha && mDNSSameEthAddress(sha, &rr->WakeUp.IMAC) ? msg1 : 13947 (rr->AnnounceCount == InitialAnnounceCount) ? msg2 : 13948 sha && mDNSSameEthAddress(sha, &intf->MAC) ? msg3 : 13949 spa && mDNSIPv6AddressIsZero(*spa) ? msg4 : msg5; 13950 LogSPS("%-7s %s %.6a %.16a for %.16a -- H-MAC %.6a I-MAC %.6a %s", 13951 intf->ifname, msg, sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 13952 if (msg == msg1) 13953 { 13954 if (rr->ProbeRestartCount < MAX_PROBE_RESTARTS) 13955 RestartARPProbing(m, rr); 13956 else 13957 LogSPS("Reached maximum number of restarts for probing - %s", ARDisplayString(m,rr)); 13958 } 13959 else if (msg == msg3) 13960 mDNSPlatformSetLocalAddressCacheEntry(&rr->AddressProxy, &rr->WakeUp.IMAC, InterfaceID); 13961 else if (msg == msg4) 13962 SendNDP(m, NDP_Adv, NDP_Solicited, rr, &ndp->target, mDNSNULL, spa, sha); 13963 else if (msg == msg5) 13964 SendNDP(m, NDP_Adv, 0, rr, &ndp->target, mDNSNULL, &AllHosts_v6, &AllHosts_v6_Eth); 13965 } 13966 } 13967 13968 // Pass 2: For all types of NDP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding. 13969 if (mDNSSameEthAddress(sha, &intf->MAC)) 13970 debugf("NDP from self for %.16a", &ndp->target); 13971 else 13972 { 13973 // For Neighbor Advertisements we check the Target address field, not the actual IPv6 source address. 13974 // When a machine has both link-local and routable IPv6 addresses, it may send NDP packets making assertions 13975 // about its routable IPv6 address, using its link-local address as the source address for all NDP packets. 13976 // Hence it is the NDP target address we care about, not the actual packet source address. 13977 if (ndp->type == NDP_Adv) spa = &ndp->target; 13978 if (!mDNSSameIPv6Address(*spa, zerov6Addr)) 13979 for (rr = m->ResourceRecords; rr; rr=rr->next) 13980 if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && 13981 rr->AddressProxy.type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->AddressProxy.ip.v6, *spa) && (rr->ProbeRestartCount < MAX_PROBE_RESTARTS)) 13982 { 13983 if (mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC)) 13984 { 13985 LogSPS("%-7s NDP from %.6a %.16a for %.16a -- Invalid H-MAC %.6a I-MAC %.6a %s", intf->ifname, 13986 sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 13987 } 13988 else 13989 { 13990 RestartARPProbing(m, rr); 13991 if (mDNSSameEthAddress(sha, &rr->WakeUp.IMAC)) 13992 { 13993 LogSPS("%-7s NDP %s from owner %.6a %.16a for %.16a -- re-starting probing for %s", intf->ifname, 13994 ndp->type == NDP_Sol ? "Solicitation " : "Advertisement", sha, spa, &ndp->target, ARDisplayString(m, rr)); 13995 } 13996 else 13997 { 13998 LogMsg("%-7s Conflicting NDP from %.6a %.16a for %.16a -- waking H-MAC %.6a I-MAC %.6a %s", intf->ifname, 13999 sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); 14000 ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC); 14001 } 14002 } 14003 } 14004 } 14005 14006 mDNS_Unlock(m); 14007} 14008 14009mDNSlocal void mDNSCoreReceiveRawTransportPacket(mDNS *const m, const mDNSEthAddr *const sha, const mDNSAddr *const src, const mDNSAddr *const dst, const mDNSu8 protocol, 14010 const mDNSu8 *const p, const TransportLayerPacket *const t, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID, const mDNSu16 len) 14011{ 14012 const mDNSIPPort port = (protocol == 0x06) ? t->tcp.dst : (protocol == 0x11) ? t->udp.dst : zeroIPPort; 14013 mDNSBool wake = mDNSfalse; 14014 mDNSBool kaWake = mDNSfalse; 14015 14016 switch (protocol) 14017 { 14018 #define XX wake ? "Received" : "Ignoring", end-p 14019 case 0x01: LogSPS("Ignoring %d-byte ICMP from %#a to %#a", end-p, src, dst); 14020 break; 14021 14022 case 0x06: { 14023 AuthRecord *kr; 14024 mDNSu32 seq, ack; 14025 #define TH_FIN 0x01 14026 #define TH_SYN 0x02 14027 #define TH_RST 0x04 14028 #define TH_ACK 0x10 14029 14030 kr = mDNS_MatchKeepaliveInfo(m, dst, src, port, t->tcp.src, &seq, &ack); 14031 if (kr) 14032 { 14033 LogSPS("mDNSCoreReceiveRawTransportPacket: Found a Keepalive record from %#a:%d to %#a:%d", src, mDNSVal16(t->tcp.src), dst, mDNSVal16(port)); 14034 // Plan to wake if 14035 // (a) RST or FIN is set (the keepalive that we sent could have caused a reset) 14036 // (b) packet that contains new data and acks a sequence number higher than the one 14037 // we have been sending in the keepalive 14038 14039 wake = ((t->tcp.flags & TH_RST) || (t->tcp.flags & TH_FIN)) ; 14040 if (!wake) 14041 { 14042 mDNSu8 *ptr; 14043 mDNSu32 pseq, pack; 14044 mDNSBool data = mDNSfalse; 14045 mDNSu8 tcphlen; 14046 14047 // Convert to host order 14048 ptr = (mDNSu8 *)&seq; 14049 seq = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; 14050 14051 ptr = (mDNSu8 *)&ack; 14052 ack = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; 14053 14054 pseq = t->tcp.seq; 14055 ptr = (mDNSu8 *)&pseq; 14056 pseq = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; 14057 14058 pack = t->tcp.ack; 14059 ptr = (mDNSu8 *)&pack; 14060 pack = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; 14061 14062 // If the other side is acking one more than our sequence number (keepalive is one 14063 // less than the last valid sequence sent) and it's sequence is more than what we 14064 // acked before 14065 //if (end - p - 34 - ((t->tcp.offset >> 4) * 4) > 0) data = mDNStrue; 14066 tcphlen = ((t->tcp.offset >> 4) * 4); 14067 if (end - ((mDNSu8 *)t + tcphlen) > 0) data = mDNStrue; 14068 wake = ((int)(pack - seq) > 0) && ((int)(pseq - ack) >= 0) && data; 14069 14070 // If we got a regular keepalive on a connection that was registed with the KeepAlive API, respond with an ACK 14071 if ((t->tcp.flags & TH_ACK) && (data == mDNSfalse) && 14072 ((int)(ack - pseq) == 1)) 14073 { 14074 // Send an ACK; 14075 mDNS_SendKeepaliveACK(m, kr); 14076 } 14077 LogSPS("mDNSCoreReceiveRawTransportPacket: End %p, hlen %d, Datalen %d, pack %u, seq %u, pseq %u, ack %u, wake %d", 14078 end, tcphlen, end - ((mDNSu8 *)t + tcphlen), pack, seq, pseq, ack, wake); 14079 } 14080 else { LogSPS("mDNSCoreReceiveRawTransportPacket: waking because of RST or FIN th_flags %d", t->tcp.flags); } 14081 kaWake = wake; 14082 } 14083 else 14084 { 14085 // Plan to wake if 14086 // (a) RST is not set, AND 14087 // (b) packet is SYN, SYN+FIN, or plain data packet (no SYN or FIN). We won't wake for FIN alone. 14088 wake = (!(t->tcp.flags & TH_RST) && (t->tcp.flags & (TH_FIN|TH_SYN)) != TH_FIN); 14089 14090 // For now, to reduce spurious wakeups, we wake only for TCP SYN, 14091 // except for ssh connections, where we'll wake for plain data packets too 14092 if (!mDNSSameIPPort(port, SSHPort) && !(t->tcp.flags & 2)) wake = mDNSfalse; 14093 14094 LogSPS("%s %d-byte TCP from %#a:%d to %#a:%d%s%s%s", XX, 14095 src, mDNSVal16(t->tcp.src), dst, mDNSVal16(port), 14096 (t->tcp.flags & 2) ? " SYN" : "", 14097 (t->tcp.flags & 1) ? " FIN" : "", 14098 (t->tcp.flags & 4) ? " RST" : ""); 14099 } 14100 break; 14101 } 14102 14103 case 0x11: { 14104 #define ARD_AsNumber 3283 14105 static const mDNSIPPort ARD = { { ARD_AsNumber >> 8, ARD_AsNumber & 0xFF } }; 14106 const mDNSu16 udplen = (mDNSu16)((mDNSu16)t->bytes[4] << 8 | t->bytes[5]); // Length *including* 8-byte UDP header 14107 if (udplen >= sizeof(UDPHeader)) 14108 { 14109 const mDNSu16 datalen = udplen - sizeof(UDPHeader); 14110 wake = mDNStrue; 14111 14112 // For Back to My Mac UDP port 4500 (IPSEC) packets, we do some special handling 14113 if (mDNSSameIPPort(port, IPSECPort)) 14114 { 14115 // Specifically ignore NAT keepalive packets 14116 if (datalen == 1 && end >= &t->bytes[9] && t->bytes[8] == 0xFF) wake = mDNSfalse; 14117 else 14118 { 14119 // Skip over the Non-ESP Marker if present 14120 const mDNSBool NonESP = (end >= &t->bytes[12] && t->bytes[8] == 0 && t->bytes[9] == 0 && t->bytes[10] == 0 && t->bytes[11] == 0); 14121 const IKEHeader *const ike = (IKEHeader *)(t + (NonESP ? 12 : 8)); 14122 const mDNSu16 ikelen = datalen - (NonESP ? 4 : 0); 14123 if (ikelen >= sizeof(IKEHeader) && end >= ((mDNSu8 *)ike) + sizeof(IKEHeader)) 14124 if ((ike->Version & 0x10) == 0x10) 14125 { 14126 // ExchangeType == 5 means 'Informational' <http://www.ietf.org/rfc/rfc2408.txt> 14127 // ExchangeType == 34 means 'IKE_SA_INIT' <http://www.iana.org/assignments/ikev2-parameters> 14128 if (ike->ExchangeType == 5 || ike->ExchangeType == 34) wake = mDNSfalse; 14129 LogSPS("%s %d-byte IKE ExchangeType %d", XX, ike->ExchangeType); 14130 } 14131 } 14132 } 14133 14134 // For now, because we haven't yet worked out a clean elegant way to do this, we just special-case the 14135 // Apple Remote Desktop port number -- we ignore all packets to UDP 3283 (the "Net Assistant" port), 14136 // except for Apple Remote Desktop's explicit manual wakeup packet, which looks like this: 14137 // UDP header (8 bytes) 14138 // Payload: 13 88 00 6a 41 4e 41 20 (8 bytes) ffffffffffff (6 bytes) 16xMAC (96 bytes) = 110 bytes total 14139 if (mDNSSameIPPort(port, ARD)) wake = (datalen >= 110 && end >= &t->bytes[10] && t->bytes[8] == 0x13 && t->bytes[9] == 0x88); 14140 14141 LogSPS("%s %d-byte UDP from %#a:%d to %#a:%d", XX, src, mDNSVal16(t->udp.src), dst, mDNSVal16(port)); 14142 } 14143 } 14144 break; 14145 14146 case 0x3A: if (&t->bytes[len] <= end) 14147 { 14148 mDNSu16 checksum = IPv6CheckSum(&src->ip.v6, &dst->ip.v6, protocol, t->bytes, len); 14149 if (!checksum) mDNSCoreReceiveRawND(m, sha, &src->ip.v6, &t->ndp, &t->bytes[len], InterfaceID); 14150 else LogInfo("IPv6CheckSum bad %04X %02X%02X from %#a to %#a", checksum, t->bytes[2], t->bytes[3], src, dst); 14151 } 14152 break; 14153 14154 default: LogSPS("Ignoring %d-byte IP packet unknown protocol %d from %#a to %#a", end-p, protocol, src, dst); 14155 break; 14156 } 14157 14158 if (wake) 14159 { 14160 AuthRecord *rr, *r2; 14161 14162 mDNS_Lock(m); 14163 for (rr = m->ResourceRecords; rr; rr=rr->next) 14164 if (rr->resrec.InterfaceID == InterfaceID && 14165 rr->resrec.RecordType != kDNSRecordTypeDeregistering && 14166 rr->AddressProxy.type && mDNSSameAddress(&rr->AddressProxy, dst)) 14167 { 14168 const mDNSu8 *const tp = (protocol == 6) ? (const mDNSu8 *)"\x4_tcp" : (const mDNSu8 *)"\x4_udp"; 14169 for (r2 = m->ResourceRecords; r2; r2=r2->next) 14170 if (r2->resrec.InterfaceID == InterfaceID && mDNSSameEthAddress(&r2->WakeUp.HMAC, &rr->WakeUp.HMAC) && 14171 r2->resrec.RecordType != kDNSRecordTypeDeregistering && 14172 r2->resrec.rrtype == kDNSType_SRV && mDNSSameIPPort(r2->resrec.rdata->u.srv.port, port) && 14173 SameDomainLabel(ThirdLabel(r2->resrec.name)->c, tp)) 14174 break; 14175 if (!r2 && mDNSSameIPPort(port, IPSECPort)) r2 = rr; // So that we wake for BTMM IPSEC packets, even without a matching SRV record 14176 if (!r2 && kaWake) r2 = rr; // So that we wake for keepalive packets, even without a matching SRV record 14177 if (r2) 14178 { 14179 LogMsg("Waking host at %s %#a H-MAC %.6a I-MAC %.6a for %s", 14180 InterfaceNameForID(m, rr->resrec.InterfaceID), dst, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, r2)); 14181 ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC); 14182 } 14183 else 14184 LogSPS("Sleeping host at %s %#a %.6a has no service on %#s %d", 14185 InterfaceNameForID(m, rr->resrec.InterfaceID), dst, &rr->WakeUp.HMAC, tp, mDNSVal16(port)); 14186 } 14187 mDNS_Unlock(m); 14188 } 14189} 14190 14191mDNSexport void mDNSCoreReceiveRawPacket(mDNS *const m, const mDNSu8 *const p, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID) 14192{ 14193 static const mDNSOpaque16 Ethertype_ARP = { { 0x08, 0x06 } }; // Ethertype 0x0806 = ARP 14194 static const mDNSOpaque16 Ethertype_IPv4 = { { 0x08, 0x00 } }; // Ethertype 0x0800 = IPv4 14195 static const mDNSOpaque16 Ethertype_IPv6 = { { 0x86, 0xDD } }; // Ethertype 0x86DD = IPv6 14196 static const mDNSOpaque16 ARP_hrd_eth = { { 0x00, 0x01 } }; // Hardware address space (Ethernet = 1) 14197 static const mDNSOpaque16 ARP_pro_ip = { { 0x08, 0x00 } }; // Protocol address space (IP = 0x0800) 14198 14199 // Note: BPF guarantees that the NETWORK LAYER header will be word aligned, not the link-layer header. 14200 // In other words, we can safely assume that pkt below (ARP, IPv4 or IPv6) is properly word aligned, 14201 // but if pkt is 4-byte aligned, that necessarily means that eth CANNOT also be 4-byte aligned 14202 // since it points to a an address 14 bytes before pkt. 14203 const EthernetHeader *const eth = (const EthernetHeader *)p; 14204 const NetworkLayerPacket *const pkt = (const NetworkLayerPacket *)(eth+1); 14205 mDNSAddr src, dst; 14206 #define RequiredCapLen(P) ((P)==0x01 ? 4 : (P)==0x06 ? 20 : (P)==0x11 ? 8 : (P)==0x3A ? 24 : 0) 14207 14208 // Is ARP? Length must be at least 14 + 28 = 42 bytes 14209 if (end >= p+42 && mDNSSameOpaque16(eth->ethertype, Ethertype_ARP) && mDNSSameOpaque16(pkt->arp.hrd, ARP_hrd_eth) && mDNSSameOpaque16(pkt->arp.pro, ARP_pro_ip)) 14210 mDNSCoreReceiveRawARP(m, &pkt->arp, InterfaceID); 14211 // Is IPv4 with zero fragmentation offset? Length must be at least 14 + 20 = 34 bytes 14212 else if (end >= p+34 && mDNSSameOpaque16(eth->ethertype, Ethertype_IPv4) && (pkt->v4.flagsfrags.b[0] & 0x1F) == 0 && pkt->v4.flagsfrags.b[1] == 0) 14213 { 14214 const mDNSu8 *const trans = p + 14 + (pkt->v4.vlen & 0xF) * 4; 14215 const mDNSu8 * transEnd = p + 14 + mDNSVal16(pkt->v4.totlen); 14216 if (transEnd > end) transEnd = end; 14217 debugf("Got IPv4 %02X from %.4a to %.4a", pkt->v4.protocol, &pkt->v4.src, &pkt->v4.dst); 14218 src.type = mDNSAddrType_IPv4; src.ip.v4 = pkt->v4.src; 14219 dst.type = mDNSAddrType_IPv4; dst.ip.v4 = pkt->v4.dst; 14220 if (transEnd >= trans + RequiredCapLen(pkt->v4.protocol)) 14221 mDNSCoreReceiveRawTransportPacket(m, ð->src, &src, &dst, pkt->v4.protocol, p, (TransportLayerPacket*)trans, transEnd, InterfaceID, 0); 14222 } 14223 // Is IPv6? Length must be at least 14 + 28 = 42 bytes 14224 else if (end >= p+54 && mDNSSameOpaque16(eth->ethertype, Ethertype_IPv6)) 14225 { 14226 const mDNSu8 *const trans = p + 54; 14227 debugf("Got IPv6 %02X from %.16a to %.16a", pkt->v6.pro, &pkt->v6.src, &pkt->v6.dst); 14228 src.type = mDNSAddrType_IPv6; src.ip.v6 = pkt->v6.src; 14229 dst.type = mDNSAddrType_IPv6; dst.ip.v6 = pkt->v6.dst; 14230 if (end >= trans + RequiredCapLen(pkt->v6.pro)) 14231 mDNSCoreReceiveRawTransportPacket(m, ð->src, &src, &dst, pkt->v6.pro, p, (TransportLayerPacket*)trans, end, InterfaceID, 14232 (mDNSu16)pkt->bytes[4] << 8 | pkt->bytes[5]); 14233 } 14234} 14235 14236mDNSlocal void ConstructSleepProxyServerName(mDNS *const m, domainlabel *name) 14237{ 14238 name->c[0] = (mDNSu8)mDNS_snprintf((char*)name->c+1, 62, "%d-%d-%d-%d.%d %#s", 14239 m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower, m->SPSFeatureFlags, &m->nicelabel); 14240} 14241 14242#ifndef SPC_DISABLED 14243mDNSlocal void SleepProxyServerCallback(mDNS *const m, ServiceRecordSet *const srs, mStatus result) 14244{ 14245 if (result == mStatus_NameConflict) 14246 mDNS_RenameAndReregisterService(m, srs, mDNSNULL); 14247 else if (result == mStatus_MemFree) 14248 { 14249 if (m->SleepState) 14250 m->SPSState = 3; 14251 else 14252 { 14253 m->SPSState = (mDNSu8)(m->SPSSocket != mDNSNULL); 14254 if (m->SPSState) 14255 { 14256 domainlabel name; 14257 ConstructSleepProxyServerName(m, &name); 14258 mDNS_RegisterService(m, srs, 14259 &name, &SleepProxyServiceType, &localdomain, 14260 mDNSNULL, m->SPSSocket->port, // Host, port 14261 (mDNSu8 *)"", 1, // TXT data, length 14262 mDNSNULL, 0, // Subtypes (none) 14263 mDNSInterface_Any, // Interface ID 14264 SleepProxyServerCallback, mDNSNULL, 0); // Callback, context, flags 14265 } 14266 LogSPS("Sleep Proxy Server %#s %s", srs->RR_SRV.resrec.name->c, m->SPSState ? "started" : "stopped"); 14267 } 14268 } 14269} 14270#endif 14271 14272// Called with lock held 14273mDNSexport void mDNSCoreBeSleepProxyServer_internal(mDNS *const m, mDNSu8 sps, mDNSu8 port, mDNSu8 marginalpower, mDNSu8 totpower, mDNSu8 features) 14274{ 14275 // This routine uses mDNS_DeregisterService and calls SleepProxyServerCallback, so we execute in user callback context 14276 mDNS_DropLockBeforeCallback(); 14277 14278 // If turning off SPS, close our socket 14279 // (Do this first, BEFORE calling mDNS_DeregisterService below) 14280 if (!sps && m->SPSSocket) { mDNSPlatformUDPClose(m->SPSSocket); m->SPSSocket = mDNSNULL; } 14281 14282 // If turning off, or changing type, deregister old name 14283#ifndef SPC_DISABLED 14284 if (m->SPSState == 1 && sps != m->SPSType) 14285 { m->SPSState = 2; mDNS_DeregisterService_drt(m, &m->SPSRecords, sps ? mDNS_Dereg_rapid : mDNS_Dereg_normal); } 14286#endif // SPC_DISABLED 14287 14288 // Record our new SPS parameters 14289 m->SPSType = sps; 14290 m->SPSPortability = port; 14291 m->SPSMarginalPower = marginalpower; 14292 m->SPSTotalPower = totpower; 14293 m->SPSFeatureFlags = features; 14294 // If turning on, open socket and advertise service 14295 if (sps) 14296 { 14297 if (!m->SPSSocket) 14298 { 14299 m->SPSSocket = mDNSPlatformUDPSocket(zeroIPPort); 14300 if (!m->SPSSocket) { LogMsg("mDNSCoreBeSleepProxyServer: Failed to allocate SPSSocket"); goto fail; } 14301 } 14302#ifndef SPC_DISABLED 14303 if (m->SPSState == 0) SleepProxyServerCallback(m, &m->SPSRecords, mStatus_MemFree); 14304#endif // SPC_DISABLED 14305 } 14306 else if (m->SPSState) 14307 { 14308 LogSPS("mDNSCoreBeSleepProxyServer turning off from state %d; will wake clients", m->SPSState); 14309 m->NextScheduledSPS = m->timenow; 14310 } 14311fail: 14312 mDNS_ReclaimLockAfterCallback(); 14313} 14314 14315// *************************************************************************** 14316#if COMPILER_LIKES_PRAGMA_MARK 14317#pragma mark - 14318#pragma mark - Startup and Shutdown 14319#endif 14320 14321mDNSlocal void mDNS_GrowCache_internal(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords) 14322{ 14323 if (storage && numrecords) 14324 { 14325 mDNSu32 i; 14326 debugf("Adding cache storage for %d more records (%d bytes)", numrecords, numrecords*sizeof(CacheEntity)); 14327 for (i=0; i<numrecords; i++) storage[i].next = &storage[i+1]; 14328 storage[numrecords-1].next = m->rrcache_free; 14329 m->rrcache_free = storage; 14330 m->rrcache_size += numrecords; 14331 } 14332} 14333 14334mDNSexport void mDNS_GrowCache(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords) 14335{ 14336 mDNS_Lock(m); 14337 mDNS_GrowCache_internal(m, storage, numrecords); 14338 mDNS_Unlock(m); 14339} 14340 14341mDNSlocal mStatus mDNS_InitStorage(mDNS *const m, mDNS_PlatformSupport *const p, 14342 CacheEntity *rrcachestorage, mDNSu32 rrcachesize, 14343 mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context) 14344{ 14345 mDNSu32 slot; 14346 mDNSs32 timenow; 14347 mStatus result; 14348 14349 if (!rrcachestorage) rrcachesize = 0; 14350 14351 m->p = p; 14352 m->NetworkChanged = 0; 14353 m->CanReceiveUnicastOn5353 = mDNSfalse; // Assume we can't receive unicasts on 5353, unless platform layer tells us otherwise 14354 m->AdvertiseLocalAddresses = AdvertiseLocalAddresses; 14355 m->DivertMulticastAdvertisements = mDNSfalse; 14356 m->mDNSPlatformStatus = mStatus_Waiting; 14357 m->UnicastPort4 = zeroIPPort; 14358 m->UnicastPort6 = zeroIPPort; 14359 m->PrimaryMAC = zeroEthAddr; 14360 m->MainCallback = Callback; 14361 m->MainContext = Context; 14362 m->rec.r.resrec.RecordType = 0; 14363 m->rec.r.resrec.AnonInfo = mDNSNULL; 14364 14365 // For debugging: To catch and report locking failures 14366 m->mDNS_busy = 0; 14367 m->mDNS_reentrancy = 0; 14368 m->ShutdownTime = 0; 14369 m->lock_rrcache = 0; 14370 m->lock_Questions = 0; 14371 m->lock_Records = 0; 14372 14373 // Task Scheduling variables 14374 result = mDNSPlatformTimeInit(); 14375 if (result != mStatus_NoError) return(result); 14376 m->timenow_adjust = (mDNSs32)mDNSRandom(0xFFFFFFFF); 14377 timenow = mDNS_TimeNow_NoLock(m); 14378 14379 m->timenow = 0; // MUST only be set within mDNS_Lock/mDNS_Unlock section 14380 m->timenow_last = timenow; 14381 m->NextScheduledEvent = timenow; 14382 m->SuppressSending = timenow; 14383 m->NextCacheCheck = timenow + FutureTime; 14384 m->NextScheduledQuery = timenow + FutureTime; 14385 m->NextScheduledProbe = timenow + FutureTime; 14386 m->NextScheduledResponse = timenow + FutureTime; 14387 m->NextScheduledNATOp = timenow + FutureTime; 14388 m->NextScheduledSPS = timenow + FutureTime; 14389 m->NextScheduledKA = timenow + FutureTime; 14390 m->NextScheduledStopTime = timenow + FutureTime; 14391 m->NextBLEServiceTime = 0; // zero indicates inactive 14392 14393#if BONJOUR_ON_DEMAND 14394 m->NextBonjourDisableTime = 0; // Timer active when non zero. 14395 m->BonjourEnabled = 0; // Set when Bonjour on Demand is enabled and Bonjour is currently enabled. 14396#endif // BONJOUR_ON_DEMAND 14397 14398 m->DelayConflictProcessing = MAX_CONFLICT_PROCESSING_DELAYS; 14399 m->RandomQueryDelay = 0; 14400 m->RandomReconfirmDelay = 0; 14401 m->PktNum = 0; 14402 m->MPktNum = 0; 14403 m->LocalRemoveEvents = mDNSfalse; 14404 m->SleepState = SleepState_Awake; 14405 m->SleepSeqNum = 0; 14406 m->SystemWakeOnLANEnabled = mDNSfalse; 14407 m->AnnounceOwner = NonZeroTime(timenow + 60 * mDNSPlatformOneSecond); 14408 m->DelaySleep = 0; 14409 m->SleepLimit = 0; 14410 14411#if APPLE_OSX_mDNSResponder 14412 m->UnicastPacketsSent = 0; 14413 m->MulticastPacketsSent = 0; 14414 m->RemoteSubnet = 0; 14415#endif // APPLE_OSX_mDNSResponder 14416 14417 // These fields only required for mDNS Searcher... 14418 m->Questions = mDNSNULL; 14419 m->NewQuestions = mDNSNULL; 14420 m->CurrentQuestion = mDNSNULL; 14421 m->LocalOnlyQuestions = mDNSNULL; 14422 m->NewLocalOnlyQuestions = mDNSNULL; 14423 m->RestartQuestion = mDNSNULL; 14424 m->ValidationQuestion = mDNSNULL; 14425 m->rrcache_size = 0; 14426 m->rrcache_totalused = 0; 14427 m->rrcache_active = 0; 14428 m->rrcache_report = 10; 14429 m->rrcache_free = mDNSNULL; 14430 14431 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) 14432 { 14433 m->rrcache_hash[slot] = mDNSNULL; 14434 m->rrcache_nextcheck[slot] = timenow + FutureTime;; 14435 } 14436 14437 mDNS_GrowCache_internal(m, rrcachestorage, rrcachesize); 14438 m->rrauth.rrauth_free = mDNSNULL; 14439 14440 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) 14441 m->rrauth.rrauth_hash[slot] = mDNSNULL; 14442 14443 // Fields below only required for mDNS Responder... 14444 m->hostlabel.c[0] = 0; 14445 m->nicelabel.c[0] = 0; 14446 m->MulticastHostname.c[0] = 0; 14447 m->HIHardware.c[0] = 0; 14448 m->HISoftware.c[0] = 0; 14449 m->ResourceRecords = mDNSNULL; 14450 m->DuplicateRecords = mDNSNULL; 14451 m->NewLocalRecords = mDNSNULL; 14452 m->NewLocalOnlyRecords = mDNSfalse; 14453 m->CurrentRecord = mDNSNULL; 14454 m->HostInterfaces = mDNSNULL; 14455 m->ProbeFailTime = 0; 14456 m->NumFailedProbes = 0; 14457 m->SuppressProbes = 0; 14458 14459#ifndef UNICAST_DISABLED 14460 m->NextuDNSEvent = timenow + FutureTime; 14461 m->NextSRVUpdate = timenow + FutureTime; 14462 14463 m->DNSServers = mDNSNULL; 14464 14465 m->Router = zeroAddr; 14466 m->AdvertisedV4 = zeroAddr; 14467 m->AdvertisedV6 = zeroAddr; 14468 14469 m->AuthInfoList = mDNSNULL; 14470 14471 m->ReverseMap.ThisQInterval = -1; 14472 m->StaticHostname.c[0] = 0; 14473 m->FQDN.c[0] = 0; 14474 m->Hostnames = mDNSNULL; 14475 m->AutoTunnelNAT.clientContext = mDNSNULL; 14476 14477 m->WABBrowseQueriesCount = 0; 14478 m->WABLBrowseQueriesCount = 0; 14479 m->WABRegQueriesCount = 0; 14480 m->AutoTargetServices = 1; 14481 14482#if BONJOUR_ON_DEMAND 14483 m->NumAllInterfaceRecords = 0; 14484 m->NumAllInterfaceQuestions = 0; 14485#endif 14486 // NAT traversal fields 14487 m->LLQNAT.clientCallback = mDNSNULL; 14488 m->LLQNAT.clientContext = mDNSNULL; 14489 m->NATTraversals = mDNSNULL; 14490 m->CurrentNATTraversal = mDNSNULL; 14491 m->retryIntervalGetAddr = 0; // delta between time sent and retry 14492 m->retryGetAddr = timenow + FutureTime; // absolute time when we retry 14493 m->ExtAddress = zerov4Addr; 14494 m->PCPNonce[0] = mDNSRandom(-1); 14495 m->PCPNonce[1] = mDNSRandom(-1); 14496 m->PCPNonce[2] = mDNSRandom(-1); 14497 14498 m->NATMcastRecvskt = mDNSNULL; 14499 m->LastNATupseconds = 0; 14500 m->LastNATReplyLocalTime = timenow; 14501 m->LastNATMapResultCode = NATErr_None; 14502 14503 m->UPnPInterfaceID = 0; 14504 m->SSDPSocket = mDNSNULL; 14505 m->SSDPWANPPPConnection = mDNSfalse; 14506 m->UPnPRouterPort = zeroIPPort; 14507 m->UPnPSOAPPort = zeroIPPort; 14508 m->UPnPRouterURL = mDNSNULL; 14509 m->UPnPWANPPPConnection = mDNSfalse; 14510 m->UPnPSOAPURL = mDNSNULL; 14511 m->UPnPRouterAddressString = mDNSNULL; 14512 m->UPnPSOAPAddressString = mDNSNULL; 14513 m->SPSType = 0; 14514 m->SPSPortability = 0; 14515 m->SPSMarginalPower = 0; 14516 m->SPSTotalPower = 0; 14517 m->SPSFeatureFlags = 0; 14518 m->SPSState = 0; 14519 m->SPSProxyListChanged = mDNSNULL; 14520 m->SPSSocket = mDNSNULL; 14521 m->SPSBrowseCallback = mDNSNULL; 14522 m->ProxyRecords = 0; 14523 14524 m->DNSPushServers = mDNSNULL; 14525 m->DNSPushZones = mDNSNULL; 14526#endif 14527 14528#if APPLE_OSX_mDNSResponder 14529 m->TunnelClients = mDNSNULL; 14530 14531#if !NO_WCF 14532 CHECK_WCF_FUNCTION(WCFConnectionNew) 14533 { 14534 m->WCF = WCFConnectionNew(); 14535 if (!m->WCF) { LogMsg("WCFConnectionNew failed"); return -1; } 14536 } 14537#endif 14538 14539#endif 14540 14541 return(result); 14542} 14543 14544mDNSexport mStatus mDNS_Init(mDNS *const m, mDNS_PlatformSupport *const p, 14545 CacheEntity *rrcachestorage, mDNSu32 rrcachesize, 14546 mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context) 14547{ 14548 mStatus result = mDNS_InitStorage(m, p, rrcachestorage, rrcachesize, AdvertiseLocalAddresses, Callback, Context); 14549 if (result != mStatus_NoError) 14550 return(result); 14551 14552 result = mDNSPlatformInit(m); 14553 14554#ifndef UNICAST_DISABLED 14555 // It's better to do this *after* the platform layer has set up the 14556 // interface list and security credentials 14557 uDNS_SetupDNSConfig(m); // Get initial DNS configuration 14558#endif 14559 14560 return(result); 14561} 14562 14563mDNSexport void mDNS_ConfigChanged(mDNS *const m) 14564{ 14565 if (m->SPSState == 1) 14566 { 14567 domainlabel name, newname; 14568#ifndef SPC_DISABLED 14569 domainname type, domain; 14570 DeconstructServiceName(m->SPSRecords.RR_SRV.resrec.name, &name, &type, &domain); 14571#endif // SPC_DISABLED 14572 ConstructSleepProxyServerName(m, &newname); 14573 if (!SameDomainLabelCS(name.c, newname.c)) 14574 { 14575 LogSPS("Renaming SPS from ���%#s��� to ���%#s���", name.c, newname.c); 14576 // When SleepProxyServerCallback gets the mStatus_MemFree message, 14577 // it will reregister the service under the new name 14578 m->SPSState = 2; 14579#ifndef SPC_DISABLED 14580 mDNS_DeregisterService_drt(m, &m->SPSRecords, mDNS_Dereg_rapid); 14581#endif // SPC_DISABLED 14582 } 14583 } 14584 14585 if (m->MainCallback) 14586 m->MainCallback(m, mStatus_ConfigChanged); 14587} 14588 14589mDNSlocal void DynDNSHostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 14590{ 14591 (void)m; // unused 14592 debugf("NameStatusCallback: result %d for registration of name %##s", result, rr->resrec.name->c); 14593 mDNSPlatformDynDNSHostNameStatusChanged(rr->resrec.name, result); 14594} 14595 14596mDNSlocal void PurgeOrReconfirmCacheRecord(mDNS *const m, CacheRecord *cr, const DNSServer * const ptr, mDNSBool lameduck) 14597{ 14598 mDNSBool purge = cr->resrec.RecordType == kDNSRecordTypePacketNegative || 14599 cr->resrec.rrtype == kDNSType_A || 14600 cr->resrec.rrtype == kDNSType_AAAA || 14601 cr->resrec.rrtype == kDNSType_SRV || 14602 cr->resrec.rrtype == kDNSType_CNAME; 14603 14604 (void) lameduck; 14605 (void) ptr; 14606 debugf("PurgeOrReconfirmCacheRecord: %s cache record due to %s server %p %#a:%d (%##s): %s", 14607 purge ? "purging" : "reconfirming", 14608 lameduck ? "lame duck" : "new", 14609 ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c, CRDisplayString(m, cr)); 14610 14611 if (purge) 14612 { 14613 LogInfo("PurgeorReconfirmCacheRecord: Purging Resourcerecord %s, RecordType %x", CRDisplayString(m, cr), cr->resrec.RecordType); 14614 mDNS_PurgeCacheResourceRecord(m, cr); 14615 } 14616 else 14617 { 14618 LogInfo("PurgeorReconfirmCacheRecord: Reconfirming Resourcerecord %s, RecordType %x", CRDisplayString(m, cr), cr->resrec.RecordType); 14619 mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); 14620 } 14621} 14622 14623mDNSlocal void mDNS_PurgeForQuestion(mDNS *const m, DNSQuestion *q) 14624{ 14625 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 14626 CacheRecord *rp; 14627 mDNSu8 validatingResponse = 0; 14628 14629 // For DNSSEC questions, purge the corresponding RRSIGs also. 14630 if (DNSSECQuestion(q)) 14631 { 14632 validatingResponse = q->ValidatingResponse; 14633 q->ValidatingResponse = mDNStrue; 14634 } 14635 for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next) 14636 { 14637 if (SameNameRecordAnswersQuestion(&rp->resrec, q)) 14638 { 14639 LogInfo("mDNS_PurgeForQuestion: Flushing %s", CRDisplayString(m, rp)); 14640 mDNS_PurgeCacheResourceRecord(m, rp); 14641 } 14642 } 14643 if (DNSSECQuestion(q)) 14644 { 14645 q->ValidatingResponse = validatingResponse; 14646 } 14647} 14648 14649// For DNSSEC question, we need the DNSSEC records also. If the cache does not 14650// have the DNSSEC records, we need to re-issue the question with EDNS0/DO bit set. 14651// Just re-issuing the question for RRSIGs does not work in practice as the response 14652// may not contain the RRSIGs whose typeCovered field matches the question's qtype. 14653// 14654// For negative responses, we need the NSECs to prove the non-existence. If we don't 14655// have the cached NSECs, purge them. For positive responses, if we don't have the 14656// RRSIGs and if we have not already issued the question with EDNS0/DO bit set, purge 14657// them. 14658mDNSlocal void CheckForDNSSECRecords(mDNS *const m, DNSQuestion *q) 14659{ 14660 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 14661 CacheRecord *rp; 14662 14663 for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next) 14664 { 14665 if (SameNameRecordAnswersQuestion(&rp->resrec, q)) 14666 { 14667 if (rp->resrec.RecordType != kDNSRecordTypePacketNegative || !rp->nsec) 14668 { 14669 if (!rp->CRDNSSECQuestion) 14670 { 14671 LogInfo("CheckForDNSSECRecords: Flushing %s", CRDisplayString(m, rp)); 14672 mDNS_PurgeCacheResourceRecord(m, rp); 14673 } 14674 } 14675 } 14676 } 14677} 14678 14679// Check for a positive unicast response to the question but with qtype 14680mDNSexport mDNSBool mDNS_CheckForCacheRecord(mDNS *const m, DNSQuestion *q, mDNSu16 qtype) 14681{ 14682 DNSQuestion question; 14683 CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); 14684 CacheRecord *rp; 14685 14686 // Create an identical question but with qtype 14687 mDNS_SetupQuestion(&question, q->InterfaceID, &q->qname, qtype, mDNSNULL, mDNSNULL); 14688 question.qDNSServer = q->qDNSServer; 14689 14690 for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next) 14691 { 14692 if (!rp->resrec.InterfaceID && rp->resrec.RecordType != kDNSRecordTypePacketNegative && 14693 SameNameRecordAnswersQuestion(&rp->resrec, &question)) 14694 { 14695 LogInfo("mDNS_CheckForCacheRecord: Found %s", CRDisplayString(m, rp)); 14696 return mDNStrue; 14697 } 14698 } 14699 return mDNSfalse; 14700} 14701 14702mDNSexport void DNSServerChangeForQuestion(mDNS *const m, DNSQuestion *q, DNSServer *new) 14703{ 14704 DNSQuestion *qptr; 14705 14706 (void) m; 14707 14708 if (q->DuplicateOf) 14709 LogMsg("DNSServerChangeForQuestion: ERROR: Called for duplicate question %##s", q->qname.c); 14710 14711 // Make sure all the duplicate questions point to the same DNSServer so that delivery 14712 // of events for all of them are consistent. Duplicates for a question are always inserted 14713 // after in the list. 14714 q->qDNSServer = new; 14715 for (qptr = q->next ; qptr; qptr = qptr->next) 14716 { 14717 if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = new; } 14718 } 14719} 14720 14721mDNSlocal void SetConfigState(mDNS *const m, mDNSBool delete) 14722{ 14723 McastResolver *mr; 14724 DNSServer *ptr; 14725 14726 if (delete) 14727 { 14728 for (ptr = m->DNSServers; ptr; ptr = ptr->next) 14729 { 14730 ptr->penaltyTime = 0; 14731 NumUnicastDNSServers--; 14732 ptr->flags |= DNSServer_FlagDelete; 14733#if APPLE_OSX_mDNSResponder 14734 if (ptr->flags & DNSServer_FlagUnreachable) 14735 NumUnreachableDNSServers--; 14736#endif 14737 } 14738 // We handle the mcast resolvers here itself as mDNSPlatformSetDNSConfig looks at 14739 // mcast resolvers. Today we get both mcast and ucast configuration using the same 14740 // API 14741 for (mr = m->McastResolvers; mr; mr = mr->next) 14742 mr->flags |= McastResolver_FlagDelete; 14743 } 14744 else 14745 { 14746 for (ptr = m->DNSServers; ptr; ptr = ptr->next) 14747 { 14748 ptr->penaltyTime = 0; 14749 NumUnicastDNSServers++; 14750 ptr->flags &= ~DNSServer_FlagDelete; 14751#if APPLE_OSX_mDNSResponder 14752 if (ptr->flags & DNSServer_FlagUnreachable) 14753 NumUnreachableDNSServers++; 14754#endif 14755 } 14756 for (mr = m->McastResolvers; mr; mr = mr->next) 14757 mr->flags &= ~McastResolver_FlagDelete; 14758 } 14759} 14760 14761mDNSlocal void SetDynDNSHostNameIfChanged(mDNS *const m, domainname *const fqdn) 14762{ 14763 // Did our FQDN change? 14764 if (!SameDomainName(fqdn, &m->FQDN)) 14765 { 14766 if (m->FQDN.c[0]) mDNS_RemoveDynDNSHostName(m, &m->FQDN); 14767 14768 AssignDomainName(&m->FQDN, fqdn); 14769 14770 if (m->FQDN.c[0]) 14771 { 14772 mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); 14773 mDNS_AddDynDNSHostName(m, &m->FQDN, DynDNSHostNameCallback, mDNSNULL); 14774 } 14775 } 14776} 14777 14778mDNSexport mStatus uDNS_SetupDNSConfig(mDNS *const m) 14779{ 14780 mDNSu32 slot; 14781 CacheGroup *cg; 14782 CacheRecord *cr; 14783 mDNSBool Restart = mDNSfalse; 14784 mDNSAddr v4, v6, r; 14785 domainname fqdn; 14786 DNSServer *ptr, **p = &m->DNSServers; 14787 const DNSServer *oldServers = m->DNSServers; 14788 DNSQuestion *q; 14789 McastResolver *mr, **mres = &m->McastResolvers; 14790 14791 debugf("uDNS_SetupDNSConfig: entry"); 14792 14793 // Let the platform layer get the current DNS information and setup the WAB queries if needed. 14794 uDNS_SetupWABQueries(m); 14795 14796 mDNS_Lock(m); 14797 14798 // We need to first mark all the entries to be deleted. If the configuration changed, then 14799 // the entries would be undeleted appropriately. Otherwise, we need to clear them. 14800 // 14801 // Note: The last argument to mDNSPlatformSetDNSConfig is "mDNStrue" which means ack the 14802 // configuration. We already processed search domains in uDNS_SetupWABQueries above and 14803 // hence we are ready to ack the configuration as this is the last call to mDNSPlatformSetConfig 14804 // for the dns configuration change notification. 14805 SetConfigState(m, mDNStrue); 14806 if (!mDNSPlatformSetDNSConfig(mDNStrue, mDNSfalse, &fqdn, mDNSNULL, mDNSNULL, mDNStrue)) 14807 { 14808 SetDynDNSHostNameIfChanged(m, &fqdn); 14809 SetConfigState(m, mDNSfalse); 14810 mDNS_Unlock(m); 14811 LogInfo("uDNS_SetupDNSConfig: No configuration change"); 14812 return mStatus_NoError; 14813 } 14814 14815 // For now, we just delete the mcast resolvers. We don't deal with cache or 14816 // questions here. Neither question nor cache point to mcast resolvers. Questions 14817 // do inherit the timeout values from mcast resolvers. But we don't bother 14818 // affecting them as they never change. 14819 while (*mres) 14820 { 14821 if (((*mres)->flags & McastResolver_FlagDelete) != 0) 14822 { 14823 mr = *mres; 14824 *mres = (*mres)->next; 14825 debugf("uDNS_SetupDNSConfig: Deleting mcast resolver %##s", mr, mr->domain.c); 14826 mDNSPlatformMemFree(mr); 14827 } 14828 else 14829 { 14830 (*mres)->flags &= ~McastResolver_FlagNew; 14831 mres = &(*mres)->next; 14832 } 14833 } 14834 14835 // Update our qDNSServer pointers before we go and free the DNSServer object memory 14836 // 14837 // All non-scoped resolvers share the same resGroupID. At no point in time a cache entry using DNSServer 14838 // from scoped resolver will be used to answer non-scoped questions and vice versa, as scoped and non-scoped 14839 // resolvers don't share the same resGroupID. A few examples to describe the interaction with how we pick 14840 // DNSServers and flush the cache. 14841 // 14842 // - A non-scoped question picks DNSServer X, creates a cache entry with X. If a new resolver gets added later that 14843 // is a better match, we pick the new DNSServer for the question and activate the unicast query. We may or may not 14844 // flush the cache (See PurgeOrReconfirmCacheRecord). In either case, we don't change the cache record's DNSServer 14845 // pointer immediately (qDNSServer and rDNSServer may be different but still share the same resGroupID). If we don't 14846 // flush the cache immediately, the record's rDNSServer pointer will be updated (in mDNSCoreReceiveResponse) 14847 // later when we get the response. If we purge the cache, we still deliver a RMV when it is purged even though 14848 // we don't update the cache record's DNSServer pointer to match the question's DNSSever, as they both point to 14849 // the same resGroupID. 14850 // 14851 // Note: If the new DNSServer comes back with a different response than what we have in the cache, we will deliver a RMV 14852 // of the old followed by ADD of the new records. 14853 // 14854 // - A non-scoped question picks DNSServer X, creates a cache entry with X. If the resolver gets removed later, we will 14855 // pick a new DNSServer for the question which may or may not be NULL and set the cache record's pointer to the same 14856 // as in question's qDNSServer if the cache record is not flushed. If there is no active question, it will be set to NULL. 14857 // 14858 // - Two questions scoped and non-scoped for the same name will pick two different DNSServer and will end up creating separate 14859 // cache records and as the resGroupID is different, you can't use the cache record from the scoped DNSServer to answer the 14860 // non-scoped question and vice versa. 14861 // 14862#if USE_DNS64 14863 DNS64RestartQuestions(m); 14864#endif 14865 for (q = m->Questions; q; q=q->next) 14866 { 14867 if (!mDNSOpaque16IsZero(q->TargetQID)) 14868 { 14869 DNSServer *s, *t; 14870 DNSQuestion *qptr; 14871 if (q->DuplicateOf) continue; 14872 SetValidDNSServers(m, q); 14873 q->triedAllServersOnce = 0; 14874 s = GetServerForQuestion(m, q); 14875 t = q->qDNSServer; 14876 if (t != s) 14877 { 14878 mDNSBool old, new; 14879 // If DNS Server for this question has changed, reactivate it 14880 LogInfo("uDNS_SetupDNSConfig: Updating DNS Server from %#a:%d (%##s) to %#a:%d (%##s) for question %##s (%s) (scope:%p)", 14881 t ? &t->addr : mDNSNULL, mDNSVal16(t ? t->port : zeroIPPort), t ? t->domain.c : (mDNSu8*)"", 14882 s ? &s->addr : mDNSNULL, mDNSVal16(s ? s->port : zeroIPPort), s ? s->domain.c : (mDNSu8*)"", 14883 q->qname.c, DNSTypeName(q->qtype), q->InterfaceID); 14884 14885 old = q->SuppressQuery; 14886 new = ShouldSuppressUnicastQuery(m, q, s); 14887 if (old != new) 14888 { 14889 // Changing the DNS server affected the SuppressQuery status. We need to 14890 // deliver RMVs for the previous ADDs (if any) before switching to the new 14891 // DNSServer. To keep it simple, we walk all the questions and mark them 14892 // to be restarted and then handle all of them at once. 14893 q->Restart = 1; 14894 q->SuppressQuery = new; 14895 for (qptr = q->next ; qptr; qptr = qptr->next) 14896 { 14897 if (qptr->DuplicateOf == q) 14898 qptr->Restart = 1; 14899 } 14900 Restart = mDNStrue; 14901 } 14902 else 14903 { 14904 DNSServerChangeForQuestion(m, q, s); 14905 q->unansweredQueries = 0; 14906 14907 // If we had sent a query out to DNSServer "t" and we are changing to "s", we 14908 // need to ignore the responses coming back from "t" as the DNS configuration 14909 // has changed e.g., when a new interface is coming up and that becomes the primary 14910 // interface, we switch to the DNS servers configured for the primary interface. In 14911 // this case, we should not accept responses associated with the previous interface as 14912 // the "name" could resolve differently on this new primary interface. Hence, discard 14913 // in-flight responses. 14914 q->TargetQID = mDNS_NewMessageID(m); 14915 14916 if (!QuerySuppressed(q)) 14917 { 14918 debugf("uDNS_SetupDNSConfig: Activating query %p %##s (%s)", q, q->qname.c, DNSTypeName(q->qtype)); 14919 ActivateUnicastQuery(m, q, mDNStrue); 14920 // ActivateUnicastQuery is called for duplicate questions also as it does something 14921 // special for AutoTunnel questions 14922 for (qptr = q->next ; qptr; qptr = qptr->next) 14923 { 14924 if (qptr->DuplicateOf == q) ActivateUnicastQuery(m, qptr, mDNStrue); 14925 } 14926 } 14927 } 14928 } 14929 else 14930 { 14931 debugf("uDNS_SetupDNSConfig: Not Updating DNS server question %p %##s (%s) DNS server %#a:%d %p %d", 14932 q, q->qname.c, DNSTypeName(q->qtype), t ? &t->addr : mDNSNULL, mDNSVal16(t ? t->port : zeroIPPort), q->DuplicateOf, q->SuppressUnusable); 14933 for (qptr = q->next ; qptr; qptr = qptr->next) 14934 if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = q->qDNSServer; } 14935 } 14936 } 14937 } 14938 if (Restart) 14939 RestartUnicastQuestions(m); 14940 14941 FORALL_CACHERECORDS(slot, cg, cr) 14942 { 14943 if (cr->resrec.InterfaceID) 14944 continue; 14945 14946 // We already walked the questions and restarted/reactivated them if the dns server 14947 // change affected the question. That should take care of updating the cache. But 14948 // what if there is no active question at this point when the DNS server change 14949 // happened ? There could be old cache entries lying around and if we don't flush 14950 // them, a new question after the DNS server change could pick up these stale 14951 // entries and get a wrong answer. 14952 // 14953 // For cache entries that have active questions we might have skipped rescheduling 14954 // the questions if they were suppressed (see above). To keep it simple, we walk 14955 // all the cache entries to make sure that there are no stale entries. We use the 14956 // active question's InterfaceID/ServiceID for looking up the right DNS server. 14957 // Note that the unscoped value for ServiceID is -1. 14958 // 14959 // Note: If GetServerForName returns NULL, it could either mean that there are no 14960 // DNS servers or no matching DNS servers for this question. In either case, 14961 // the cache should get purged below when we process deleted DNS servers. 14962 14963 ptr = GetServerForName(m, cr->resrec.name, 14964 (cr->CRActiveQuestion ? cr->CRActiveQuestion->InterfaceID : mDNSNULL), 14965 (cr->CRActiveQuestion ? cr->CRActiveQuestion->ServiceID : -1)); 14966 14967 // Purge or Reconfirm if this cache entry would use the new DNS server 14968 if (ptr && (ptr != cr->resrec.rDNSServer)) 14969 { 14970 // As the DNSServers for this cache record is not the same anymore, we don't 14971 // want any new questions to pick this old value. If there is no active question, 14972 // we can't possibly re-confirm, so purge in that case. If it is a DNSSEC question, 14973 // purge the cache as the DNSSEC capabilities of the DNS server may have changed. 14974 14975 if (cr->CRActiveQuestion == mDNSNULL || DNSSECQuestion(cr->CRActiveQuestion)) 14976 { 14977 LogInfo("uDNS_SetupDNSConfig: Purging Resourcerecord %s, New DNS server %#a , Old DNS server %#a", CRDisplayString(m, cr), 14978 &ptr->addr, (cr->resrec.rDNSServer != mDNSNULL ? &cr->resrec.rDNSServer->addr : mDNSNULL)); 14979 mDNS_PurgeCacheResourceRecord(m, cr); 14980 } 14981 else 14982 { 14983 LogInfo("uDNS_SetupDNSConfig: Purging/Reconfirming Resourcerecord %s, New DNS server %#a, Old DNS server %#a", CRDisplayString(m, cr), 14984 &ptr->addr, (cr->resrec.rDNSServer != mDNSNULL ? &cr->resrec.rDNSServer->addr : mDNSNULL)); 14985 PurgeOrReconfirmCacheRecord(m, cr, ptr, mDNSfalse); 14986 } 14987 } 14988 14989 // If a cache record's DNSServer pointer is NULL, but its active question got a DNSServer in this DNS configuration 14990 // update, then use its DNSServer. This way, the active question and its duplicates don't miss out on RMV events. 14991 if (!cr->resrec.rDNSServer && cr->CRActiveQuestion && cr->CRActiveQuestion->qDNSServer) 14992 { 14993 cr->resrec.rDNSServer = cr->CRActiveQuestion->qDNSServer; 14994 LogInfo("uDNS_SetupDNSConfig: Using active question's DNS server %#a for cache record %s", &cr->resrec.rDNSServer->addr, CRDisplayString(m, cr)); 14995 } 14996 } 14997 14998 while (*p) 14999 { 15000 if (((*p)->flags & DNSServer_FlagDelete) != 0) 15001 { 15002 // Scan our cache, looking for uDNS records that we would have queried this server for. 15003 // We reconfirm any records that match, because in this world of split DNS, firewalls, etc. 15004 // different DNS servers can give different answers to the same question. 15005 ptr = *p; 15006 FORALL_CACHERECORDS(slot, cg, cr) 15007 { 15008 if (cr->resrec.InterfaceID) continue; 15009 if (cr->resrec.rDNSServer == ptr) 15010 { 15011 // If we don't have an active question for this cache record, neither Purge can 15012 // generate RMV events nor Reconfirm can send queries out. Just set the DNSServer 15013 // pointer on the record NULL so that we don't point to freed memory (We might dereference 15014 // DNSServer pointers from resource record for logging purposes). 15015 // 15016 // If there is an active question, point to its DNSServer as long as it does not point to the 15017 // freed one. We already went through the questions above and made them point at either the 15018 // new server or NULL if there is no server. 15019 15020 if (cr->CRActiveQuestion) 15021 { 15022 DNSQuestion *qptr = cr->CRActiveQuestion; 15023 15024 if (qptr->qDNSServer == ptr) 15025 { 15026 LogMsg("uDNS_SetupDNSConfig: ERROR!! Cache Record %s Active question %##s (%s) (scope:%p) pointing to DNSServer Address %#a" 15027 " to be freed", CRDisplayString(m, cr), qptr->qname.c, DNSTypeName(qptr->qtype), qptr->InterfaceID, &ptr->addr); 15028 qptr->validDNSServers = zeroOpaque128; 15029 qptr->qDNSServer = mDNSNULL; 15030 cr->resrec.rDNSServer = mDNSNULL; 15031 } 15032 else 15033 { 15034 LogInfo("uDNS_SetupDNSConfig: Cache Record %s, Active question %##s (%s) (scope:%p), pointing to DNSServer %#a (to be deleted)," 15035 " resetting to question's DNSServer Address %#a", CRDisplayString(m, cr), qptr->qname.c, DNSTypeName(qptr->qtype), 15036 qptr->InterfaceID, &ptr->addr, (qptr->qDNSServer) ? &qptr->qDNSServer->addr : mDNSNULL); 15037 cr->resrec.rDNSServer = qptr->qDNSServer; 15038 } 15039 } 15040 else 15041 { 15042 LogInfo("uDNS_SetupDNSConfig: Cache Record %##s has no Active question, Record's DNSServer Address %#a, Server to be deleted %#a", 15043 cr->resrec.name, &cr->resrec.rDNSServer->addr, &ptr->addr); 15044 cr->resrec.rDNSServer = mDNSNULL; 15045 } 15046 15047 PurgeOrReconfirmCacheRecord(m, cr, ptr, mDNStrue); 15048 } 15049 } 15050 *p = (*p)->next; 15051 LogInfo("uDNS_SetupDNSConfig: Deleting server %p %#a:%d (%##s) %d", ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c, NumUnicastDNSServers); 15052 mDNSPlatformMemFree(ptr); 15053 } 15054 else 15055 { 15056 (*p)->flags &= ~DNSServer_FlagNew; 15057 p = &(*p)->next; 15058 } 15059 } 15060 15061 // If we now have no DNS servers at all and we used to have some, then immediately purge all unicast cache records (including for LLQs). 15062 // This is important for giving prompt remove events when the user disconnects the Ethernet cable or turns off wireless. 15063 // Otherwise, stale data lingers for 5-10 seconds, which is not the user-experience people expect from Bonjour. 15064 // Similarly, if we now have some DNS servers and we used to have none, we want to purge any fake negative results we may have generated. 15065 if ((m->DNSServers != mDNSNULL) != (oldServers != mDNSNULL)) 15066 { 15067 int count = 0; 15068 FORALL_CACHERECORDS(slot, cg, cr) 15069 { 15070 if (!cr->resrec.InterfaceID) 15071 { 15072 mDNS_PurgeCacheResourceRecord(m, cr); 15073 count++; 15074 } 15075 } 15076 LogInfo("uDNS_SetupDNSConfig: %s available; purged %d unicast DNS records from cache", 15077 m->DNSServers ? "DNS server became" : "No DNS servers", count); 15078 15079 // Force anything that needs to get zone data to get that information again 15080 RestartRecordGetZoneData(m); 15081 } 15082 15083 SetDynDNSHostNameIfChanged(m, &fqdn); 15084 15085 mDNS_Unlock(m); 15086 15087 // handle router and primary interface changes 15088 v4 = v6 = r = zeroAddr; 15089 v4.type = r.type = mDNSAddrType_IPv4; 15090 15091 if (mDNSPlatformGetPrimaryInterface(&v4, &v6, &r) == mStatus_NoError && !mDNSv4AddressIsLinkLocal(&v4.ip.v4)) 15092 { 15093 mDNS_SetPrimaryInterfaceInfo(m, 15094 !mDNSIPv4AddressIsZero(v4.ip.v4) ? &v4 : mDNSNULL, 15095 !mDNSIPv6AddressIsZero(v6.ip.v6) ? &v6 : mDNSNULL, 15096 !mDNSIPv4AddressIsZero(r.ip.v4) ? &r : mDNSNULL); 15097 } 15098 else 15099 { 15100 mDNS_SetPrimaryInterfaceInfo(m, mDNSNULL, mDNSNULL, mDNSNULL); 15101 if (m->FQDN.c[0]) mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); // Set status to 1 to indicate temporary failure 15102 } 15103 15104 debugf("uDNS_SetupDNSConfig: number of unicast DNS servers %d", NumUnicastDNSServers); 15105 return mStatus_NoError; 15106} 15107 15108mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result) 15109{ 15110 m->mDNSPlatformStatus = result; 15111 if (m->MainCallback) 15112 { 15113 mDNS_Lock(m); 15114 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 15115 m->MainCallback(m, mStatus_NoError); 15116 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 15117 mDNS_Unlock(m); 15118 } 15119} 15120 15121mDNSlocal void DeregLoop(mDNS *const m, AuthRecord *const start) 15122{ 15123 m->CurrentRecord = start; 15124 while (m->CurrentRecord) 15125 { 15126 AuthRecord *rr = m->CurrentRecord; 15127 LogInfo("DeregLoop: %s deregistration for %p %02X %s", 15128 (rr->resrec.RecordType != kDNSRecordTypeDeregistering) ? "Initiating " : "Accelerating", 15129 rr, rr->resrec.RecordType, ARDisplayString(m, rr)); 15130 if (rr->resrec.RecordType != kDNSRecordTypeDeregistering) 15131 mDNS_Deregister_internal(m, rr, mDNS_Dereg_rapid); 15132 else if (rr->AnnounceCount > 1) 15133 { 15134 rr->AnnounceCount = 1; 15135 rr->LastAPTime = m->timenow - rr->ThisAPInterval; 15136 } 15137 // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because 15138 // new records could have been added to the end of the list as a result of that call. 15139 if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now 15140 m->CurrentRecord = rr->next; 15141 } 15142} 15143 15144mDNSexport void mDNS_StartExit(mDNS *const m) 15145{ 15146 AuthRecord *rr; 15147 15148 mDNS_Lock(m); 15149 15150 LogInfo("mDNS_StartExit"); 15151 m->ShutdownTime = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5); 15152 15153 mDNSCoreBeSleepProxyServer_internal(m, 0, 0, 0, 0, 0); 15154 15155#if APPLE_OSX_mDNSResponder 15156#if !NO_WCF 15157 CHECK_WCF_FUNCTION(WCFConnectionDealloc) 15158 { 15159 if (m->WCF) WCFConnectionDealloc((WCFConnection *)m->WCF); 15160 } 15161#endif 15162#endif 15163 15164#ifndef UNICAST_DISABLED 15165 { 15166 SearchListElem *s; 15167 SuspendLLQs(m); 15168 // Don't need to do SleepRecordRegistrations() here 15169 // because we deregister all records and services later in this routine 15170 while (m->Hostnames) mDNS_RemoveDynDNSHostName(m, &m->Hostnames->fqdn); 15171 15172 // For each member of our SearchList, deregister any records it may have created, and cut them from the list. 15173 // Otherwise they'll be forcibly deregistered for us (without being cut them from the appropriate list) 15174 // and we may crash because the list still contains dangling pointers. 15175 for (s = SearchList; s; s = s->next) 15176 while (s->AuthRecs) 15177 { 15178 ARListElem *dereg = s->AuthRecs; 15179 s->AuthRecs = s->AuthRecs->next; 15180 mDNS_Deregister_internal(m, &dereg->ar, mDNS_Dereg_normal); // Memory will be freed in the FreeARElemCallback 15181 } 15182 } 15183#endif 15184 15185 DeadvertiseAllInterfaceRecords(m); 15186 15187 // Shut down all our active NAT Traversals 15188 while (m->NATTraversals) 15189 { 15190 NATTraversalInfo *t = m->NATTraversals; 15191 mDNS_StopNATOperation_internal(m, t); // This will cut 't' from the list, thereby advancing m->NATTraversals in the process 15192 15193 // After stopping the NAT Traversal, we zero out the fields. 15194 // This has particularly important implications for our AutoTunnel records -- 15195 // when we deregister our AutoTunnel records below, we don't want their mStatus_MemFree 15196 // handlers to just turn around and attempt to re-register those same records. 15197 // Clearing t->ExternalPort/t->RequestedPort will cause the mStatus_MemFree callback handlers 15198 // to not do this. 15199 t->ExternalAddress = zerov4Addr; 15200 t->NewAddress = zerov4Addr; 15201 t->ExternalPort = zeroIPPort; 15202 t->RequestedPort = zeroIPPort; 15203 t->Lifetime = 0; 15204 t->Result = mStatus_NoError; 15205 } 15206 15207 // Make sure there are nothing but deregistering records remaining in the list 15208 if (m->CurrentRecord) 15209 LogMsg("mDNS_StartExit: ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 15210 15211 // We're in the process of shutting down, so queries, etc. are no longer available. 15212 // Consequently, determining certain information, e.g. the uDNS update server's IP 15213 // address, will not be possible. The records on the main list are more likely to 15214 // already contain such information, so we deregister the duplicate records first. 15215 LogInfo("mDNS_StartExit: Deregistering duplicate resource records"); 15216 DeregLoop(m, m->DuplicateRecords); 15217 LogInfo("mDNS_StartExit: Deregistering resource records"); 15218 DeregLoop(m, m->ResourceRecords); 15219 15220 // If we scheduled a response to send goodbye packets, we set NextScheduledResponse to now. Normally when deregistering records, 15221 // we allow up to 100ms delay (to help improve record grouping) but when shutting down we don't want any such delay. 15222 if (m->NextScheduledResponse - m->timenow < mDNSPlatformOneSecond) 15223 { 15224 m->NextScheduledResponse = m->timenow; 15225 m->SuppressSending = 0; 15226 } 15227 15228 if (m->ResourceRecords) LogInfo("mDNS_StartExit: Sending final record deregistrations"); 15229 else LogInfo("mDNS_StartExit: No deregistering records remain"); 15230 15231 for (rr = m->DuplicateRecords; rr; rr = rr->next) 15232 LogMsg("mDNS_StartExit: Should not still have Duplicate Records remaining: %02X %s", rr->resrec.RecordType, ARDisplayString(m, rr)); 15233 15234 // If any deregistering records remain, send their deregistration announcements before we exit 15235 if (m->mDNSPlatformStatus != mStatus_NoError) DiscardDeregistrations(m); 15236 15237 mDNS_Unlock(m); 15238 15239 LogInfo("mDNS_StartExit: done"); 15240} 15241 15242mDNSexport void mDNS_FinalExit(mDNS *const m) 15243{ 15244 mDNSu32 rrcache_active = 0; 15245 mDNSu32 rrcache_totalused = m->rrcache_totalused; 15246 mDNSu32 slot; 15247 AuthRecord *rr; 15248 15249 LogInfo("mDNS_FinalExit: mDNSPlatformClose"); 15250 mDNSPlatformClose(m); 15251 15252 for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) 15253 { 15254 while (m->rrcache_hash[slot]) 15255 { 15256 CacheGroup *cg = m->rrcache_hash[slot]; 15257 while (cg->members) 15258 { 15259 CacheRecord *cr = cg->members; 15260 cg->members = cg->members->next; 15261 if (cr->CRActiveQuestion) rrcache_active++; 15262 ReleaseCacheRecord(m, cr); 15263 } 15264 cg->rrcache_tail = &cg->members; 15265 ReleaseCacheGroup(m, &m->rrcache_hash[slot]); 15266 } 15267 } 15268 debugf("mDNS_FinalExit: RR Cache was using %ld records, %lu active", rrcache_totalused, rrcache_active); 15269 if (rrcache_active != m->rrcache_active) 15270 LogMsg("*** ERROR *** rrcache_totalused %lu; rrcache_active %lu != m->rrcache_active %lu", rrcache_totalused, rrcache_active, m->rrcache_active); 15271 15272 for (rr = m->ResourceRecords; rr; rr = rr->next) 15273 LogMsg("mDNS_FinalExit failed to send goodbye for: %p %02X %s", rr, rr->resrec.RecordType, ARDisplayString(m, rr)); 15274 15275 LogInfo("mDNS_FinalExit: done"); 15276} 15277 15278#ifdef UNIT_TEST 15279#include "../unittests/mdns_ut.c" 15280#endif 15281