1/* -*- Mode: C; tab-width: 4 -*- 2 * 3 * Copyright (c) 2002-2013 Apple Computer, Inc. All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 17 * To Do: 18 * Elimate all mDNSPlatformMemAllocate/mDNSPlatformMemFree from this code -- the core code 19 * is supposed to be malloc-free so that it runs in constant memory determined at compile-time. 20 * Any dynamic run-time requirements should be handled by the platform layer below or client layer above 21 */ 22 23#if APPLE_OSX_mDNSResponder 24#include <TargetConditionals.h> 25#endif 26#include "uDNS.h" 27 28#if (defined(_MSC_VER)) 29// Disable "assignment within conditional expression". 30// Other compilers understand the convention that if you place the assignment expression within an extra pair 31// of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary. 32// The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal 33// to the compiler that the assignment is intentional, we have to just turn this warning off completely. 34 #pragma warning(disable:4706) 35#endif 36 37// For domain enumeration and automatic browsing 38// This is the user's DNS search list. 39// In each of these domains we search for our special pointer records (lb._dns-sd._udp.<domain>, etc.) 40// to discover recommended domains for domain enumeration (browse, default browse, registration, 41// default registration) and possibly one or more recommended automatic browsing domains. 42mDNSexport SearchListElem *SearchList = mDNSNULL; 43 44// The value can be set to true by the Platform code e.g., MacOSX uses the plist mechanism 45mDNSBool StrictUnicastOrdering = mDNSfalse; 46 47// We keep track of the number of unicast DNS servers and log a message when we exceed 64. 48// Currently the unicast queries maintain a 64 bit map to track the valid DNS servers for that 49// question. Bit position is the index into the DNS server list. This is done so to try all 50// the servers exactly once before giving up. If we could allocate memory in the core, then 51// arbitrary limitation of 64 DNSServers can be removed. 52mDNSu8 NumUnicastDNSServers = 0; 53#define MAX_UNICAST_DNS_SERVERS 64 54 55#define SetNextuDNSEvent(m, rr) { \ 56 if ((m)->NextuDNSEvent - ((rr)->LastAPTime + (rr)->ThisAPInterval) >= 0) \ 57 (m)->NextuDNSEvent = ((rr)->LastAPTime + (rr)->ThisAPInterval); \ 58} 59 60#ifndef UNICAST_DISABLED 61 62// *************************************************************************** 63#if COMPILER_LIKES_PRAGMA_MARK 64#pragma mark - General Utility Functions 65#endif 66 67// set retry timestamp for record with exponential backoff 68mDNSlocal void SetRecordRetry(mDNS *const m, AuthRecord *rr, mDNSu32 random) 69{ 70 rr->LastAPTime = m->timenow; 71 72 if (rr->expire && rr->refreshCount < MAX_UPDATE_REFRESH_COUNT) 73 { 74 mDNSs32 remaining = rr->expire - m->timenow; 75 rr->refreshCount++; 76 if (remaining > MIN_UPDATE_REFRESH_TIME) 77 { 78 // Refresh at 70% + random (currently it is 0 to 10%) 79 rr->ThisAPInterval = 7 * (remaining/10) + (random ? random : mDNSRandom(remaining/10)); 80 // Don't update more often than 5 minutes 81 if (rr->ThisAPInterval < MIN_UPDATE_REFRESH_TIME) 82 rr->ThisAPInterval = MIN_UPDATE_REFRESH_TIME; 83 LogInfo("SetRecordRetry refresh in %d of %d for %s", 84 rr->ThisAPInterval/mDNSPlatformOneSecond, (rr->expire - m->timenow)/mDNSPlatformOneSecond, ARDisplayString(m, rr)); 85 } 86 else 87 { 88 rr->ThisAPInterval = MIN_UPDATE_REFRESH_TIME; 89 LogInfo("SetRecordRetry clamping to min refresh in %d of %d for %s", 90 rr->ThisAPInterval/mDNSPlatformOneSecond, (rr->expire - m->timenow)/mDNSPlatformOneSecond, ARDisplayString(m, rr)); 91 } 92 return; 93 } 94 95 rr->expire = 0; 96 97 rr->ThisAPInterval = rr->ThisAPInterval * QuestionIntervalStep; // Same Retry logic as Unicast Queries 98 if (rr->ThisAPInterval < INIT_RECORD_REG_INTERVAL) 99 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 100 if (rr->ThisAPInterval > MAX_RECORD_REG_INTERVAL) 101 rr->ThisAPInterval = MAX_RECORD_REG_INTERVAL; 102 103 LogInfo("SetRecordRetry retry in %d ms for %s", rr->ThisAPInterval, ARDisplayString(m, rr)); 104} 105 106// *************************************************************************** 107#if COMPILER_LIKES_PRAGMA_MARK 108#pragma mark - Name Server List Management 109#endif 110 111mDNSexport DNSServer *mDNS_AddDNSServer(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, const mDNSs32 serviceID, const mDNSAddr *addr, 112 const mDNSIPPort port, mDNSu32 scoped, mDNSu32 timeout, mDNSBool cellIntf, mDNSu16 resGroupID, mDNSBool reqA, 113 mDNSBool reqAAAA, mDNSBool reqDO) 114{ 115 DNSServer **p = &m->DNSServers; 116 DNSServer *tmp = mDNSNULL; 117 118 if ((NumUnicastDNSServers + 1) > MAX_UNICAST_DNS_SERVERS) 119 { 120 LogMsg("mDNS_AddDNSServer: DNS server limit of %d reached, not adding this server", MAX_UNICAST_DNS_SERVERS); 121 return mDNSNULL; 122 } 123 124 if (!d) 125 d = (const domainname *)""; 126 127 LogInfo("mDNS_AddDNSServer(%d): Adding %#a for %##s, InterfaceID %p, serviceID %u, scoped %d, resGroupID %d req_A is %s req_AAAA is %s cell %s req_DO is %s", 128 NumUnicastDNSServers, addr, d->c, interface, serviceID, scoped, resGroupID, reqA ? "True" : "False", reqAAAA ? "True" : "False", 129 cellIntf ? "True" : "False", reqDO ? "True" : "False"); 130 131 mDNS_CheckLock(m); 132 133 while (*p) // Check if we already have this {interface,address,port,domain} tuple registered + reqA/reqAAAA bits 134 { 135 if ((*p)->scoped == scoped && (*p)->interface == interface && (*p)->serviceID == serviceID && (*p)->teststate != DNSServer_Disabled && 136 mDNSSameAddress(&(*p)->addr, addr) && mDNSSameIPPort((*p)->port, port) && SameDomainName(&(*p)->domain, d) && 137 (*p)->req_A == reqA && (*p)->req_AAAA == reqAAAA) 138 { 139 if (!((*p)->flags & DNSServer_FlagDelete)) 140 debugf("Note: DNS Server %#a:%d for domain %##s (%p) registered more than once", addr, mDNSVal16(port), d->c, interface); 141 tmp = *p; 142 *p = tmp->next; 143 tmp->next = mDNSNULL; 144 } 145 else 146 { 147 p=&(*p)->next; 148 } 149 } 150 151 // NumUnicastDNSServers is the count of active DNS servers i.e., ones that are not marked 152 // with DNSServer_FlagDelete. We should increment it: 153 // 154 // 1) When we add a new DNS server 155 // 2) When we resurrect a old DNS server that is marked with DNSServer_FlagDelete 156 // 157 // Don't increment when we resurrect a DNS server that is not marked with DNSServer_FlagDelete. 158 // We have already accounted for it when it was added for the first time. This case happens when 159 // we add DNS servers with the same address multiple times (mis-configuration). 160 161 if (!tmp || (tmp->flags & DNSServer_FlagDelete)) 162 NumUnicastDNSServers++; 163 164 165 if (tmp) 166 { 167 tmp->flags &= ~DNSServer_FlagDelete; 168 *p = tmp; // move to end of list, to ensure ordering from platform layer 169 } 170 else 171 { 172 // allocate, add to list 173 *p = mDNSPlatformMemAllocate(sizeof(**p)); 174 if (!*p) 175 { 176 LogMsg("Error: mDNS_AddDNSServer - malloc"); 177 } 178 else 179 { 180 (*p)->scoped = scoped; 181 (*p)->interface = interface; 182 (*p)->serviceID = serviceID; 183 (*p)->addr = *addr; 184 (*p)->port = port; 185 (*p)->flags = DNSServer_FlagNew; 186 (*p)->teststate = /* DNSServer_Untested */ DNSServer_Passed; 187 (*p)->lasttest = m->timenow - INIT_UCAST_POLL_INTERVAL; 188 (*p)->timeout = timeout; 189 (*p)->cellIntf = cellIntf; 190 (*p)->req_A = reqA; 191 (*p)->req_AAAA = reqAAAA; 192 (*p)->req_DO = reqDO; 193 // We start off assuming that the DNS server is not DNSSEC aware and 194 // when we receive the first response to a DNSSEC question, we set 195 // it to true. 196 (*p)->DNSSECAware = mDNSfalse; 197 (*p)->retransDO = 0; 198 AssignDomainName(&(*p)->domain, d); 199 (*p)->next = mDNSNULL; 200 } 201 } 202 (*p)->penaltyTime = 0; 203 // We always update the ID (not just when we allocate a new instance) because we could 204 // be adding a new non-scoped resolver with a new ID and we want all the non-scoped 205 // resolvers belong to the same group. 206 (*p)->resGroupID = resGroupID; 207 return(*p); 208} 209 210// PenalizeDNSServer is called when the number of queries to the unicast 211// DNS server exceeds MAX_UCAST_UNANSWERED_QUERIES or when we receive an 212// error e.g., SERV_FAIL from DNS server. 213mDNSexport void PenalizeDNSServer(mDNS *const m, DNSQuestion *q, mDNSOpaque16 responseFlags) 214{ 215 DNSServer *new; 216 DNSServer *orig = q->qDNSServer; 217 218 mDNS_CheckLock(m); 219 220 LogInfo("PenalizeDNSServer: Penalizing DNS server %#a question for question %p %##s (%s) SuppressUnusable %d", 221 (q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL), q, q->qname.c, DNSTypeName(q->qtype), q->SuppressUnusable); 222 223 // If we get error from any DNS server, remember the error. If all of the servers, 224 // return the error, then return the first error. 225 if (mDNSOpaque16IsZero(q->responseFlags)) 226 q->responseFlags = responseFlags; 227 228 // After we reset the qDNSServer to NULL, we could get more SERV_FAILS that might end up 229 // peanlizing again. 230 if (!q->qDNSServer) goto end; 231 232 // If strict ordering of unicast servers needs to be preserved, we just lookup 233 // the next best match server below 234 // 235 // If strict ordering is not required which is the default behavior, we penalize the server 236 // for DNSSERVER_PENALTY_TIME. We may also use additional logic e.g., don't penalize for PTR 237 // in the future. 238 239 if (!StrictUnicastOrdering) 240 { 241 LogInfo("PenalizeDNSServer: Strict Unicast Ordering is FALSE"); 242 // We penalize the server so that new queries don't pick this server for DNSSERVER_PENALTY_TIME 243 // XXX Include other logic here to see if this server should really be penalized 244 // 245 if (q->qtype == kDNSType_PTR) 246 { 247 LogInfo("PenalizeDNSServer: Not Penalizing PTR question"); 248 } 249 else 250 { 251 LogInfo("PenalizeDNSServer: Penalizing question type %d", q->qtype); 252 q->qDNSServer->penaltyTime = NonZeroTime(m->timenow + DNSSERVER_PENALTY_TIME); 253 } 254 } 255 else 256 { 257 LogInfo("PenalizeDNSServer: Strict Unicast Ordering is TRUE"); 258 } 259 260end: 261 new = GetServerForQuestion(m, q); 262 263 if (new == orig) 264 { 265 if (new) 266 { 267 LogMsg("PenalizeDNSServer: ERROR!! GetServerForQuestion returned the same server %#a:%d", &new->addr, 268 mDNSVal16(new->port)); 269 q->ThisQInterval = 0; // Inactivate this question so that we dont bombard the network 270 } 271 else 272 { 273 // When we have no more DNS servers, we might end up calling PenalizeDNSServer multiple 274 // times when we receive SERVFAIL from delayed packets in the network e.g., DNS server 275 // is slow in responding and we have sent three queries. When we repeatedly call, it is 276 // okay to receive the same NULL DNS server. Next time we try to send the query, we will 277 // realize and re-initialize the DNS servers. 278 LogInfo("PenalizeDNSServer: GetServerForQuestion returned the same server NULL"); 279 } 280 } 281 else 282 { 283 // The new DNSServer is set in DNSServerChangeForQuestion 284 DNSServerChangeForQuestion(m, q, new); 285 286 if (new) 287 { 288 LogInfo("PenalizeDNSServer: Server for %##s (%s) changed to %#a:%d (%##s)", 289 q->qname.c, DNSTypeName(q->qtype), &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port), q->qDNSServer->domain.c); 290 // We want to try the next server immediately. As the question may already have backed off, reset 291 // the interval. We do this only the first time when we try all the DNS servers. Once we reached the end of 292 // list and retrying all the servers again e.g., at least one server failed to respond in the previous try, we 293 // use the normal backoff which is done in uDNS_CheckCurrentQuestion when we send the packet out. 294 if (!q->triedAllServersOnce) 295 { 296 q->ThisQInterval = InitialQuestionInterval; 297 q->LastQTime = m->timenow - q->ThisQInterval; 298 SetNextQueryTime(m, q); 299 } 300 } 301 else 302 { 303 // We don't have any more DNS servers for this question. If some server in the list did not return 304 // any response, we need to keep retrying till we get a response. uDNS_CheckCurrentQuestion handles 305 // this case. 306 // 307 // If all servers responded with a negative response, We need to do two things. First, generate a 308 // negative response so that applications get a reply. We also need to reinitialize the DNS servers 309 // so that when the cache expires, we can restart the query. We defer this up until we generate 310 // a negative cache response in uDNS_CheckCurrentQuestion. 311 // 312 // Be careful not to touch the ThisQInterval here. For a normal question, when we answer the question 313 // in AnswerCurrentQuestionWithResourceRecord will set ThisQInterval to MaxQuestionInterval and hence 314 // the next query will not happen until cache expiry. If it is a long lived question, 315 // AnswerCurrentQuestionWithResourceRecord will not set it to MaxQuestionInterval. In that case, 316 // we want the normal backoff to work. 317 LogInfo("PenalizeDNSServer: Server for %p, %##s (%s) changed to NULL, Interval %d", q, q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval); 318 } 319 q->unansweredQueries = 0; 320 321 } 322} 323 324// *************************************************************************** 325#if COMPILER_LIKES_PRAGMA_MARK 326#pragma mark - authorization management 327#endif 328 329mDNSlocal DomainAuthInfo *GetAuthInfoForName_direct(mDNS *m, const domainname *const name) 330{ 331 const domainname *n = name; 332 while (n->c[0]) 333 { 334 DomainAuthInfo *ptr; 335 for (ptr = m->AuthInfoList; ptr; ptr = ptr->next) 336 if (SameDomainName(&ptr->domain, n)) 337 { 338 debugf("GetAuthInfoForName %##s Matched %##s Key name %##s", name->c, ptr->domain.c, ptr->keyname.c); 339 return(ptr); 340 } 341 n = (const domainname *)(n->c + 1 + n->c[0]); 342 } 343 //LogInfo("GetAuthInfoForName none found for %##s", name->c); 344 return mDNSNULL; 345} 346 347// MUST be called with lock held 348mDNSexport DomainAuthInfo *GetAuthInfoForName_internal(mDNS *m, const domainname *const name) 349{ 350 DomainAuthInfo **p = &m->AuthInfoList; 351 352 mDNS_CheckLock(m); 353 354 // First purge any dead keys from the list 355 while (*p) 356 { 357 if ((*p)->deltime && m->timenow - (*p)->deltime >= 0 && AutoTunnelUnregistered(*p)) 358 { 359 DNSQuestion *q; 360 DomainAuthInfo *info = *p; 361 LogInfo("GetAuthInfoForName_internal deleting expired key %##s %##s", info->domain.c, info->keyname.c); 362 *p = info->next; // Cut DomainAuthInfo from list *before* scanning our question list updating AuthInfo pointers 363 for (q = m->Questions; q; q=q->next) 364 if (q->AuthInfo == info) 365 { 366 q->AuthInfo = GetAuthInfoForName_direct(m, &q->qname); 367 debugf("GetAuthInfoForName_internal updated q->AuthInfo from %##s to %##s for %##s (%s)", 368 info->domain.c, q->AuthInfo ? q->AuthInfo->domain.c : mDNSNULL, q->qname.c, DNSTypeName(q->qtype)); 369 } 370 371 // Probably not essential, but just to be safe, zero out the secret key data 372 // so we don't leave it hanging around in memory 373 // (where it could potentially get exposed via some other bug) 374 mDNSPlatformMemZero(info, sizeof(*info)); 375 mDNSPlatformMemFree(info); 376 } 377 else 378 p = &(*p)->next; 379 } 380 381 return(GetAuthInfoForName_direct(m, name)); 382} 383 384mDNSexport DomainAuthInfo *GetAuthInfoForName(mDNS *m, const domainname *const name) 385{ 386 DomainAuthInfo *d; 387 mDNS_Lock(m); 388 d = GetAuthInfoForName_internal(m, name); 389 mDNS_Unlock(m); 390 return(d); 391} 392 393// MUST be called with the lock held 394mDNSexport mStatus mDNS_SetSecretForDomain(mDNS *m, DomainAuthInfo *info, 395 const domainname *domain, const domainname *keyname, const char *b64keydata, const domainname *hostname, mDNSIPPort *port, mDNSBool autoTunnel) 396{ 397 DNSQuestion *q; 398 DomainAuthInfo **p = &m->AuthInfoList; 399 if (!info || !b64keydata) { LogMsg("mDNS_SetSecretForDomain: ERROR: info %p b64keydata %p", info, b64keydata); return(mStatus_BadParamErr); } 400 401 LogInfo("mDNS_SetSecretForDomain: domain %##s key %##s%s", domain->c, keyname->c, autoTunnel ? " AutoTunnel" : ""); 402 403 info->AutoTunnel = autoTunnel; 404 AssignDomainName(&info->domain, domain); 405 AssignDomainName(&info->keyname, keyname); 406 if (hostname) 407 AssignDomainName(&info->hostname, hostname); 408 else 409 info->hostname.c[0] = 0; 410 if (port) 411 info->port = *port; 412 else 413 info->port = zeroIPPort; 414 mDNS_snprintf(info->b64keydata, sizeof(info->b64keydata), "%s", b64keydata); 415 416 if (DNSDigest_ConstructHMACKeyfromBase64(info, b64keydata) < 0) 417 { 418 LogMsg("mDNS_SetSecretForDomain: ERROR: Could not convert shared secret from base64: domain %##s key %##s %s", domain->c, keyname->c, mDNS_LoggingEnabled ? b64keydata : ""); 419 return(mStatus_BadParamErr); 420 } 421 422 // Don't clear deltime until after we've ascertained that b64keydata is valid 423 info->deltime = 0; 424 425 while (*p && (*p) != info) p=&(*p)->next; 426 if (*p) {LogInfo("mDNS_SetSecretForDomain: Domain %##s Already in list", (*p)->domain.c); return(mStatus_AlreadyRegistered);} 427 428 // Caution: Only zero AutoTunnelHostRecord.namestorage AFTER we've determined that this is a NEW DomainAuthInfo 429 // being added to the list. Otherwise we risk smashing our AutoTunnel host records that are already active and in use. 430 info->AutoTunnelHostRecord.resrec.RecordType = kDNSRecordTypeUnregistered; 431 info->AutoTunnelHostRecord.namestorage.c[0] = 0; 432 info->AutoTunnelTarget.resrec.RecordType = kDNSRecordTypeUnregistered; 433 info->AutoTunnelDeviceInfo.resrec.RecordType = kDNSRecordTypeUnregistered; 434 info->AutoTunnelService.resrec.RecordType = kDNSRecordTypeUnregistered; 435 info->AutoTunnel6Record.resrec.RecordType = kDNSRecordTypeUnregistered; 436 info->AutoTunnelServiceStarted = mDNSfalse; 437 info->AutoTunnelInnerAddress = zerov6Addr; 438 info->next = mDNSNULL; 439 *p = info; 440 441 // Check to see if adding this new DomainAuthInfo has changed the credentials for any of our questions 442 for (q = m->Questions; q; q=q->next) 443 { 444 DomainAuthInfo *newinfo = GetAuthInfoForQuestion(m, q); 445 if (q->AuthInfo != newinfo) 446 { 447 debugf("mDNS_SetSecretForDomain updating q->AuthInfo from %##s to %##s for %##s (%s)", 448 q->AuthInfo ? q->AuthInfo->domain.c : mDNSNULL, 449 newinfo ? newinfo->domain.c : mDNSNULL, q->qname.c, DNSTypeName(q->qtype)); 450 q->AuthInfo = newinfo; 451 } 452 } 453 454 return(mStatus_NoError); 455} 456 457// *************************************************************************** 458#if COMPILER_LIKES_PRAGMA_MARK 459#pragma mark - 460#pragma mark - NAT Traversal 461#endif 462 463// Keep track of when to request/refresh the external address using NAT-PMP or UPnP/IGD, 464// and do so when necessary 465mDNSlocal mStatus uDNS_RequestAddress(mDNS *m) 466{ 467 mStatus err = mStatus_NoError; 468 469 if (!m->NATTraversals) 470 { 471 m->retryGetAddr = NonZeroTime(m->timenow + 0x78000000); 472 LogInfo("uDNS_RequestAddress: Setting retryGetAddr to future"); 473 } 474 else if (m->timenow - m->retryGetAddr >= 0) 475 { 476 if (mDNSv4AddrIsRFC1918(&m->Router.ip.v4)) 477 { 478 static NATAddrRequest req = {NATMAP_VERS, NATOp_AddrRequest}; 479 static mDNSu8* start = (mDNSu8*)&req; 480 mDNSu8* end = start + sizeof(NATAddrRequest); 481 err = mDNSPlatformSendUDP(m, start, end, 0, mDNSNULL, &m->Router, NATPMPPort, mDNSfalse); 482 debugf("uDNS_RequestAddress: Sent NAT-PMP external address request %d", err); 483 484#ifdef _LEGACY_NAT_TRAVERSAL_ 485 if (mDNSIPPortIsZero(m->UPnPRouterPort) || mDNSIPPortIsZero(m->UPnPSOAPPort)) 486 { 487 LNT_SendDiscoveryMsg(m); 488 debugf("uDNS_RequestAddress: LNT_SendDiscoveryMsg"); 489 } 490 else 491 { 492 mStatus lnterr = LNT_GetExternalAddress(m); 493 if (lnterr) 494 LogMsg("uDNS_RequestAddress: LNT_GetExternalAddress returned error %d", lnterr); 495 496 err = err ? err : lnterr; // NAT-PMP error takes precedence 497 } 498#endif // _LEGACY_NAT_TRAVERSAL_ 499 } 500 501 // Always update the interval and retry time, so that even if we fail to send the 502 // packet, we won't spin in an infinite loop repeatedly failing to send the packet 503 if (m->retryIntervalGetAddr < NATMAP_INIT_RETRY) 504 { 505 m->retryIntervalGetAddr = NATMAP_INIT_RETRY; 506 } 507 else if (m->retryIntervalGetAddr < NATMAP_MAX_RETRY_INTERVAL / 2) 508 { 509 m->retryIntervalGetAddr *= 2; 510 } 511 else 512 { 513 m->retryIntervalGetAddr = NATMAP_MAX_RETRY_INTERVAL; 514 } 515 516 m->retryGetAddr = NonZeroTime(m->timenow + m->retryIntervalGetAddr); 517 } 518 else 519 { 520 debugf("uDNS_RequestAddress: Not time to send address request"); 521 } 522 523 // Always update NextScheduledNATOp, even if we didn't change retryGetAddr, so we'll 524 // be called when we need to send the request(s) 525 if (m->NextScheduledNATOp - m->retryGetAddr > 0) 526 m->NextScheduledNATOp = m->retryGetAddr; 527 528 return err; 529} 530 531mDNSlocal mStatus uDNS_SendNATMsg(mDNS *m, NATTraversalInfo *info, mDNSBool usePCP) 532{ 533 mStatus err = mStatus_NoError; 534 535 if (!info) 536 { 537 LogMsg("uDNS_SendNATMsg called unexpectedly with NULL info"); 538 return mStatus_BadParamErr; 539 } 540 541 // send msg if the router's address is private (which means it's non-zero) 542 if (mDNSv4AddrIsRFC1918(&m->Router.ip.v4)) 543 { 544 if (!usePCP) 545 { 546 if (!info->sentNATPMP) 547 { 548 if (info->Protocol) 549 { 550 static NATPortMapRequest NATPortReq; 551 static const mDNSu8* end = (mDNSu8 *)&NATPortReq + sizeof(NATPortMapRequest); 552 mDNSu8 *p = (mDNSu8 *)&NATPortReq.NATReq_lease; 553 554 NATPortReq.vers = NATMAP_VERS; 555 NATPortReq.opcode = info->Protocol; 556 NATPortReq.unused = zeroID; 557 NATPortReq.intport = info->IntPort; 558 NATPortReq.extport = info->RequestedPort; 559 p[0] = (mDNSu8)((info->NATLease >> 24) & 0xFF); 560 p[1] = (mDNSu8)((info->NATLease >> 16) & 0xFF); 561 p[2] = (mDNSu8)((info->NATLease >> 8) & 0xFF); 562 p[3] = (mDNSu8)( info->NATLease & 0xFF); 563 564 err = mDNSPlatformSendUDP(m, (mDNSu8 *)&NATPortReq, end, 0, mDNSNULL, &m->Router, NATPMPPort, mDNSfalse); 565 debugf("uDNS_SendNATMsg: Sent NAT-PMP mapping request %d", err); 566 } 567 568 // In case the address request already went out for another NAT-T, 569 // set the NewAddress to the currently known global external address, so 570 // Address-only operations will get the callback immediately 571 info->NewAddress = m->ExtAddress; 572 573 // Remember that we just sent a NAT-PMP packet, so we won't resend one later. 574 // We do this because the NAT-PMP "Unsupported Version" response has no 575 // information about the (PCP) request that triggered it, so we must send 576 // NAT-PMP requests for all operations. Without this, we'll send n PCP 577 // requests for n operations, receive n NAT-PMP "Unsupported Version" 578 // responses, and send n NAT-PMP requests for each of those responses, 579 // resulting in (n + n^2) packets sent. We only want to send 2n packets: 580 // n PCP requests followed by n NAT-PMP requests. 581 info->sentNATPMP = mDNStrue; 582 } 583 } 584 else 585 { 586 PCPMapRequest req; 587 mDNSu8* start = (mDNSu8*)&req; 588 mDNSu8* end = start + sizeof(req); 589 mDNSu8* p = (mDNSu8*)&req.lifetime; 590 591 req.version = PCP_VERS; 592 req.opCode = PCPOp_Map; 593 req.reserved = zeroID; 594 595 p[0] = (mDNSu8)((info->NATLease >> 24) & 0xFF); 596 p[1] = (mDNSu8)((info->NATLease >> 16) & 0xFF); 597 p[2] = (mDNSu8)((info->NATLease >> 8) & 0xFF); 598 p[3] = (mDNSu8)( info->NATLease & 0xFF); 599 600 mDNSAddrMapIPv4toIPv6(&m->AdvertisedV4.ip.v4, &req.clientAddr); 601 602 req.nonce[0] = m->PCPNonce[0]; 603 req.nonce[1] = m->PCPNonce[1]; 604 req.nonce[2] = m->PCPNonce[2]; 605 606 req.protocol = (info->Protocol == NATOp_MapUDP ? PCPProto_UDP : PCPProto_TCP); 607 608 req.reservedMapOp[0] = 0; 609 req.reservedMapOp[1] = 0; 610 req.reservedMapOp[2] = 0; 611 612 req.intPort = info->Protocol ? info->IntPort : DiscardPort; 613 req.extPort = info->RequestedPort; 614 615 // Since we only support IPv4, even if using the all-zeros address, map it, so 616 // the PCP gateway will give us an IPv4 address & not an IPv6 address. 617 mDNSAddrMapIPv4toIPv6(&info->NewAddress, &req.extAddress); 618 619 err = mDNSPlatformSendUDP(m, start, end, 0, mDNSNULL, &m->Router, NATPMPPort, mDNSfalse); 620 debugf("uDNS_SendNATMsg: Sent PCP Mapping request %d", err); 621 622 // Unset the sentNATPMP flag, so that we'll send a NAT-PMP packet if we 623 // receive a NAT-PMP "Unsupported Version" packet. This will result in every 624 // renewal, retransmission, etc. being tried first as PCP, then if a NAT-PMP 625 // "Unsupported Version" response is received, fall-back & send the request 626 // using NAT-PMP. 627 info->sentNATPMP = mDNSfalse; 628 629#ifdef _LEGACY_NAT_TRAVERSAL_ 630 if (mDNSIPPortIsZero(m->UPnPRouterPort) || mDNSIPPortIsZero(m->UPnPSOAPPort)) 631 { 632 LNT_SendDiscoveryMsg(m); 633 debugf("uDNS_SendNATMsg: LNT_SendDiscoveryMsg"); 634 } 635 else 636 { 637 mStatus lnterr = LNT_MapPort(m, info); 638 if (lnterr) 639 LogMsg("uDNS_SendNATMsg: LNT_MapPort returned error %d", lnterr); 640 641 err = err ? err : lnterr; // PCP error takes precedence 642 } 643#endif // _LEGACY_NAT_TRAVERSAL_ 644 } 645 } 646 647 return(err); 648} 649 650mDNSexport void RecreateNATMappings(mDNS *const m, const mDNSu32 waitTicks) 651{ 652 mDNSu32 when = NonZeroTime(m->timenow + waitTicks); 653 NATTraversalInfo *n; 654 for (n = m->NATTraversals; n; n=n->next) 655 { 656 n->ExpiryTime = 0; // Mark this mapping as expired 657 n->retryInterval = NATMAP_INIT_RETRY; 658 n->retryPortMap = when; 659 n->lastSuccessfulProtocol = NATTProtocolNone; 660 if (!n->Protocol) n->NewResult = mStatus_NoError; 661#ifdef _LEGACY_NAT_TRAVERSAL_ 662 if (n->tcpInfo.sock) { mDNSPlatformTCPCloseConnection(n->tcpInfo.sock); n->tcpInfo.sock = mDNSNULL; } 663#endif // _LEGACY_NAT_TRAVERSAL_ 664 } 665 666 m->PCPNonce[0] = mDNSRandom(-1); 667 m->PCPNonce[1] = mDNSRandom(-1); 668 m->PCPNonce[2] = mDNSRandom(-1); 669 m->retryIntervalGetAddr = 0; 670 m->retryGetAddr = when; 671 672#ifdef _LEGACY_NAT_TRAVERSAL_ 673 LNT_ClearState(m); 674#endif // _LEGACY_NAT_TRAVERSAL_ 675 676 m->NextScheduledNATOp = m->timenow; // Need to send packets immediately 677} 678 679mDNSexport void natTraversalHandleAddressReply(mDNS *const m, mDNSu16 err, mDNSv4Addr ExtAddr) 680{ 681 static mDNSu16 last_err = 0; 682 NATTraversalInfo *n; 683 684 if (err) 685 { 686 if (err != last_err) LogMsg("Error getting external address %d", err); 687 ExtAddr = zerov4Addr; 688 } 689 else 690 { 691 LogInfo("Received external IP address %.4a from NAT", &ExtAddr); 692 if (mDNSv4AddrIsRFC1918(&ExtAddr)) 693 LogMsg("Double NAT (external NAT gateway address %.4a is also a private RFC 1918 address)", &ExtAddr); 694 if (mDNSIPv4AddressIsZero(ExtAddr)) 695 err = NATErr_NetFail; // fake error to handle routers that pathologically report success with the zero address 696 } 697 698 // Globally remember the most recently discovered address, so it can be used in each 699 // new NATTraversal structure 700 m->ExtAddress = ExtAddr; 701 702 if (!err) // Success, back-off to maximum interval 703 m->retryIntervalGetAddr = NATMAP_MAX_RETRY_INTERVAL; 704 else if (!last_err) // Failure after success, retry quickly (then back-off exponentially) 705 m->retryIntervalGetAddr = NATMAP_INIT_RETRY; 706 // else back-off normally in case of pathological failures 707 708 m->retryGetAddr = m->timenow + m->retryIntervalGetAddr; 709 if (m->NextScheduledNATOp - m->retryGetAddr > 0) 710 m->NextScheduledNATOp = m->retryGetAddr; 711 712 last_err = err; 713 714 for (n = m->NATTraversals; n; n=n->next) 715 { 716 // We should change n->NewAddress only when n is one of: 717 // 1) a mapping operation that most recently succeeded using NAT-PMP or UPnP/IGD, 718 // because such an operation needs the update now. If the lastSuccessfulProtocol 719 // is currently none, then natTraversalHandlePortMapReplyWithAddress() will be 720 // called should NAT-PMP or UPnP/IGD succeed in the future. 721 // 2) an address-only operation that did not succeed via PCP, because when such an 722 // operation succeeds via PCP, it's for the TCP discard port just to learn the 723 // address. And that address may be different than the external address 724 // discovered via NAT-PMP or UPnP/IGD. If the lastSuccessfulProtocol 725 // is currently none, we must update the NewAddress as PCP may not succeed. 726 if (!mDNSSameIPv4Address(n->NewAddress, ExtAddr) && 727 (n->Protocol ? 728 (n->lastSuccessfulProtocol == NATTProtocolNATPMP || n->lastSuccessfulProtocol == NATTProtocolUPNPIGD) : 729 (n->lastSuccessfulProtocol != NATTProtocolPCP))) 730 { 731 // Needs an update immediately 732 n->NewAddress = ExtAddr; 733 n->ExpiryTime = 0; 734 n->retryInterval = NATMAP_INIT_RETRY; 735 n->retryPortMap = m->timenow; 736#ifdef _LEGACY_NAT_TRAVERSAL_ 737 if (n->tcpInfo.sock) { mDNSPlatformTCPCloseConnection(n->tcpInfo.sock); n->tcpInfo.sock = mDNSNULL; } 738#endif // _LEGACY_NAT_TRAVERSAL_ 739 740 m->NextScheduledNATOp = m->timenow; // Need to send packets immediately 741 } 742 } 743} 744 745// Both places that call NATSetNextRenewalTime() update m->NextScheduledNATOp correctly afterwards 746mDNSlocal void NATSetNextRenewalTime(mDNS *const m, NATTraversalInfo *n) 747{ 748 n->retryInterval = (n->ExpiryTime - m->timenow)/2; 749 if (n->retryInterval < NATMAP_MIN_RETRY_INTERVAL) // Min retry interval is 2 seconds 750 n->retryInterval = NATMAP_MIN_RETRY_INTERVAL; 751 n->retryPortMap = m->timenow + n->retryInterval; 752} 753 754mDNSlocal void natTraversalHandlePortMapReplyWithAddress(mDNS *const m, NATTraversalInfo *n, const mDNSInterfaceID InterfaceID, mDNSu16 err, mDNSv4Addr extaddr, mDNSIPPort extport, mDNSu32 lease, NATTProtocol protocol) 755{ 756 const char *prot = n->Protocol == 0 ? "Add" : n->Protocol == NATOp_MapUDP ? "UDP" : n->Protocol == NATOp_MapTCP ? "TCP" : "???"; 757 (void)prot; 758 n->NewResult = err; 759 if (err || lease == 0 || mDNSIPPortIsZero(extport)) 760 { 761 LogInfo("natTraversalHandlePortMapReplyWithAddress: %p Response %s Port %5d External %.4a:%d lease %d error %d", 762 n, prot, mDNSVal16(n->IntPort), &extaddr, mDNSVal16(extport), lease, err); 763 n->retryInterval = NATMAP_MAX_RETRY_INTERVAL; 764 n->retryPortMap = m->timenow + NATMAP_MAX_RETRY_INTERVAL; 765 // No need to set m->NextScheduledNATOp here, since we're only ever extending the m->retryPortMap time 766 if (err == NATErr_Refused) n->NewResult = mStatus_NATPortMappingDisabled; 767 else if (err > NATErr_None && err <= NATErr_Opcode) n->NewResult = mStatus_NATPortMappingUnsupported; 768 } 769 else 770 { 771 if (lease > 999999999UL / mDNSPlatformOneSecond) 772 lease = 999999999UL / mDNSPlatformOneSecond; 773 n->ExpiryTime = NonZeroTime(m->timenow + lease * mDNSPlatformOneSecond); 774 775 if (!mDNSSameIPv4Address(n->NewAddress, extaddr) || !mDNSSameIPPort(n->RequestedPort, extport)) 776 LogInfo("natTraversalHandlePortMapReplyWithAddress: %p %s Response %s Port %5d External %.4a:%d changed to %.4a:%d lease %d", 777 n, 778 (n->lastSuccessfulProtocol == NATTProtocolNone ? "None " : 779 n->lastSuccessfulProtocol == NATTProtocolNATPMP ? "NAT-PMP " : 780 n->lastSuccessfulProtocol == NATTProtocolUPNPIGD ? "UPnP/IGD" : 781 n->lastSuccessfulProtocol == NATTProtocolPCP ? "PCP " : 782 /* else */ "Unknown " ), 783 prot, mDNSVal16(n->IntPort), &n->NewAddress, mDNSVal16(n->RequestedPort), 784 &extaddr, mDNSVal16(extport), lease); 785 786 n->InterfaceID = InterfaceID; 787 n->NewAddress = extaddr; 788 if (n->Protocol) n->RequestedPort = extport; // Don't report the (PCP) external port to address-only operations 789 n->lastSuccessfulProtocol = protocol; 790 791 NATSetNextRenewalTime(m, n); // Got our port mapping; now set timer to renew it at halfway point 792 m->NextScheduledNATOp = m->timenow; // May need to invoke client callback immediately 793 } 794} 795 796// To be called for NAT-PMP or UPnP/IGD mappings, to use currently discovered (global) address 797mDNSexport void natTraversalHandlePortMapReply(mDNS *const m, NATTraversalInfo *n, const mDNSInterfaceID InterfaceID, mDNSu16 err, mDNSIPPort extport, mDNSu32 lease, NATTProtocol protocol) 798{ 799 natTraversalHandlePortMapReplyWithAddress(m, n, InterfaceID, err, m->ExtAddress, extport, lease, protocol); 800} 801 802// Must be called with the mDNS_Lock held 803mDNSexport mStatus mDNS_StartNATOperation_internal(mDNS *const m, NATTraversalInfo *traversal) 804{ 805 NATTraversalInfo **n; 806 807 LogInfo("mDNS_StartNATOperation_internal %p Protocol %d IntPort %d RequestedPort %d NATLease %d", traversal, 808 traversal->Protocol, mDNSVal16(traversal->IntPort), mDNSVal16(traversal->RequestedPort), traversal->NATLease); 809 810 // Note: It important that new traversal requests are appended at the *end* of the list, not prepended at the start 811 for (n = &m->NATTraversals; *n; n=&(*n)->next) 812 { 813 if (traversal == *n) 814 { 815 LogMsg("Error! Tried to add a NAT traversal that's already in the active list: request %p Prot %d Int %d TTL %d", 816 traversal, traversal->Protocol, mDNSVal16(traversal->IntPort), traversal->NATLease); 817 #if ForceAlerts 818 *(long*)0 = 0; 819 #endif 820 return(mStatus_AlreadyRegistered); 821 } 822 if (traversal->Protocol && traversal->Protocol == (*n)->Protocol && mDNSSameIPPort(traversal->IntPort, (*n)->IntPort) && 823 !mDNSSameIPPort(traversal->IntPort, SSHPort)) 824 LogMsg("Warning: Created port mapping request %p Prot %d Int %d TTL %d " 825 "duplicates existing port mapping request %p Prot %d Int %d TTL %d", 826 traversal, traversal->Protocol, mDNSVal16(traversal->IntPort), traversal->NATLease, 827 *n, (*n)->Protocol, mDNSVal16((*n)->IntPort), (*n)->NATLease); 828 } 829 830 // Initialize necessary fields 831 traversal->next = mDNSNULL; 832 traversal->ExpiryTime = 0; 833 traversal->retryInterval = NATMAP_INIT_RETRY; 834 traversal->retryPortMap = m->timenow; 835 traversal->NewResult = mStatus_NoError; 836 traversal->lastSuccessfulProtocol = NATTProtocolNone; 837 traversal->sentNATPMP = mDNSfalse; 838 traversal->ExternalAddress = onesIPv4Addr; 839 traversal->NewAddress = zerov4Addr; 840 traversal->ExternalPort = zeroIPPort; 841 traversal->Lifetime = 0; 842 traversal->Result = mStatus_NoError; 843 844 // set default lease if necessary 845 if (!traversal->NATLease) traversal->NATLease = NATMAP_DEFAULT_LEASE; 846 847#ifdef _LEGACY_NAT_TRAVERSAL_ 848 mDNSPlatformMemZero(&traversal->tcpInfo, sizeof(traversal->tcpInfo)); 849#endif // _LEGACY_NAT_TRAVERSAL_ 850 851 if (!m->NATTraversals) // If this is our first NAT request, kick off an address request too 852 { 853 m->retryGetAddr = m->timenow; 854 m->retryIntervalGetAddr = NATMAP_INIT_RETRY; 855 } 856 857 // If this is an address-only operation, initialize to the current global address, 858 // or (in non-PCP environments) we won't know the address until the next external 859 // address request/response. 860 if (!traversal->Protocol) 861 { 862 traversal->NewAddress = m->ExtAddress; 863 } 864 865 m->NextScheduledNATOp = m->timenow; // This will always trigger sending the packet ASAP, and generate client callback if necessary 866 867 *n = traversal; // Append new NATTraversalInfo to the end of our list 868 869 return(mStatus_NoError); 870} 871 872// Must be called with the mDNS_Lock held 873mDNSexport mStatus mDNS_StopNATOperation_internal(mDNS *m, NATTraversalInfo *traversal) 874{ 875 mDNSBool unmap = mDNStrue; 876 NATTraversalInfo *p; 877 NATTraversalInfo **ptr = &m->NATTraversals; 878 879 while (*ptr && *ptr != traversal) ptr=&(*ptr)->next; 880 if (*ptr) *ptr = (*ptr)->next; // If we found it, cut this NATTraversalInfo struct from our list 881 else 882 { 883 LogMsg("mDNS_StopNATOperation_internal: NATTraversalInfo %p not found in list", traversal); 884 return(mStatus_BadReferenceErr); 885 } 886 887 LogInfo("mDNS_StopNATOperation_internal %p %d %d %d %d", traversal, 888 traversal->Protocol, mDNSVal16(traversal->IntPort), mDNSVal16(traversal->RequestedPort), traversal->NATLease); 889 890 if (m->CurrentNATTraversal == traversal) 891 m->CurrentNATTraversal = m->CurrentNATTraversal->next; 892 893 // If there is a match for the operation being stopped, don't send a deletion request (unmap) 894 for (p = m->NATTraversals; p; p=p->next) 895 { 896 if (traversal->Protocol ? 897 ((traversal->Protocol == p->Protocol && mDNSSameIPPort(traversal->IntPort, p->IntPort)) || 898 (!p->Protocol && traversal->Protocol == NATOp_MapTCP && mDNSSameIPPort(traversal->IntPort, DiscardPort))) : 899 (!p->Protocol || (p->Protocol == NATOp_MapTCP && mDNSSameIPPort(p->IntPort, DiscardPort)))) 900 { 901 LogInfo("Warning: Removed port mapping request %p Prot %d Int %d TTL %d " 902 "duplicates existing port mapping request %p Prot %d Int %d TTL %d", 903 traversal, traversal->Protocol, mDNSVal16(traversal->IntPort), traversal->NATLease, 904 p, p->Protocol, mDNSVal16( p->IntPort), p->NATLease); 905 unmap = mDNSfalse; 906 } 907 } 908 909 if (traversal->ExpiryTime && unmap) 910 { 911 traversal->NATLease = 0; 912 traversal->retryInterval = 0; 913 914 // In case we most recently sent NAT-PMP, we need to set sentNATPMP to false so 915 // that we'll send a NAT-PMP request to destroy the mapping. We do this because 916 // the NATTraversal struct has already been cut from the list, and the client 917 // layer will destroy the memory upon returning from this function, so we can't 918 // try PCP first and then fall-back to NAT-PMP. That is, if we most recently 919 // created/renewed the mapping using NAT-PMP, we need to destroy it using NAT-PMP 920 // now, because we won't get a chance later. 921 traversal->sentNATPMP = mDNSfalse; 922 923 // Both NAT-PMP & PCP RFCs state that the suggested port in deletion requests 924 // should be zero. And for PCP, the suggested external address should also be 925 // zero, specifically, the all-zeros IPv4-mapped address, since we would only 926 // would have requested an IPv4 address. 927 traversal->RequestedPort = zeroIPPort; 928 traversal->NewAddress = zerov4Addr; 929 930 uDNS_SendNATMsg(m, traversal, traversal->lastSuccessfulProtocol != NATTProtocolNATPMP); 931 } 932 933 // Even if we DIDN'T make a successful UPnP mapping yet, we might still have a partially-open TCP connection we need to clean up 934 #ifdef _LEGACY_NAT_TRAVERSAL_ 935 { 936 mStatus err = LNT_UnmapPort(m, traversal); 937 if (err) LogMsg("Legacy NAT Traversal - unmap request failed with error %d", err); 938 } 939 #endif // _LEGACY_NAT_TRAVERSAL_ 940 941 return(mStatus_NoError); 942} 943 944mDNSexport mStatus mDNS_StartNATOperation(mDNS *const m, NATTraversalInfo *traversal) 945{ 946 mStatus status; 947 mDNS_Lock(m); 948 status = mDNS_StartNATOperation_internal(m, traversal); 949 mDNS_Unlock(m); 950 return(status); 951} 952 953mDNSexport mStatus mDNS_StopNATOperation(mDNS *const m, NATTraversalInfo *traversal) 954{ 955 mStatus status; 956 mDNS_Lock(m); 957 status = mDNS_StopNATOperation_internal(m, traversal); 958 mDNS_Unlock(m); 959 return(status); 960} 961 962// *************************************************************************** 963#if COMPILER_LIKES_PRAGMA_MARK 964#pragma mark - 965#pragma mark - Long-Lived Queries 966#endif 967 968// Lock must be held -- otherwise m->timenow is undefined 969mDNSlocal void StartLLQPolling(mDNS *const m, DNSQuestion *q) 970{ 971 debugf("StartLLQPolling: %##s", q->qname.c); 972 q->state = LLQ_Poll; 973 q->ThisQInterval = INIT_UCAST_POLL_INTERVAL; 974 // We want to send our poll query ASAP, but the "+ 1" is because if we set the time to now, 975 // we risk causing spurious "SendQueries didn't send all its queries" log messages 976 q->LastQTime = m->timenow - q->ThisQInterval + 1; 977 SetNextQueryTime(m, q); 978#if APPLE_OSX_mDNSResponder 979 UpdateAutoTunnelDomainStatuses(m); 980#endif 981} 982 983mDNSlocal mDNSu8 *putLLQ(DNSMessage *const msg, mDNSu8 *ptr, const DNSQuestion *const question, const LLQOptData *const data) 984{ 985 AuthRecord rr; 986 ResourceRecord *opt = &rr.resrec; 987 rdataOPT *optRD; 988 989 //!!!KRS when we implement multiple llqs per message, we'll need to memmove anything past the question section 990 ptr = putQuestion(msg, ptr, msg->data + AbsoluteMaxDNSMessageData, &question->qname, question->qtype, question->qclass); 991 if (!ptr) { LogMsg("ERROR: putLLQ - putQuestion"); return mDNSNULL; } 992 993 // locate OptRR if it exists, set pointer to end 994 // !!!KRS implement me 995 996 // format opt rr (fields not specified are zero-valued) 997 mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); 998 opt->rrclass = NormalMaxDNSMessageData; 999 opt->rdlength = sizeof(rdataOPT); // One option in this OPT record 1000 opt->rdestimate = sizeof(rdataOPT); 1001 1002 optRD = &rr.resrec.rdata->u.opt[0]; 1003 optRD->opt = kDNSOpt_LLQ; 1004 optRD->u.llq = *data; 1005 ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.numAdditionals, opt, 0); 1006 if (!ptr) { LogMsg("ERROR: putLLQ - PutResourceRecordTTLJumbo"); return mDNSNULL; } 1007 1008 return ptr; 1009} 1010 1011// Normally we'd just request event packets be sent directly to m->LLQNAT.ExternalPort, except... 1012// with LLQs over TLS/TCP we're doing a weird thing where instead of requesting packets be sent to ExternalAddress:ExternalPort 1013// we're requesting that packets be sent to ExternalPort, but at the source address of our outgoing TCP connection. 1014// Normally, after going through the NAT gateway, the source address of our outgoing TCP connection is the same as ExternalAddress, 1015// so this is fine, except when the TCP connection ends up going over a VPN tunnel instead. 1016// To work around this, if we find that the source address for our TCP connection is not a private address, we tell the Dot Mac 1017// LLQ server to send events to us directly at port 5353 on that address, instead of at our mapped external NAT port. 1018 1019mDNSlocal mDNSu16 GetLLQEventPort(const mDNS *const m, const mDNSAddr *const dst) 1020{ 1021 mDNSAddr src; 1022 mDNSPlatformSourceAddrForDest(&src, dst); 1023 //LogMsg("GetLLQEventPort: src %#a for dst %#a (%d)", &src, dst, mDNSv4AddrIsRFC1918(&src.ip.v4) ? mDNSVal16(m->LLQNAT.ExternalPort) : 0); 1024 return(mDNSv4AddrIsRFC1918(&src.ip.v4) ? mDNSVal16(m->LLQNAT.ExternalPort) : mDNSVal16(MulticastDNSPort)); 1025} 1026 1027// Normally called with llq set. 1028// May be called with llq NULL, when retransmitting a lost Challenge Response 1029mDNSlocal void sendChallengeResponse(mDNS *const m, DNSQuestion *const q, const LLQOptData *llq) 1030{ 1031 mDNSu8 *responsePtr = m->omsg.data; 1032 LLQOptData llqBuf; 1033 1034 if (q->tcp) { LogMsg("sendChallengeResponse: ERROR!!: question %##s (%s) tcp non-NULL", q->qname.c, DNSTypeName(q->qtype)); return; } 1035 1036 if (PrivateQuery(q)) { LogMsg("sendChallengeResponse: ERROR!!: Private Query %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; } 1037 1038 if (q->ntries++ == kLLQ_MAX_TRIES) 1039 { 1040 LogMsg("sendChallengeResponse: %d failed attempts for LLQ %##s", kLLQ_MAX_TRIES, q->qname.c); 1041 StartLLQPolling(m,q); 1042 return; 1043 } 1044 1045 if (!llq) // Retransmission: need to make a new LLQOptData 1046 { 1047 llqBuf.vers = kLLQ_Vers; 1048 llqBuf.llqOp = kLLQOp_Setup; 1049 llqBuf.err = LLQErr_NoError; // Don't need to tell server UDP notification port when sending over UDP 1050 llqBuf.id = q->id; 1051 llqBuf.llqlease = q->ReqLease; 1052 llq = &llqBuf; 1053 } 1054 1055 q->LastQTime = m->timenow; 1056 q->ThisQInterval = q->tcp ? 0 : (kLLQ_INIT_RESEND * q->ntries * mDNSPlatformOneSecond); // If using TCP, don't need to retransmit 1057 SetNextQueryTime(m, q); 1058 1059 // To simulate loss of challenge response packet, uncomment line below 1060 //if (q->ntries == 1) return; 1061 1062 InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags); 1063 responsePtr = putLLQ(&m->omsg, responsePtr, q, llq); 1064 if (responsePtr) 1065 { 1066 mStatus err = mDNSSendDNSMessage(m, &m->omsg, responsePtr, mDNSInterface_Any, q->LocalSocket, &q->servAddr, q->servPort, mDNSNULL, mDNSNULL, mDNSfalse); 1067 if (err) { LogMsg("sendChallengeResponse: mDNSSendDNSMessage%s failed: %d", q->tcp ? " (TCP)" : "", err); } 1068 } 1069 else StartLLQPolling(m,q); 1070} 1071 1072mDNSlocal void SetLLQTimer(mDNS *const m, DNSQuestion *const q, const LLQOptData *const llq) 1073{ 1074 mDNSs32 lease = (mDNSs32)llq->llqlease * mDNSPlatformOneSecond; 1075 q->ReqLease = llq->llqlease; 1076 q->LastQTime = m->timenow; 1077 q->expire = m->timenow + lease; 1078 q->ThisQInterval = lease/2 + mDNSRandom(lease/10); 1079 debugf("SetLLQTimer setting %##s (%s) to %d %d", q->qname.c, DNSTypeName(q->qtype), lease/mDNSPlatformOneSecond, q->ThisQInterval/mDNSPlatformOneSecond); 1080 SetNextQueryTime(m, q); 1081} 1082 1083mDNSlocal void recvSetupResponse(mDNS *const m, mDNSu8 rcode, DNSQuestion *const q, const LLQOptData *const llq) 1084{ 1085 if (rcode && rcode != kDNSFlag1_RC_NXDomain) 1086 { LogMsg("ERROR: recvSetupResponse %##s (%s) - rcode && rcode != kDNSFlag1_RC_NXDomain", q->qname.c, DNSTypeName(q->qtype)); return; } 1087 1088 if (llq->llqOp != kLLQOp_Setup) 1089 { LogMsg("ERROR: recvSetupResponse %##s (%s) - bad op %d", q->qname.c, DNSTypeName(q->qtype), llq->llqOp); return; } 1090 1091 if (llq->vers != kLLQ_Vers) 1092 { LogMsg("ERROR: recvSetupResponse %##s (%s) - bad vers %d", q->qname.c, DNSTypeName(q->qtype), llq->vers); return; } 1093 1094 if (q->state == LLQ_InitialRequest) 1095 { 1096 //LogInfo("Got LLQ_InitialRequest"); 1097 1098 if (llq->err) { LogMsg("recvSetupResponse - received llq->err %d from server", llq->err); StartLLQPolling(m,q); return; } 1099 1100 if (q->ReqLease != llq->llqlease) 1101 debugf("recvSetupResponse: requested lease %lu, granted lease %lu", q->ReqLease, llq->llqlease); 1102 1103 // cache expiration in case we go to sleep before finishing setup 1104 q->ReqLease = llq->llqlease; 1105 q->expire = m->timenow + ((mDNSs32)llq->llqlease * mDNSPlatformOneSecond); 1106 1107 // update state 1108 q->state = LLQ_SecondaryRequest; 1109 q->id = llq->id; 1110 q->ntries = 0; // first attempt to send response 1111 sendChallengeResponse(m, q, llq); 1112 } 1113 else if (q->state == LLQ_SecondaryRequest) 1114 { 1115 //LogInfo("Got LLQ_SecondaryRequest"); 1116 1117 // Fix this immediately if not sooner. Copy the id from the LLQOptData into our DNSQuestion struct. This is only 1118 // an issue for private LLQs, because we skip parts 2 and 3 of the handshake. This is related to a bigger 1119 // problem of the current implementation of TCP LLQ setup: we're not handling state transitions correctly 1120 // if the server sends back SERVFULL or STATIC. 1121 if (PrivateQuery(q)) 1122 { 1123 LogInfo("Private LLQ_SecondaryRequest; copying id %08X%08X", llq->id.l[0], llq->id.l[1]); 1124 q->id = llq->id; 1125 } 1126 1127 if (llq->err) { LogMsg("ERROR: recvSetupResponse %##s (%s) code %d from server", q->qname.c, DNSTypeName(q->qtype), llq->err); StartLLQPolling(m,q); return; } 1128 if (!mDNSSameOpaque64(&q->id, &llq->id)) 1129 { LogMsg("recvSetupResponse - ID changed. discarding"); return; } // this can happen rarely (on packet loss + reordering) 1130 q->state = LLQ_Established; 1131 q->ntries = 0; 1132 SetLLQTimer(m, q, llq); 1133#if APPLE_OSX_mDNSResponder 1134 UpdateAutoTunnelDomainStatuses(m); 1135#endif 1136 } 1137} 1138 1139mDNSexport uDNS_LLQType uDNS_recvLLQResponse(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, 1140 const mDNSAddr *const srcaddr, const mDNSIPPort srcport, DNSQuestion **matchQuestion) 1141{ 1142 DNSQuestion pktQ, *q; 1143 if (msg->h.numQuestions && getQuestion(msg, msg->data, end, 0, &pktQ)) 1144 { 1145 const rdataOPT *opt = GetLLQOptData(m, msg, end); 1146 1147 for (q = m->Questions; q; q = q->next) 1148 { 1149 if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->qtype == pktQ.qtype && q->qnamehash == pktQ.qnamehash && SameDomainName(&q->qname, &pktQ.qname)) 1150 { 1151 debugf("uDNS_recvLLQResponse found %##s (%s) %d %#a %#a %X %X %X %X %d", 1152 q->qname.c, DNSTypeName(q->qtype), q->state, srcaddr, &q->servAddr, 1153 opt ? opt->u.llq.id.l[0] : 0, opt ? opt->u.llq.id.l[1] : 0, q->id.l[0], q->id.l[1], opt ? opt->u.llq.llqOp : 0); 1154 if (q->state == LLQ_Poll) debugf("uDNS_LLQ_Events: q->state == LLQ_Poll msg->h.id %d q->TargetQID %d", mDNSVal16(msg->h.id), mDNSVal16(q->TargetQID)); 1155 if (q->state == LLQ_Poll && mDNSSameOpaque16(msg->h.id, q->TargetQID)) 1156 { 1157 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 1158 1159 // Don't reset the state to IntialRequest as we may write that to the dynamic store 1160 // and PrefPane might wrongly think that we are "Starting" instead of "Polling". If 1161 // we are in polling state because of PCP/NAT-PMP disabled or DoubleNAT, next LLQNATCallback 1162 // would kick us back to LLQInitialRequest. So, resetting the state here may not be useful. 1163 // 1164 // If we have a good NAT (neither PCP/NAT-PMP disabled nor Double-NAT), then we should not be 1165 // possibly in polling state. To be safe, we want to retry from the start in that case 1166 // as there may not be another LLQNATCallback 1167 // 1168 // NOTE: We can be in polling state if we cannot resolve the SOA record i.e, servAddr is set to 1169 // all ones. In that case, we would set it in LLQ_InitialRequest as it overrides the PCP/NAT-PMP or 1170 // Double-NAT state. 1171 if (!mDNSAddressIsOnes(&q->servAddr) && !mDNSIPPortIsZero(m->LLQNAT.ExternalPort) && 1172 !m->LLQNAT.Result) 1173 { 1174 debugf("uDNS_recvLLQResponse got poll response; moving to LLQ_InitialRequest for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 1175 q->state = LLQ_InitialRequest; 1176 } 1177 q->servPort = zeroIPPort; // Clear servPort so that startLLQHandshake will retry the GetZoneData processing 1178 q->ThisQInterval = LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10); // Retry LLQ setup in approx 15 minutes 1179 q->LastQTime = m->timenow; 1180 SetNextQueryTime(m, q); 1181 *matchQuestion = q; 1182 return uDNS_LLQ_Entire; // uDNS_LLQ_Entire means flush stale records; assume a large effective TTL 1183 } 1184 // Note: In LLQ Event packets, the msg->h.id does not match our q->TargetQID, because in that case the msg->h.id nonce is selected by the server 1185 else if (opt && q->state == LLQ_Established && opt->u.llq.llqOp == kLLQOp_Event && mDNSSameOpaque64(&opt->u.llq.id, &q->id)) 1186 { 1187 mDNSu8 *ackEnd; 1188 //debugf("Sending LLQ ack for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 1189 InitializeDNSMessage(&m->omsg.h, msg->h.id, ResponseFlags); 1190 ackEnd = putLLQ(&m->omsg, m->omsg.data, q, &opt->u.llq); 1191 if (ackEnd) mDNSSendDNSMessage(m, &m->omsg, ackEnd, mDNSInterface_Any, q->LocalSocket, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse); 1192 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 1193 debugf("uDNS_LLQ_Events: q->state == LLQ_Established msg->h.id %d q->TargetQID %d", mDNSVal16(msg->h.id), mDNSVal16(q->TargetQID)); 1194 *matchQuestion = q; 1195 return uDNS_LLQ_Events; 1196 } 1197 if (opt && mDNSSameOpaque16(msg->h.id, q->TargetQID)) 1198 { 1199 if (q->state == LLQ_Established && opt->u.llq.llqOp == kLLQOp_Refresh && mDNSSameOpaque64(&opt->u.llq.id, &q->id) && msg->h.numAdditionals && !msg->h.numAnswers) 1200 { 1201 if (opt->u.llq.err != LLQErr_NoError) LogMsg("recvRefreshReply: received error %d from server", opt->u.llq.err); 1202 else 1203 { 1204 //LogInfo("Received refresh confirmation ntries %d for %##s (%s)", q->ntries, q->qname.c, DNSTypeName(q->qtype)); 1205 // If we're waiting to go to sleep, then this LLQ deletion may have been the thing 1206 // we were waiting for, so schedule another check to see if we can sleep now. 1207 if (opt->u.llq.llqlease == 0 && m->SleepLimit) m->NextScheduledSPRetry = m->timenow; 1208 GrantCacheExtensions(m, q, opt->u.llq.llqlease); 1209 SetLLQTimer(m, q, &opt->u.llq); 1210 q->ntries = 0; 1211 } 1212 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 1213 *matchQuestion = q; 1214 return uDNS_LLQ_Ignore; 1215 } 1216 if (q->state < LLQ_Established && mDNSSameAddress(srcaddr, &q->servAddr)) 1217 { 1218 LLQ_State oldstate = q->state; 1219 recvSetupResponse(m, msg->h.flags.b[1] & kDNSFlag1_RC_Mask, q, &opt->u.llq); 1220 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 1221 // We have a protocol anomaly here in the LLQ definition. 1222 // Both the challenge packet from the server and the ack+answers packet have opt->u.llq.llqOp == kLLQOp_Setup. 1223 // However, we need to treat them differently: 1224 // The challenge packet has no answers in it, and tells us nothing about whether our cache entries 1225 // are still valid, so this packet should not cause us to do anything that messes with our cache. 1226 // The ack+answers packet gives us the whole truth, so we should handle it by updating our cache 1227 // to match the answers in the packet, and only the answers in the packet. 1228 *matchQuestion = q; 1229 return (oldstate == LLQ_SecondaryRequest ? uDNS_LLQ_Entire : uDNS_LLQ_Ignore); 1230 } 1231 } 1232 } 1233 } 1234 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 1235 } 1236 *matchQuestion = mDNSNULL; 1237 return uDNS_LLQ_Not; 1238} 1239 1240// Stub definition of TCPSocket_struct so we can access flags field. (Rest of TCPSocket_struct is platform-dependent.) 1241struct TCPSocket_struct { TCPSocketFlags flags; /* ... */ }; 1242 1243// tcpCallback is called to handle events (e.g. connection opening and data reception) on TCP connections for 1244// Private DNS operations -- private queries, private LLQs, private record updates and private service updates 1245mDNSlocal void tcpCallback(TCPSocket *sock, void *context, mDNSBool ConnectionEstablished, mStatus err) 1246{ 1247 tcpInfo_t *tcpInfo = (tcpInfo_t *)context; 1248 mDNSBool closed = mDNSfalse; 1249 mDNS *m = tcpInfo->m; 1250 DNSQuestion *const q = tcpInfo->question; 1251 tcpInfo_t **backpointer = 1252 q ? &q->tcp : 1253 tcpInfo->rr ? &tcpInfo->rr->tcp : mDNSNULL; 1254 if (backpointer && *backpointer != tcpInfo) 1255 LogMsg("tcpCallback: %d backpointer %p incorrect tcpInfo %p question %p rr %p", 1256 mDNSPlatformTCPGetFD(tcpInfo->sock), *backpointer, tcpInfo, q, tcpInfo->rr); 1257 1258 if (err) goto exit; 1259 1260 if (ConnectionEstablished) 1261 { 1262 mDNSu8 *end = ((mDNSu8*) &tcpInfo->request) + tcpInfo->requestLen; 1263 DomainAuthInfo *AuthInfo; 1264 1265 // Defensive coding for <rdar://problem/5546824> Crash in mDNSResponder at GetAuthInfoForName_internal + 366 1266 // Don't know yet what's causing this, but at least we can be cautious and try to avoid crashing if we find our pointers in an unexpected state 1267 if (tcpInfo->rr && tcpInfo->rr->resrec.name != &tcpInfo->rr->namestorage) 1268 LogMsg("tcpCallback: ERROR: tcpInfo->rr->resrec.name %p != &tcpInfo->rr->namestorage %p", 1269 tcpInfo->rr->resrec.name, &tcpInfo->rr->namestorage); 1270 if (tcpInfo->rr && tcpInfo->rr->resrec.name != &tcpInfo->rr->namestorage) return; 1271 1272 AuthInfo = tcpInfo->rr ? GetAuthInfoForName(m, tcpInfo->rr->resrec.name) : mDNSNULL; 1273 1274 // connection is established - send the message 1275 if (q && q->LongLived && q->state == LLQ_Established) 1276 { 1277 // Lease renewal over TCP, resulting from opening a TCP connection in sendLLQRefresh 1278 end = ((mDNSu8*) &tcpInfo->request) + tcpInfo->requestLen; 1279 } 1280 else if (q && q->LongLived && q->state != LLQ_Poll && !mDNSIPPortIsZero(m->LLQNAT.ExternalPort) && !mDNSIPPortIsZero(q->servPort)) 1281 { 1282 // Notes: 1283 // If we have a NAT port mapping, ExternalPort is the external port 1284 // If we have a routable address so we don't need a port mapping, ExternalPort is the same as our own internal port 1285 // If we need a NAT port mapping but can't get one, then ExternalPort is zero 1286 LLQOptData llqData; // set llq rdata 1287 llqData.vers = kLLQ_Vers; 1288 llqData.llqOp = kLLQOp_Setup; 1289 llqData.err = GetLLQEventPort(m, &tcpInfo->Addr); // We're using TCP; tell server what UDP port to send notifications to 1290 LogInfo("tcpCallback: eventPort %d", llqData.err); 1291 llqData.id = zeroOpaque64; 1292 llqData.llqlease = kLLQ_DefLease; 1293 InitializeDNSMessage(&tcpInfo->request.h, q->TargetQID, uQueryFlags); 1294 end = putLLQ(&tcpInfo->request, tcpInfo->request.data, q, &llqData); 1295 if (!end) { LogMsg("ERROR: tcpCallback - putLLQ"); err = mStatus_UnknownErr; goto exit; } 1296 AuthInfo = q->AuthInfo; // Need to add TSIG to this message 1297 q->ntries = 0; // Reset ntries so that tcp/tls connection failures don't affect sendChallengeResponse failures 1298 } 1299 else if (q) 1300 { 1301 // LLQ Polling mode or non-LLQ uDNS over TCP 1302 InitializeDNSMessage(&tcpInfo->request.h, q->TargetQID, (DNSSECQuestion(q) ? DNSSecQFlags : uQueryFlags)); 1303 end = putQuestion(&tcpInfo->request, tcpInfo->request.data, tcpInfo->request.data + AbsoluteMaxDNSMessageData, &q->qname, q->qtype, q->qclass); 1304 if (DNSSECQuestion(q) && q->qDNSServer && !q->qDNSServer->cellIntf) 1305 { 1306 if (q->ProxyQuestion) 1307 end = DNSProxySetAttributes(q, &tcpInfo->request.h, &tcpInfo->request, end, tcpInfo->request.data + AbsoluteMaxDNSMessageData); 1308 else 1309 end = putDNSSECOption(&tcpInfo->request, end, tcpInfo->request.data + AbsoluteMaxDNSMessageData); 1310 } 1311 1312 AuthInfo = q->AuthInfo; // Need to add TSIG to this message 1313 } 1314 1315 err = mDNSSendDNSMessage(m, &tcpInfo->request, end, mDNSInterface_Any, mDNSNULL, &tcpInfo->Addr, tcpInfo->Port, sock, AuthInfo, mDNSfalse); 1316 if (err) { debugf("ERROR: tcpCallback: mDNSSendDNSMessage - %d", err); err = mStatus_UnknownErr; goto exit; } 1317 1318 // Record time we sent this question 1319 if (q) 1320 { 1321 mDNS_Lock(m); 1322 q->LastQTime = m->timenow; 1323 if (q->ThisQInterval < (256 * mDNSPlatformOneSecond)) // Now we have a TCP connection open, make sure we wait at least 256 seconds before retrying 1324 q->ThisQInterval = (256 * mDNSPlatformOneSecond); 1325 SetNextQueryTime(m, q); 1326 mDNS_Unlock(m); 1327 } 1328 } 1329 else 1330 { 1331 long n; 1332 if (tcpInfo->nread < 2) // First read the two-byte length preceeding the DNS message 1333 { 1334 mDNSu8 *lenptr = (mDNSu8 *)&tcpInfo->replylen; 1335 n = mDNSPlatformReadTCP(sock, lenptr + tcpInfo->nread, 2 - tcpInfo->nread, &closed); 1336 if (n < 0) 1337 { 1338 LogMsg("ERROR: tcpCallback - attempt to read message length failed (%d)", n); 1339 err = mStatus_ConnFailed; 1340 goto exit; 1341 } 1342 else if (closed) 1343 { 1344 // It's perfectly fine for this socket to close after the first reply. The server might 1345 // be sending gratuitous replies using UDP and doesn't have a need to leave the TCP socket open. 1346 // We'll only log this event if we've never received a reply before. 1347 // BIND 9 appears to close an idle connection after 30 seconds. 1348 if (tcpInfo->numReplies == 0) 1349 { 1350 LogMsg("ERROR: socket closed prematurely tcpInfo->nread = %d", tcpInfo->nread); 1351 err = mStatus_ConnFailed; 1352 goto exit; 1353 } 1354 else 1355 { 1356 // Note that we may not be doing the best thing if an error occurs after we've sent a second request 1357 // over this tcp connection. That is, we only track whether we've received at least one response 1358 // which may have been to a previous request sent over this tcp connection. 1359 if (backpointer) *backpointer = mDNSNULL; // Clear client backpointer FIRST so we don't risk double-disposing our tcpInfo_t 1360 DisposeTCPConn(tcpInfo); 1361 return; 1362 } 1363 } 1364 1365 tcpInfo->nread += n; 1366 if (tcpInfo->nread < 2) goto exit; 1367 1368 tcpInfo->replylen = (mDNSu16)((mDNSu16)lenptr[0] << 8 | lenptr[1]); 1369 if (tcpInfo->replylen < sizeof(DNSMessageHeader)) 1370 { LogMsg("ERROR: tcpCallback - length too short (%d bytes)", tcpInfo->replylen); err = mStatus_UnknownErr; goto exit; } 1371 1372 tcpInfo->reply = mDNSPlatformMemAllocate(tcpInfo->replylen); 1373 if (!tcpInfo->reply) { LogMsg("ERROR: tcpCallback - malloc failed"); err = mStatus_NoMemoryErr; goto exit; } 1374 } 1375 1376 n = mDNSPlatformReadTCP(sock, ((char *)tcpInfo->reply) + (tcpInfo->nread - 2), tcpInfo->replylen - (tcpInfo->nread - 2), &closed); 1377 1378 if (n < 0) 1379 { 1380 LogMsg("ERROR: tcpCallback - read returned %d", n); 1381 err = mStatus_ConnFailed; 1382 goto exit; 1383 } 1384 else if (closed) 1385 { 1386 if (tcpInfo->numReplies == 0) 1387 { 1388 LogMsg("ERROR: socket closed prematurely tcpInfo->nread = %d", tcpInfo->nread); 1389 err = mStatus_ConnFailed; 1390 goto exit; 1391 } 1392 else 1393 { 1394 // Note that we may not be doing the best thing if an error occurs after we've sent a second request 1395 // over this tcp connection. That is, we only track whether we've received at least one response 1396 // which may have been to a previous request sent over this tcp connection. 1397 if (backpointer) *backpointer = mDNSNULL; // Clear client backpointer FIRST so we don't risk double-disposing our tcpInfo_t 1398 DisposeTCPConn(tcpInfo); 1399 return; 1400 } 1401 } 1402 1403 tcpInfo->nread += n; 1404 1405 if ((tcpInfo->nread - 2) == tcpInfo->replylen) 1406 { 1407 mDNSBool tls; 1408 DNSMessage *reply = tcpInfo->reply; 1409 mDNSu8 *end = (mDNSu8 *)tcpInfo->reply + tcpInfo->replylen; 1410 mDNSAddr Addr = tcpInfo->Addr; 1411 mDNSIPPort Port = tcpInfo->Port; 1412 mDNSIPPort srcPort = zeroIPPort; 1413 tcpInfo->numReplies++; 1414 tcpInfo->reply = mDNSNULL; // Detach reply buffer from tcpInfo_t, to make sure client callback can't cause it to be disposed 1415 tcpInfo->nread = 0; 1416 tcpInfo->replylen = 0; 1417 1418 // If we're going to dispose this connection, do it FIRST, before calling client callback 1419 // Note: Sleep code depends on us clearing *backpointer here -- it uses the clearing of rr->tcp 1420 // as the signal that the DNS deregistration operation with the server has completed, and the machine may now sleep 1421 // If we clear the tcp pointer in the question, mDNSCoreReceiveResponse cannot find a matching question. Hence 1422 // we store the minimal information i.e., the source port of the connection in the question itself. 1423 // Dereference sock before it is disposed in DisposeTCPConn below. 1424 1425 if (sock->flags & kTCPSocketFlags_UseTLS) tls = mDNStrue; 1426 else tls = mDNSfalse; 1427 1428 if (q && q->tcp) {srcPort = q->tcp->SrcPort; q->tcpSrcPort = srcPort;} 1429 1430 if (backpointer) 1431 if (!q || !q->LongLived || m->SleepState) 1432 { *backpointer = mDNSNULL; DisposeTCPConn(tcpInfo); } 1433 1434 mDNSCoreReceive(m, reply, end, &Addr, Port, tls ? (mDNSAddr *)1 : mDNSNULL, srcPort, 0); 1435 // USE CAUTION HERE: Invoking mDNSCoreReceive may have caused the environment to change, including canceling this operation itself 1436 1437 mDNSPlatformMemFree(reply); 1438 return; 1439 } 1440 } 1441 1442exit: 1443 1444 if (err) 1445 { 1446 // Clear client backpointer FIRST -- that way if one of the callbacks cancels its operation 1447 // we won't end up double-disposing our tcpInfo_t 1448 if (backpointer) *backpointer = mDNSNULL; 1449 1450 mDNS_Lock(m); // Need to grab the lock to get m->timenow 1451 1452 if (q) 1453 { 1454 if (q->ThisQInterval == 0) 1455 { 1456 // We get here when we fail to establish a new TCP/TLS connection that would have been used for a new LLQ request or an LLQ renewal. 1457 // Note that ThisQInterval is also zero when sendChallengeResponse resends the LLQ request on an extant TCP/TLS connection. 1458 q->LastQTime = m->timenow; 1459 if (q->LongLived) 1460 { 1461 // We didn't get the chance to send our request packet before the TCP/TLS connection failed. 1462 // We want to retry quickly, but want to back off exponentially in case the server is having issues. 1463 // Since ThisQInterval was 0, we can't just multiply by QuestionIntervalStep, we must track the number 1464 // of TCP/TLS connection failures using ntries. 1465 mDNSu32 count = q->ntries + 1; // want to wait at least 1 second before retrying 1466 1467 q->ThisQInterval = InitialQuestionInterval; 1468 1469 for (; count; count--) 1470 q->ThisQInterval *= QuestionIntervalStep; 1471 1472 if (q->ThisQInterval > LLQ_POLL_INTERVAL) 1473 q->ThisQInterval = LLQ_POLL_INTERVAL; 1474 else 1475 q->ntries++; 1476 1477 LogMsg("tcpCallback: stream connection for LLQ %##s (%s) failed %d times, retrying in %d ms", q->qname.c, DNSTypeName(q->qtype), q->ntries, q->ThisQInterval); 1478 } 1479 else 1480 { 1481 q->ThisQInterval = MAX_UCAST_POLL_INTERVAL; 1482 LogMsg("tcpCallback: stream connection for %##s (%s) failed, retrying in %d ms", q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval); 1483 } 1484 SetNextQueryTime(m, q); 1485 } 1486 else if (NextQSendTime(q) - m->timenow > (q->LongLived ? LLQ_POLL_INTERVAL : MAX_UCAST_POLL_INTERVAL)) 1487 { 1488 // If we get an error and our next scheduled query for this question is more than the max interval from now, 1489 // reset the next query to ensure we wait no longer the maximum interval from now before trying again. 1490 q->LastQTime = m->timenow; 1491 q->ThisQInterval = q->LongLived ? LLQ_POLL_INTERVAL : MAX_UCAST_POLL_INTERVAL; 1492 SetNextQueryTime(m, q); 1493 LogMsg("tcpCallback: stream connection for %##s (%s) failed, retrying in %d ms", q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval); 1494 } 1495 1496 // We're about to dispose of the TCP connection, so we must reset the state to retry over TCP/TLS 1497 // because sendChallengeResponse will send the query via UDP if we don't have a tcp pointer. 1498 // Resetting to LLQ_InitialRequest will cause uDNS_CheckCurrentQuestion to call startLLQHandshake, which 1499 // will attempt to establish a new tcp connection. 1500 if (q->LongLived && q->state == LLQ_SecondaryRequest) 1501 q->state = LLQ_InitialRequest; 1502 1503 // ConnFailed may happen if the server sends a TCP reset or TLS fails, in which case we want to retry establishing the LLQ 1504 // quickly rather than switching to polling mode. This case is handled by the above code to set q->ThisQInterval just above. 1505 // If the error isn't ConnFailed, then the LLQ is in bad shape, so we switch to polling mode. 1506 if (err != mStatus_ConnFailed) 1507 { 1508 if (q->LongLived && q->state != LLQ_Poll) StartLLQPolling(m, q); 1509 } 1510 } 1511 1512 mDNS_Unlock(m); 1513 1514 DisposeTCPConn(tcpInfo); 1515 } 1516} 1517 1518mDNSlocal tcpInfo_t *MakeTCPConn(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, 1519 TCPSocketFlags flags, const mDNSAddr *const Addr, const mDNSIPPort Port, domainname *hostname, 1520 DNSQuestion *const question, AuthRecord *const rr) 1521{ 1522 mStatus err; 1523 mDNSIPPort srcport = zeroIPPort; 1524 tcpInfo_t *info; 1525 mDNSBool useBackgroundTrafficClass; 1526 1527 useBackgroundTrafficClass = question ? question->UseBackgroundTrafficClass : mDNSfalse; 1528 1529 if ((flags & kTCPSocketFlags_UseTLS) && (!hostname || !hostname->c[0])) 1530 { LogMsg("MakeTCPConn: TLS connection being setup with NULL hostname"); return mDNSNULL; } 1531 1532 info = (tcpInfo_t *)mDNSPlatformMemAllocate(sizeof(tcpInfo_t)); 1533 if (!info) { LogMsg("ERROR: MakeTCP - memallocate failed"); return(mDNSNULL); } 1534 mDNSPlatformMemZero(info, sizeof(tcpInfo_t)); 1535 1536 info->m = m; 1537 info->sock = mDNSPlatformTCPSocket(m, flags, &srcport, useBackgroundTrafficClass); 1538 info->requestLen = 0; 1539 info->question = question; 1540 info->rr = rr; 1541 info->Addr = *Addr; 1542 info->Port = Port; 1543 info->reply = mDNSNULL; 1544 info->replylen = 0; 1545 info->nread = 0; 1546 info->numReplies = 0; 1547 info->SrcPort = srcport; 1548 1549 if (msg) 1550 { 1551 info->requestLen = (int) (end - ((mDNSu8*)msg)); 1552 mDNSPlatformMemCopy(&info->request, msg, info->requestLen); 1553 } 1554 1555 if (!info->sock) { LogMsg("MakeTCPConn: unable to create TCP socket"); mDNSPlatformMemFree(info); return(mDNSNULL); } 1556 err = mDNSPlatformTCPConnect(info->sock, Addr, Port, hostname, (question ? question->InterfaceID : mDNSNULL), tcpCallback, info); 1557 1558 // Probably suboptimal here. 1559 // Instead of returning mDNSNULL here on failure, we should probably invoke the callback with an error code. 1560 // That way clients can put all the error handling and retry/recovery code in one place, 1561 // instead of having to handle immediate errors in one place and async errors in another. 1562 // Also: "err == mStatus_ConnEstablished" probably never happens. 1563 1564 // Don't need to log "connection failed" in customer builds -- it happens quite often during sleep, wake, configuration changes, etc. 1565 if (err == mStatus_ConnEstablished) { tcpCallback(info->sock, info, mDNStrue, mStatus_NoError); } 1566 else if (err != mStatus_ConnPending ) { LogInfo("MakeTCPConn: connection failed"); DisposeTCPConn(info); return(mDNSNULL); } 1567 return(info); 1568} 1569 1570mDNSexport void DisposeTCPConn(struct tcpInfo_t *tcp) 1571{ 1572 mDNSPlatformTCPCloseConnection(tcp->sock); 1573 if (tcp->reply) mDNSPlatformMemFree(tcp->reply); 1574 mDNSPlatformMemFree(tcp); 1575} 1576 1577// Lock must be held 1578mDNSexport void startLLQHandshake(mDNS *m, DNSQuestion *q) 1579{ 1580 if (m->LLQNAT.clientContext != mDNSNULL) // LLQNAT just started, give it some time 1581 { 1582 LogInfo("startLLQHandshake: waiting for NAT status for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 1583 q->ThisQInterval = LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10); // Retry in approx 15 minutes 1584 q->LastQTime = m->timenow; 1585 SetNextQueryTime(m, q); 1586 return; 1587 } 1588 1589 // Either we don't have {PCP, NAT-PMP, UPnP/IGD} support (ExternalPort is zero) or behind a Double NAT that may or 1590 // may not have {PCP, NAT-PMP, UPnP/IGD} support (NATResult is non-zero) 1591 if (mDNSIPPortIsZero(m->LLQNAT.ExternalPort) || m->LLQNAT.Result) 1592 { 1593 LogInfo("startLLQHandshake: Cannot receive inbound packets; will poll for %##s (%s) External Port %d, NAT Result %d", 1594 q->qname.c, DNSTypeName(q->qtype), mDNSVal16(m->LLQNAT.ExternalPort), m->LLQNAT.Result); 1595 StartLLQPolling(m, q); 1596 return; 1597 } 1598 1599 if (mDNSIPPortIsZero(q->servPort)) 1600 { 1601 debugf("startLLQHandshake: StartGetZoneData for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 1602 q->ThisQInterval = LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10); // Retry in approx 15 minutes 1603 q->LastQTime = m->timenow; 1604 SetNextQueryTime(m, q); 1605 q->servAddr = zeroAddr; 1606 // We know q->servPort is zero because of check above 1607 if (q->nta) CancelGetZoneData(m, q->nta); 1608 q->nta = StartGetZoneData(m, &q->qname, ZoneServiceLLQ, LLQGotZoneData, q); 1609 return; 1610 } 1611 1612 if (PrivateQuery(q)) 1613 { 1614 if (q->tcp) LogInfo("startLLQHandshake: Disposing existing TCP connection for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 1615 if (q->tcp) { DisposeTCPConn(q->tcp); q->tcp = mDNSNULL; } 1616 if (!q->nta) 1617 { 1618 // Normally we lookup the zone data and then call this function. And we never free the zone data 1619 // for "PrivateQuery". But sometimes this can happen due to some race conditions. When we 1620 // switch networks, we might end up "Polling" the network e.g., we are behind a Double NAT. 1621 // When we poll, we free the zone information as we send the query to the server (See 1622 // PrivateQueryGotZoneData). The NAT callback (LLQNATCallback) may happen soon after that. If we 1623 // are still behind Double NAT, we would have returned early in this function. But we could 1624 // have switched to a network with no NATs and we should get the zone data again. 1625 LogInfo("startLLQHandshake: nta is NULL for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 1626 q->nta = StartGetZoneData(m, &q->qname, ZoneServiceLLQ, LLQGotZoneData, q); 1627 return; 1628 } 1629 else if (!q->nta->Host.c[0]) 1630 { 1631 // This should not happen. If it happens, we print a log and MakeTCPConn will fail if it can't find a hostname 1632 LogMsg("startLLQHandshake: ERROR!!: nta non NULL for %##s (%s) but HostName %d NULL, LongLived %d", q->qname.c, DNSTypeName(q->qtype), q->nta->Host.c[0], q->LongLived); 1633 } 1634 q->tcp = MakeTCPConn(m, mDNSNULL, mDNSNULL, kTCPSocketFlags_UseTLS, &q->servAddr, q->servPort, &q->nta->Host, q, mDNSNULL); 1635 if (!q->tcp) 1636 q->ThisQInterval = mDNSPlatformOneSecond * 5; // If TCP failed (transient networking glitch) try again in five seconds 1637 else 1638 { 1639 q->state = LLQ_SecondaryRequest; // Right now, for private DNS, we skip the four-way LLQ handshake 1640 q->ReqLease = kLLQ_DefLease; 1641 q->ThisQInterval = 0; 1642 } 1643 q->LastQTime = m->timenow; 1644 SetNextQueryTime(m, q); 1645 } 1646 else 1647 { 1648 debugf("startLLQHandshake: m->AdvertisedV4 %#a%s Server %#a:%d%s %##s (%s)", 1649 &m->AdvertisedV4, mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) ? " (RFC 1918)" : "", 1650 &q->servAddr, mDNSVal16(q->servPort), mDNSAddrIsRFC1918(&q->servAddr) ? " (RFC 1918)" : "", 1651 q->qname.c, DNSTypeName(q->qtype)); 1652 1653 if (q->ntries++ >= kLLQ_MAX_TRIES) 1654 { 1655 LogMsg("startLLQHandshake: %d failed attempts for LLQ %##s Polling.", kLLQ_MAX_TRIES, q->qname.c); 1656 StartLLQPolling(m, q); 1657 } 1658 else 1659 { 1660 mDNSu8 *end; 1661 LLQOptData llqData; 1662 1663 // set llq rdata 1664 llqData.vers = kLLQ_Vers; 1665 llqData.llqOp = kLLQOp_Setup; 1666 llqData.err = LLQErr_NoError; // Don't need to tell server UDP notification port when sending over UDP 1667 llqData.id = zeroOpaque64; 1668 llqData.llqlease = kLLQ_DefLease; 1669 1670 InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags); 1671 end = putLLQ(&m->omsg, m->omsg.data, q, &llqData); 1672 if (!end) { LogMsg("ERROR: startLLQHandshake - putLLQ"); StartLLQPolling(m,q); return; } 1673 1674 mDNSSendDNSMessage(m, &m->omsg, end, mDNSInterface_Any, q->LocalSocket, &q->servAddr, q->servPort, mDNSNULL, mDNSNULL, mDNSfalse); 1675 1676 // update question state 1677 q->state = LLQ_InitialRequest; 1678 q->ReqLease = kLLQ_DefLease; 1679 q->ThisQInterval = (kLLQ_INIT_RESEND * mDNSPlatformOneSecond); 1680 q->LastQTime = m->timenow; 1681 SetNextQueryTime(m, q); 1682 } 1683 } 1684} 1685 1686// forward declaration so GetServiceTarget can do reverse lookup if needed 1687mDNSlocal void GetStaticHostname(mDNS *m); 1688 1689mDNSexport const domainname *GetServiceTarget(mDNS *m, AuthRecord *const rr) 1690{ 1691 debugf("GetServiceTarget %##s", rr->resrec.name->c); 1692 1693 if (!rr->AutoTarget) // If not automatically tracking this host's current name, just return the existing target 1694 return(&rr->resrec.rdata->u.srv.target); 1695 else 1696 { 1697#if APPLE_OSX_mDNSResponder 1698 DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name); 1699 if (AuthInfo && AuthInfo->AutoTunnel) 1700 { 1701 StartServerTunnel(m, AuthInfo); 1702 if (AuthInfo->AutoTunnelHostRecord.namestorage.c[0] == 0) return(mDNSNULL); 1703 debugf("GetServiceTarget: Returning %##s", AuthInfo->AutoTunnelHostRecord.namestorage.c); 1704 return(&AuthInfo->AutoTunnelHostRecord.namestorage); 1705 } 1706 else 1707#endif // APPLE_OSX_mDNSResponder 1708 { 1709 const int srvcount = CountLabels(rr->resrec.name); 1710 HostnameInfo *besthi = mDNSNULL, *hi; 1711 int best = 0; 1712 for (hi = m->Hostnames; hi; hi = hi->next) 1713 if (hi->arv4.state == regState_Registered || hi->arv4.state == regState_Refresh || 1714 hi->arv6.state == regState_Registered || hi->arv6.state == regState_Refresh) 1715 { 1716 int x, hostcount = CountLabels(&hi->fqdn); 1717 for (x = hostcount < srvcount ? hostcount : srvcount; x > 0 && x > best; x--) 1718 if (SameDomainName(SkipLeadingLabels(rr->resrec.name, srvcount - x), SkipLeadingLabels(&hi->fqdn, hostcount - x))) 1719 { best = x; besthi = hi; } 1720 } 1721 1722 if (besthi) return(&besthi->fqdn); 1723 } 1724 if (m->StaticHostname.c[0]) return(&m->StaticHostname); 1725 else GetStaticHostname(m); // asynchronously do reverse lookup for primary IPv4 address 1726 LogInfo("GetServiceTarget: Returning NULL for %s", ARDisplayString(m, rr)); 1727 return(mDNSNULL); 1728 } 1729} 1730 1731mDNSlocal const domainname *PUBLIC_UPDATE_SERVICE_TYPE = (const domainname*)"\x0B_dns-update" "\x04_udp"; 1732mDNSlocal const domainname *PUBLIC_LLQ_SERVICE_TYPE = (const domainname*)"\x08_dns-llq" "\x04_udp"; 1733 1734mDNSlocal const domainname *PRIVATE_UPDATE_SERVICE_TYPE = (const domainname*)"\x0F_dns-update-tls" "\x04_tcp"; 1735mDNSlocal const domainname *PRIVATE_QUERY_SERVICE_TYPE = (const domainname*)"\x0E_dns-query-tls" "\x04_tcp"; 1736mDNSlocal const domainname *PRIVATE_LLQ_SERVICE_TYPE = (const domainname*)"\x0C_dns-llq-tls" "\x04_tcp"; 1737 1738#define ZoneDataSRV(X) ( \ 1739 (X)->ZoneService == ZoneServiceUpdate ? ((X)->ZonePrivate ? PRIVATE_UPDATE_SERVICE_TYPE : PUBLIC_UPDATE_SERVICE_TYPE) : \ 1740 (X)->ZoneService == ZoneServiceQuery ? ((X)->ZonePrivate ? PRIVATE_QUERY_SERVICE_TYPE : (const domainname*)"" ) : \ 1741 (X)->ZoneService == ZoneServiceLLQ ? ((X)->ZonePrivate ? PRIVATE_LLQ_SERVICE_TYPE : PUBLIC_LLQ_SERVICE_TYPE ) : (const domainname*)"") 1742 1743// Forward reference: GetZoneData_StartQuery references GetZoneData_QuestionCallback, and 1744// GetZoneData_QuestionCallback calls GetZoneData_StartQuery 1745mDNSlocal mStatus GetZoneData_StartQuery(mDNS *const m, ZoneData *zd, mDNSu16 qtype); 1746 1747// GetZoneData_QuestionCallback is called from normal client callback context (core API calls allowed) 1748mDNSlocal void GetZoneData_QuestionCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 1749{ 1750 ZoneData *zd = (ZoneData*)question->QuestionContext; 1751 1752 debugf("GetZoneData_QuestionCallback: %s %s", AddRecord ? "Add" : "Rmv", RRDisplayString(m, answer)); 1753 1754 if (!AddRecord) return; // Don't care about REMOVE events 1755 if (AddRecord == QC_addnocache && answer->rdlength == 0) return; // Don't care about transient failure indications 1756 if (answer->rrtype != question->qtype) return; // Don't care about CNAMEs 1757 1758 if (answer->rrtype == kDNSType_SOA) 1759 { 1760 debugf("GetZoneData GOT SOA %s", RRDisplayString(m, answer)); 1761 mDNS_StopQuery(m, question); 1762 if (question->ThisQInterval != -1) 1763 LogMsg("GetZoneData_QuestionCallback: Question %##s (%s) ThisQInterval %d not -1", question->qname.c, DNSTypeName(question->qtype), question->ThisQInterval); 1764 if (answer->rdlength) 1765 { 1766 AssignDomainName(&zd->ZoneName, answer->name); 1767 zd->ZoneClass = answer->rrclass; 1768 AssignDomainName(&zd->question.qname, &zd->ZoneName); 1769 GetZoneData_StartQuery(m, zd, kDNSType_SRV); 1770 } 1771 else if (zd->CurrentSOA->c[0]) 1772 { 1773 DomainAuthInfo *AuthInfo = GetAuthInfoForName(m, zd->CurrentSOA); 1774 if (AuthInfo && AuthInfo->AutoTunnel) 1775 { 1776 // To keep the load on the server down, we don't chop down on 1777 // SOA lookups for AutoTunnels 1778 LogInfo("GetZoneData_QuestionCallback: not chopping labels for %##s", zd->CurrentSOA->c); 1779 zd->ZoneDataCallback(m, mStatus_NoSuchNameErr, zd); 1780 } 1781 else 1782 { 1783 zd->CurrentSOA = (domainname *)(zd->CurrentSOA->c + zd->CurrentSOA->c[0]+1); 1784 AssignDomainName(&zd->question.qname, zd->CurrentSOA); 1785 GetZoneData_StartQuery(m, zd, kDNSType_SOA); 1786 } 1787 } 1788 else 1789 { 1790 LogInfo("GetZoneData recursed to root label of %##s without finding SOA", zd->ChildName.c); 1791 zd->ZoneDataCallback(m, mStatus_NoSuchNameErr, zd); 1792 } 1793 } 1794 else if (answer->rrtype == kDNSType_SRV) 1795 { 1796 debugf("GetZoneData GOT SRV %s", RRDisplayString(m, answer)); 1797 mDNS_StopQuery(m, question); 1798 if (question->ThisQInterval != -1) 1799 LogMsg("GetZoneData_QuestionCallback: Question %##s (%s) ThisQInterval %d not -1", question->qname.c, DNSTypeName(question->qtype), question->ThisQInterval); 1800// Right now we don't want to fail back to non-encrypted operations 1801// If the AuthInfo has the AutoTunnel field set, then we want private or nothing 1802// <rdar://problem/5687667> BTMM: Don't fallback to unencrypted operations when SRV lookup fails 1803#if 0 1804 if (!answer->rdlength && zd->ZonePrivate && zd->ZoneService != ZoneServiceQuery) 1805 { 1806 zd->ZonePrivate = mDNSfalse; // Causes ZoneDataSRV() to yield a different SRV name when building the query 1807 GetZoneData_StartQuery(m, zd, kDNSType_SRV); // Try again, non-private this time 1808 } 1809 else 1810#endif 1811 { 1812 if (answer->rdlength) 1813 { 1814 AssignDomainName(&zd->Host, &answer->rdata->u.srv.target); 1815 zd->Port = answer->rdata->u.srv.port; 1816 AssignDomainName(&zd->question.qname, &zd->Host); 1817 GetZoneData_StartQuery(m, zd, kDNSType_A); 1818 } 1819 else 1820 { 1821 zd->ZonePrivate = mDNSfalse; 1822 zd->Host.c[0] = 0; 1823 zd->Port = zeroIPPort; 1824 zd->Addr = zeroAddr; 1825 zd->ZoneDataCallback(m, mStatus_NoError, zd); 1826 } 1827 } 1828 } 1829 else if (answer->rrtype == kDNSType_A) 1830 { 1831 debugf("GetZoneData GOT A %s", RRDisplayString(m, answer)); 1832 mDNS_StopQuery(m, question); 1833 if (question->ThisQInterval != -1) 1834 LogMsg("GetZoneData_QuestionCallback: Question %##s (%s) ThisQInterval %d not -1", question->qname.c, DNSTypeName(question->qtype), question->ThisQInterval); 1835 zd->Addr.type = mDNSAddrType_IPv4; 1836 zd->Addr.ip.v4 = (answer->rdlength == 4) ? answer->rdata->u.ipv4 : zerov4Addr; 1837 // In order to simulate firewalls blocking our outgoing TCP connections, returning immediate ICMP errors or TCP resets, 1838 // the code below will make us try to connect to loopback, resulting in an immediate "port unreachable" failure. 1839 // This helps us test to make sure we handle this case gracefully 1840 // <rdar://problem/5607082> BTMM: mDNSResponder taking 100 percent CPU after upgrading to 10.5.1 1841#if 0 1842 zd->Addr.ip.v4.b[0] = 127; 1843 zd->Addr.ip.v4.b[1] = 0; 1844 zd->Addr.ip.v4.b[2] = 0; 1845 zd->Addr.ip.v4.b[3] = 1; 1846#endif 1847 // The caller needs to free the memory when done with zone data 1848 zd->ZoneDataCallback(m, mStatus_NoError, zd); 1849 } 1850} 1851 1852// GetZoneData_StartQuery is called from normal client context (lock not held, or client callback) 1853mDNSlocal mStatus GetZoneData_StartQuery(mDNS *const m, ZoneData *zd, mDNSu16 qtype) 1854{ 1855 if (qtype == kDNSType_SRV) 1856 { 1857 AssignDomainName(&zd->question.qname, ZoneDataSRV(zd)); 1858 AppendDomainName(&zd->question.qname, &zd->ZoneName); 1859 debugf("lookupDNSPort %##s", zd->question.qname.c); 1860 } 1861 1862 // CancelGetZoneData can get called at any time. We should stop the question if it has not been 1863 // stopped already. A value of -1 for ThisQInterval indicates that the question is not active 1864 // yet. 1865 zd->question.ThisQInterval = -1; 1866 zd->question.InterfaceID = mDNSInterface_Any; 1867 zd->question.flags = 0; 1868 zd->question.Target = zeroAddr; 1869 //zd->question.qname.c[0] = 0; // Already set 1870 zd->question.qtype = qtype; 1871 zd->question.qclass = kDNSClass_IN; 1872 zd->question.LongLived = mDNSfalse; 1873 zd->question.ExpectUnique = mDNStrue; 1874 zd->question.ForceMCast = mDNSfalse; 1875 zd->question.ReturnIntermed = mDNStrue; 1876 zd->question.SuppressUnusable = mDNSfalse; 1877 zd->question.SearchListIndex = 0; 1878 zd->question.AppendSearchDomains = 0; 1879 zd->question.RetryWithSearchDomains = mDNSfalse; 1880 zd->question.TimeoutQuestion = 0; 1881 zd->question.WakeOnResolve = 0; 1882 zd->question.UseBackgroundTrafficClass = mDNSfalse; 1883 zd->question.ValidationRequired = 0; 1884 zd->question.ValidatingResponse = 0; 1885 zd->question.ProxyQuestion = 0; 1886 zd->question.qnameOrig = mDNSNULL; 1887 zd->question.AnonInfo = mDNSNULL; 1888 zd->question.pid = mDNSPlatformGetPID(); 1889 zd->question.QuestionCallback = GetZoneData_QuestionCallback; 1890 zd->question.QuestionContext = zd; 1891 1892 //LogMsg("GetZoneData_StartQuery %##s (%s) %p", zd->question.qname.c, DNSTypeName(zd->question.qtype), zd->question.Private); 1893 return(mDNS_StartQuery(m, &zd->question)); 1894} 1895 1896// StartGetZoneData is an internal routine (i.e. must be called with the lock already held) 1897mDNSexport ZoneData *StartGetZoneData(mDNS *const m, const domainname *const name, const ZoneService target, ZoneDataCallback callback, void *ZoneDataContext) 1898{ 1899 DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, name); 1900 int initialskip = (AuthInfo && AuthInfo->AutoTunnel) ? DomainNameLength(name) - DomainNameLength(&AuthInfo->domain) : 0; 1901 ZoneData *zd = (ZoneData*)mDNSPlatformMemAllocate(sizeof(ZoneData)); 1902 if (!zd) { LogMsg("ERROR: StartGetZoneData - mDNSPlatformMemAllocate failed"); return mDNSNULL; } 1903 mDNSPlatformMemZero(zd, sizeof(ZoneData)); 1904 AssignDomainName(&zd->ChildName, name); 1905 zd->ZoneService = target; 1906 zd->CurrentSOA = (domainname *)(&zd->ChildName.c[initialskip]); 1907 zd->ZoneName.c[0] = 0; 1908 zd->ZoneClass = 0; 1909 zd->Host.c[0] = 0; 1910 zd->Port = zeroIPPort; 1911 zd->Addr = zeroAddr; 1912 zd->ZonePrivate = AuthInfo && AuthInfo->AutoTunnel ? mDNStrue : mDNSfalse; 1913 zd->ZoneDataCallback = callback; 1914 zd->ZoneDataContext = ZoneDataContext; 1915 1916 zd->question.QuestionContext = zd; 1917 1918 mDNS_DropLockBeforeCallback(); // GetZoneData_StartQuery expects to be called from a normal callback, so we emulate that here 1919 if (AuthInfo && AuthInfo->AutoTunnel && !mDNSIPPortIsZero(AuthInfo->port)) 1920 { 1921 LogInfo("StartGetZoneData: Bypassing SOA, SRV query for %##s", AuthInfo->domain.c); 1922 // We bypass SOA and SRV queries if we know the hostname and port already from the configuration. 1923 // Today this is only true for AutoTunnel. As we bypass, we need to infer a few things: 1924 // 1925 // 1. Zone name is the same as the AuthInfo domain 1926 // 2. ZoneClass is kDNSClass_IN which should be a safe assumption 1927 // 1928 // If we want to make this bypass mechanism work for non-AutoTunnels also, (1) has to hold 1929 // good. Otherwise, it has to be configured also. 1930 1931 AssignDomainName(&zd->ZoneName, &AuthInfo->domain); 1932 zd->ZoneClass = kDNSClass_IN; 1933 AssignDomainName(&zd->Host, &AuthInfo->hostname); 1934 zd->Port = AuthInfo->port; 1935 AssignDomainName(&zd->question.qname, &zd->Host); 1936 GetZoneData_StartQuery(m, zd, kDNSType_A); 1937 } 1938 else 1939 { 1940 if (AuthInfo && AuthInfo->AutoTunnel) LogInfo("StartGetZoneData: Not Bypassing SOA, SRV query for %##s", AuthInfo->domain.c); 1941 AssignDomainName(&zd->question.qname, zd->CurrentSOA); 1942 GetZoneData_StartQuery(m, zd, kDNSType_SOA); 1943 } 1944 mDNS_ReclaimLockAfterCallback(); 1945 1946 return zd; 1947} 1948 1949// Returns if the question is a GetZoneData question. These questions are special in 1950// that they are created internally while resolving a private query or LLQs. 1951mDNSexport mDNSBool IsGetZoneDataQuestion(DNSQuestion *q) 1952{ 1953 if (q->QuestionCallback == GetZoneData_QuestionCallback) return(mDNStrue); 1954 else return(mDNSfalse); 1955} 1956 1957// GetZoneData queries are a special case -- even if we have a key for them, we don't do them privately, 1958// because that would result in an infinite loop (i.e. to do a private query we first need to get 1959// the _dns-query-tls SRV record for the zone, and we can't do *that* privately because to do so 1960// we'd need to already know the _dns-query-tls SRV record. 1961// Also, as a general rule, we never do SOA queries privately 1962mDNSexport DomainAuthInfo *GetAuthInfoForQuestion(mDNS *m, const DNSQuestion *const q) // Must be called with lock held 1963{ 1964 if (q->QuestionCallback == GetZoneData_QuestionCallback) return(mDNSNULL); 1965 if (q->qtype == kDNSType_SOA ) return(mDNSNULL); 1966 return(GetAuthInfoForName_internal(m, &q->qname)); 1967} 1968 1969// *************************************************************************** 1970#if COMPILER_LIKES_PRAGMA_MARK 1971#pragma mark - host name and interface management 1972#endif 1973 1974mDNSlocal void SendRecordRegistration(mDNS *const m, AuthRecord *rr); 1975mDNSlocal void SendRecordDeregistration(mDNS *m, AuthRecord *rr); 1976mDNSlocal mDNSBool IsRecordMergeable(mDNS *const m, AuthRecord *rr, mDNSs32 time); 1977 1978// When this function is called, service record is already deregistered. We just 1979// have to deregister the PTR and TXT records. 1980mDNSlocal void UpdateAllServiceRecords(mDNS *const m, AuthRecord *rr, mDNSBool reg) 1981{ 1982 AuthRecord *r, *srvRR; 1983 1984 if (rr->resrec.rrtype != kDNSType_SRV) { LogMsg("UpdateAllServiceRecords:ERROR!! ResourceRecord not a service record %s", ARDisplayString(m, rr)); return; } 1985 1986 if (reg && rr->state == regState_NoTarget) { LogMsg("UpdateAllServiceRecords:ERROR!! SRV record %s in noTarget state during registration", ARDisplayString(m, rr)); return; } 1987 1988 LogInfo("UpdateAllServiceRecords: ResourceRecord %s", ARDisplayString(m, rr)); 1989 1990 for (r = m->ResourceRecords; r; r=r->next) 1991 { 1992 if (!AuthRecord_uDNS(r)) continue; 1993 srvRR = mDNSNULL; 1994 if (r->resrec.rrtype == kDNSType_PTR) 1995 srvRR = r->Additional1; 1996 else if (r->resrec.rrtype == kDNSType_TXT) 1997 srvRR = r->DependentOn; 1998 if (srvRR && srvRR->resrec.rrtype != kDNSType_SRV) 1999 LogMsg("UpdateAllServiceRecords: ERROR!! Resource record %s wrong, expecting SRV type", ARDisplayString(m, srvRR)); 2000 if (srvRR == rr) 2001 { 2002 if (!reg) 2003 { 2004 LogInfo("UpdateAllServiceRecords: deregistering %s", ARDisplayString(m, r)); 2005 r->SRVChanged = mDNStrue; 2006 r->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 2007 r->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 2008 r->state = regState_DeregPending; 2009 } 2010 else 2011 { 2012 // Clearing SRVchanged is a safety measure. If our pevious dereg never 2013 // came back and we had a target change, we are starting fresh 2014 r->SRVChanged = mDNSfalse; 2015 // if it is already registered or in the process of registering, then don't 2016 // bother re-registering. This happens today for non-BTMM domains where the 2017 // TXT and PTR get registered before SRV records because of the delay in 2018 // getting the port mapping. There is no point in re-registering the TXT 2019 // and PTR records. 2020 if ((r->state == regState_Registered) || 2021 (r->state == regState_Pending && r->nta && !mDNSIPv4AddressIsZero(r->nta->Addr.ip.v4))) 2022 LogInfo("UpdateAllServiceRecords: not registering %s, state %d", ARDisplayString(m, r), r->state); 2023 else 2024 { 2025 LogInfo("UpdateAllServiceRecords: registering %s, state %d", ARDisplayString(m, r), r->state); 2026 ActivateUnicastRegistration(m, r); 2027 } 2028 } 2029 } 2030 } 2031} 2032 2033// Called in normal client context (lock not held) 2034// Currently only supports SRV records for nat mapping 2035mDNSlocal void CompleteRecordNatMap(mDNS *m, NATTraversalInfo *n) 2036{ 2037 const domainname *target; 2038 domainname *srvt; 2039 AuthRecord *rr = (AuthRecord *)n->clientContext; 2040 debugf("SRVNatMap complete %.4a IntPort %u ExternalPort %u NATLease %u", &n->ExternalAddress, mDNSVal16(n->IntPort), mDNSVal16(n->ExternalPort), n->NATLease); 2041 2042 if (!rr) { LogMsg("CompleteRecordNatMap called with unknown AuthRecord object"); return; } 2043 if (!n->NATLease) { LogMsg("CompleteRecordNatMap No NATLease for %s", ARDisplayString(m, rr)); return; } 2044 2045 if (rr->resrec.rrtype != kDNSType_SRV) {LogMsg("CompleteRecordNatMap: Not a service record %s", ARDisplayString(m, rr)); return; } 2046 2047 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) { LogInfo("CompleteRecordNatMap called for %s, Service deregistering", ARDisplayString(m, rr)); return; } 2048 2049 if (rr->state == regState_DeregPending) { LogInfo("CompleteRecordNatMap called for %s, record in DeregPending", ARDisplayString(m, rr)); return; } 2050 2051 // As we free the zone info after registering/deregistering with the server (See hndlRecordUpdateReply), 2052 // we need to restart the get zone data and nat mapping request to get the latest mapping result as we can't handle it 2053 // at this moment. Restart from the beginning. 2054 if (!rr->nta || mDNSIPv4AddressIsZero(rr->nta->Addr.ip.v4)) 2055 { 2056 LogInfo("CompleteRecordNatMap called for %s but no zone information!", ARDisplayString(m, rr)); 2057 // We need to clear out the NATinfo state so that it will result in re-acquiring the mapping 2058 // and hence this callback called again. 2059 if (rr->NATinfo.clientContext) 2060 { 2061 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 2062 rr->NATinfo.clientContext = mDNSNULL; 2063 } 2064 rr->state = regState_Pending; 2065 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 2066 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 2067 return; 2068 } 2069 2070 mDNS_Lock(m); 2071 // Reevaluate the target always as Target could have changed while 2072 // we were getting the port mapping (See UpdateOneSRVRecord) 2073 target = GetServiceTarget(m, rr); 2074 srvt = GetRRDomainNameTarget(&rr->resrec); 2075 if (!target || target->c[0] == 0 || mDNSIPPortIsZero(n->ExternalPort)) 2076 { 2077 if (target && target->c[0]) 2078 LogInfo("CompleteRecordNatMap - Target %##s for ResourceRecord %##s, ExternalPort %d", target->c, rr->resrec.name->c, mDNSVal16(n->ExternalPort)); 2079 else 2080 LogInfo("CompleteRecordNatMap - no target for %##s, ExternalPort %d", rr->resrec.name->c, mDNSVal16(n->ExternalPort)); 2081 if (srvt) srvt->c[0] = 0; 2082 rr->state = regState_NoTarget; 2083 rr->resrec.rdlength = rr->resrec.rdestimate = 0; 2084 mDNS_Unlock(m); 2085 UpdateAllServiceRecords(m, rr, mDNSfalse); 2086 return; 2087 } 2088 LogInfo("CompleteRecordNatMap - Target %##s for ResourceRecord %##s, ExternalPort %d", target->c, rr->resrec.name->c, mDNSVal16(n->ExternalPort)); 2089 // This function might get called multiple times during a network transition event. Previosuly, we could 2090 // have put the SRV record in NoTarget state above and deregistered all the other records. When this 2091 // function gets called again with a non-zero ExternalPort, we need to set the target and register the 2092 // other records again. 2093 if (srvt && !SameDomainName(srvt, target)) 2094 { 2095 AssignDomainName(srvt, target); 2096 SetNewRData(&rr->resrec, mDNSNULL, 0); // Update rdlength, rdestimate, rdatahash 2097 } 2098 2099 // SRVChanged is set when when the target of the SRV record changes (See UpdateOneSRVRecord). 2100 // As a result of the target change, we might register just that SRV Record if it was 2101 // previously registered and we have a new target OR deregister SRV (and the associated 2102 // PTR/TXT records) if we don't have a target anymore. When we get a response from the server, 2103 // SRVChanged state tells that we registered/deregistered because of a target change 2104 // and hence handle accordingly e.g., if we deregistered, put the records in NoTarget state OR 2105 // if we registered then put it in Registered state. 2106 // 2107 // Here, we are registering all the records again from the beginning. Treat this as first time 2108 // registration rather than a temporary target change. 2109 rr->SRVChanged = mDNSfalse; 2110 2111 // We want IsRecordMergeable to check whether it is a record whose update can be 2112 // sent with others. We set the time before we call IsRecordMergeable, so that 2113 // it does not fail this record based on time. We are interested in other checks 2114 // at this time 2115 rr->state = regState_Pending; 2116 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 2117 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 2118 if (IsRecordMergeable(m, rr, m->timenow + MERGE_DELAY_TIME)) 2119 // Delay the record registration by MERGE_DELAY_TIME so that we can merge them 2120 // into one update 2121 rr->LastAPTime += MERGE_DELAY_TIME; 2122 mDNS_Unlock(m); 2123 // We call this always even though it may not be necessary always e.g., normal registration 2124 // process where TXT and PTR gets registered followed by the SRV record after it gets 2125 // the port mapping. In that case, UpdateAllServiceRecords handles the optimization. The 2126 // update of TXT and PTR record is required if we entered noTargetState before as explained 2127 // above. 2128 UpdateAllServiceRecords(m, rr, mDNStrue); 2129} 2130 2131mDNSlocal void StartRecordNatMap(mDNS *m, AuthRecord *rr) 2132{ 2133 const mDNSu8 *p; 2134 mDNSu8 protocol; 2135 2136 if (rr->resrec.rrtype != kDNSType_SRV) 2137 { 2138 LogInfo("StartRecordNatMap: Resource Record %##s type %d, not supported", rr->resrec.name->c, rr->resrec.rrtype); 2139 return; 2140 } 2141 p = rr->resrec.name->c; 2142 //Assume <Service Instance>.<App Protocol>.<Transport protocol>.<Name> 2143 // Skip the first two labels to get to the transport protocol 2144 if (p[0]) p += 1 + p[0]; 2145 if (p[0]) p += 1 + p[0]; 2146 if (SameDomainLabel(p, (mDNSu8 *)"\x4" "_tcp")) protocol = NATOp_MapTCP; 2147 else if (SameDomainLabel(p, (mDNSu8 *)"\x4" "_udp")) protocol = NATOp_MapUDP; 2148 else { LogMsg("StartRecordNatMap: could not determine transport protocol of service %##s", rr->resrec.name->c); return; } 2149 2150 //LogMsg("StartRecordNatMap: clientContext %p IntPort %d srv.port %d %s", 2151 // rr->NATinfo.clientContext, mDNSVal16(rr->NATinfo.IntPort), mDNSVal16(rr->resrec.rdata->u.srv.port), ARDisplayString(m, rr)); 2152 if (rr->NATinfo.clientContext) mDNS_StopNATOperation_internal(m, &rr->NATinfo); 2153 rr->NATinfo.Protocol = protocol; 2154 2155 // Shouldn't be trying to set IntPort here -- 2156 // BuildUpdateMessage overwrites srs->RR_SRV.resrec.rdata->u.srv.port with external (mapped) port number 2157 rr->NATinfo.IntPort = rr->resrec.rdata->u.srv.port; 2158 rr->NATinfo.RequestedPort = rr->resrec.rdata->u.srv.port; 2159 rr->NATinfo.NATLease = 0; // Request default lease 2160 rr->NATinfo.clientCallback = CompleteRecordNatMap; 2161 rr->NATinfo.clientContext = rr; 2162 mDNS_StartNATOperation_internal(m, &rr->NATinfo); 2163} 2164 2165// Unlink an Auth Record from the m->ResourceRecords list. 2166// When a resource record enters regState_NoTarget initially, mDNS_Register_internal 2167// does not initialize completely e.g., it cannot check for duplicates etc. The resource 2168// record is temporarily left in the ResourceRecords list so that we can initialize later 2169// when the target is resolvable. Similarly, when host name changes, we enter regState_NoTarget 2170// and we do the same. 2171 2172// This UnlinkResourceRecord routine is very worrying. It bypasses all the normal cleanup performed 2173// by mDNS_Deregister_internal and just unceremoniously cuts the record from the active list. 2174// This is why re-regsitering this record was producing syslog messages like this: 2175// "Error! Tried to add a NAT traversal that's already in the active list" 2176// Right now UnlinkResourceRecord is fortunately only called by RegisterAllServiceRecords, 2177// which then immediately calls mDNS_Register_internal to re-register the record, which probably 2178// masked more serious problems. Any other use of UnlinkResourceRecord is likely to lead to crashes. 2179// For now we'll workaround that specific problem by explicitly calling mDNS_StopNATOperation_internal, 2180// but long-term we should either stop cancelling the record registration and then re-registering it, 2181// or if we really do need to do this for some reason it should be done via the usual 2182// mDNS_Deregister_internal path instead of just cutting the record from the list. 2183 2184mDNSlocal mStatus UnlinkResourceRecord(mDNS *const m, AuthRecord *const rr) 2185{ 2186 AuthRecord **list = &m->ResourceRecords; 2187 while (*list && *list != rr) list = &(*list)->next; 2188 if (*list) 2189 { 2190 *list = rr->next; 2191 rr->next = mDNSNULL; 2192 2193 // Temporary workaround to cancel any active NAT mapping operation 2194 if (rr->NATinfo.clientContext) 2195 { 2196 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 2197 rr->NATinfo.clientContext = mDNSNULL; 2198 if (rr->resrec.rrtype == kDNSType_SRV) rr->resrec.rdata->u.srv.port = rr->NATinfo.IntPort; 2199 } 2200 2201 return(mStatus_NoError); 2202 } 2203 LogMsg("UnlinkResourceRecord:ERROR!! - no such active record %##s", rr->resrec.name->c); 2204 return(mStatus_NoSuchRecord); 2205} 2206 2207// We need to go through mDNS_Register again as we did not complete the 2208// full initialization last time e.g., duplicate checks. 2209// After we register, we will be in regState_GetZoneData. 2210mDNSlocal void RegisterAllServiceRecords(mDNS *const m, AuthRecord *rr) 2211{ 2212 LogInfo("RegisterAllServiceRecords: Service Record %##s", rr->resrec.name->c); 2213 // First Register the service record, we do this differently from other records because 2214 // when it entered NoTarget state, it did not go through complete initialization 2215 rr->SRVChanged = mDNSfalse; 2216 UnlinkResourceRecord(m, rr); 2217 mDNS_Register_internal(m, rr); 2218 // Register the other records 2219 UpdateAllServiceRecords(m, rr, mDNStrue); 2220} 2221 2222// Called with lock held 2223mDNSlocal void UpdateOneSRVRecord(mDNS *m, AuthRecord *rr) 2224{ 2225 // Target change if: 2226 // We have a target and were previously waiting for one, or 2227 // We had a target and no longer do, or 2228 // The target has changed 2229 2230 domainname *curtarget = &rr->resrec.rdata->u.srv.target; 2231 const domainname *const nt = GetServiceTarget(m, rr); 2232 const domainname *const newtarget = nt ? nt : (domainname*)""; 2233 mDNSBool TargetChanged = (newtarget->c[0] && rr->state == regState_NoTarget) || !SameDomainName(curtarget, newtarget); 2234 mDNSBool HaveZoneData = rr->nta && !mDNSIPv4AddressIsZero(rr->nta->Addr.ip.v4); 2235 2236 // Nat state change if: 2237 // We were behind a NAT, and now we are behind a new NAT, or 2238 // We're not behind a NAT but our port was previously mapped to a different external port 2239 // We were not behind a NAT and now we are 2240 2241 mDNSIPPort port = rr->resrec.rdata->u.srv.port; 2242 mDNSBool NowNeedNATMAP = (rr->AutoTarget == Target_AutoHostAndNATMAP && !mDNSIPPortIsZero(port) && mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) && rr->nta && !mDNSAddrIsRFC1918(&rr->nta->Addr)); 2243 mDNSBool WereBehindNAT = (rr->NATinfo.clientContext != mDNSNULL); 2244 mDNSBool PortWasMapped = (rr->NATinfo.clientContext && !mDNSSameIPPort(rr->NATinfo.RequestedPort, port)); // I think this is always false -- SC Sept 07 2245 mDNSBool NATChanged = (!WereBehindNAT && NowNeedNATMAP) || (!NowNeedNATMAP && PortWasMapped); 2246 2247 (void)HaveZoneData; //unused 2248 2249 LogInfo("UpdateOneSRVRecord: Resource Record %s TargetChanged %d, NewTarget %##s", ARDisplayString(m, rr), TargetChanged, nt->c); 2250 2251 debugf("UpdateOneSRVRecord: %##s newtarget %##s TargetChanged %d HaveZoneData %d port %d NowNeedNATMAP %d WereBehindNAT %d PortWasMapped %d NATChanged %d", 2252 rr->resrec.name->c, newtarget, 2253 TargetChanged, HaveZoneData, mDNSVal16(port), NowNeedNATMAP, WereBehindNAT, PortWasMapped, NATChanged); 2254 2255 mDNS_CheckLock(m); 2256 2257 if (!TargetChanged && !NATChanged) return; 2258 2259 // If we are deregistering the record, then ignore any NAT/Target change. 2260 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) 2261 { 2262 LogInfo("UpdateOneSRVRecord: Deregistering record, Ignoring TargetChanged %d, NATChanged %d for %##s, state %d", TargetChanged, NATChanged, 2263 rr->resrec.name->c, rr->state); 2264 return; 2265 } 2266 2267 if (newtarget) 2268 LogInfo("UpdateOneSRVRecord: TargetChanged %d, NATChanged %d for %##s, state %d, newtarget %##s", TargetChanged, NATChanged, rr->resrec.name->c, rr->state, newtarget->c); 2269 else 2270 LogInfo("UpdateOneSRVRecord: TargetChanged %d, NATChanged %d for %##s, state %d, null newtarget", TargetChanged, NATChanged, rr->resrec.name->c, rr->state); 2271 switch(rr->state) 2272 { 2273 case regState_NATMap: 2274 // In these states, the SRV has either not yet been registered (it will get up-to-date information when it is) 2275 // or is in the process of, or has already been, deregistered. This assumes that whenever we transition out 2276 // of this state, we need to look at the target again. 2277 return; 2278 2279 case regState_UpdatePending: 2280 // We are getting a Target change/NAT change while the SRV record is being updated ? 2281 // let us not do anything for now. 2282 return; 2283 2284 case regState_NATError: 2285 if (!NATChanged) return; 2286 // if nat changed, register if we have a target (below) 2287 2288 case regState_NoTarget: 2289 if (!newtarget->c[0]) 2290 { 2291 LogInfo("UpdateOneSRVRecord: No target yet for Resource Record %s", ARDisplayString(m, rr)); 2292 return; 2293 } 2294 RegisterAllServiceRecords(m, rr); 2295 return; 2296 case regState_DeregPending: 2297 // We are in DeregPending either because the service was deregistered from above or we handled 2298 // a NAT/Target change before and sent the deregistration below. There are a few race conditions 2299 // possible 2300 // 2301 // 1. We are handling a second NAT/Target change while the first dereg is in progress. It is possible 2302 // that first dereg never made it through because there was no network connectivity e.g., disconnecting 2303 // from network triggers this function due to a target change and later connecting to the network 2304 // retriggers this function but the deregistration never made it through yet. Just fall through. 2305 // If there is a target register otherwise deregister. 2306 // 2307 // 2. While we sent the dereg during a previous NAT/Target change, uDNS_DeregisterRecord gets 2308 // called as part of service deregistration. When the response comes back, we call 2309 // CompleteDeregistration rather than handle NAT/Target change because the record is in 2310 // kDNSRecordTypeDeregistering state. 2311 // 2312 // 3. If the upper layer deregisters the service, we check for kDNSRecordTypeDeregistering both 2313 // here in this function to avoid handling NAT/Target change and in hndlRecordUpdateReply to call 2314 // CompleteDeregistration instead of handling NAT/Target change. Hence, we are not concerned 2315 // about that case here. 2316 // 2317 // We just handle case (1) by falling through 2318 case regState_Pending: 2319 case regState_Refresh: 2320 case regState_Registered: 2321 // target or nat changed. deregister service. upon completion, we'll look for a new target 2322 rr->SRVChanged = mDNStrue; 2323 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 2324 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 2325 if (newtarget->c[0]) 2326 { 2327 LogInfo("UpdateOneSRVRecord: SRV record changed for service %##s, registering with new target %##s", 2328 rr->resrec.name->c, newtarget->c); 2329 rr->state = regState_Pending; 2330 } 2331 else 2332 { 2333 LogInfo("UpdateOneSRVRecord: SRV record changed for service %##s de-registering", rr->resrec.name->c); 2334 rr->state = regState_DeregPending; 2335 UpdateAllServiceRecords(m, rr, mDNSfalse); 2336 } 2337 return; 2338 case regState_Unregistered: 2339 default: LogMsg("UpdateOneSRVRecord: Unknown state %d for %##s", rr->state, rr->resrec.name->c); 2340 } 2341} 2342 2343mDNSexport void UpdateAllSRVRecords(mDNS *m) 2344{ 2345 m->NextSRVUpdate = 0; 2346 LogInfo("UpdateAllSRVRecords %d", m->SleepState); 2347 2348 if (m->CurrentRecord) 2349 LogMsg("UpdateAllSRVRecords ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 2350 m->CurrentRecord = m->ResourceRecords; 2351 while (m->CurrentRecord) 2352 { 2353 AuthRecord *rptr = m->CurrentRecord; 2354 m->CurrentRecord = m->CurrentRecord->next; 2355 if (AuthRecord_uDNS(rptr) && rptr->resrec.rrtype == kDNSType_SRV) 2356 UpdateOneSRVRecord(m, rptr); 2357 } 2358} 2359 2360// Forward reference: AdvertiseHostname references HostnameCallback, and HostnameCallback calls AdvertiseHostname 2361mDNSlocal void HostnameCallback(mDNS *const m, AuthRecord *const rr, mStatus result); 2362 2363// Called in normal client context (lock not held) 2364mDNSlocal void hostnameGetPublicAddressCallback(mDNS *m, NATTraversalInfo *n) 2365{ 2366 HostnameInfo *h = (HostnameInfo *)n->clientContext; 2367 2368 if (!h) { LogMsg("RegisterHostnameRecord: registration cancelled"); return; } 2369 2370 if (!n->Result) 2371 { 2372 if (mDNSIPv4AddressIsZero(n->ExternalAddress) || mDNSv4AddrIsRFC1918(&n->ExternalAddress)) return; 2373 2374 if (h->arv4.resrec.RecordType) 2375 { 2376 if (mDNSSameIPv4Address(h->arv4.resrec.rdata->u.ipv4, n->ExternalAddress)) return; // If address unchanged, do nothing 2377 LogInfo("Updating hostname %p %##s IPv4 from %.4a to %.4a (NAT gateway's external address)",n, 2378 h->arv4.resrec.name->c, &h->arv4.resrec.rdata->u.ipv4, &n->ExternalAddress); 2379 mDNS_Deregister(m, &h->arv4); // mStatus_MemFree callback will re-register with new address 2380 } 2381 else 2382 { 2383 LogInfo("Advertising hostname %##s IPv4 %.4a (NAT gateway's external address)", h->arv4.resrec.name->c, &n->ExternalAddress); 2384 h->arv4.resrec.RecordType = kDNSRecordTypeKnownUnique; 2385 h->arv4.resrec.rdata->u.ipv4 = n->ExternalAddress; 2386 mDNS_Register(m, &h->arv4); 2387 } 2388 } 2389} 2390 2391// register record or begin NAT traversal 2392mDNSlocal void AdvertiseHostname(mDNS *m, HostnameInfo *h) 2393{ 2394 if (!mDNSIPv4AddressIsZero(m->AdvertisedV4.ip.v4) && h->arv4.resrec.RecordType == kDNSRecordTypeUnregistered) 2395 { 2396 mDNS_SetupResourceRecord(&h->arv4, mDNSNULL, mDNSInterface_Any, kDNSType_A, kHostNameTTL, kDNSRecordTypeUnregistered, AuthRecordAny, HostnameCallback, h); 2397 AssignDomainName(&h->arv4.namestorage, &h->fqdn); 2398 h->arv4.resrec.rdata->u.ipv4 = m->AdvertisedV4.ip.v4; 2399 h->arv4.state = regState_Unregistered; 2400 if (mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4)) 2401 { 2402 // If we already have a NAT query active, stop it and restart it to make sure we get another callback 2403 if (h->natinfo.clientContext) mDNS_StopNATOperation_internal(m, &h->natinfo); 2404 h->natinfo.Protocol = 0; 2405 h->natinfo.IntPort = zeroIPPort; 2406 h->natinfo.RequestedPort = zeroIPPort; 2407 h->natinfo.NATLease = 0; 2408 h->natinfo.clientCallback = hostnameGetPublicAddressCallback; 2409 h->natinfo.clientContext = h; 2410 mDNS_StartNATOperation_internal(m, &h->natinfo); 2411 } 2412 else 2413 { 2414 LogInfo("Advertising hostname %##s IPv4 %.4a", h->arv4.resrec.name->c, &m->AdvertisedV4.ip.v4); 2415 h->arv4.resrec.RecordType = kDNSRecordTypeKnownUnique; 2416 mDNS_Register_internal(m, &h->arv4); 2417 } 2418 } 2419 2420 if (!mDNSIPv6AddressIsZero(m->AdvertisedV6.ip.v6) && h->arv6.resrec.RecordType == kDNSRecordTypeUnregistered) 2421 { 2422 mDNS_SetupResourceRecord(&h->arv6, mDNSNULL, mDNSInterface_Any, kDNSType_AAAA, kHostNameTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, HostnameCallback, h); 2423 AssignDomainName(&h->arv6.namestorage, &h->fqdn); 2424 h->arv6.resrec.rdata->u.ipv6 = m->AdvertisedV6.ip.v6; 2425 h->arv6.state = regState_Unregistered; 2426 LogInfo("Advertising hostname %##s IPv6 %.16a", h->arv6.resrec.name->c, &m->AdvertisedV6.ip.v6); 2427 mDNS_Register_internal(m, &h->arv6); 2428 } 2429} 2430 2431mDNSlocal void HostnameCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 2432{ 2433 HostnameInfo *hi = (HostnameInfo *)rr->RecordContext; 2434 2435 if (result == mStatus_MemFree) 2436 { 2437 if (hi) 2438 { 2439 // If we're still in the Hostnames list, update to new address 2440 HostnameInfo *i; 2441 LogInfo("HostnameCallback: Got mStatus_MemFree for %p %p %s", hi, rr, ARDisplayString(m, rr)); 2442 for (i = m->Hostnames; i; i = i->next) 2443 if (rr == &i->arv4 || rr == &i->arv6) 2444 { mDNS_Lock(m); AdvertiseHostname(m, i); mDNS_Unlock(m); return; } 2445 2446 // Else, we're not still in the Hostnames list, so free the memory 2447 if (hi->arv4.resrec.RecordType == kDNSRecordTypeUnregistered && 2448 hi->arv6.resrec.RecordType == kDNSRecordTypeUnregistered) 2449 { 2450 if (hi->natinfo.clientContext) mDNS_StopNATOperation_internal(m, &hi->natinfo); 2451 hi->natinfo.clientContext = mDNSNULL; 2452 mDNSPlatformMemFree(hi); // free hi when both v4 and v6 AuthRecs deallocated 2453 } 2454 } 2455 return; 2456 } 2457 2458 if (result) 2459 { 2460 // don't unlink or free - we can retry when we get a new address/router 2461 if (rr->resrec.rrtype == kDNSType_A) 2462 LogMsg("HostnameCallback: Error %d for registration of %##s IP %.4a", result, rr->resrec.name->c, &rr->resrec.rdata->u.ipv4); 2463 else 2464 LogMsg("HostnameCallback: Error %d for registration of %##s IP %.16a", result, rr->resrec.name->c, &rr->resrec.rdata->u.ipv6); 2465 if (!hi) { mDNSPlatformMemFree(rr); return; } 2466 if (rr->state != regState_Unregistered) LogMsg("Error: HostnameCallback invoked with error code for record not in regState_Unregistered!"); 2467 2468 if (hi->arv4.state == regState_Unregistered && 2469 hi->arv6.state == regState_Unregistered) 2470 { 2471 // only deliver status if both v4 and v6 fail 2472 rr->RecordContext = (void *)hi->StatusContext; 2473 if (hi->StatusCallback) 2474 hi->StatusCallback(m, rr, result); // client may NOT make API calls here 2475 rr->RecordContext = (void *)hi; 2476 } 2477 return; 2478 } 2479 2480 // register any pending services that require a target 2481 mDNS_Lock(m); 2482 m->NextSRVUpdate = NonZeroTime(m->timenow); 2483 mDNS_Unlock(m); 2484 2485 // Deliver success to client 2486 if (!hi) { LogMsg("HostnameCallback invoked with orphaned address record"); return; } 2487 if (rr->resrec.rrtype == kDNSType_A) 2488 LogInfo("Registered hostname %##s IP %.4a", rr->resrec.name->c, &rr->resrec.rdata->u.ipv4); 2489 else 2490 LogInfo("Registered hostname %##s IP %.16a", rr->resrec.name->c, &rr->resrec.rdata->u.ipv6); 2491 2492 rr->RecordContext = (void *)hi->StatusContext; 2493 if (hi->StatusCallback) 2494 hi->StatusCallback(m, rr, result); // client may NOT make API calls here 2495 rr->RecordContext = (void *)hi; 2496} 2497 2498mDNSlocal void FoundStaticHostname(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 2499{ 2500 const domainname *pktname = &answer->rdata->u.name; 2501 domainname *storedname = &m->StaticHostname; 2502 HostnameInfo *h = m->Hostnames; 2503 2504 (void)question; 2505 2506 if (answer->rdlength != 0) 2507 LogInfo("FoundStaticHostname: question %##s -> answer %##s (%s)", question->qname.c, answer->rdata->u.name.c, AddRecord ? "ADD" : "RMV"); 2508 else 2509 LogInfo("FoundStaticHostname: question %##s -> answer NULL (%s)", question->qname.c, AddRecord ? "ADD" : "RMV"); 2510 2511 if (AddRecord && answer->rdlength != 0 && !SameDomainName(pktname, storedname)) 2512 { 2513 AssignDomainName(storedname, pktname); 2514 while (h) 2515 { 2516 if (h->arv4.state == regState_Pending || h->arv4.state == regState_NATMap || h->arv6.state == regState_Pending) 2517 { 2518 // if we're in the process of registering a dynamic hostname, delay SRV update so we don't have to reregister services if the dynamic name succeeds 2519 m->NextSRVUpdate = NonZeroTime(m->timenow + 5 * mDNSPlatformOneSecond); 2520 debugf("FoundStaticHostname: NextSRVUpdate in %d %d", m->NextSRVUpdate - m->timenow, m->timenow); 2521 return; 2522 } 2523 h = h->next; 2524 } 2525 mDNS_Lock(m); 2526 m->NextSRVUpdate = NonZeroTime(m->timenow); 2527 mDNS_Unlock(m); 2528 } 2529 else if (!AddRecord && SameDomainName(pktname, storedname)) 2530 { 2531 mDNS_Lock(m); 2532 storedname->c[0] = 0; 2533 m->NextSRVUpdate = NonZeroTime(m->timenow); 2534 mDNS_Unlock(m); 2535 } 2536} 2537 2538// Called with lock held 2539mDNSlocal void GetStaticHostname(mDNS *m) 2540{ 2541 char buf[MAX_REVERSE_MAPPING_NAME_V4]; 2542 DNSQuestion *q = &m->ReverseMap; 2543 mDNSu8 *ip = m->AdvertisedV4.ip.v4.b; 2544 mStatus err; 2545 2546 if (m->ReverseMap.ThisQInterval != -1) return; // already running 2547 if (mDNSIPv4AddressIsZero(m->AdvertisedV4.ip.v4)) return; 2548 2549 mDNSPlatformMemZero(q, sizeof(*q)); 2550 // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code 2551 mDNS_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa.", ip[3], ip[2], ip[1], ip[0]); 2552 if (!MakeDomainNameFromDNSNameString(&q->qname, buf)) { LogMsg("Error: GetStaticHostname - bad name %s", buf); return; } 2553 2554 q->InterfaceID = mDNSInterface_Any; 2555 q->flags = 0; 2556 q->Target = zeroAddr; 2557 q->qtype = kDNSType_PTR; 2558 q->qclass = kDNSClass_IN; 2559 q->LongLived = mDNSfalse; 2560 q->ExpectUnique = mDNSfalse; 2561 q->ForceMCast = mDNSfalse; 2562 q->ReturnIntermed = mDNStrue; 2563 q->SuppressUnusable = mDNSfalse; 2564 q->SearchListIndex = 0; 2565 q->AppendSearchDomains = 0; 2566 q->RetryWithSearchDomains = mDNSfalse; 2567 q->TimeoutQuestion = 0; 2568 q->WakeOnResolve = 0; 2569 q->UseBackgroundTrafficClass = mDNSfalse; 2570 q->ValidationRequired = 0; 2571 q->ValidatingResponse = 0; 2572 q->ProxyQuestion = 0; 2573 q->qnameOrig = mDNSNULL; 2574 q->AnonInfo = mDNSNULL; 2575 q->pid = mDNSPlatformGetPID(); 2576 q->QuestionCallback = FoundStaticHostname; 2577 q->QuestionContext = mDNSNULL; 2578 2579 LogInfo("GetStaticHostname: %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 2580 err = mDNS_StartQuery_internal(m, q); 2581 if (err) LogMsg("Error: GetStaticHostname - StartQuery returned error %d", err); 2582} 2583 2584mDNSexport void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *StatusContext) 2585{ 2586 HostnameInfo **ptr = &m->Hostnames; 2587 2588 LogInfo("mDNS_AddDynDNSHostName %##s", fqdn); 2589 2590 while (*ptr && !SameDomainName(fqdn, &(*ptr)->fqdn)) ptr = &(*ptr)->next; 2591 if (*ptr) { LogMsg("DynDNSHostName %##s already in list", fqdn->c); return; } 2592 2593 // allocate and format new address record 2594 *ptr = mDNSPlatformMemAllocate(sizeof(**ptr)); 2595 if (!*ptr) { LogMsg("ERROR: mDNS_AddDynDNSHostName - malloc"); return; } 2596 2597 mDNSPlatformMemZero(*ptr, sizeof(**ptr)); 2598 AssignDomainName(&(*ptr)->fqdn, fqdn); 2599 (*ptr)->arv4.state = regState_Unregistered; 2600 (*ptr)->arv6.state = regState_Unregistered; 2601 (*ptr)->StatusCallback = StatusCallback; 2602 (*ptr)->StatusContext = StatusContext; 2603 2604 AdvertiseHostname(m, *ptr); 2605} 2606 2607mDNSexport void mDNS_RemoveDynDNSHostName(mDNS *m, const domainname *fqdn) 2608{ 2609 HostnameInfo **ptr = &m->Hostnames; 2610 2611 LogInfo("mDNS_RemoveDynDNSHostName %##s", fqdn); 2612 2613 while (*ptr && !SameDomainName(fqdn, &(*ptr)->fqdn)) ptr = &(*ptr)->next; 2614 if (!*ptr) LogMsg("mDNS_RemoveDynDNSHostName: no such domainname %##s", fqdn->c); 2615 else 2616 { 2617 HostnameInfo *hi = *ptr; 2618 // We do it this way because, if we have no active v6 record, the "mDNS_Deregister_internal(m, &hi->arv4);" 2619 // below could free the memory, and we have to make sure we don't touch hi fields after that. 2620 mDNSBool f4 = hi->arv4.resrec.RecordType != kDNSRecordTypeUnregistered && hi->arv4.state != regState_Unregistered; 2621 mDNSBool f6 = hi->arv6.resrec.RecordType != kDNSRecordTypeUnregistered && hi->arv6.state != regState_Unregistered; 2622 if (f4) LogInfo("mDNS_RemoveDynDNSHostName removing v4 %##s", fqdn); 2623 if (f6) LogInfo("mDNS_RemoveDynDNSHostName removing v6 %##s", fqdn); 2624 *ptr = (*ptr)->next; // unlink 2625 if (f4) mDNS_Deregister_internal(m, &hi->arv4, mDNS_Dereg_normal); 2626 if (f6) mDNS_Deregister_internal(m, &hi->arv6, mDNS_Dereg_normal); 2627 // When both deregistrations complete we'll free the memory in the mStatus_MemFree callback 2628 } 2629 mDNS_CheckLock(m); 2630 m->NextSRVUpdate = NonZeroTime(m->timenow); 2631} 2632 2633// Currently called without holding the lock 2634// Maybe we should change that? 2635mDNSexport void mDNS_SetPrimaryInterfaceInfo(mDNS *m, const mDNSAddr *v4addr, const mDNSAddr *v6addr, const mDNSAddr *router) 2636{ 2637 mDNSBool v4Changed, v6Changed, RouterChanged; 2638 2639 if (m->mDNS_busy != m->mDNS_reentrancy) 2640 LogMsg("mDNS_SetPrimaryInterfaceInfo: mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy); 2641 2642 if (v4addr && v4addr->type != mDNSAddrType_IPv4) { LogMsg("mDNS_SetPrimaryInterfaceInfo v4 address - incorrect type. Discarding. %#a", v4addr); return; } 2643 if (v6addr && v6addr->type != mDNSAddrType_IPv6) { LogMsg("mDNS_SetPrimaryInterfaceInfo v6 address - incorrect type. Discarding. %#a", v6addr); return; } 2644 if (router && router->type != mDNSAddrType_IPv4) { LogMsg("mDNS_SetPrimaryInterfaceInfo passed non-v4 router. Discarding. %#a", router); return; } 2645 2646 mDNS_Lock(m); 2647 2648 v4Changed = !mDNSSameIPv4Address(m->AdvertisedV4.ip.v4, v4addr ? v4addr->ip.v4 : zerov4Addr); 2649 v6Changed = !mDNSSameIPv6Address(m->AdvertisedV6.ip.v6, v6addr ? v6addr->ip.v6 : zerov6Addr); 2650 RouterChanged = !mDNSSameIPv4Address(m->Router.ip.v4, router ? router->ip.v4 : zerov4Addr); 2651 2652 if (v4addr && (v4Changed || RouterChanged)) 2653 debugf("mDNS_SetPrimaryInterfaceInfo: address changed from %#a to %#a", &m->AdvertisedV4, v4addr); 2654 2655 if (v4addr) m->AdvertisedV4 = *v4addr;else m->AdvertisedV4.ip.v4 = zerov4Addr; 2656 if (v6addr) m->AdvertisedV6 = *v6addr;else m->AdvertisedV6.ip.v6 = zerov6Addr; 2657 if (router) m->Router = *router;else m->Router.ip.v4 = zerov4Addr; 2658 // setting router to zero indicates that nat mappings must be reestablished when router is reset 2659 2660 if (v4Changed || RouterChanged || v6Changed) 2661 { 2662 HostnameInfo *i; 2663 LogInfo("mDNS_SetPrimaryInterfaceInfo: %s%s%s%#a %#a %#a", 2664 v4Changed ? "v4Changed " : "", 2665 RouterChanged ? "RouterChanged " : "", 2666 v6Changed ? "v6Changed " : "", v4addr, v6addr, router); 2667 2668 for (i = m->Hostnames; i; i = i->next) 2669 { 2670 LogInfo("mDNS_SetPrimaryInterfaceInfo updating host name registrations for %##s", i->fqdn.c); 2671 2672 if (i->arv4.resrec.RecordType > kDNSRecordTypeDeregistering && 2673 !mDNSSameIPv4Address(i->arv4.resrec.rdata->u.ipv4, m->AdvertisedV4.ip.v4)) 2674 { 2675 LogInfo("mDNS_SetPrimaryInterfaceInfo deregistering %s", ARDisplayString(m, &i->arv4)); 2676 mDNS_Deregister_internal(m, &i->arv4, mDNS_Dereg_normal); 2677 } 2678 2679 if (i->arv6.resrec.RecordType > kDNSRecordTypeDeregistering && 2680 !mDNSSameIPv6Address(i->arv6.resrec.rdata->u.ipv6, m->AdvertisedV6.ip.v6)) 2681 { 2682 LogInfo("mDNS_SetPrimaryInterfaceInfo deregistering %s", ARDisplayString(m, &i->arv6)); 2683 mDNS_Deregister_internal(m, &i->arv6, mDNS_Dereg_normal); 2684 } 2685 2686 // AdvertiseHostname will only register new address records. 2687 // For records still in the process of deregistering it will ignore them, and let the mStatus_MemFree callback handle them. 2688 AdvertiseHostname(m, i); 2689 } 2690 2691 if (v4Changed || RouterChanged) 2692 { 2693 // If we have a non-zero IPv4 address, we should try immediately to see if we have a NAT gateway 2694 // If we have no IPv4 address, we don't want to be in quite such a hurry to report failures to our clients 2695 // <rdar://problem/6935929> Sleeping server sometimes briefly disappears over Back to My Mac after it wakes up 2696 mDNSu32 waitSeconds = v4addr ? 0 : 5; 2697 NATTraversalInfo *n; 2698 m->ExtAddress = zerov4Addr; 2699 m->LastNATMapResultCode = NATErr_None; 2700 2701 RecreateNATMappings(m, mDNSPlatformOneSecond * waitSeconds); 2702 2703 for (n = m->NATTraversals; n; n=n->next) 2704 n->NewAddress = zerov4Addr; 2705 2706 LogInfo("mDNS_SetPrimaryInterfaceInfo:%s%s: recreating NAT mappings in %d seconds", 2707 v4Changed ? " v4Changed" : "", 2708 RouterChanged ? " RouterChanged" : "", 2709 waitSeconds); 2710 } 2711 2712 if (m->ReverseMap.ThisQInterval != -1) mDNS_StopQuery_internal(m, &m->ReverseMap); 2713 m->StaticHostname.c[0] = 0; 2714 2715 m->NextSRVUpdate = NonZeroTime(m->timenow); 2716 2717#if APPLE_OSX_mDNSResponder 2718 if (RouterChanged) uuid_generate(m->asl_uuid); 2719 UpdateAutoTunnelDomainStatuses(m); 2720#endif 2721 } 2722 2723 mDNS_Unlock(m); 2724} 2725 2726// *************************************************************************** 2727#if COMPILER_LIKES_PRAGMA_MARK 2728#pragma mark - Incoming Message Processing 2729#endif 2730 2731mDNSlocal mStatus ParseTSIGError(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, const domainname *const displayname) 2732{ 2733 const mDNSu8 *ptr; 2734 mStatus err = mStatus_NoError; 2735 int i; 2736 2737 ptr = LocateAdditionals(msg, end); 2738 if (!ptr) goto finish; 2739 2740 for (i = 0; i < msg->h.numAdditionals; i++) 2741 { 2742 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); 2743 if (!ptr) goto finish; 2744 if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_TSIG) 2745 { 2746 mDNSu32 macsize; 2747 mDNSu8 *rd = m->rec.r.resrec.rdata->u.data; 2748 mDNSu8 *rdend = rd + m->rec.r.resrec.rdlength; 2749 int alglen = DomainNameLengthLimit(&m->rec.r.resrec.rdata->u.name, rdend); 2750 if (alglen > MAX_DOMAIN_NAME) goto finish; 2751 rd += alglen; // algorithm name 2752 if (rd + 6 > rdend) goto finish; 2753 rd += 6; // 48-bit timestamp 2754 if (rd + sizeof(mDNSOpaque16) > rdend) goto finish; 2755 rd += sizeof(mDNSOpaque16); // fudge 2756 if (rd + sizeof(mDNSOpaque16) > rdend) goto finish; 2757 macsize = mDNSVal16(*(mDNSOpaque16 *)rd); 2758 rd += sizeof(mDNSOpaque16); // MAC size 2759 if (rd + macsize > rdend) goto finish; 2760 rd += macsize; 2761 if (rd + sizeof(mDNSOpaque16) > rdend) goto finish; 2762 rd += sizeof(mDNSOpaque16); // orig id 2763 if (rd + sizeof(mDNSOpaque16) > rdend) goto finish; 2764 err = mDNSVal16(*(mDNSOpaque16 *)rd); // error code 2765 2766 if (err == TSIG_ErrBadSig) { LogMsg("%##s: bad signature", displayname->c); err = mStatus_BadSig; } 2767 else if (err == TSIG_ErrBadKey) { LogMsg("%##s: bad key", displayname->c); err = mStatus_BadKey; } 2768 else if (err == TSIG_ErrBadTime) { LogMsg("%##s: bad time", displayname->c); err = mStatus_BadTime; } 2769 else if (err) { LogMsg("%##s: unknown tsig error %d", displayname->c, err); err = mStatus_UnknownErr; } 2770 goto finish; 2771 } 2772 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 2773 } 2774 2775finish: 2776 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 2777 return err; 2778} 2779 2780mDNSlocal mStatus checkUpdateResult(mDNS *const m, const domainname *const displayname, const mDNSu8 rcode, const DNSMessage *const msg, const mDNSu8 *const end) 2781{ 2782 (void)msg; // currently unused, needed for TSIG errors 2783 if (!rcode) return mStatus_NoError; 2784 else if (rcode == kDNSFlag1_RC_YXDomain) 2785 { 2786 debugf("name in use: %##s", displayname->c); 2787 return mStatus_NameConflict; 2788 } 2789 else if (rcode == kDNSFlag1_RC_Refused) 2790 { 2791 LogMsg("Update %##s refused", displayname->c); 2792 return mStatus_Refused; 2793 } 2794 else if (rcode == kDNSFlag1_RC_NXRRSet) 2795 { 2796 LogMsg("Reregister refused (NXRRSET): %##s", displayname->c); 2797 return mStatus_NoSuchRecord; 2798 } 2799 else if (rcode == kDNSFlag1_RC_NotAuth) 2800 { 2801 // TSIG errors should come with FormErr as per RFC 2845, but BIND 9 sends them with NotAuth so we look here too 2802 mStatus tsigerr = ParseTSIGError(m, msg, end, displayname); 2803 if (!tsigerr) 2804 { 2805 LogMsg("Permission denied (NOAUTH): %##s", displayname->c); 2806 return mStatus_UnknownErr; 2807 } 2808 else return tsigerr; 2809 } 2810 else if (rcode == kDNSFlag1_RC_FormErr) 2811 { 2812 mStatus tsigerr = ParseTSIGError(m, msg, end, displayname); 2813 if (!tsigerr) 2814 { 2815 LogMsg("Format Error: %##s", displayname->c); 2816 return mStatus_UnknownErr; 2817 } 2818 else return tsigerr; 2819 } 2820 else 2821 { 2822 LogMsg("Update %##s failed with rcode %d", displayname->c, rcode); 2823 return mStatus_UnknownErr; 2824 } 2825} 2826 2827// We add three Additional Records for unicast resource record registrations 2828// which is a function of AuthInfo and AutoTunnel properties 2829mDNSlocal mDNSu32 RRAdditionalSize(mDNS *const m, DomainAuthInfo *AuthInfo) 2830{ 2831 mDNSu32 leaseSize, hinfoSize, tsigSize; 2832 mDNSu32 rr_base_size = 10; // type (2) class (2) TTL (4) rdlength (2) 2833 2834 // OPT RR : Emptyname(.) + base size + rdataOPT 2835 leaseSize = 1 + rr_base_size + sizeof(rdataOPT); 2836 2837 // HINFO: Resource Record Name + base size + RDATA 2838 // HINFO is added only for autotunnels 2839 hinfoSize = 0; 2840 if (AuthInfo && AuthInfo->AutoTunnel) 2841 hinfoSize = (m->hostlabel.c[0] + 1) + DomainNameLength(&AuthInfo->domain) + 2842 rr_base_size + (2 + m->HIHardware.c[0] + m->HISoftware.c[0]); 2843 2844 //TSIG: Resource Record Name + base size + RDATA 2845 // RDATA: 2846 // Algorithm name: hmac-md5.sig-alg.reg.int (8+7+3+3 + 5 bytes for length = 26 bytes) 2847 // Time: 6 bytes 2848 // Fudge: 2 bytes 2849 // Mac Size: 2 bytes 2850 // Mac: 16 bytes 2851 // ID: 2 bytes 2852 // Error: 2 bytes 2853 // Len: 2 bytes 2854 // Total: 58 bytes 2855 tsigSize = 0; 2856 if (AuthInfo) tsigSize = DomainNameLength(&AuthInfo->keyname) + rr_base_size + 58; 2857 2858 return (leaseSize + hinfoSize + tsigSize); 2859} 2860 2861//Note: Make sure that RREstimatedSize is updated accordingly if anything that is done here 2862//would modify rdlength/rdestimate 2863mDNSlocal mDNSu8* BuildUpdateMessage(mDNS *const m, mDNSu8 *ptr, AuthRecord *rr, mDNSu8 *limit) 2864{ 2865 //If this record is deregistering, then just send the deletion record 2866 if (rr->state == regState_DeregPending) 2867 { 2868 rr->expire = 0; // Indicate that we have no active registration any more 2869 ptr = putDeletionRecordWithLimit(&m->omsg, ptr, &rr->resrec, limit); 2870 if (!ptr) goto exit; 2871 return ptr; 2872 } 2873 2874 // This is a common function to both sending an update in a group or individual 2875 // records separately. Hence, we change the state here. 2876 if (rr->state == regState_Registered) rr->state = regState_Refresh; 2877 if (rr->state != regState_Refresh && rr->state != regState_UpdatePending) 2878 rr->state = regState_Pending; 2879 2880 // For Advisory records like e.g., _services._dns-sd, which is shared, don't send goodbyes as multiple 2881 // host might be registering records and deregistering from one does not make sense 2882 if (rr->resrec.RecordType != kDNSRecordTypeAdvisory) rr->RequireGoodbye = mDNStrue; 2883 2884 if ((rr->resrec.rrtype == kDNSType_SRV) && (rr->AutoTarget == Target_AutoHostAndNATMAP) && 2885 !mDNSIPPortIsZero(rr->NATinfo.ExternalPort)) 2886 { 2887 rr->resrec.rdata->u.srv.port = rr->NATinfo.ExternalPort; 2888 } 2889 2890 if (rr->state == regState_UpdatePending) 2891 { 2892 // delete old RData 2893 SetNewRData(&rr->resrec, rr->OrigRData, rr->OrigRDLen); 2894 if (!(ptr = putDeletionRecordWithLimit(&m->omsg, ptr, &rr->resrec, limit))) goto exit; // delete old rdata 2895 2896 // add new RData 2897 SetNewRData(&rr->resrec, rr->InFlightRData, rr->InFlightRDLen); 2898 if (!(ptr = PutResourceRecordTTLWithLimit(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit))) goto exit; 2899 } 2900 else 2901 { 2902 if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique || rr->resrec.RecordType == kDNSRecordTypeVerified) 2903 { 2904 // KnownUnique : Delete any previous value 2905 // For Unicast registrations, we don't verify that it is unique, but set to verified and hence we want to 2906 // delete any previous value 2907 ptr = putDeleteRRSetWithLimit(&m->omsg, ptr, rr->resrec.name, rr->resrec.rrtype, limit); 2908 if (!ptr) goto exit; 2909 } 2910 else if (rr->resrec.RecordType != kDNSRecordTypeShared) 2911 { 2912 // For now don't do this, until we have the logic for intelligent grouping of individual records into logical service record sets 2913 //ptr = putPrereqNameNotInUse(rr->resrec.name, &m->omsg, ptr, end); 2914 if (!ptr) goto exit; 2915 } 2916 2917 ptr = PutResourceRecordTTLWithLimit(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit); 2918 if (!ptr) goto exit; 2919 } 2920 2921 return ptr; 2922exit: 2923 LogMsg("BuildUpdateMessage: Error formatting message for %s", ARDisplayString(m, rr)); 2924 return mDNSNULL; 2925} 2926 2927// Called with lock held 2928mDNSlocal void SendRecordRegistration(mDNS *const m, AuthRecord *rr) 2929{ 2930 mDNSu8 *ptr = m->omsg.data; 2931 mStatus err = mStatus_UnknownErr; 2932 mDNSu8 *limit; 2933 DomainAuthInfo *AuthInfo; 2934 2935 // For the ability to register large TXT records, we limit the single record registrations 2936 // to AbsoluteMaxDNSMessageData 2937 limit = ptr + AbsoluteMaxDNSMessageData; 2938 2939 AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name); 2940 limit -= RRAdditionalSize(m, AuthInfo); 2941 2942 mDNS_CheckLock(m); 2943 2944 if (!rr->nta || mDNSIPv4AddressIsZero(rr->nta->Addr.ip.v4)) 2945 { 2946 // We never call this function when there is no zone information . Log a message if it ever happens. 2947 LogMsg("SendRecordRegistration: No Zone information, should not happen %s", ARDisplayString(m, rr)); 2948 return; 2949 } 2950 2951 rr->updateid = mDNS_NewMessageID(m); 2952 InitializeDNSMessage(&m->omsg.h, rr->updateid, UpdateReqFlags); 2953 2954 // set zone 2955 ptr = putZone(&m->omsg, ptr, limit, rr->zone, mDNSOpaque16fromIntVal(rr->resrec.rrclass)); 2956 if (!ptr) goto exit; 2957 2958 if (!(ptr = BuildUpdateMessage(m, ptr, rr, limit))) goto exit; 2959 2960 if (rr->uselease) 2961 { 2962 ptr = putUpdateLeaseWithLimit(&m->omsg, ptr, DEFAULT_UPDATE_LEASE, limit); 2963 if (!ptr) goto exit; 2964 } 2965 if (rr->Private) 2966 { 2967 LogInfo("SendRecordRegistration TCP %p %s", rr->tcp, ARDisplayString(m, rr)); 2968 if (rr->tcp) LogInfo("SendRecordRegistration: Disposing existing TCP connection for %s", ARDisplayString(m, rr)); 2969 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 2970 if (!rr->nta) { LogMsg("SendRecordRegistration:Private:ERROR!! nta is NULL for %s", ARDisplayString(m, rr)); return; } 2971 rr->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &rr->nta->Addr, rr->nta->Port, &rr->nta->Host, mDNSNULL, rr); 2972 } 2973 else 2974 { 2975 LogInfo("SendRecordRegistration UDP %s", ARDisplayString(m, rr)); 2976 if (!rr->nta) { LogMsg("SendRecordRegistration:ERROR!! nta is NULL for %s", ARDisplayString(m, rr)); return; } 2977 err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &rr->nta->Addr, rr->nta->Port, mDNSNULL, GetAuthInfoForName_internal(m, rr->resrec.name), mDNSfalse); 2978 if (err) debugf("ERROR: SendRecordRegistration - mDNSSendDNSMessage - %d", err); 2979 } 2980 2981 SetRecordRetry(m, rr, 0); 2982 return; 2983exit: 2984 LogMsg("SendRecordRegistration: Error formatting message for %s, disabling further updates", ARDisplayString(m, rr)); 2985 // Disable this record from future updates 2986 rr->state = regState_NoTarget; 2987} 2988 2989// Is the given record "rr" eligible for merging ? 2990mDNSlocal mDNSBool IsRecordMergeable(mDNS *const m, AuthRecord *rr, mDNSs32 time) 2991{ 2992 DomainAuthInfo *info; 2993 (void) m; //unused 2994 // A record is eligible for merge, if the following properties are met. 2995 // 2996 // 1. uDNS Resource Record 2997 // 2. It is time to send them now 2998 // 3. It is in proper state 2999 // 4. Update zone has been resolved 3000 // 5. if DomainAuthInfo exists for the zone, it should not be soon deleted 3001 // 6. Zone information is present 3002 // 7. Update server is not zero 3003 // 8. It has a non-null zone 3004 // 9. It uses a lease option 3005 // 10. DontMerge is not set 3006 // 3007 // Following code is implemented as separate "if" statements instead of one "if" statement 3008 // is for better debugging purposes e.g., we know exactly what failed if debugging turned on. 3009 3010 if (!AuthRecord_uDNS(rr)) return mDNSfalse; 3011 3012 if (rr->LastAPTime + rr->ThisAPInterval - time > 0) 3013 { debugf("IsRecordMergeable: Time %d not reached for %s", rr->LastAPTime + rr->ThisAPInterval - m->timenow, ARDisplayString(m, rr)); return mDNSfalse; } 3014 3015 if (!rr->zone) return mDNSfalse; 3016 3017 info = GetAuthInfoForName_internal(m, rr->zone); 3018 3019 if (info && info->deltime && m->timenow - info->deltime >= 0) {debugf("IsRecordMergeable: Domain %##s will be deleted soon", info->domain.c); return mDNSfalse;} 3020 3021 if (rr->state != regState_DeregPending && rr->state != regState_Pending && rr->state != regState_Registered && rr->state != regState_Refresh && rr->state != regState_UpdatePending) 3022 { debugf("IsRecordMergeable: state %d not right %s", rr->state, ARDisplayString(m, rr)); return mDNSfalse; } 3023 3024 if (!rr->nta || mDNSIPv4AddressIsZero(rr->nta->Addr.ip.v4)) return mDNSfalse; 3025 3026 if (!rr->uselease) return mDNSfalse; 3027 3028 if (rr->mState == mergeState_DontMerge) {debugf("IsRecordMergeable Dontmerge true %s", ARDisplayString(m, rr)); return mDNSfalse;} 3029 debugf("IsRecordMergeable: Returning true for %s", ARDisplayString(m, rr)); 3030 return mDNStrue; 3031} 3032 3033// Is the resource record "rr" eligible to merge to with "currentRR" ? 3034mDNSlocal mDNSBool AreRecordsMergeable(mDNS *const m, AuthRecord *currentRR, AuthRecord *rr, mDNSs32 time) 3035{ 3036 // A record is eligible to merge with another record as long it is eligible for merge in itself 3037 // and it has the same zone information as the other record 3038 if (!IsRecordMergeable(m, rr, time)) return mDNSfalse; 3039 3040 if (!SameDomainName(currentRR->zone, rr->zone)) 3041 { debugf("AreRecordMergeable zone mismatch current rr Zone %##s, rr zone %##s", currentRR->zone->c, rr->zone->c); return mDNSfalse; } 3042 3043 if (!mDNSSameIPv4Address(currentRR->nta->Addr.ip.v4, rr->nta->Addr.ip.v4)) return mDNSfalse; 3044 3045 if (!mDNSSameIPPort(currentRR->nta->Port, rr->nta->Port)) return mDNSfalse; 3046 3047 debugf("AreRecordsMergeable: Returning true for %s", ARDisplayString(m, rr)); 3048 return mDNStrue; 3049} 3050 3051// If we can't build the message successfully because of problems in pre-computing 3052// the space, we disable merging for all the current records 3053mDNSlocal void RRMergeFailure(mDNS *const m) 3054{ 3055 AuthRecord *rr; 3056 for (rr = m->ResourceRecords; rr; rr = rr->next) 3057 { 3058 rr->mState = mergeState_DontMerge; 3059 rr->SendRNow = mDNSNULL; 3060 // Restarting the registration is much simpler than saving and restoring 3061 // the exact time 3062 ActivateUnicastRegistration(m, rr); 3063 } 3064} 3065 3066mDNSlocal void SendGroupRRMessage(mDNS *const m, AuthRecord *anchorRR, mDNSu8 *ptr, DomainAuthInfo *info) 3067{ 3068 mDNSu8 *limit; 3069 if (!anchorRR) {debugf("SendGroupRRMessage: Could not merge records"); return;} 3070 3071 if (info && info->AutoTunnel) limit = m->omsg.data + AbsoluteMaxDNSMessageData; 3072 else limit = m->omsg.data + NormalMaxDNSMessageData; 3073 3074 // This has to go in the additional section and hence need to be done last 3075 ptr = putUpdateLeaseWithLimit(&m->omsg, ptr, DEFAULT_UPDATE_LEASE, limit); 3076 if (!ptr) 3077 { 3078 LogMsg("SendGroupRRMessage: ERROR: Could not put lease option, failing the group registration"); 3079 // if we can't put the lease, we need to undo the merge 3080 RRMergeFailure(m); 3081 return; 3082 } 3083 if (anchorRR->Private) 3084 { 3085 if (anchorRR->tcp) debugf("SendGroupRRMessage: Disposing existing TCP connection for %s", ARDisplayString(m, anchorRR)); 3086 if (anchorRR->tcp) { DisposeTCPConn(anchorRR->tcp); anchorRR->tcp = mDNSNULL; } 3087 if (!anchorRR->nta) { LogMsg("SendGroupRRMessage:ERROR!! nta is NULL for %s", ARDisplayString(m, anchorRR)); return; } 3088 anchorRR->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &anchorRR->nta->Addr, anchorRR->nta->Port, &anchorRR->nta->Host, mDNSNULL, anchorRR); 3089 if (!anchorRR->tcp) LogInfo("SendGroupRRMessage: Cannot establish TCP connection for %s", ARDisplayString(m, anchorRR)); 3090 else LogInfo("SendGroupRRMessage: Sent a group update ID: %d start %p, end %p, limit %p", mDNSVal16(m->omsg.h.id), m->omsg.data, ptr, limit); 3091 } 3092 else 3093 { 3094 mStatus err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &anchorRR->nta->Addr, anchorRR->nta->Port, mDNSNULL, info, mDNSfalse); 3095 if (err) LogInfo("SendGroupRRMessage: Cannot send UDP message for %s", ARDisplayString(m, anchorRR)); 3096 else LogInfo("SendGroupRRMessage: Sent a group UDP update ID: %d start %p, end %p, limit %p", mDNSVal16(m->omsg.h.id), m->omsg.data, ptr, limit); 3097 } 3098 return; 3099} 3100 3101// As we always include the zone information and the resource records contain zone name 3102// at the end, it will get compressed. Hence, we subtract zoneSize and add two bytes for 3103// the compression pointer 3104mDNSlocal mDNSu32 RREstimatedSize(AuthRecord *rr, int zoneSize) 3105{ 3106 int rdlength; 3107 3108 // Note: Estimation of the record size has to mirror the logic in BuildUpdateMessage, otherwise estimation 3109 // would be wrong. Currently BuildUpdateMessage calls SetNewRData in UpdatePending case. Hence, we need 3110 // to account for that here. Otherwise, we might under estimate the size. 3111 if (rr->state == regState_UpdatePending) 3112 // old RData that will be deleted 3113 // new RData that will be added 3114 rdlength = rr->OrigRDLen + rr->InFlightRDLen; 3115 else 3116 rdlength = rr->resrec.rdestimate; 3117 3118 if (rr->state == regState_DeregPending) 3119 { 3120 debugf("RREstimatedSize: ResourceRecord %##s (%s), DomainNameLength %d, zoneSize %d, rdestimate %d", 3121 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), DomainNameLength(rr->resrec.name), zoneSize, rdlength); 3122 return DomainNameLength(rr->resrec.name) - zoneSize + 2 + 10 + rdlength; 3123 } 3124 3125 // For SRV, TXT, AAAA etc. that are Unique/Verified, we also send a Deletion Record 3126 if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique || rr->resrec.RecordType == kDNSRecordTypeVerified) 3127 { 3128 // Deletion Record: Resource Record Name + Base size (10) + 0 3129 // Record: Resource Record Name (Compressed = 2) + Base size (10) + rdestimate 3130 3131 debugf("RREstimatedSize: ResourceRecord %##s (%s), DomainNameLength %d, zoneSize %d, rdestimate %d", 3132 rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), DomainNameLength(rr->resrec.name), zoneSize, rdlength); 3133 return DomainNameLength(rr->resrec.name) - zoneSize + 2 + 10 + 2 + 10 + rdlength; 3134 } 3135 else 3136 { 3137 return DomainNameLength(rr->resrec.name) - zoneSize + 2 + 10 + rdlength; 3138 } 3139} 3140 3141mDNSlocal AuthRecord *MarkRRForSending(mDNS *const m) 3142{ 3143 AuthRecord *rr; 3144 AuthRecord *firstRR = mDNSNULL; 3145 3146 // Look for records that needs to be sent in the next two seconds (MERGE_DELAY_TIME is set to 1 second). 3147 // The logic is as follows. 3148 // 3149 // 1. Record 1 finishes getting zone data and its registration gets delayed by 1 second 3150 // 2. Record 2 comes 0.1 second later, finishes getting its zone data and its registration is also delayed by 3151 // 1 second which is now scheduled at 1.1 second 3152 // 3153 // By looking for 1 second into the future (m->timenow + MERGE_DELAY_TIME below does that) we have merged both 3154 // of the above records. Note that we can't look for records too much into the future as this will affect the 3155 // retry logic. The first retry is scheduled at 3 seconds. Hence, we should always look smaller than that. 3156 // Anything more than one second will affect the first retry to happen sooner. 3157 // 3158 // Note: As a side effect of looking one second into the future to facilitate merging, the retries happen 3159 // one second sooner. 3160 for (rr = m->ResourceRecords; rr; rr = rr->next) 3161 { 3162 if (!firstRR) 3163 { 3164 if (!IsRecordMergeable(m, rr, m->timenow + MERGE_DELAY_TIME)) continue; 3165 firstRR = rr; 3166 } 3167 else if (!AreRecordsMergeable(m, firstRR, rr, m->timenow + MERGE_DELAY_TIME)) continue; 3168 3169 if (rr->SendRNow) LogMsg("MarkRRForSending: Resourcerecord %s already marked for sending", ARDisplayString(m, rr)); 3170 rr->SendRNow = uDNSInterfaceMark; 3171 } 3172 3173 // We parsed through all records and found something to send. The services/records might 3174 // get registered at different times but we want the refreshes to be all merged and sent 3175 // as one update. Hence, we accelerate some of the records so that they will sync up in 3176 // the future. Look at the records excluding the ones that we have already sent in the 3177 // previous pass. If it half way through its scheduled refresh/retransmit, merge them 3178 // into this packet. 3179 // 3180 // Note that we only look at Registered/Refresh state to keep it simple. As we don't know 3181 // whether the current update will fit into one or more packets, merging a resource record 3182 // (which is in a different state) that has been scheduled for retransmit would trigger 3183 // sending more packets. 3184 if (firstRR) 3185 { 3186 int acc = 0; 3187 for (rr = m->ResourceRecords; rr; rr = rr->next) 3188 { 3189 if ((rr->state != regState_Registered && rr->state != regState_Refresh) || 3190 (rr->SendRNow == uDNSInterfaceMark) || 3191 (!AreRecordsMergeable(m, firstRR, rr, m->timenow + rr->ThisAPInterval/2))) 3192 continue; 3193 rr->SendRNow = uDNSInterfaceMark; 3194 acc++; 3195 } 3196 if (acc) LogInfo("MarkRRForSending: Accelereated %d records", acc); 3197 } 3198 return firstRR; 3199} 3200 3201mDNSlocal mDNSBool SendGroupUpdates(mDNS *const m) 3202{ 3203 mDNSOpaque16 msgid; 3204 mDNSs32 spaceleft = 0; 3205 mDNSs32 zoneSize, rrSize; 3206 mDNSu8 *oldnext; // for debugging 3207 mDNSu8 *next = m->omsg.data; 3208 AuthRecord *rr; 3209 AuthRecord *anchorRR = mDNSNULL; 3210 int nrecords = 0; 3211 AuthRecord *startRR = m->ResourceRecords; 3212 mDNSu8 *limit = mDNSNULL; 3213 DomainAuthInfo *AuthInfo = mDNSNULL; 3214 mDNSBool sentallRecords = mDNStrue; 3215 3216 3217 // We try to fit as many ResourceRecords as possible in AbsoluteNormal/MaxDNSMessageData. Before we start 3218 // putting in resource records, we need to reserve space for a few things. Every group/packet should 3219 // have the following. 3220 // 3221 // 1) Needs space for the Zone information (which needs to be at the beginning) 3222 // 2) Additional section MUST have space for lease option, HINFO and TSIG option (which needs to 3223 // to be at the end) 3224 // 3225 // In future we need to reserve space for the pre-requisites which also goes at the beginning. 3226 // To accomodate pre-requisites in the future, first we walk the whole list marking records 3227 // that can be sent in this packet and computing the space needed for these records. 3228 // For TXT and SRV records, we delete the previous record if any by sending the same 3229 // resource record with ANY RDATA and zero rdlen. Hence, we need to have space for both of them. 3230 3231 while (startRR) 3232 { 3233 AuthInfo = mDNSNULL; 3234 anchorRR = mDNSNULL; 3235 nrecords = 0; 3236 zoneSize = 0; 3237 for (rr = startRR; rr; rr = rr->next) 3238 { 3239 if (rr->SendRNow != uDNSInterfaceMark) continue; 3240 3241 rr->SendRNow = mDNSNULL; 3242 3243 if (!anchorRR) 3244 { 3245 AuthInfo = GetAuthInfoForName_internal(m, rr->zone); 3246 3247 // Though we allow single record registrations for UDP to be AbsoluteMaxDNSMessageData (See 3248 // SendRecordRegistration) to handle large TXT records, to avoid fragmentation we limit UDP 3249 // message to NormalMaxDNSMessageData 3250 if (AuthInfo && AuthInfo->AutoTunnel) spaceleft = AbsoluteMaxDNSMessageData; 3251 else spaceleft = NormalMaxDNSMessageData; 3252 3253 next = m->omsg.data; 3254 spaceleft -= RRAdditionalSize(m, AuthInfo); 3255 if (spaceleft <= 0) 3256 { 3257 LogMsg("SendGroupUpdates: ERROR!!: spaceleft is zero at the beginning"); 3258 RRMergeFailure(m); 3259 return mDNSfalse; 3260 } 3261 limit = next + spaceleft; 3262 3263 // Build the initial part of message before putting in the other records 3264 msgid = mDNS_NewMessageID(m); 3265 InitializeDNSMessage(&m->omsg.h, msgid, UpdateReqFlags); 3266 3267 // We need zone information at the beginning of the packet. Length: ZNAME, ZTYPE(2), ZCLASS(2) 3268 // zone has to be non-NULL for a record to be mergeable, hence it is safe to set/ examine zone 3269 //without checking for NULL. 3270 zoneSize = DomainNameLength(rr->zone) + 4; 3271 spaceleft -= zoneSize; 3272 if (spaceleft <= 0) 3273 { 3274 LogMsg("SendGroupUpdates: ERROR no space for zone information, disabling merge"); 3275 RRMergeFailure(m); 3276 return mDNSfalse; 3277 } 3278 next = putZone(&m->omsg, next, limit, rr->zone, mDNSOpaque16fromIntVal(rr->resrec.rrclass)); 3279 if (!next) 3280 { 3281 LogMsg("SendGroupUpdates: ERROR! Cannot put zone, disabling merge"); 3282 RRMergeFailure(m); 3283 return mDNSfalse; 3284 } 3285 anchorRR = rr; 3286 } 3287 3288 rrSize = RREstimatedSize(rr, zoneSize - 4); 3289 3290 if ((spaceleft - rrSize) < 0) 3291 { 3292 // If we can't fit even a single message, skip it, it will be sent separately 3293 // in CheckRecordUpdates 3294 if (!nrecords) 3295 { 3296 LogInfo("SendGroupUpdates: Skipping message %s, spaceleft %d, rrSize %d", ARDisplayString(m, rr), spaceleft, rrSize); 3297 // Mark this as not sent so that the caller knows about it 3298 rr->SendRNow = uDNSInterfaceMark; 3299 // We need to remove the merge delay so that we can send it immediately 3300 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 3301 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 3302 rr = rr->next; 3303 anchorRR = mDNSNULL; 3304 sentallRecords = mDNSfalse; 3305 } 3306 else 3307 { 3308 LogInfo("SendGroupUpdates:1: Parsed %d records and sending using %s, spaceleft %d, rrSize %d", nrecords, ARDisplayString(m, anchorRR), spaceleft, rrSize); 3309 SendGroupRRMessage(m, anchorRR, next, AuthInfo); 3310 } 3311 break; // breaks out of for loop 3312 } 3313 spaceleft -= rrSize; 3314 oldnext = next; 3315 LogInfo("SendGroupUpdates: Building a message with resource record %s, next %p, state %d, ttl %d", ARDisplayString(m, rr), next, rr->state, rr->resrec.rroriginalttl); 3316 if (!(next = BuildUpdateMessage(m, next, rr, limit))) 3317 { 3318 // We calculated the space and if we can't fit in, we had some bug in the calculation, 3319 // disable merge completely. 3320 LogMsg("SendGroupUpdates: ptr NULL while building message with %s", ARDisplayString(m, rr)); 3321 RRMergeFailure(m); 3322 return mDNSfalse; 3323 } 3324 // If our estimate was higher, adjust to the actual size 3325 if ((next - oldnext) > rrSize) 3326 LogMsg("SendGroupUpdates: ERROR!! Record size estimation is wrong for %s, Estimate %d, Actual %d, state %d", ARDisplayString(m, rr), rrSize, next - oldnext, rr->state); 3327 else { spaceleft += rrSize; spaceleft -= (next - oldnext); } 3328 3329 nrecords++; 3330 // We could have sent an update earlier with this "rr" as anchorRR for which we never got a response. 3331 // To preserve ordering, we blow away the previous connection before sending this. 3332 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL;} 3333 rr->updateid = msgid; 3334 3335 // By setting the retry time interval here, we will not be looking at these records 3336 // again when we return to CheckGroupRecordUpdates. 3337 SetRecordRetry(m, rr, 0); 3338 } 3339 // Either we have parsed all the records or stopped at "rr" above due to lack of space 3340 startRR = rr; 3341 } 3342 3343 if (anchorRR) 3344 { 3345 LogInfo("SendGroupUpdates: Parsed %d records and sending using %s", nrecords, ARDisplayString(m, anchorRR)); 3346 SendGroupRRMessage(m, anchorRR, next, AuthInfo); 3347 } 3348 return sentallRecords; 3349} 3350 3351// Merge the record registrations and send them as a group only if they 3352// have same DomainAuthInfo and hence the same key to put the TSIG 3353mDNSlocal void CheckGroupRecordUpdates(mDNS *const m) 3354{ 3355 AuthRecord *rr, *nextRR; 3356 // Keep sending as long as there is at least one record to be sent 3357 while (MarkRRForSending(m)) 3358 { 3359 if (!SendGroupUpdates(m)) 3360 { 3361 // if everything that was marked was not sent, send them out individually 3362 for (rr = m->ResourceRecords; rr; rr = nextRR) 3363 { 3364 // SendRecordRegistrtion might delete the rr from list, hence 3365 // dereference nextRR before calling the function 3366 nextRR = rr->next; 3367 if (rr->SendRNow == uDNSInterfaceMark) 3368 { 3369 // Any records marked for sending should be eligible to be sent out 3370 // immediately. Just being cautious 3371 if (rr->LastAPTime + rr->ThisAPInterval - m->timenow > 0) 3372 { LogMsg("CheckGroupRecordUpdates: ERROR!! Resourcerecord %s not ready", ARDisplayString(m, rr)); continue; } 3373 rr->SendRNow = mDNSNULL; 3374 SendRecordRegistration(m, rr); 3375 } 3376 } 3377 } 3378 } 3379 3380 debugf("CheckGroupRecordUpdates: No work, returning"); 3381 return; 3382} 3383 3384mDNSlocal void hndlSRVChanged(mDNS *const m, AuthRecord *rr) 3385{ 3386 // Reevaluate the target always as NAT/Target could have changed while 3387 // we were registering/deeregistering 3388 domainname *dt; 3389 const domainname *target = GetServiceTarget(m, rr); 3390 if (!target || target->c[0] == 0) 3391 { 3392 // we don't have a target, if we just derregistered, then we don't have to do anything 3393 if (rr->state == regState_DeregPending) 3394 { 3395 LogInfo("hndlSRVChanged: SRVChanged, No Target, SRV Deregistered for %##s, state %d", rr->resrec.name->c, 3396 rr->state); 3397 rr->SRVChanged = mDNSfalse; 3398 dt = GetRRDomainNameTarget(&rr->resrec); 3399 if (dt) dt->c[0] = 0; 3400 rr->state = regState_NoTarget; // Wait for the next target change 3401 rr->resrec.rdlength = rr->resrec.rdestimate = 0; 3402 return; 3403 } 3404 3405 // we don't have a target, if we just registered, we need to deregister 3406 if (rr->state == regState_Pending) 3407 { 3408 LogInfo("hndlSRVChanged: SRVChanged, No Target, Deregistering again %##s, state %d", rr->resrec.name->c, rr->state); 3409 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 3410 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 3411 rr->state = regState_DeregPending; 3412 return; 3413 } 3414 LogInfo("hndlSRVChanged: Not in DeregPending or RegPending state %##s, state %d", rr->resrec.name->c, rr->state); 3415 } 3416 else 3417 { 3418 // If we were in registered state and SRV changed to NULL, we deregister and come back here 3419 // if we have a target, we need to register again. 3420 // 3421 // if we just registered check to see if it is same. If it is different just re-register the 3422 // SRV and its assoicated records 3423 // 3424 // UpdateOneSRVRecord takes care of re-registering all service records 3425 if ((rr->state == regState_DeregPending) || 3426 (rr->state == regState_Pending && !SameDomainName(target, &rr->resrec.rdata->u.srv.target))) 3427 { 3428 dt = GetRRDomainNameTarget(&rr->resrec); 3429 if (dt) dt->c[0] = 0; 3430 rr->state = regState_NoTarget; // NoTarget will allow us to pick up new target OR nat traversal state 3431 rr->resrec.rdlength = rr->resrec.rdestimate = 0; 3432 LogInfo("hndlSRVChanged: SRVChanged, Valid Target %##s, Registering all records for %##s, state %d", 3433 target->c, rr->resrec.name->c, rr->state); 3434 rr->SRVChanged = mDNSfalse; 3435 UpdateOneSRVRecord(m, rr); 3436 return; 3437 } 3438 // Target did not change while this record was registering. Hence, we go to 3439 // Registered state - the state we started from. 3440 if (rr->state == regState_Pending) rr->state = regState_Registered; 3441 } 3442 3443 rr->SRVChanged = mDNSfalse; 3444} 3445 3446// Called with lock held 3447mDNSlocal void hndlRecordUpdateReply(mDNS *m, AuthRecord *rr, mStatus err, mDNSu32 random) 3448{ 3449 mDNSBool InvokeCallback = mDNStrue; 3450 mDNSIPPort UpdatePort = zeroIPPort; 3451 3452 mDNS_CheckLock(m); 3453 3454 LogInfo("hndlRecordUpdateReply: err %d ID %d state %d %s(%p)", err, mDNSVal16(rr->updateid), rr->state, ARDisplayString(m, rr), rr); 3455 3456 rr->updateError = err; 3457#if APPLE_OSX_mDNSResponder 3458 if (err == mStatus_BadSig || err == mStatus_BadKey || err == mStatus_BadTime) UpdateAutoTunnelDomainStatuses(m); 3459#endif 3460 3461 SetRecordRetry(m, rr, random); 3462 3463 rr->updateid = zeroID; // Make sure that this is not considered as part of a group anymore 3464 // Later when need to send an update, we will get the zone data again. Thus we avoid 3465 // using stale information. 3466 // 3467 // Note: By clearing out the zone info here, it also helps better merging of records 3468 // in some cases. For example, when we get out regState_NoTarget state e.g., move out 3469 // of Double NAT, we want all the records to be in one update. Some BTMM records like 3470 // _autotunnel6 and host records are registered/deregistered when NAT state changes. 3471 // As they are re-registered the zone information is cleared out. To merge with other 3472 // records that might be possibly going out, clearing out the information here helps 3473 // as all of them try to get the zone data. 3474 if (rr->nta) 3475 { 3476 // We always expect the question to be stopped when we get a valid response from the server. 3477 // If the zone info tries to change during this time, updateid would be different and hence 3478 // this response should not have been accepted. 3479 if (rr->nta->question.ThisQInterval != -1) 3480 LogMsg("hndlRecordUpdateReply: ResourceRecord %s, zone info question %##s (%s) interval %d not -1", 3481 ARDisplayString(m, rr), rr->nta->question.qname.c, DNSTypeName(rr->nta->question.qtype), rr->nta->question.ThisQInterval); 3482 UpdatePort = rr->nta->Port; 3483 CancelGetZoneData(m, rr->nta); 3484 rr->nta = mDNSNULL; 3485 } 3486 3487 // If we are deregistering the record, then complete the deregistration. Ignore any NAT/SRV change 3488 // that could have happened during that time. 3489 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering && rr->state == regState_DeregPending) 3490 { 3491 debugf("hndlRecordUpdateReply: Received reply for deregister record %##s type %d", rr->resrec.name->c, rr->resrec.rrtype); 3492 if (err) LogMsg("ERROR: Deregistration of record %##s type %d failed with error %d", 3493 rr->resrec.name->c, rr->resrec.rrtype, err); 3494 rr->state = regState_Unregistered; 3495 CompleteDeregistration(m, rr); 3496 return; 3497 } 3498 3499 // We are returning early without updating the state. When we come back from sleep we will re-register after 3500 // re-initializing all the state as though it is a first registration. If the record can't be registered e.g., 3501 // no target, it will be deregistered. Hence, the updating to the right state should not matter when going 3502 // to sleep. 3503 if (m->SleepState) 3504 { 3505 // Need to set it to NoTarget state so that RecordReadyForSleep knows that 3506 // we are done 3507 if (rr->resrec.rrtype == kDNSType_SRV && rr->state == regState_DeregPending) 3508 rr->state = regState_NoTarget; 3509 return; 3510 } 3511 3512 if (rr->state == regState_UpdatePending) 3513 { 3514 if (err) LogMsg("Update record failed for %##s (err %d)", rr->resrec.name->c, err); 3515 rr->state = regState_Registered; 3516 // deallocate old RData 3517 if (rr->UpdateCallback) rr->UpdateCallback(m, rr, rr->OrigRData, rr->OrigRDLen); 3518 SetNewRData(&rr->resrec, rr->InFlightRData, rr->InFlightRDLen); 3519 rr->OrigRData = mDNSNULL; 3520 rr->InFlightRData = mDNSNULL; 3521 } 3522 3523 if (rr->SRVChanged) 3524 { 3525 if (rr->resrec.rrtype == kDNSType_SRV) 3526 hndlSRVChanged(m, rr); 3527 else 3528 { 3529 LogInfo("hndlRecordUpdateReply: Deregistered %##s (%s), state %d", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->state); 3530 rr->SRVChanged = mDNSfalse; 3531 if (rr->state != regState_DeregPending) LogMsg("hndlRecordUpdateReply: ResourceRecord %s not in DeregPending state %d", ARDisplayString(m, rr), rr->state); 3532 rr->state = regState_NoTarget; // Wait for the next target change 3533 } 3534 return; 3535 } 3536 3537 if (rr->state == regState_Pending || rr->state == regState_Refresh) 3538 { 3539 if (!err) 3540 { 3541 if (rr->state == regState_Refresh) InvokeCallback = mDNSfalse; 3542 rr->state = regState_Registered; 3543 } 3544 else 3545 { 3546 // Retry without lease only for non-Private domains 3547 LogMsg("hndlRecordUpdateReply: Registration of record %##s type %d failed with error %d", rr->resrec.name->c, rr->resrec.rrtype, err); 3548 if (!rr->Private && rr->uselease && err == mStatus_UnknownErr && mDNSSameIPPort(UpdatePort, UnicastDNSPort)) 3549 { 3550 LogMsg("hndlRecordUpdateReply: Will retry update of record %##s without lease option", rr->resrec.name->c); 3551 rr->uselease = mDNSfalse; 3552 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 3553 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 3554 SetNextuDNSEvent(m, rr); 3555 return; 3556 } 3557 // Communicate the error to the application in the callback below 3558 } 3559 } 3560 3561 if (rr->QueuedRData && rr->state == regState_Registered) 3562 { 3563 rr->state = regState_UpdatePending; 3564 rr->InFlightRData = rr->QueuedRData; 3565 rr->InFlightRDLen = rr->QueuedRDLen; 3566 rr->OrigRData = rr->resrec.rdata; 3567 rr->OrigRDLen = rr->resrec.rdlength; 3568 rr->QueuedRData = mDNSNULL; 3569 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 3570 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 3571 SetNextuDNSEvent(m, rr); 3572 return; 3573 } 3574 3575 // Don't invoke the callback on error as this may not be useful to the client. 3576 // The client may potentially delete the resource record on error which we normally 3577 // delete during deregistration 3578 if (!err && InvokeCallback && rr->RecordCallback) 3579 { 3580 LogInfo("hndlRecordUpdateReply: Calling record callback on %##s", rr->resrec.name->c); 3581 mDNS_DropLockBeforeCallback(); 3582 rr->RecordCallback(m, rr, err); 3583 mDNS_ReclaimLockAfterCallback(); 3584 } 3585 // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function 3586 // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc. 3587} 3588 3589mDNSlocal void uDNS_ReceiveNATPMPPacket(mDNS *m, const mDNSInterfaceID InterfaceID, mDNSu8 *pkt, mDNSu16 len) 3590{ 3591 NATTraversalInfo *ptr; 3592 NATAddrReply *AddrReply = (NATAddrReply *)pkt; 3593 NATPortMapReply *PortMapReply = (NATPortMapReply *)pkt; 3594 mDNSu32 nat_elapsed, our_elapsed; 3595 3596 // Minimum NAT-PMP packet is vers (1) opcode (1) + err (2) = 4 bytes 3597 if (len < 4) { LogMsg("NAT-PMP message too short (%d bytes)", len); return; } 3598 3599 // Read multi-byte error value (field is identical in a NATPortMapReply) 3600 AddrReply->err = (mDNSu16) ((mDNSu16)pkt[2] << 8 | pkt[3]); 3601 3602 if (AddrReply->err == NATErr_Vers) 3603 { 3604 NATTraversalInfo *n; 3605 LogInfo("NAT-PMP version unsupported message received"); 3606 for (n = m->NATTraversals; n; n=n->next) 3607 { 3608 // Send a NAT-PMP request for this operation as needed 3609 // and update the state variables 3610 uDNS_SendNATMsg(m, n, mDNSfalse); 3611 } 3612 3613 m->NextScheduledNATOp = m->timenow; 3614 3615 return; 3616 } 3617 3618 // The minimum reasonable NAT-PMP packet length is vers (1) + opcode (1) + err (2) + upseconds (4) = 8 bytes 3619 // If it's not at least this long, bail before we byte-swap the upseconds field & overrun our buffer. 3620 // The retry timer will ensure we converge to correctness. 3621 if (len < 8) 3622 { 3623 LogMsg("NAT-PMP message too short (%d bytes) 0x%X 0x%X", len, AddrReply->opcode, AddrReply->err); 3624 return; 3625 } 3626 3627 // Read multi-byte upseconds value (field is identical in a NATPortMapReply) 3628 AddrReply->upseconds = (mDNSs32) ((mDNSs32)pkt[4] << 24 | (mDNSs32)pkt[5] << 16 | (mDNSs32)pkt[6] << 8 | pkt[7]); 3629 3630 nat_elapsed = AddrReply->upseconds - m->LastNATupseconds; 3631 our_elapsed = (m->timenow - m->LastNATReplyLocalTime) / mDNSPlatformOneSecond; 3632 debugf("uDNS_ReceiveNATPMPPacket %X upseconds %u nat_elapsed %d our_elapsed %d", AddrReply->opcode, AddrReply->upseconds, nat_elapsed, our_elapsed); 3633 3634 // We compute a conservative estimate of how much the NAT gateways's clock should have advanced 3635 // 1. We subtract 12.5% from our own measured elapsed time, to allow for NAT gateways that have an inacurate clock that runs slowly 3636 // 2. We add a two-second safety margin to allow for rounding errors: e.g. 3637 // -- if NAT gateway sends a packet at t=2.000 seconds, then one at t=7.999, that's approximately 6 real seconds, 3638 // but based on the values in the packet (2,7) the apparent difference according to the packet is only 5 seconds 3639 // -- if we're slow handling packets and/or we have coarse clock granularity, 3640 // we could receive the t=2 packet at our t=1.999 seconds, which we round down to 1 3641 // and the t=7.999 packet at our t=8.000 seconds, which we record as 8, 3642 // giving an apparent local time difference of 7 seconds 3643 // The two-second safety margin coves this possible calculation discrepancy 3644 if (AddrReply->upseconds < m->LastNATupseconds || nat_elapsed + 2 < our_elapsed - our_elapsed/8) 3645 { LogMsg("NAT-PMP epoch time check failed: assuming NAT gateway %#a rebooted", &m->Router); RecreateNATMappings(m, 0); } 3646 3647 m->LastNATupseconds = AddrReply->upseconds; 3648 m->LastNATReplyLocalTime = m->timenow; 3649#ifdef _LEGACY_NAT_TRAVERSAL_ 3650 LNT_ClearState(m); 3651#endif // _LEGACY_NAT_TRAVERSAL_ 3652 3653 if (AddrReply->opcode == NATOp_AddrResponse) 3654 { 3655#if APPLE_OSX_mDNSResponder 3656 static char msgbuf[16]; 3657 mDNS_snprintf(msgbuf, sizeof(msgbuf), "%d", AddrReply->err); 3658 mDNSASLLog((uuid_t *)&m->asl_uuid, "natt.natpmp.AddressRequest", AddrReply->err ? "failure" : "success", msgbuf, ""); 3659#endif 3660 if (!AddrReply->err && len < sizeof(NATAddrReply)) { LogMsg("NAT-PMP AddrResponse message too short (%d bytes)", len); return; } 3661 natTraversalHandleAddressReply(m, AddrReply->err, AddrReply->ExtAddr); 3662 } 3663 else if (AddrReply->opcode == NATOp_MapUDPResponse || AddrReply->opcode == NATOp_MapTCPResponse) 3664 { 3665 mDNSu8 Protocol = AddrReply->opcode & 0x7F; 3666#if APPLE_OSX_mDNSResponder 3667 static char msgbuf[16]; 3668 mDNS_snprintf(msgbuf, sizeof(msgbuf), "%s - %d", AddrReply->opcode == NATOp_MapUDPResponse ? "UDP" : "TCP", PortMapReply->err); 3669 mDNSASLLog((uuid_t *)&m->asl_uuid, "natt.natpmp.PortMapRequest", PortMapReply->err ? "failure" : "success", msgbuf, ""); 3670#endif 3671 if (!PortMapReply->err) 3672 { 3673 if (len < sizeof(NATPortMapReply)) { LogMsg("NAT-PMP PortMapReply message too short (%d bytes)", len); return; } 3674 PortMapReply->NATRep_lease = (mDNSu32) ((mDNSu32)pkt[12] << 24 | (mDNSu32)pkt[13] << 16 | (mDNSu32)pkt[14] << 8 | pkt[15]); 3675 } 3676 3677 // Since some NAT-PMP server implementations don't return the requested internal port in 3678 // the reply, we can't associate this reply with a particular NATTraversalInfo structure. 3679 // We globally keep track of the most recent error code for mappings. 3680 m->LastNATMapResultCode = PortMapReply->err; 3681 3682 for (ptr = m->NATTraversals; ptr; ptr=ptr->next) 3683 if (ptr->Protocol == Protocol && mDNSSameIPPort(ptr->IntPort, PortMapReply->intport)) 3684 natTraversalHandlePortMapReply(m, ptr, InterfaceID, PortMapReply->err, PortMapReply->extport, PortMapReply->NATRep_lease, NATTProtocolNATPMP); 3685 } 3686 else { LogMsg("Received NAT-PMP response with unknown opcode 0x%X", AddrReply->opcode); return; } 3687 3688 // Don't need an SSDP socket if we get a NAT-PMP packet 3689 if (m->SSDPSocket) { debugf("uDNS_ReceiveNATPMPPacket destroying SSDPSocket %p", &m->SSDPSocket); mDNSPlatformUDPClose(m->SSDPSocket); m->SSDPSocket = mDNSNULL; } 3690} 3691 3692mDNSlocal void uDNS_ReceivePCPPacket(mDNS *m, const mDNSInterfaceID InterfaceID, mDNSu8 *pkt, mDNSu16 len) 3693{ 3694 NATTraversalInfo *ptr; 3695 PCPMapReply *reply = (PCPMapReply*)pkt; 3696 mDNSu32 client_delta, server_delta; 3697 mDNSBool checkEpochValidity = m->LastNATupseconds != 0; 3698 mDNSu8 strippedOpCode; 3699 mDNSv4Addr mappedAddress = zerov4Addr; 3700 mDNSu8 protocol = 0; 3701 mDNSIPPort intport = zeroIPPort; 3702 mDNSIPPort extport = zeroIPPort; 3703 3704 // Minimum PCP packet is 24 bytes 3705 if (len < 24) 3706 { 3707 LogMsg("uDNS_ReceivePCPPacket: message too short (%d bytes)", len); 3708 return; 3709 } 3710 3711 strippedOpCode = reply->opCode & 0x7f; 3712 3713 if ((reply->opCode & 0x80) == 0x00 || (strippedOpCode != PCPOp_Announce && strippedOpCode != PCPOp_Map)) 3714 { 3715 LogMsg("uDNS_ReceivePCPPacket: unhandled opCode %u", reply->opCode); 3716 return; 3717 } 3718 3719 // Read multi-byte values 3720 reply->lifetime = (mDNSs32)((mDNSs32)pkt[4] << 24 | (mDNSs32)pkt[5] << 16 | (mDNSs32)pkt[ 6] << 8 | pkt[ 7]); 3721 reply->epoch = (mDNSs32)((mDNSs32)pkt[8] << 24 | (mDNSs32)pkt[9] << 16 | (mDNSs32)pkt[10] << 8 | pkt[11]); 3722 3723 client_delta = (m->timenow - m->LastNATReplyLocalTime) / mDNSPlatformOneSecond; 3724 server_delta = reply->epoch - m->LastNATupseconds; 3725 debugf("uDNS_ReceivePCPPacket: %X %X upseconds %u client_delta %d server_delta %d", reply->opCode, reply->result, reply->epoch, client_delta, server_delta); 3726 3727 // If seconds since the epoch is 0, use 1 so we'll check epoch validity next time 3728 m->LastNATupseconds = reply->epoch ? reply->epoch : 1; 3729 m->LastNATReplyLocalTime = m->timenow; 3730 3731#ifdef _LEGACY_NAT_TRAVERSAL_ 3732 LNT_ClearState(m); 3733#endif // _LEGACY_NAT_TRAVERSAL_ 3734 3735 // Don't need an SSDP socket if we get a PCP packet 3736 if (m->SSDPSocket) { debugf("uDNS_ReceivePCPPacket: destroying SSDPSocket %p", &m->SSDPSocket); mDNSPlatformUDPClose(m->SSDPSocket); m->SSDPSocket = mDNSNULL; } 3737 3738 if (checkEpochValidity && (client_delta + 2 < server_delta - server_delta / 16 || server_delta + 2 < client_delta - client_delta / 16)) 3739 { 3740 // If this is an ANNOUNCE packet, wait a random interval up to 5 seconds 3741 // otherwise, refresh immediately 3742 mDNSu32 waitTicks = strippedOpCode ? 0 : mDNSRandom(PCP_WAITSECS_AFTER_EPOCH_INVALID * mDNSPlatformOneSecond); 3743 LogMsg("uDNS_ReceivePCPPacket: Epoch invalid, %#a likely rebooted, waiting %u ticks", &m->Router, waitTicks); 3744 RecreateNATMappings(m, waitTicks); 3745 // we can ignore the rest of this packet, as new requests are about to go out 3746 return; 3747 } 3748 3749 if (strippedOpCode == PCPOp_Announce) 3750 return; 3751 3752 // We globally keep track of the most recent error code for mappings. 3753 // This seems bad to do with PCP, but best not change it now. 3754 m->LastNATMapResultCode = reply->result; 3755 3756 if (!reply->result) 3757 { 3758 if (len < sizeof(PCPMapReply)) 3759 { 3760 LogMsg("uDNS_ReceivePCPPacket: mapping response too short (%d bytes)", len); 3761 return; 3762 } 3763 3764 // Check the nonce 3765 if (reply->nonce[0] != m->PCPNonce[0] || reply->nonce[1] != m->PCPNonce[1] || reply->nonce[2] != m->PCPNonce[2]) 3766 { 3767 LogMsg("uDNS_ReceivePCPPacket: invalid nonce, ignoring. received { %x %x %x } expected { %x %x %x }", 3768 reply->nonce[0], reply->nonce[1], reply->nonce[2], 3769 m->PCPNonce[0], m->PCPNonce[1], m->PCPNonce[2]); 3770 return; 3771 } 3772 3773 // Get the values 3774 protocol = reply->protocol; 3775 intport = reply->intPort; 3776 extport = reply->extPort; 3777 3778 // Get the external address, which should be mapped, since we only support IPv4 3779 if (!mDNSAddrIPv4FromMappedIPv6(&reply->extAddress, &mappedAddress)) 3780 { 3781 LogMsg("uDNS_ReceivePCPPacket: unexpected external address: %.16a", &reply->extAddress); 3782 reply->result = NATErr_NetFail; 3783 // fall through to report the error 3784 } 3785 else if (mDNSIPv4AddressIsZero(mappedAddress)) 3786 { 3787 // If this is the deletion case, we will have sent the zero IPv4-mapped address 3788 // in our request, and the server should reflect it in the response, so we 3789 // should not log about receiving a zero address. And in this case, we no 3790 // longer have a NATTraversal to report errors back to, so it's ok to set the 3791 // result here. 3792 // In other cases, a zero address is an error, and we will have a NATTraversal 3793 // to report back to, so set an error and fall through to report it. 3794 // CheckNATMappings will log the error. 3795 reply->result = NATErr_NetFail; 3796 } 3797 } 3798 else 3799 { 3800 LogInfo("uDNS_ReceivePCPPacket: error received from server. opcode %X result %X lifetime %X epoch %X", 3801 reply->opCode, reply->result, reply->lifetime, reply->epoch); 3802 3803 // If the packet is long enough, get the protocol & intport for matching to report 3804 // the error 3805 if (len >= sizeof(PCPMapReply)) 3806 { 3807 protocol = reply->protocol; 3808 intport = reply->intPort; 3809 } 3810 } 3811 3812 for (ptr = m->NATTraversals; ptr; ptr=ptr->next) 3813 { 3814 mDNSu8 ptrProtocol = ((ptr->Protocol & NATOp_MapTCP) == NATOp_MapTCP ? PCPProto_TCP : PCPProto_UDP); 3815 if ((protocol == ptrProtocol && mDNSSameIPPort(ptr->IntPort, intport)) || 3816 (!ptr->Protocol && protocol == PCPProto_TCP && mDNSSameIPPort(DiscardPort, intport))) 3817 { 3818 natTraversalHandlePortMapReplyWithAddress(m, ptr, InterfaceID, reply->result ? NATErr_NetFail : NATErr_None, mappedAddress, extport, reply->lifetime, NATTProtocolPCP); 3819 } 3820 } 3821} 3822 3823mDNSexport void uDNS_ReceiveNATPacket(mDNS *m, const mDNSInterfaceID InterfaceID, mDNSu8 *pkt, mDNSu16 len) 3824{ 3825 if (len == 0) 3826 LogMsg("uDNS_ReceiveNATPacket: zero length packet"); 3827 else if (pkt[0] == PCP_VERS) 3828 uDNS_ReceivePCPPacket(m, InterfaceID, pkt, len); 3829 else if (pkt[0] == NATMAP_VERS) 3830 uDNS_ReceiveNATPMPPacket(m, InterfaceID, pkt, len); 3831 else 3832 LogMsg("uDNS_ReceiveNATPacket: packet with version %u (expected %u or %u)", pkt[0], PCP_VERS, NATMAP_VERS); 3833} 3834 3835// <rdar://problem/3925163> Shorten DNS-SD queries to avoid NAT bugs 3836// <rdar://problem/4288449> Add check to avoid crashing NAT gateways that have buggy DNS relay code 3837// 3838// We know of bugs in home NAT gateways that cause them to crash if they receive certain DNS queries. 3839// The DNS queries that make them crash are perfectly legal DNS queries, but even if they weren't, 3840// the gateway shouldn't crash -- in today's world of viruses and network attacks, software has to 3841// be written assuming that a malicious attacker could send them any packet, properly-formed or not. 3842// Still, we don't want to be crashing people's home gateways, so we go out of our way to avoid 3843// the queries that crash them. 3844// 3845// Some examples: 3846// 3847// 1. Any query where the name ends in ".in-addr.arpa." and the text before this is 32 or more bytes. 3848// The query type does not need to be PTR -- the gateway will crash for any query type. 3849// e.g. "ping long-name-crashes-the-buggy-router.in-addr.arpa" will crash one of these. 3850// 3851// 2. Any query that results in a large response with the TC bit set. 3852// 3853// 3. Any PTR query that doesn't begin with four decimal numbers. 3854// These gateways appear to assume that the only possible PTR query is a reverse-mapping query 3855// (e.g. "1.0.168.192.in-addr.arpa") and if they ever get a PTR query where the first four 3856// labels are not all decimal numbers in the range 0-255, they handle that by crashing. 3857// These gateways also ignore the remainder of the name following the four decimal numbers 3858// -- whether or not it actually says in-addr.arpa, they just make up an answer anyway. 3859// 3860// The challenge therefore is to craft a query that will discern whether the DNS server 3861// is one of these buggy ones, without crashing it. Furthermore we don't want our test 3862// queries making it all the way to the root name servers, putting extra load on those 3863// name servers and giving Apple a bad reputation. To this end we send this query: 3864// dig -t ptr 1.0.0.127.dnsbugtest.1.0.0.127.in-addr.arpa. 3865// 3866// The text preceding the ".in-addr.arpa." is under 32 bytes, so it won't cause crash (1). 3867// It will not yield a large response with the TC bit set, so it won't cause crash (2). 3868// It starts with four decimal numbers, so it won't cause crash (3). 3869// The name falls within the "1.0.0.127.in-addr.arpa." domain, the reverse-mapping name for the local 3870// loopback address, and therefore the query will black-hole at the first properly-configured DNS server 3871// it reaches, making it highly unlikely that this query will make it all the way to the root. 3872// 3873// Finally, the correct response to this query is NXDOMAIN or a similar error, but the 3874// gateways that ignore the remainder of the name following the four decimal numbers 3875// give themselves away by actually returning a result for this nonsense query. 3876 3877mDNSlocal const domainname *DNSRelayTestQuestion = (const domainname*) 3878 "\x1" "1" "\x1" "0" "\x1" "0" "\x3" "127" "\xa" "dnsbugtest" 3879 "\x1" "1" "\x1" "0" "\x1" "0" "\x3" "127" "\x7" "in-addr" "\x4" "arpa"; 3880 3881// See comments above for DNSRelayTestQuestion 3882// If this is the kind of query that has the risk of crashing buggy DNS servers, we do a test question first 3883mDNSlocal mDNSBool NoTestQuery(DNSQuestion *q) 3884{ 3885 int i; 3886 mDNSu8 *p = q->qname.c; 3887 if (q->AuthInfo) return(mDNStrue); // Don't need a test query for private queries sent directly to authoritative server over TLS/TCP 3888 if (q->qtype != kDNSType_PTR) return(mDNStrue); // Don't need a test query for any non-PTR queries 3889 for (i=0; i<4; i++) // If qname does not begin with num.num.num.num, can't skip the test query 3890 { 3891 if (p[0] < 1 || p[0] > 3) return(mDNSfalse); 3892 if ( p[1] < '0' || p[1] > '9' ) return(mDNSfalse); 3893 if (p[0] >= 2 && (p[2] < '0' || p[2] > '9')) return(mDNSfalse); 3894 if (p[0] >= 3 && (p[3] < '0' || p[3] > '9')) return(mDNSfalse); 3895 p += 1 + p[0]; 3896 } 3897 // If remainder of qname is ".in-addr.arpa.", this is a vanilla reverse-mapping query and 3898 // we can safely do it without needing a test query first, otherwise we need the test query. 3899 return(SameDomainName((domainname*)p, (const domainname*)"\x7" "in-addr" "\x4" "arpa")); 3900} 3901 3902// Returns mDNStrue if response was handled 3903mDNSlocal mDNSBool uDNS_ReceiveTestQuestionResponse(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end, 3904 const mDNSAddr *const srcaddr, const mDNSIPPort srcport) 3905{ 3906 const mDNSu8 *ptr = msg->data; 3907 DNSQuestion pktq; 3908 DNSServer *s; 3909 mDNSu32 result = 0; 3910 3911 // 1. Find out if this is an answer to one of our test questions 3912 if (msg->h.numQuestions != 1) return(mDNSfalse); 3913 ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &pktq); 3914 if (!ptr) return(mDNSfalse); 3915 if (pktq.qtype != kDNSType_PTR || pktq.qclass != kDNSClass_IN) return(mDNSfalse); 3916 if (!SameDomainName(&pktq.qname, DNSRelayTestQuestion)) return(mDNSfalse); 3917 3918 // 2. If the DNS relay gave us a positive response, then it's got buggy firmware 3919 // else, if the DNS relay gave us an error or no-answer response, it passed our test 3920 if ((msg->h.flags.b[1] & kDNSFlag1_RC_Mask) == kDNSFlag1_RC_NoErr && msg->h.numAnswers > 0) 3921 result = DNSServer_Failed; 3922 else 3923 result = DNSServer_Passed; 3924 3925 // 3. Find occurrences of this server in our list, and mark them appropriately 3926 for (s = m->DNSServers; s; s = s->next) 3927 { 3928 mDNSBool matchaddr = (s->teststate != result && mDNSSameAddress(srcaddr, &s->addr) && mDNSSameIPPort(srcport, s->port)); 3929 mDNSBool matchid = (s->teststate == DNSServer_Untested && mDNSSameOpaque16(msg->h.id, s->testid)); 3930 if (matchaddr || matchid) 3931 { 3932 DNSQuestion *q; 3933 s->teststate = result; 3934 if (result == DNSServer_Passed) 3935 { 3936 LogInfo("DNS Server %#a:%d (%#a:%d) %d passed%s", 3937 &s->addr, mDNSVal16(s->port), srcaddr, mDNSVal16(srcport), mDNSVal16(s->testid), 3938 matchaddr ? "" : " NOTE: Reply did not come from address to which query was sent"); 3939 } 3940 else 3941 { 3942 LogMsg("NOTE: Wide-Area Service Discovery disabled to avoid crashing defective DNS relay %#a:%d (%#a:%d) %d%s", 3943 &s->addr, mDNSVal16(s->port), srcaddr, mDNSVal16(srcport), mDNSVal16(s->testid), 3944 matchaddr ? "" : " NOTE: Reply did not come from address to which query was sent"); 3945 } 3946 3947 // If this server has just changed state from DNSServer_Untested to DNSServer_Passed, then retrigger any waiting questions. 3948 // We use the NoTestQuery() test so that we only retrigger questions that were actually blocked waiting for this test to complete. 3949 if (result == DNSServer_Passed) // Unblock any questions that were waiting for this result 3950 for (q = m->Questions; q; q=q->next) 3951 if (q->qDNSServer == s && !NoTestQuery(q)) 3952 { 3953 q->ThisQInterval = INIT_UCAST_POLL_INTERVAL / QuestionIntervalStep; 3954 q->unansweredQueries = 0; 3955 q->LastQTime = m->timenow - q->ThisQInterval; 3956 m->NextScheduledQuery = m->timenow; 3957 } 3958 } 3959 } 3960 3961 return(mDNStrue); // Return mDNStrue to tell uDNS_ReceiveMsg it doesn't need to process this packet further 3962} 3963 3964// Called from mDNSCoreReceive with the lock held 3965mDNSexport void uDNS_ReceiveMsg(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end, const mDNSAddr *const srcaddr, const mDNSIPPort srcport) 3966{ 3967 DNSQuestion *qptr; 3968 mStatus err = mStatus_NoError; 3969 3970 mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery; 3971 mDNSu8 UpdateR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update; 3972 mDNSu8 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask); 3973 mDNSu8 rcode = (mDNSu8)(msg->h.flags.b[1] & kDNSFlag1_RC_Mask); 3974 3975 (void)srcport; // Unused 3976 3977 debugf("uDNS_ReceiveMsg from %#-15a with " 3978 "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes", 3979 srcaddr, 3980 msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,", 3981 msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,", 3982 msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,", 3983 msg->h.numAdditionals, msg->h.numAdditionals == 1 ? "" : "s", end - msg->data); 3984 3985 if (QR_OP == StdR) 3986 { 3987 //if (srcaddr && recvLLQResponse(m, msg, end, srcaddr, srcport)) return; 3988 if (uDNS_ReceiveTestQuestionResponse(m, msg, end, srcaddr, srcport)) return; 3989 for (qptr = m->Questions; qptr; qptr = qptr->next) 3990 if (msg->h.flags.b[0] & kDNSFlag0_TC && mDNSSameOpaque16(qptr->TargetQID, msg->h.id) && m->timenow - qptr->LastQTime < RESPONSE_WINDOW) 3991 { 3992 if (!srcaddr) LogMsg("uDNS_ReceiveMsg: TCP DNS response had TC bit set: ignoring"); 3993 else 3994 { 3995 // Don't reuse TCP connections. We might have failed over to a different DNS server 3996 // while the first TCP connection is in progress. We need a new TCP connection to the 3997 // new DNS server. So, always try to establish a new connection. 3998 if (qptr->tcp) { DisposeTCPConn(qptr->tcp); qptr->tcp = mDNSNULL; } 3999 qptr->tcp = MakeTCPConn(m, mDNSNULL, mDNSNULL, kTCPSocketFlags_Zero, srcaddr, srcport, mDNSNULL, qptr, mDNSNULL); 4000 } 4001 } 4002 } 4003 4004 if (QR_OP == UpdateR) 4005 { 4006 mDNSu32 lease = GetPktLease(m, msg, end); 4007 mDNSs32 expire = m->timenow + (mDNSs32)lease * mDNSPlatformOneSecond; 4008 mDNSu32 random = mDNSRandom((mDNSs32)lease * mDNSPlatformOneSecond/10); 4009 4010 //rcode = kDNSFlag1_RC_ServFail; // Simulate server failure (rcode 2) 4011 4012 // Walk through all the records that matches the messageID. There could be multiple 4013 // records if we had sent them in a group 4014 if (m->CurrentRecord) 4015 LogMsg("uDNS_ReceiveMsg ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord)); 4016 m->CurrentRecord = m->ResourceRecords; 4017 while (m->CurrentRecord) 4018 { 4019 AuthRecord *rptr = m->CurrentRecord; 4020 m->CurrentRecord = m->CurrentRecord->next; 4021 if (AuthRecord_uDNS(rptr) && mDNSSameOpaque16(rptr->updateid, msg->h.id)) 4022 { 4023 err = checkUpdateResult(m, rptr->resrec.name, rcode, msg, end); 4024 if (!err && rptr->uselease && lease) 4025 if (rptr->expire - expire >= 0 || rptr->state != regState_UpdatePending) 4026 { 4027 rptr->expire = expire; 4028 rptr->refreshCount = 0; 4029 } 4030 // We pass the random value to make sure that if we update multiple 4031 // records, they all get the same random value 4032 hndlRecordUpdateReply(m, rptr, err, random); 4033 } 4034 } 4035 } 4036 debugf("Received unexpected response: ID %d matches no active records", mDNSVal16(msg->h.id)); 4037} 4038 4039// *************************************************************************** 4040#if COMPILER_LIKES_PRAGMA_MARK 4041#pragma mark - Query Routines 4042#endif 4043 4044mDNSexport void sendLLQRefresh(mDNS *m, DNSQuestion *q) 4045{ 4046 mDNSu8 *end; 4047 LLQOptData llq; 4048 mDNSu8 *limit = m->omsg.data + AbsoluteMaxDNSMessageData; 4049 4050 if (q->ReqLease) 4051 if ((q->state == LLQ_Established && q->ntries >= kLLQ_MAX_TRIES) || q->expire - m->timenow < 0) 4052 { 4053 LogMsg("Unable to refresh LLQ %##s (%s) - will retry in %d seconds", q->qname.c, DNSTypeName(q->qtype), LLQ_POLL_INTERVAL / mDNSPlatformOneSecond); 4054 StartLLQPolling(m,q); 4055 return; 4056 } 4057 4058 llq.vers = kLLQ_Vers; 4059 llq.llqOp = kLLQOp_Refresh; 4060 llq.err = q->tcp ? GetLLQEventPort(m, &q->servAddr) : LLQErr_NoError; // If using TCP tell server what UDP port to send notifications to 4061 llq.id = q->id; 4062 llq.llqlease = q->ReqLease; 4063 4064 InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags); 4065 end = putLLQ(&m->omsg, m->omsg.data, q, &llq); 4066 if (!end) { LogMsg("sendLLQRefresh: putLLQ failed %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; } 4067 4068 // Note that we (conditionally) add HINFO and TSIG here, since the question might be going away, 4069 // so we may not be able to reference it (most importantly it's AuthInfo) when we actually send the message 4070 end = putHINFO(m, &m->omsg, end, q->AuthInfo, limit); 4071 if (!end) { LogMsg("sendLLQRefresh: putHINFO failed %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; } 4072 4073 if (PrivateQuery(q)) 4074 { 4075 DNSDigest_SignMessageHostByteOrder(&m->omsg, &end, q->AuthInfo); 4076 if (!end) { LogMsg("sendLLQRefresh: DNSDigest_SignMessage failed %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; } 4077 } 4078 4079 if (PrivateQuery(q) && !q->tcp) 4080 { 4081 LogInfo("sendLLQRefresh setting up new TLS session %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4082 if (!q->nta) 4083 { 4084 // Note: If a question is in LLQ_Established state, we never free the zone data for the 4085 // question (PrivateQuery). If we free, we reset the state to something other than LLQ_Established. 4086 // This function is called only if the query is in LLQ_Established state and hence nta should 4087 // never be NULL. In spite of that, we have seen q->nta being NULL in the field. Just refetch the 4088 // zone data in that case. 4089 q->nta = StartGetZoneData(m, &q->qname, ZoneServiceLLQ, LLQGotZoneData, q); 4090 return; 4091 // ThisQInterval is not adjusted when we return from here which means that we will get called back 4092 // again immediately. As q->servAddr and q->servPort are still valid and the nta->Host is initialized 4093 // without any additional discovery for PrivateQuery, things work. 4094 } 4095 q->tcp = MakeTCPConn(m, &m->omsg, end, kTCPSocketFlags_UseTLS, &q->servAddr, q->servPort, &q->nta->Host, q, mDNSNULL); 4096 } 4097 else 4098 { 4099 mStatus err; 4100 4101 // if AuthInfo and AuthInfo->AutoTunnel is set, we use the TCP socket but don't need to pass the AuthInfo as 4102 // we already protected the message above. 4103 LogInfo("sendLLQRefresh: using existing %s session %##s (%s)", PrivateQuery(q) ? "TLS" : "UDP", 4104 q->qname.c, DNSTypeName(q->qtype)); 4105 4106 err = mDNSSendDNSMessage(m, &m->omsg, end, mDNSInterface_Any, q->LocalSocket, &q->servAddr, q->servPort, q->tcp ? q->tcp->sock : mDNSNULL, mDNSNULL, mDNSfalse); 4107 if (err) 4108 { 4109 LogMsg("sendLLQRefresh: mDNSSendDNSMessage%s failed: %d", q->tcp ? " (TCP)" : "", err); 4110 if (q->tcp) { DisposeTCPConn(q->tcp); q->tcp = mDNSNULL; } 4111 } 4112 } 4113 4114 q->ntries++; 4115 4116 debugf("sendLLQRefresh ntries %d %##s (%s)", q->ntries, q->qname.c, DNSTypeName(q->qtype)); 4117 4118 q->LastQTime = m->timenow; 4119 SetNextQueryTime(m, q); 4120} 4121 4122mDNSexport void LLQGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneInfo) 4123{ 4124 DNSQuestion *q = (DNSQuestion *)zoneInfo->ZoneDataContext; 4125 4126 mDNS_Lock(m); 4127 4128 // If we get here it means that the GetZoneData operation has completed. 4129 // We hold on to the zone data if it is AutoTunnel as we use the hostname 4130 // in zoneInfo during the TLS connection setup. 4131 q->servAddr = zeroAddr; 4132 q->servPort = zeroIPPort; 4133 4134 if (!err && zoneInfo && !mDNSIPPortIsZero(zoneInfo->Port) && !mDNSAddressIsZero(&zoneInfo->Addr) && zoneInfo->Host.c[0]) 4135 { 4136 q->servAddr = zoneInfo->Addr; 4137 q->servPort = zoneInfo->Port; 4138 if (!PrivateQuery(q)) 4139 { 4140 // We don't need the zone data as we use it only for the Host information which we 4141 // don't need if we are not going to use TLS connections. 4142 if (q->nta) 4143 { 4144 if (q->nta != zoneInfo) LogMsg("LLQGotZoneData: nta (%p) != zoneInfo (%p) %##s (%s)", q->nta, zoneInfo, q->qname.c, DNSTypeName(q->qtype)); 4145 CancelGetZoneData(m, q->nta); 4146 q->nta = mDNSNULL; 4147 } 4148 } 4149 q->ntries = 0; 4150 debugf("LLQGotZoneData %#a:%d", &q->servAddr, mDNSVal16(q->servPort)); 4151 startLLQHandshake(m, q); 4152 } 4153 else 4154 { 4155 if (q->nta) 4156 { 4157 if (q->nta != zoneInfo) LogMsg("LLQGotZoneData: nta (%p) != zoneInfo (%p) %##s (%s)", q->nta, zoneInfo, q->qname.c, DNSTypeName(q->qtype)); 4158 CancelGetZoneData(m, q->nta); 4159 q->nta = mDNSNULL; 4160 } 4161 StartLLQPolling(m,q); 4162 if (err == mStatus_NoSuchNameErr) 4163 { 4164 // this actually failed, so mark it by setting address to all ones 4165 q->servAddr.type = mDNSAddrType_IPv4; 4166 q->servAddr.ip.v4 = onesIPv4Addr; 4167 } 4168 } 4169 4170 mDNS_Unlock(m); 4171} 4172 4173// Called in normal callback context (i.e. mDNS_busy and mDNS_reentrancy are both 1) 4174mDNSlocal void PrivateQueryGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneInfo) 4175{ 4176 DNSQuestion *q = (DNSQuestion *) zoneInfo->ZoneDataContext; 4177 4178 LogInfo("PrivateQueryGotZoneData %##s (%s) err %d Zone %##s Private %d", q->qname.c, DNSTypeName(q->qtype), err, zoneInfo->ZoneName.c, zoneInfo->ZonePrivate); 4179 4180 if (q->nta != zoneInfo) LogMsg("PrivateQueryGotZoneData:ERROR!!: nta (%p) != zoneInfo (%p) %##s (%s)", q->nta, zoneInfo, q->qname.c, DNSTypeName(q->qtype)); 4181 4182 if (err || !zoneInfo || mDNSAddressIsZero(&zoneInfo->Addr) || mDNSIPPortIsZero(zoneInfo->Port) || !zoneInfo->Host.c[0]) 4183 { 4184 LogInfo("PrivateQueryGotZoneData: ERROR!! %##s (%s) invoked with error code %d %p %#a:%d", 4185 q->qname.c, DNSTypeName(q->qtype), err, zoneInfo, 4186 zoneInfo ? &zoneInfo->Addr : mDNSNULL, 4187 zoneInfo ? mDNSVal16(zoneInfo->Port) : 0); 4188 CancelGetZoneData(m, q->nta); 4189 q->nta = mDNSNULL; 4190 return; 4191 } 4192 4193 if (!zoneInfo->ZonePrivate) 4194 { 4195 debugf("Private port lookup failed -- retrying without TLS -- %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4196 q->AuthInfo = mDNSNULL; // Clear AuthInfo so we try again non-private 4197 q->ThisQInterval = InitialQuestionInterval; 4198 q->LastQTime = m->timenow - q->ThisQInterval; 4199 CancelGetZoneData(m, q->nta); 4200 q->nta = mDNSNULL; 4201 mDNS_Lock(m); 4202 SetNextQueryTime(m, q); 4203 mDNS_Unlock(m); 4204 return; 4205 // Next call to uDNS_CheckCurrentQuestion() will do this as a non-private query 4206 } 4207 4208 if (!PrivateQuery(q)) 4209 { 4210 LogMsg("PrivateQueryGotZoneData: ERROR!! Not a private query %##s (%s) AuthInfo %p", q->qname.c, DNSTypeName(q->qtype), q->AuthInfo); 4211 CancelGetZoneData(m, q->nta); 4212 q->nta = mDNSNULL; 4213 return; 4214 } 4215 4216 q->TargetQID = mDNS_NewMessageID(m); 4217 if (q->tcp) { DisposeTCPConn(q->tcp); q->tcp = mDNSNULL; } 4218 if (!q->nta) { LogMsg("PrivateQueryGotZoneData:ERROR!! nta is NULL for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; } 4219 q->tcp = MakeTCPConn(m, mDNSNULL, mDNSNULL, kTCPSocketFlags_UseTLS, &zoneInfo->Addr, zoneInfo->Port, &q->nta->Host, q, mDNSNULL); 4220 if (q->nta) { CancelGetZoneData(m, q->nta); q->nta = mDNSNULL; } 4221} 4222 4223// *************************************************************************** 4224#if COMPILER_LIKES_PRAGMA_MARK 4225#pragma mark - Dynamic Updates 4226#endif 4227 4228// Called in normal callback context (i.e. mDNS_busy and mDNS_reentrancy are both 1) 4229mDNSexport void RecordRegistrationGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneData) 4230{ 4231 AuthRecord *newRR = (AuthRecord*)zoneData->ZoneDataContext; 4232 AuthRecord *ptr; 4233 int c1, c2; 4234 4235 if (newRR->nta != zoneData) 4236 LogMsg("RecordRegistrationGotZoneData: nta (%p) != zoneData (%p) %##s (%s)", newRR->nta, zoneData, newRR->resrec.name->c, DNSTypeName(newRR->resrec.rrtype)); 4237 4238 if (m->mDNS_busy != m->mDNS_reentrancy) 4239 LogMsg("RecordRegistrationGotZoneData: mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy); 4240 4241 // make sure record is still in list (!!!) 4242 for (ptr = m->ResourceRecords; ptr; ptr = ptr->next) if (ptr == newRR) break; 4243 if (!ptr) 4244 { 4245 LogMsg("RecordRegistrationGotZoneData - RR no longer in list. Discarding."); 4246 CancelGetZoneData(m, newRR->nta); 4247 newRR->nta = mDNSNULL; 4248 return; 4249 } 4250 4251 // check error/result 4252 if (err) 4253 { 4254 if (err != mStatus_NoSuchNameErr) LogMsg("RecordRegistrationGotZoneData: error %d", err); 4255 CancelGetZoneData(m, newRR->nta); 4256 newRR->nta = mDNSNULL; 4257 return; 4258 } 4259 4260 if (!zoneData) { LogMsg("ERROR: RecordRegistrationGotZoneData invoked with NULL result and no error"); return; } 4261 4262 if (newRR->resrec.rrclass != zoneData->ZoneClass) 4263 { 4264 LogMsg("ERROR: New resource record's class (%d) does not match zone class (%d)", newRR->resrec.rrclass, zoneData->ZoneClass); 4265 CancelGetZoneData(m, newRR->nta); 4266 newRR->nta = mDNSNULL; 4267 return; 4268 } 4269 4270 // Don't try to do updates to the root name server. 4271 // We might be tempted also to block updates to any single-label name server (e.g. com, edu, net, etc.) but some 4272 // organizations use their own private pseudo-TLD, like ".home", etc, and we don't want to block that. 4273 if (zoneData->ZoneName.c[0] == 0) 4274 { 4275 LogInfo("RecordRegistrationGotZoneData: No name server found claiming responsibility for \"%##s\"!", newRR->resrec.name->c); 4276 CancelGetZoneData(m, newRR->nta); 4277 newRR->nta = mDNSNULL; 4278 return; 4279 } 4280 4281 // Store discovered zone data 4282 c1 = CountLabels(newRR->resrec.name); 4283 c2 = CountLabels(&zoneData->ZoneName); 4284 if (c2 > c1) 4285 { 4286 LogMsg("RecordRegistrationGotZoneData: Zone \"%##s\" is longer than \"%##s\"", zoneData->ZoneName.c, newRR->resrec.name->c); 4287 CancelGetZoneData(m, newRR->nta); 4288 newRR->nta = mDNSNULL; 4289 return; 4290 } 4291 newRR->zone = SkipLeadingLabels(newRR->resrec.name, c1-c2); 4292 if (!SameDomainName(newRR->zone, &zoneData->ZoneName)) 4293 { 4294 LogMsg("RecordRegistrationGotZoneData: Zone \"%##s\" does not match \"%##s\" for \"%##s\"", newRR->zone->c, zoneData->ZoneName.c, newRR->resrec.name->c); 4295 CancelGetZoneData(m, newRR->nta); 4296 newRR->nta = mDNSNULL; 4297 return; 4298 } 4299 4300 if (mDNSIPPortIsZero(zoneData->Port) || mDNSAddressIsZero(&zoneData->Addr) || !zoneData->Host.c[0]) 4301 { 4302 LogInfo("RecordRegistrationGotZoneData: No _dns-update._udp service found for \"%##s\"!", newRR->resrec.name->c); 4303 CancelGetZoneData(m, newRR->nta); 4304 newRR->nta = mDNSNULL; 4305 return; 4306 } 4307 4308 newRR->Private = zoneData->ZonePrivate; 4309 debugf("RecordRegistrationGotZoneData: Set zone information for %##s %##s to %#a:%d", 4310 newRR->resrec.name->c, zoneData->ZoneName.c, &zoneData->Addr, mDNSVal16(zoneData->Port)); 4311 4312 // If we are deregistering, uDNS_DeregisterRecord will do that as it has the zone data now. 4313 if (newRR->state == regState_DeregPending) 4314 { 4315 mDNS_Lock(m); 4316 uDNS_DeregisterRecord(m, newRR); 4317 mDNS_Unlock(m); 4318 return; 4319 } 4320 4321 if (newRR->resrec.rrtype == kDNSType_SRV) 4322 { 4323 const domainname *target; 4324 // Reevaluate the target always as NAT/Target could have changed while 4325 // we were fetching zone data. 4326 mDNS_Lock(m); 4327 target = GetServiceTarget(m, newRR); 4328 mDNS_Unlock(m); 4329 if (!target || target->c[0] == 0) 4330 { 4331 domainname *t = GetRRDomainNameTarget(&newRR->resrec); 4332 LogInfo("RecordRegistrationGotZoneData - no target for %##s", newRR->resrec.name->c); 4333 if (t) t->c[0] = 0; 4334 newRR->resrec.rdlength = newRR->resrec.rdestimate = 0; 4335 newRR->state = regState_NoTarget; 4336 CancelGetZoneData(m, newRR->nta); 4337 newRR->nta = mDNSNULL; 4338 return; 4339 } 4340 } 4341 // If we have non-zero service port (always?) 4342 // and a private address, and update server is non-private 4343 // and this service is AutoTarget 4344 // then initiate a NAT mapping request. On completion it will do SendRecordRegistration() for us 4345 if (newRR->resrec.rrtype == kDNSType_SRV && !mDNSIPPortIsZero(newRR->resrec.rdata->u.srv.port) && 4346 mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) && newRR->nta && !mDNSAddrIsRFC1918(&newRR->nta->Addr) && 4347 newRR->AutoTarget == Target_AutoHostAndNATMAP) 4348 { 4349 DomainAuthInfo *AuthInfo; 4350 AuthInfo = GetAuthInfoForName(m, newRR->resrec.name); 4351 if (AuthInfo && AuthInfo->AutoTunnel) 4352 { 4353 domainname *t = GetRRDomainNameTarget(&newRR->resrec); 4354 LogMsg("RecordRegistrationGotZoneData: ERROR!! AutoTunnel has Target_AutoHostAndNATMAP for %s", ARDisplayString(m, newRR)); 4355 if (t) t->c[0] = 0; 4356 newRR->resrec.rdlength = newRR->resrec.rdestimate = 0; 4357 newRR->state = regState_NoTarget; 4358 CancelGetZoneData(m, newRR->nta); 4359 newRR->nta = mDNSNULL; 4360 return; 4361 } 4362 // During network transitions, we are called multiple times in different states. Setup NAT 4363 // state just once for this record. 4364 if (!newRR->NATinfo.clientContext) 4365 { 4366 LogInfo("RecordRegistrationGotZoneData StartRecordNatMap %s", ARDisplayString(m, newRR)); 4367 newRR->state = regState_NATMap; 4368 StartRecordNatMap(m, newRR); 4369 return; 4370 } 4371 else LogInfo("RecordRegistrationGotZoneData: StartRecordNatMap for %s, state %d, context %p", ARDisplayString(m, newRR), newRR->state, newRR->NATinfo.clientContext); 4372 } 4373 mDNS_Lock(m); 4374 // We want IsRecordMergeable to check whether it is a record whose update can be 4375 // sent with others. We set the time before we call IsRecordMergeable, so that 4376 // it does not fail this record based on time. We are interested in other checks 4377 // at this time. If a previous update resulted in error, then don't reset the 4378 // interval. Preserve the back-off so that we don't keep retrying aggressively. 4379 if (newRR->updateError == mStatus_NoError) 4380 { 4381 newRR->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 4382 newRR->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 4383 } 4384 if (IsRecordMergeable(m, newRR, m->timenow + MERGE_DELAY_TIME)) 4385 { 4386 // Delay the record registration by MERGE_DELAY_TIME so that we can merge them 4387 // into one update 4388 LogInfo("RecordRegistrationGotZoneData: Delayed registration for %s", ARDisplayString(m, newRR)); 4389 newRR->LastAPTime += MERGE_DELAY_TIME; 4390 } 4391 mDNS_Unlock(m); 4392} 4393 4394mDNSlocal void SendRecordDeregistration(mDNS *m, AuthRecord *rr) 4395{ 4396 mDNSu8 *ptr = m->omsg.data; 4397 mDNSu8 *limit; 4398 DomainAuthInfo *AuthInfo; 4399 4400 mDNS_CheckLock(m); 4401 4402 if (!rr->nta || mDNSIPv4AddressIsZero(rr->nta->Addr.ip.v4)) 4403 { 4404 LogMsg("SendRecordDeRegistration: No zone info for Resource record %s RecordType %d", ARDisplayString(m, rr), rr->resrec.RecordType); 4405 return; 4406 } 4407 4408 limit = ptr + AbsoluteMaxDNSMessageData; 4409 AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name); 4410 limit -= RRAdditionalSize(m, AuthInfo); 4411 4412 rr->updateid = mDNS_NewMessageID(m); 4413 InitializeDNSMessage(&m->omsg.h, rr->updateid, UpdateReqFlags); 4414 4415 // set zone 4416 ptr = putZone(&m->omsg, ptr, limit, rr->zone, mDNSOpaque16fromIntVal(rr->resrec.rrclass)); 4417 if (!ptr) goto exit; 4418 4419 ptr = BuildUpdateMessage(m, ptr, rr, limit); 4420 4421 if (!ptr) goto exit; 4422 4423 if (rr->Private) 4424 { 4425 LogInfo("SendRecordDeregistration TCP %p %s", rr->tcp, ARDisplayString(m, rr)); 4426 if (rr->tcp) LogInfo("SendRecordDeregistration: Disposing existing TCP connection for %s", ARDisplayString(m, rr)); 4427 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 4428 if (!rr->nta) { LogMsg("SendRecordDeregistration:Private:ERROR!! nta is NULL for %s", ARDisplayString(m, rr)); return; } 4429 rr->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &rr->nta->Addr, rr->nta->Port, &rr->nta->Host, mDNSNULL, rr); 4430 } 4431 else 4432 { 4433 mStatus err; 4434 LogInfo("SendRecordDeregistration UDP %s", ARDisplayString(m, rr)); 4435 if (!rr->nta) { LogMsg("SendRecordDeregistration:ERROR!! nta is NULL for %s", ARDisplayString(m, rr)); return; } 4436 err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &rr->nta->Addr, rr->nta->Port, mDNSNULL, GetAuthInfoForName_internal(m, rr->resrec.name), mDNSfalse); 4437 if (err) debugf("ERROR: SendRecordDeregistration - mDNSSendDNSMessage - %d", err); 4438 //if (rr->state == regState_DeregPending) CompleteDeregistration(m, rr); // Don't touch rr after this 4439 } 4440 SetRecordRetry(m, rr, 0); 4441 return; 4442exit: 4443 LogMsg("SendRecordDeregistration: Error formatting message for %s", ARDisplayString(m, rr)); 4444} 4445 4446mDNSexport mStatus uDNS_DeregisterRecord(mDNS *const m, AuthRecord *const rr) 4447{ 4448 DomainAuthInfo *info; 4449 4450 LogInfo("uDNS_DeregisterRecord: Resource Record %s, state %d", ARDisplayString(m, rr), rr->state); 4451 4452 switch (rr->state) 4453 { 4454 case regState_Refresh: 4455 case regState_Pending: 4456 case regState_UpdatePending: 4457 case regState_Registered: break; 4458 case regState_DeregPending: break; 4459 4460 case regState_NATError: 4461 case regState_NATMap: 4462 // A record could be in NoTarget to start with if the corresponding SRV record could not find a target. 4463 // It is also possible to reenter the NoTarget state when we move to a network with a NAT that has 4464 // no {PCP, NAT-PMP, UPnP/IGD} support. In that case before we entered NoTarget, we already deregistered with 4465 // the server. 4466 case regState_NoTarget: 4467 case regState_Unregistered: 4468 case regState_Zero: 4469 default: 4470 LogInfo("uDNS_DeregisterRecord: State %d for %##s type %s", rr->state, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); 4471 // This function may be called during sleep when there are no sleep proxy servers 4472 if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) CompleteDeregistration(m, rr); 4473 return mStatus_NoError; 4474 } 4475 4476 // if unsent rdata is queued, free it. 4477 // 4478 // The data may be queued in QueuedRData or InFlightRData. 4479 // 4480 // 1) If the record is in Registered state, we store it in InFlightRData and copy the same in "rdata" 4481 // *just* before sending the update to the server. Till we get the response, InFlightRData and "rdata" 4482 // in the resource record are same. We don't want to free in that case. It will be freed when "rdata" 4483 // is freed. If they are not same, the update has not been sent and we should free it here. 4484 // 4485 // 2) If the record is in UpdatePending state, we queue the update in QueuedRData. When the previous update 4486 // comes back from the server, we copy it from QueuedRData to InFlightRData and repeat (1). This implies 4487 // that QueuedRData can never be same as "rdata" in the resource record. As long as we have something 4488 // left in QueuedRData, we should free it here. 4489 4490 if (rr->InFlightRData && rr->UpdateCallback) 4491 { 4492 if (rr->InFlightRData != rr->resrec.rdata) 4493 { 4494 LogInfo("uDNS_DeregisterRecord: Freeing InFlightRData for %s", ARDisplayString(m, rr)); 4495 rr->UpdateCallback(m, rr, rr->InFlightRData, rr->InFlightRDLen); 4496 rr->InFlightRData = mDNSNULL; 4497 } 4498 else 4499 LogInfo("uDNS_DeregisterRecord: InFlightRData same as rdata for %s", ARDisplayString(m, rr)); 4500 } 4501 4502 if (rr->QueuedRData && rr->UpdateCallback) 4503 { 4504 if (rr->QueuedRData == rr->resrec.rdata) 4505 LogMsg("uDNS_DeregisterRecord: ERROR!! QueuedRData same as rdata for %s", ARDisplayString(m, rr)); 4506 else 4507 { 4508 LogInfo("uDNS_DeregisterRecord: Freeing QueuedRData for %s", ARDisplayString(m, rr)); 4509 rr->UpdateCallback(m, rr, rr->QueuedRData, rr->QueuedRDLen); 4510 rr->QueuedRData = mDNSNULL; 4511 } 4512 } 4513 4514 // If a current group registration is pending, we can't send this deregisration till that registration 4515 // has reached the server i.e., the ordering is important. Previously, if we did not send this 4516 // registration in a group, then the previous connection will be torn down as part of sending the 4517 // deregistration. If we send this in a group, we need to locate the resource record that was used 4518 // to send this registration and terminate that connection. This means all the updates on that might 4519 // be lost (assuming the response is not waiting for us at the socket) and the retry will send the 4520 // update again sometime in the near future. 4521 // 4522 // NOTE: SSL handshake failures normally free the TCP connection immediately. Hence, you may not 4523 // find the TCP below there. This case can happen only when tcp is trying to actively retransmit 4524 // the request or SSL negotiation taking time i.e resource record is actively trying to get the 4525 // message to the server. During that time a deregister has to happen. 4526 4527 if (!mDNSOpaque16IsZero(rr->updateid)) 4528 { 4529 AuthRecord *anchorRR; 4530 mDNSBool found = mDNSfalse; 4531 for (anchorRR = m->ResourceRecords; anchorRR; anchorRR = anchorRR->next) 4532 { 4533 if (AuthRecord_uDNS(rr) && mDNSSameOpaque16(anchorRR->updateid, rr->updateid) && anchorRR->tcp) 4534 { 4535 LogInfo("uDNS_DeregisterRecord: Found Anchor RR %s terminated", ARDisplayString(m, anchorRR)); 4536 if (found) 4537 LogMsg("uDNS_DeregisterRecord: ERROR: Another anchorRR %s found", ARDisplayString(m, anchorRR)); 4538 DisposeTCPConn(anchorRR->tcp); 4539 anchorRR->tcp = mDNSNULL; 4540 found = mDNStrue; 4541 } 4542 } 4543 if (!found) LogInfo("uDNSDeregisterRecord: Cannot find the anchor Resource Record for %s, not an error", ARDisplayString(m, rr)); 4544 } 4545 4546 // Retry logic for deregistration should be no different from sending registration the first time. 4547 // Currently ThisAPInterval most likely is set to the refresh interval 4548 rr->state = regState_DeregPending; 4549 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 4550 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 4551 info = GetAuthInfoForName_internal(m, rr->resrec.name); 4552 if (IsRecordMergeable(m, rr, m->timenow + MERGE_DELAY_TIME)) 4553 { 4554 // Delay the record deregistration by MERGE_DELAY_TIME so that we can merge them 4555 // into one update. If the domain is being deleted, delay by 2 * MERGE_DELAY_TIME 4556 // so that we can merge all the AutoTunnel records and the service records in 4557 // one update (they get deregistered a little apart) 4558 if (info && info->deltime) rr->LastAPTime += (2 * MERGE_DELAY_TIME); 4559 else rr->LastAPTime += MERGE_DELAY_TIME; 4560 } 4561 // IsRecordMergeable could have returned false for several reasons e.g., DontMerge is set or 4562 // no zone information. Most likely it is the latter, CheckRecordUpdates will fetch the zone 4563 // data when it encounters this record. 4564 4565 if (m->NextuDNSEvent - (rr->LastAPTime + rr->ThisAPInterval) >= 0) 4566 m->NextuDNSEvent = (rr->LastAPTime + rr->ThisAPInterval); 4567 4568 return mStatus_NoError; 4569} 4570 4571mDNSexport mStatus uDNS_UpdateRecord(mDNS *m, AuthRecord *rr) 4572{ 4573 LogInfo("uDNS_UpdateRecord: Resource Record %##s, state %d", rr->resrec.name->c, rr->state); 4574 switch(rr->state) 4575 { 4576 case regState_DeregPending: 4577 case regState_Unregistered: 4578 // not actively registered 4579 goto unreg_error; 4580 4581 case regState_NATMap: 4582 case regState_NoTarget: 4583 // change rdata directly since it hasn't been sent yet 4584 if (rr->UpdateCallback) rr->UpdateCallback(m, rr, rr->resrec.rdata, rr->resrec.rdlength); 4585 SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); 4586 rr->NewRData = mDNSNULL; 4587 return mStatus_NoError; 4588 4589 case regState_Pending: 4590 case regState_Refresh: 4591 case regState_UpdatePending: 4592 // registration in-flight. queue rdata and return 4593 if (rr->QueuedRData && rr->UpdateCallback) 4594 // if unsent rdata is already queued, free it before we replace it 4595 rr->UpdateCallback(m, rr, rr->QueuedRData, rr->QueuedRDLen); 4596 rr->QueuedRData = rr->NewRData; 4597 rr->QueuedRDLen = rr->newrdlength; 4598 rr->NewRData = mDNSNULL; 4599 return mStatus_NoError; 4600 4601 case regState_Registered: 4602 rr->OrigRData = rr->resrec.rdata; 4603 rr->OrigRDLen = rr->resrec.rdlength; 4604 rr->InFlightRData = rr->NewRData; 4605 rr->InFlightRDLen = rr->newrdlength; 4606 rr->NewRData = mDNSNULL; 4607 rr->state = regState_UpdatePending; 4608 rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; 4609 rr->LastAPTime = m->timenow - INIT_RECORD_REG_INTERVAL; 4610 SetNextuDNSEvent(m, rr); 4611 return mStatus_NoError; 4612 4613 case regState_NATError: 4614 LogMsg("ERROR: uDNS_UpdateRecord called for record %##s with bad state regState_NATError", rr->resrec.name->c); 4615 return mStatus_UnknownErr; // states for service records only 4616 4617 default: LogMsg("uDNS_UpdateRecord: Unknown state %d for %##s", rr->state, rr->resrec.name->c); 4618 } 4619 4620unreg_error: 4621 LogMsg("uDNS_UpdateRecord: Requested update of record %##s type %d, in erroneous state %d", 4622 rr->resrec.name->c, rr->resrec.rrtype, rr->state); 4623 return mStatus_Invalid; 4624} 4625 4626// *************************************************************************** 4627#if COMPILER_LIKES_PRAGMA_MARK 4628#pragma mark - Periodic Execution Routines 4629#endif 4630 4631mDNSlocal void handle_unanswered_query(mDNS *const m) 4632{ 4633 DNSQuestion *q = m->CurrentQuestion; 4634 4635 if (q->unansweredQueries >= MAX_DNSSEC_UNANSWERED_QUERIES && DNSSECOptionalQuestion(q)) 4636 { 4637 // If we are not receiving any responses for DNSSEC question, it could be due to 4638 // a broken middlebox or a DNS server that does not understand the EDNS0/DOK option that 4639 // silently drops the packets. Also as per RFC 5625 there are certain buggy DNS Proxies 4640 // that are known to drop these pkts. To handle this, we turn off sending the EDNS0/DOK 4641 // option if we have not received any responses indicating that the server or 4642 // the middlebox is DNSSEC aware. If we receive at least one response to a DNSSEC 4643 // question, we don't turn off validation. Also, we wait for MAX_DNSSEC_RETRANSMISSIONS 4644 // before turning off validation to accomodate packet loss. 4645 // 4646 // Note: req_DO affects only DNSSEC_VALIDATION_SECURE_OPTIONAL questions; 4647 // DNSSEC_VALIDATION_SECURE questions ignores req_DO. 4648 4649 if (q->qDNSServer && !q->qDNSServer->DNSSECAware && q->qDNSServer->req_DO) 4650 { 4651 q->qDNSServer->retransDO++; 4652 if (q->qDNSServer->retransDO == MAX_DNSSEC_RETRANSMISSIONS) 4653 { 4654 LogInfo("handle_unanswered_query: setting req_DO false for %#a", &q->qDNSServer->addr); 4655 q->qDNSServer->req_DO = mDNSfalse; 4656 } 4657 } 4658 4659 if (!q->qDNSServer->req_DO) 4660 { 4661 q->ValidationState = DNSSECValNotRequired; 4662 q->ValidationRequired = DNSSEC_VALIDATION_NONE; 4663 4664 if (q->ProxyQuestion) 4665 q->ProxyDNSSECOK = mDNSfalse; 4666 LogInfo("handle_unanswered_query: unanswered query for %##s (%s), so turned off validation for %#a", 4667 q->qname.c, DNSTypeName(q->qtype), &q->qDNSServer->addr); 4668 } 4669 } 4670} 4671 4672// The question to be checked is not passed in as an explicit parameter; 4673// instead it is implicit that the question to be checked is m->CurrentQuestion. 4674mDNSexport void uDNS_CheckCurrentQuestion(mDNS *const m) 4675{ 4676 DNSQuestion *q = m->CurrentQuestion; 4677 if (m->timenow - NextQSendTime(q) < 0) return; 4678 4679 if (q->LongLived) 4680 { 4681 switch (q->state) 4682 { 4683 case LLQ_InitialRequest: startLLQHandshake(m, q); break; 4684 case LLQ_SecondaryRequest: 4685 // For PrivateQueries, we need to start the handshake again as we don't do the Challenge/Response step 4686 if (PrivateQuery(q)) 4687 startLLQHandshake(m, q); 4688 else 4689 sendChallengeResponse(m, q, mDNSNULL); 4690 break; 4691 case LLQ_Established: sendLLQRefresh(m, q); break; 4692 case LLQ_Poll: break; // Do nothing (handled below) 4693 } 4694 } 4695 4696 handle_unanswered_query(m); 4697 // We repeat the check above (rather than just making this the "else" case) because startLLQHandshake can change q->state to LLQ_Poll 4698 if (!(q->LongLived && q->state != LLQ_Poll)) 4699 { 4700 if (q->unansweredQueries >= MAX_UCAST_UNANSWERED_QUERIES) 4701 { 4702 DNSServer *orig = q->qDNSServer; 4703 if (orig) 4704 LogInfo("uDNS_CheckCurrentQuestion: Sent %d unanswered queries for %##s (%s) to %#a:%d (%##s)", 4705 q->unansweredQueries, q->qname.c, DNSTypeName(q->qtype), &orig->addr, mDNSVal16(orig->port), orig->domain.c); 4706 4707 PenalizeDNSServer(m, q, zeroID); 4708 q->noServerResponse = 1; 4709 } 4710 // There are two cases here. 4711 // 4712 // 1. We have only one DNS server for this question. It is not responding even after we sent MAX_UCAST_UNANSWERED_QUERIES. 4713 // In that case, we need to keep retrying till we get a response. But we need to backoff as we retry. We set 4714 // noServerResponse in the block above and below we do not touch the question interval. When we come here, we 4715 // already waited for the response. We need to send another query right at this moment. We do that below by 4716 // reinitializing dns servers and reissuing the query. 4717 // 4718 // 2. We have more than one DNS server. If at least one server did not respond, we would have set noServerResponse 4719 // either now (the last server in the list) or before (non-last server in the list). In either case, if we have 4720 // reached the end of DNS server list, we need to try again from the beginning. Ideally we should try just the 4721 // servers that did not respond, but for simplicity we try all the servers. Once we reached the end of list, we 4722 // set triedAllServersOnce so that we don't try all the servers aggressively. See PenalizeDNSServer. 4723 if (!q->qDNSServer && q->noServerResponse) 4724 { 4725 DNSServer *new; 4726 DNSQuestion *qptr; 4727 q->triedAllServersOnce = 1; 4728 // Re-initialize all DNS servers for this question. If we have a DNSServer, DNSServerChangeForQuestion will 4729 // handle all the work including setting the new DNS server. 4730 SetValidDNSServers(m, q); 4731 new = GetServerForQuestion(m, q); 4732 if (new) 4733 { 4734 LogInfo("uDNS_checkCurrentQuestion: Retrying question %p %##s (%s) DNS Server %#a:%d ThisQInterval %d", 4735 q, q->qname.c, DNSTypeName(q->qtype), new ? &new->addr : mDNSNULL, mDNSVal16(new ? new->port : zeroIPPort), q->ThisQInterval); 4736 DNSServerChangeForQuestion(m, q, new); 4737 } 4738 for (qptr = q->next ; qptr; qptr = qptr->next) 4739 if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = q->qDNSServer; } 4740 } 4741 if (q->qDNSServer && q->qDNSServer->teststate != DNSServer_Disabled) 4742 { 4743 mDNSu8 *end = m->omsg.data; 4744 mStatus err = mStatus_NoError; 4745 mDNSBool private = mDNSfalse; 4746 4747 InitializeDNSMessage(&m->omsg.h, q->TargetQID, (DNSSECQuestion(q) ? DNSSecQFlags : uQueryFlags)); 4748 4749 if (q->qDNSServer->teststate != DNSServer_Untested || NoTestQuery(q)) 4750 { 4751 end = putQuestion(&m->omsg, m->omsg.data, m->omsg.data + AbsoluteMaxDNSMessageData, &q->qname, q->qtype, q->qclass); 4752 if (DNSSECQuestion(q) && !q->qDNSServer->cellIntf) 4753 { 4754 if (q->ProxyQuestion) 4755 end = DNSProxySetAttributes(q, &m->omsg.h, &m->omsg, end, m->omsg.data + AbsoluteMaxDNSMessageData); 4756 else 4757 end = putDNSSECOption(&m->omsg, end, m->omsg.data + AbsoluteMaxDNSMessageData); 4758 } 4759 private = PrivateQuery(q); 4760 } 4761 else if (m->timenow - q->qDNSServer->lasttest >= INIT_UCAST_POLL_INTERVAL) // Make sure at least three seconds has elapsed since last test query 4762 { 4763 LogInfo("Sending DNS test query to %#a:%d", &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port)); 4764 q->ThisQInterval = INIT_UCAST_POLL_INTERVAL / QuestionIntervalStep; 4765 q->qDNSServer->lasttest = m->timenow; 4766 end = putQuestion(&m->omsg, m->omsg.data, m->omsg.data + AbsoluteMaxDNSMessageData, DNSRelayTestQuestion, kDNSType_PTR, kDNSClass_IN); 4767 q->qDNSServer->testid = m->omsg.h.id; 4768 } 4769 4770 if (end > m->omsg.data && (q->qDNSServer->teststate != DNSServer_Failed || NoTestQuery(q))) 4771 { 4772 //LogMsg("uDNS_CheckCurrentQuestion %p %d %p %##s (%s)", q, NextQSendTime(q) - m->timenow, private, q->qname.c, DNSTypeName(q->qtype)); 4773 if (private) 4774 { 4775 if (q->nta) CancelGetZoneData(m, q->nta); 4776 q->nta = StartGetZoneData(m, &q->qname, q->LongLived ? ZoneServiceLLQ : ZoneServiceQuery, PrivateQueryGotZoneData, q); 4777 if (q->state == LLQ_Poll) q->ThisQInterval = (LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10)) / QuestionIntervalStep; 4778 } 4779 else 4780 { 4781 debugf("uDNS_CheckCurrentQuestion sending %p %##s (%s) %#a:%d UnansweredQueries %d", 4782 q, q->qname.c, DNSTypeName(q->qtype), 4783 q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL, mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort), q->unansweredQueries); 4784 if (!q->LocalSocket) 4785 { 4786 q->LocalSocket = mDNSPlatformUDPSocket(m, zeroIPPort); 4787 if (q->LocalSocket) 4788 mDNSPlatformSetDelegatePID(q->LocalSocket, &q->qDNSServer->addr, q); 4789 } 4790 if (!q->LocalSocket) err = mStatus_NoMemoryErr; // If failed to make socket (should be very rare), we'll try again next time 4791 else err = mDNSSendDNSMessage(m, &m->omsg, end, q->qDNSServer->interface, q->LocalSocket, &q->qDNSServer->addr, q->qDNSServer->port, mDNSNULL, mDNSNULL, q->UseBackgroundTrafficClass); 4792 } 4793 } 4794 4795 if (err != mStatus_TransientErr) // if it is not a transient error backoff and DO NOT flood queries unnecessarily 4796 { 4797 q->ThisQInterval = q->ThisQInterval * QuestionIntervalStep; // Only increase interval if send succeeded 4798 q->unansweredQueries++; 4799 if (q->ThisQInterval > MAX_UCAST_POLL_INTERVAL) 4800 q->ThisQInterval = MAX_UCAST_POLL_INTERVAL; 4801 if (private && q->state != LLQ_Poll) 4802 { 4803 // We don't want to retransmit too soon. Hence, we always schedule our first 4804 // retransmisson at 3 seconds rather than one second 4805 if (q->ThisQInterval < (3 * mDNSPlatformOneSecond)) 4806 q->ThisQInterval = q->ThisQInterval * QuestionIntervalStep; 4807 if (q->ThisQInterval > LLQ_POLL_INTERVAL) 4808 q->ThisQInterval = LLQ_POLL_INTERVAL; 4809 LogInfo("uDNS_CheckCurrentQuestion: private non polling question for %##s (%s) will be retried in %d ms", q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval); 4810 } 4811 if (q->qDNSServer->cellIntf) 4812 { 4813 // We don't want to retransmit too soon. Schedule our first retransmisson at 4814 // MIN_UCAST_RETRANS_TIMEOUT seconds. 4815 if (q->ThisQInterval < MIN_UCAST_RETRANS_TIMEOUT) 4816 q->ThisQInterval = MIN_UCAST_RETRANS_TIMEOUT; 4817 } 4818 debugf("uDNS_CheckCurrentQuestion: Increased ThisQInterval to %d for %##s (%s), cell %d", q->ThisQInterval, q->qname.c, DNSTypeName(q->qtype), q->qDNSServer->cellIntf); 4819 } 4820 q->LastQTime = m->timenow; 4821 SetNextQueryTime(m, q); 4822 } 4823 else 4824 { 4825 // If we have no server for this query, or the only server is a disabled one, then we deliver 4826 // a transient failure indication to the client. This is important for things like iPhone 4827 // where we want to return timely feedback to the user when no network is available. 4828 // After calling MakeNegativeCacheRecord() we store the resulting record in the 4829 // cache so that it will be visible to other clients asking the same question. 4830 // (When we have a group of identical questions, only the active representative of the group gets 4831 // passed to uDNS_CheckCurrentQuestion -- we only want one set of query packets hitting the wire -- 4832 // but we want *all* of the questions to get answer callbacks.) 4833 CacheRecord *rr; 4834 const mDNSu32 slot = HashSlot(&q->qname); 4835 CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname); 4836 4837 if (!q->qDNSServer) 4838 { 4839 if (!mDNSOpaque64IsZero(&q->validDNSServers)) 4840 LogMsg("uDNS_CheckCurrentQuestion: ERROR!!: valid DNSServer bits not zero 0x%x, 0x%x for question %##s (%s)", 4841 q->validDNSServers.l[1], q->validDNSServers.l[0], q->qname.c, DNSTypeName(q->qtype)); 4842 // If we reached the end of list while picking DNS servers, then we don't want to deactivate the 4843 // question. Try after 60 seconds. We find this by looking for valid DNSServers for this question, 4844 // if we find any, then we must have tried them before we came here. This avoids maintaining 4845 // another state variable to see if we had valid DNS servers for this question. 4846 SetValidDNSServers(m, q); 4847 if (mDNSOpaque64IsZero(&q->validDNSServers)) 4848 { 4849 LogInfo("uDNS_CheckCurrentQuestion: no DNS server for %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 4850 q->ThisQInterval = 0; 4851 } 4852 else 4853 { 4854 DNSQuestion *qptr; 4855 // Pretend that we sent this question. As this is an ActiveQuestion, the NextScheduledQuery should 4856 // be set properly. Also, we need to properly backoff in cases where we don't set the question to 4857 // MaxQuestionInterval when we answer the question e.g., LongLived, we need to keep backing off 4858 q->ThisQInterval = q->ThisQInterval * QuestionIntervalStep; 4859 q->LastQTime = m->timenow; 4860 SetNextQueryTime(m, q); 4861 // Pick a new DNS server now. Otherwise, when the cache is 80% of its expiry, we will try 4862 // to send a query and come back to the same place here and log the above message. 4863 q->qDNSServer = GetServerForQuestion(m, q); 4864 for (qptr = q->next ; qptr; qptr = qptr->next) 4865 if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = q->qDNSServer; } 4866 LogInfo("uDNS_checkCurrentQuestion: Tried all DNS servers, retry question %p SuppressUnusable %d %##s (%s) with DNS Server %#a:%d after 60 seconds, ThisQInterval %d", 4867 q, q->SuppressUnusable, q->qname.c, DNSTypeName(q->qtype), 4868 q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL, mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort), q->ThisQInterval); 4869 } 4870 } 4871 else 4872 { 4873 q->ThisQInterval = 0; 4874 LogMsg("uDNS_CheckCurrentQuestion DNS server %#a:%d for %##s is disabled", &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port), q->qname.c); 4875 } 4876 4877 if (cg) 4878 { 4879 for (rr = cg->members; rr; rr=rr->next) 4880 { 4881 if (SameNameRecordAnswersQuestion(&rr->resrec, q)) 4882 { 4883 LogInfo("uDNS_CheckCurrentQuestion: Purged resourcerecord %s", CRDisplayString(m, rr)); 4884 mDNS_PurgeCacheResourceRecord(m, rr); 4885 } 4886 } 4887 } 4888 // For some of the WAB queries that we generate form within the mDNSResponder, most of the home routers 4889 // don't understand and return ServFail/NXDomain. In those cases, we don't want to try too often. We try 4890 // every fifteen minutes in that case 4891 MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, (DomainEnumQuery(&q->qname) ? 60 * 15 : 60), mDNSInterface_Any, q->qDNSServer); 4892 q->unansweredQueries = 0; 4893 if (!mDNSOpaque16IsZero(q->responseFlags)) 4894 m->rec.r.responseFlags = q->responseFlags; 4895 // We're already using the m->CurrentQuestion pointer, so CacheRecordAdd can't use it to walk the question list. 4896 // To solve this problem we set rr->DelayDelivery to a nonzero value (which happens to be 'now') so that we 4897 // momentarily defer generating answer callbacks until mDNS_Execute time. 4898 CreateNewCacheEntry(m, slot, cg, NonZeroTime(m->timenow), mDNStrue, mDNSNULL); 4899 ScheduleNextCacheCheckTime(m, slot, NonZeroTime(m->timenow)); 4900 m->rec.r.responseFlags = zeroID; 4901 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 4902 // MUST NOT touch m->CurrentQuestion (or q) after this -- client callback could have deleted it 4903 } 4904 } 4905} 4906 4907mDNSexport void CheckNATMappings(mDNS *m) 4908{ 4909 mStatus err = mStatus_NoError; 4910 mDNSBool rfc1918 = mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4); 4911 mDNSBool HaveRoutable = !rfc1918 && !mDNSIPv4AddressIsZero(m->AdvertisedV4.ip.v4); 4912 m->NextScheduledNATOp = m->timenow + 0x3FFFFFFF; 4913 4914 if (HaveRoutable) m->ExtAddress = m->AdvertisedV4.ip.v4; 4915 4916 if (m->NATTraversals && rfc1918) // Do we need to open a socket to receive multicast announcements from router? 4917 { 4918 if (m->NATMcastRecvskt == mDNSNULL) // If we are behind a NAT and the socket hasn't been opened yet, open it 4919 { 4920 // we need to log a message if we can't get our socket, but only the first time (after success) 4921 static mDNSBool needLog = mDNStrue; 4922 m->NATMcastRecvskt = mDNSPlatformUDPSocket(m, NATPMPAnnouncementPort); 4923 if (!m->NATMcastRecvskt) 4924 { 4925 if (needLog) 4926 { 4927 LogMsg("CheckNATMappings: Failed to allocate port 5350 UDP multicast socket for PCP & NAT-PMP announcements"); 4928 needLog = mDNSfalse; 4929 } 4930 } 4931 else 4932 needLog = mDNStrue; 4933 } 4934 } 4935 else // else, we don't want to listen for announcements, so close them if they're open 4936 { 4937 if (m->NATMcastRecvskt) { mDNSPlatformUDPClose(m->NATMcastRecvskt); m->NATMcastRecvskt = mDNSNULL; } 4938 if (m->SSDPSocket) { debugf("CheckNATMappings destroying SSDPSocket %p", &m->SSDPSocket); mDNSPlatformUDPClose(m->SSDPSocket); m->SSDPSocket = mDNSNULL; } 4939 } 4940 4941 uDNS_RequestAddress(m); 4942 4943 if (m->CurrentNATTraversal) LogMsg("WARNING m->CurrentNATTraversal already in use"); 4944 m->CurrentNATTraversal = m->NATTraversals; 4945 4946 while (m->CurrentNATTraversal) 4947 { 4948 NATTraversalInfo *cur = m->CurrentNATTraversal; 4949 mDNSv4Addr EffectiveAddress = HaveRoutable ? m->AdvertisedV4.ip.v4 : cur->NewAddress; 4950 m->CurrentNATTraversal = m->CurrentNATTraversal->next; 4951 4952 if (HaveRoutable) // If not RFC 1918 address, our own address and port are effectively our external address and port 4953 { 4954 cur->ExpiryTime = 0; 4955 cur->NewResult = mStatus_NoError; 4956 } 4957 else // Check if it's time to send port mapping packet(s) 4958 { 4959 if (m->timenow - cur->retryPortMap >= 0) // Time to send a mapping request for this packet 4960 { 4961 if (cur->ExpiryTime && cur->ExpiryTime - m->timenow < 0) // Mapping has expired 4962 { 4963 cur->ExpiryTime = 0; 4964 cur->retryInterval = NATMAP_INIT_RETRY; 4965 } 4966 4967 err = uDNS_SendNATMsg(m, cur, mDNStrue); // Will also do UPnP discovery for us, if necessary 4968 4969 if (cur->ExpiryTime) // If have active mapping then set next renewal time halfway to expiry 4970 NATSetNextRenewalTime(m, cur); 4971 else // else no mapping; use exponential backoff sequence 4972 { 4973 if (cur->retryInterval < NATMAP_INIT_RETRY ) cur->retryInterval = NATMAP_INIT_RETRY; 4974 else if (cur->retryInterval < NATMAP_MAX_RETRY_INTERVAL / 2) cur->retryInterval *= 2; 4975 else cur->retryInterval = NATMAP_MAX_RETRY_INTERVAL; 4976 cur->retryPortMap = m->timenow + cur->retryInterval; 4977 } 4978 } 4979 4980 if (m->NextScheduledNATOp - cur->retryPortMap > 0) 4981 { 4982 m->NextScheduledNATOp = cur->retryPortMap; 4983 } 4984 } 4985 4986 // Notify the client if necessary. We invoke the callback if: 4987 // (1) We have an effective address, 4988 // or we've tried and failed a couple of times to discover it 4989 // AND 4990 // (2) the client requested the address only, 4991 // or the client won't need a mapping because we have a routable address, 4992 // or the client has an expiry time and therefore a successful mapping, 4993 // or we've tried and failed a couple of times (see "Time line" below) 4994 // AND 4995 // (3) we have new data to give the client that's changed since the last callback 4996 // 4997 // Time line is: Send, Wait 500ms, Send, Wait 1sec, Send, Wait 2sec, Send 4998 // At this point we've sent three requests without an answer, we've just sent our fourth request, 4999 // retryInterval is now 4 seconds, which is greater than NATMAP_INIT_RETRY * 8 (2 seconds), 5000 // so we return an error result to the caller. 5001 if (!mDNSIPv4AddressIsZero(EffectiveAddress) || cur->retryInterval > NATMAP_INIT_RETRY * 8) 5002 { 5003 const mStatus EffectiveResult = cur->NewResult ? cur->NewResult : mDNSv4AddrIsRFC1918(&EffectiveAddress) ? mStatus_DoubleNAT : mStatus_NoError; 5004 const mDNSIPPort ExternalPort = HaveRoutable ? cur->IntPort : 5005 !mDNSIPv4AddressIsZero(EffectiveAddress) && cur->ExpiryTime ? cur->RequestedPort : zeroIPPort; 5006 5007 if (!cur->Protocol || HaveRoutable || cur->ExpiryTime || cur->retryInterval > NATMAP_INIT_RETRY * 8) 5008 { 5009 if (!mDNSSameIPv4Address(cur->ExternalAddress, EffectiveAddress) || 5010 !mDNSSameIPPort (cur->ExternalPort, ExternalPort) || 5011 cur->Result != EffectiveResult) 5012 { 5013 //LogMsg("NAT callback %d %d %d", cur->Protocol, cur->ExpiryTime, cur->retryInterval); 5014 if (cur->Protocol && mDNSIPPortIsZero(ExternalPort) && !mDNSIPv4AddressIsZero(m->Router.ip.v4)) 5015 { 5016 if (!EffectiveResult) 5017 LogInfo("CheckNATMapping: Failed to obtain NAT port mapping %p from router %#a external address %.4a internal port %5d interval %d error %d", 5018 cur, &m->Router, &EffectiveAddress, mDNSVal16(cur->IntPort), cur->retryInterval, EffectiveResult); 5019 else 5020 LogMsg("CheckNATMapping: Failed to obtain NAT port mapping %p from router %#a external address %.4a internal port %5d interval %d error %d", 5021 cur, &m->Router, &EffectiveAddress, mDNSVal16(cur->IntPort), cur->retryInterval, EffectiveResult); 5022 } 5023 5024 cur->ExternalAddress = EffectiveAddress; 5025 cur->ExternalPort = ExternalPort; 5026 cur->Lifetime = cur->ExpiryTime && !mDNSIPPortIsZero(ExternalPort) ? 5027 (cur->ExpiryTime - m->timenow + mDNSPlatformOneSecond/2) / mDNSPlatformOneSecond : 0; 5028 cur->Result = EffectiveResult; 5029 mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback 5030 if (cur->clientCallback) 5031 cur->clientCallback(m, cur); 5032 mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again 5033 // MUST NOT touch cur after invoking the callback 5034 } 5035 } 5036 } 5037 } 5038} 5039 5040mDNSlocal mDNSs32 CheckRecordUpdates(mDNS *m) 5041{ 5042 AuthRecord *rr; 5043 mDNSs32 nextevent = m->timenow + 0x3FFFFFFF; 5044 5045 CheckGroupRecordUpdates(m); 5046 5047 for (rr = m->ResourceRecords; rr; rr = rr->next) 5048 { 5049 if (!AuthRecord_uDNS(rr)) continue; 5050 if (rr->state == regState_NoTarget) {debugf("CheckRecordUpdates: Record %##s in NoTarget", rr->resrec.name->c); continue;} 5051 // While we are waiting for the port mapping, we have nothing to do. The port mapping callback 5052 // will take care of this 5053 if (rr->state == regState_NATMap) {debugf("CheckRecordUpdates: Record %##s in NATMap", rr->resrec.name->c); continue;} 5054 if (rr->state == regState_Pending || rr->state == regState_DeregPending || rr->state == regState_UpdatePending || 5055 rr->state == regState_Refresh || rr->state == regState_Registered) 5056 { 5057 if (rr->LastAPTime + rr->ThisAPInterval - m->timenow <= 0) 5058 { 5059 if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } 5060 if (!rr->nta || mDNSIPv4AddressIsZero(rr->nta->Addr.ip.v4)) 5061 { 5062 // Zero out the updateid so that if we have a pending response from the server, it won't 5063 // be accepted as a valid response. If we accept the response, we might free the new "nta" 5064 if (rr->nta) { rr->updateid = zeroID; CancelGetZoneData(m, rr->nta); } 5065 rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationGotZoneData, rr); 5066 5067 // We have just started the GetZoneData. We need to wait for it to finish. SetRecordRetry here 5068 // schedules the update timer to fire in the future. 5069 // 5070 // There are three cases. 5071 // 5072 // 1) When the updates are sent the first time, the first retry is intended to be at three seconds 5073 // in the future. But by calling SetRecordRetry here we set it to nine seconds. But it does not 5074 // matter because when the answer comes back, RecordRegistrationGotZoneData resets the interval 5075 // back to INIT_RECORD_REG_INTERVAL. This also gives enough time for the query. 5076 // 5077 // 2) In the case of update errors (updateError), this causes further backoff as 5078 // RecordRegistrationGotZoneData does not reset the timer. This is intentional as in the case of 5079 // errors, we don't want to update aggressively. 5080 // 5081 // 3) We might be refreshing the update. This is very similar to case (1). RecordRegistrationGotZoneData 5082 // resets it back to INIT_RECORD_REG_INTERVAL. 5083 // 5084 SetRecordRetry(m, rr, 0); 5085 } 5086 else if (rr->state == regState_DeregPending) SendRecordDeregistration(m, rr); 5087 else SendRecordRegistration(m, rr); 5088 } 5089 } 5090 if (nextevent - (rr->LastAPTime + rr->ThisAPInterval) > 0) 5091 nextevent = (rr->LastAPTime + rr->ThisAPInterval); 5092 } 5093 return nextevent; 5094} 5095 5096mDNSexport void uDNS_Tasks(mDNS *const m) 5097{ 5098 mDNSs32 nexte; 5099 DNSServer *d; 5100 5101 m->NextuDNSEvent = m->timenow + 0x3FFFFFFF; 5102 5103 nexte = CheckRecordUpdates(m); 5104 if (m->NextuDNSEvent - nexte > 0) 5105 m->NextuDNSEvent = nexte; 5106 5107 for (d = m->DNSServers; d; d=d->next) 5108 if (d->penaltyTime) 5109 { 5110 if (m->timenow - d->penaltyTime >= 0) 5111 { 5112 LogInfo("DNS server %#a:%d out of penalty box", &d->addr, mDNSVal16(d->port)); 5113 d->penaltyTime = 0; 5114 } 5115 else 5116 if (m->NextuDNSEvent - d->penaltyTime > 0) 5117 m->NextuDNSEvent = d->penaltyTime; 5118 } 5119 5120 if (m->CurrentQuestion) 5121 LogMsg("uDNS_Tasks ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); 5122 m->CurrentQuestion = m->Questions; 5123 while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) 5124 { 5125 DNSQuestion *const q = m->CurrentQuestion; 5126 if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID)) 5127 { 5128 uDNS_CheckCurrentQuestion(m); 5129 if (q == m->CurrentQuestion) 5130 if (m->NextuDNSEvent - NextQSendTime(q) > 0) 5131 m->NextuDNSEvent = NextQSendTime(q); 5132 } 5133 // If m->CurrentQuestion wasn't modified out from under us, advance it now 5134 // We can't do this at the start of the loop because uDNS_CheckCurrentQuestion() 5135 // depends on having m->CurrentQuestion point to the right question 5136 if (m->CurrentQuestion == q) 5137 m->CurrentQuestion = q->next; 5138 } 5139 m->CurrentQuestion = mDNSNULL; 5140} 5141 5142// *************************************************************************** 5143#if COMPILER_LIKES_PRAGMA_MARK 5144#pragma mark - Startup, Shutdown, and Sleep 5145#endif 5146 5147mDNSexport void SleepRecordRegistrations(mDNS *m) 5148{ 5149 AuthRecord *rr; 5150 for (rr = m->ResourceRecords; rr; rr=rr->next) 5151 { 5152 if (AuthRecord_uDNS(rr)) 5153 { 5154 // Zero out the updateid so that if we have a pending response from the server, it won't 5155 // be accepted as a valid response. 5156 if (rr->nta) { rr->updateid = zeroID; CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; } 5157 5158 if (rr->NATinfo.clientContext) 5159 { 5160 mDNS_StopNATOperation_internal(m, &rr->NATinfo); 5161 rr->NATinfo.clientContext = mDNSNULL; 5162 } 5163 // We are waiting to update the resource record. The original data of the record is 5164 // in OrigRData and the updated value is in InFlightRData. Free the old and the new 5165 // one will be registered when we come back. 5166 if (rr->state == regState_UpdatePending) 5167 { 5168 // act as if the update succeeded, since we're about to delete the name anyway 5169 rr->state = regState_Registered; 5170 // deallocate old RData 5171 if (rr->UpdateCallback) rr->UpdateCallback(m, rr, rr->OrigRData, rr->OrigRDLen); 5172 SetNewRData(&rr->resrec, rr->InFlightRData, rr->InFlightRDLen); 5173 rr->OrigRData = mDNSNULL; 5174 rr->InFlightRData = mDNSNULL; 5175 } 5176 5177 // If we have not begun the registration process i.e., never sent a registration packet, 5178 // then uDNS_DeregisterRecord will not send a deregistration 5179 uDNS_DeregisterRecord(m, rr); 5180 5181 // When we wake, we call ActivateUnicastRegistration which starts at StartGetZoneData 5182 } 5183 } 5184} 5185 5186mDNSexport void mDNS_AddSearchDomain(const domainname *const domain, mDNSInterfaceID InterfaceID) 5187{ 5188 SearchListElem **p; 5189 SearchListElem *tmp = mDNSNULL; 5190 5191 // Check to see if we already have this domain in our list 5192 for (p = &SearchList; *p; p = &(*p)->next) 5193 if (((*p)->InterfaceID == InterfaceID) && SameDomainName(&(*p)->domain, domain)) 5194 { 5195 // If domain is already in list, and marked for deletion, unmark the delete 5196 // Be careful not to touch the other flags that may be present 5197 LogInfo("mDNS_AddSearchDomain already in list %##s", domain->c); 5198 if ((*p)->flag & SLE_DELETE) (*p)->flag &= ~SLE_DELETE; 5199 tmp = *p; 5200 *p = tmp->next; 5201 tmp->next = mDNSNULL; 5202 break; 5203 } 5204 5205 5206 // move to end of list so that we maintain the same order 5207 while (*p) p = &(*p)->next; 5208 5209 if (tmp) *p = tmp; 5210 else 5211 { 5212 // if domain not in list, add to list, mark as add (1) 5213 *p = mDNSPlatformMemAllocate(sizeof(SearchListElem)); 5214 if (!*p) { LogMsg("ERROR: mDNS_AddSearchDomain - malloc"); return; } 5215 mDNSPlatformMemZero(*p, sizeof(SearchListElem)); 5216 AssignDomainName(&(*p)->domain, domain); 5217 (*p)->next = mDNSNULL; 5218 (*p)->InterfaceID = InterfaceID; 5219 LogInfo("mDNS_AddSearchDomain created new %##s, InterfaceID %p", domain->c, InterfaceID); 5220 } 5221} 5222 5223mDNSlocal void FreeARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result) 5224{ 5225 (void)m; // unused 5226 if (result == mStatus_MemFree) mDNSPlatformMemFree(rr->RecordContext); 5227} 5228 5229mDNSlocal void FoundDomain(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) 5230{ 5231 SearchListElem *slElem = question->QuestionContext; 5232 mStatus err; 5233 const char *name; 5234 5235 if (answer->rrtype != kDNSType_PTR) return; 5236 if (answer->RecordType == kDNSRecordTypePacketNegative) return; 5237 if (answer->InterfaceID == mDNSInterface_LocalOnly) return; 5238 5239 if (question == &slElem->BrowseQ) name = mDNS_DomainTypeNames[mDNS_DomainTypeBrowse]; 5240 else if (question == &slElem->DefBrowseQ) name = mDNS_DomainTypeNames[mDNS_DomainTypeBrowseDefault]; 5241 else if (question == &slElem->AutomaticBrowseQ) name = mDNS_DomainTypeNames[mDNS_DomainTypeBrowseAutomatic]; 5242 else if (question == &slElem->RegisterQ) name = mDNS_DomainTypeNames[mDNS_DomainTypeRegistration]; 5243 else if (question == &slElem->DefRegisterQ) name = mDNS_DomainTypeNames[mDNS_DomainTypeRegistrationDefault]; 5244 else { LogMsg("FoundDomain - unknown question"); return; } 5245 5246 LogInfo("FoundDomain: %p %s %s Q %##s A %s", answer->InterfaceID, AddRecord ? "Add" : "Rmv", name, question->qname.c, RRDisplayString(m, answer)); 5247 5248 if (AddRecord) 5249 { 5250 ARListElem *arElem = mDNSPlatformMemAllocate(sizeof(ARListElem)); 5251 if (!arElem) { LogMsg("ERROR: FoundDomain out of memory"); return; } 5252 mDNS_SetupResourceRecord(&arElem->ar, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, AuthRecordLocalOnly, FreeARElemCallback, arElem); 5253 MakeDomainNameFromDNSNameString(&arElem->ar.namestorage, name); 5254 AppendDNSNameString (&arElem->ar.namestorage, "local"); 5255 AssignDomainName(&arElem->ar.resrec.rdata->u.name, &answer->rdata->u.name); 5256 LogInfo("FoundDomain: Registering %s", ARDisplayString(m, &arElem->ar)); 5257 err = mDNS_Register(m, &arElem->ar); 5258 if (err) { LogMsg("ERROR: FoundDomain - mDNS_Register returned %d", err); mDNSPlatformMemFree(arElem); return; } 5259 arElem->next = slElem->AuthRecs; 5260 slElem->AuthRecs = arElem; 5261 } 5262 else 5263 { 5264 ARListElem **ptr = &slElem->AuthRecs; 5265 while (*ptr) 5266 { 5267 if (SameDomainName(&(*ptr)->ar.resrec.rdata->u.name, &answer->rdata->u.name)) 5268 { 5269 ARListElem *dereg = *ptr; 5270 *ptr = (*ptr)->next; 5271 LogInfo("FoundDomain: Deregistering %s", ARDisplayString(m, &dereg->ar)); 5272 err = mDNS_Deregister(m, &dereg->ar); 5273 if (err) LogMsg("ERROR: FoundDomain - mDNS_Deregister returned %d", err); 5274 // Memory will be freed in the FreeARElemCallback 5275 } 5276 else 5277 ptr = &(*ptr)->next; 5278 } 5279 } 5280} 5281 5282#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING 5283mDNSexport void udns_validatelists(void *const v) 5284{ 5285 mDNS *const m = v; 5286 5287 NATTraversalInfo *n; 5288 for (n = m->NATTraversals; n; n=n->next) 5289 if (n->next == (NATTraversalInfo *)~0 || n->clientCallback == (NATTraversalClientCallback) ~0) 5290 LogMemCorruption("m->NATTraversals: %p is garbage", n); 5291 5292 DNSServer *d; 5293 for (d = m->DNSServers; d; d=d->next) 5294 if (d->next == (DNSServer *)~0 || d->teststate > DNSServer_Disabled) 5295 LogMemCorruption("m->DNSServers: %p is garbage (%d)", d, d->teststate); 5296 5297 DomainAuthInfo *info; 5298 for (info = m->AuthInfoList; info; info = info->next) 5299 if (info->next == (DomainAuthInfo *)~0) 5300 LogMemCorruption("m->AuthInfoList: %p is garbage", info); 5301 5302 HostnameInfo *hi; 5303 for (hi = m->Hostnames; hi; hi = hi->next) 5304 if (hi->next == (HostnameInfo *)~0 || hi->StatusCallback == (mDNSRecordCallback*)~0) 5305 LogMemCorruption("m->Hostnames: %p is garbage", n); 5306 5307 SearchListElem *ptr; 5308 for (ptr = SearchList; ptr; ptr = ptr->next) 5309 if (ptr->next == (SearchListElem *)~0 || ptr->AuthRecs == (void*)~0) 5310 LogMemCorruption("SearchList: %p is garbage (%X)", ptr, ptr->AuthRecs); 5311} 5312#endif 5313 5314// This should probably move to the UDS daemon -- the concept of legacy clients and automatic registration / automatic browsing 5315// is really a UDS API issue, not something intrinsic to uDNS 5316 5317mDNSlocal void uDNS_DeleteWABQueries(mDNS *const m, SearchListElem *ptr, int delete) 5318{ 5319 const char *name1 = mDNSNULL; 5320 const char *name2 = mDNSNULL; 5321 ARListElem **arList = &ptr->AuthRecs; 5322 domainname namestorage1, namestorage2; 5323 mStatus err; 5324 5325 // "delete" parameter indicates the type of query. 5326 switch (delete) 5327 { 5328 case UDNS_WAB_BROWSE_QUERY: 5329 mDNS_StopGetDomains(m, &ptr->BrowseQ); 5330 mDNS_StopGetDomains(m, &ptr->DefBrowseQ); 5331 name1 = mDNS_DomainTypeNames[mDNS_DomainTypeBrowse]; 5332 name2 = mDNS_DomainTypeNames[mDNS_DomainTypeBrowseDefault]; 5333 break; 5334 case UDNS_WAB_LBROWSE_QUERY: 5335 mDNS_StopGetDomains(m, &ptr->AutomaticBrowseQ); 5336 name1 = mDNS_DomainTypeNames[mDNS_DomainTypeBrowseAutomatic]; 5337 break; 5338 case UDNS_WAB_REG_QUERY: 5339 mDNS_StopGetDomains(m, &ptr->RegisterQ); 5340 mDNS_StopGetDomains(m, &ptr->DefRegisterQ); 5341 name1 = mDNS_DomainTypeNames[mDNS_DomainTypeRegistration]; 5342 name2 = mDNS_DomainTypeNames[mDNS_DomainTypeRegistrationDefault]; 5343 break; 5344 default: 5345 LogMsg("uDNS_DeleteWABQueries: ERROR!! returning from default"); 5346 return; 5347 } 5348 // When we get the results to the domain enumeration queries, we add a LocalOnly 5349 // entry. For example, if we issue a domain enumeration query for b._dns-sd._udp.xxxx.com, 5350 // and when we get a response, we add a LocalOnly entry b._dns-sd._udp.local whose RDATA 5351 // points to what we got in the response. Locate the appropriate LocalOnly entries and delete 5352 // them. 5353 if (name1) 5354 { 5355 MakeDomainNameFromDNSNameString(&namestorage1, name1); 5356 AppendDNSNameString(&namestorage1, "local"); 5357 } 5358 if (name2) 5359 { 5360 MakeDomainNameFromDNSNameString(&namestorage2, name2); 5361 AppendDNSNameString(&namestorage2, "local"); 5362 } 5363 while (*arList) 5364 { 5365 ARListElem *dereg = *arList; 5366 if ((name1 && SameDomainName(&dereg->ar.namestorage, &namestorage1)) || 5367 (name2 && SameDomainName(&dereg->ar.namestorage, &namestorage2))) 5368 { 5369 LogInfo("uDNS_DeleteWABQueries: Deregistering PTR %##s -> %##s", dereg->ar.resrec.name->c, dereg->ar.resrec.rdata->u.name.c); 5370 *arList = dereg->next; 5371 err = mDNS_Deregister(m, &dereg->ar); 5372 if (err) LogMsg("uDNS_DeleteWABQueries:: ERROR!! mDNS_Deregister returned %d", err); 5373 // Memory will be freed in the FreeARElemCallback 5374 } 5375 else 5376 { 5377 LogInfo("uDNS_DeleteWABQueries: Skipping PTR %##s -> %##s", dereg->ar.resrec.name->c, dereg->ar.resrec.rdata->u.name.c); 5378 arList = &(*arList)->next; 5379 } 5380 } 5381} 5382 5383mDNSexport void uDNS_SetupWABQueries(mDNS *const m) 5384{ 5385 SearchListElem **p = &SearchList, *ptr; 5386 mStatus err; 5387 int action = 0; 5388 5389 // step 1: mark each element for removal 5390 for (ptr = SearchList; ptr; ptr = ptr->next) 5391 ptr->flag |= SLE_DELETE; 5392 5393 // Make sure we have the search domains from the platform layer so that if we start the WAB 5394 // queries below, we have the latest information. 5395 mDNS_Lock(m); 5396 if (!mDNSPlatformSetDNSConfig(m, mDNSfalse, mDNStrue, mDNSNULL, mDNSNULL, mDNSNULL, mDNSfalse)) 5397 { 5398 // If the configuration did not change, clear the flag so that we don't free the searchlist. 5399 // We still have to start the domain enumeration queries as we may not have started them 5400 // before. 5401 for (ptr = SearchList; ptr; ptr = ptr->next) 5402 ptr->flag &= ~SLE_DELETE; 5403 LogInfo("uDNS_SetupWABQueries: No config change"); 5404 } 5405 mDNS_Unlock(m); 5406 5407 if (m->WABBrowseQueriesCount) 5408 action |= UDNS_WAB_BROWSE_QUERY; 5409 if (m->WABLBrowseQueriesCount) 5410 action |= UDNS_WAB_LBROWSE_QUERY; 5411 if (m->WABRegQueriesCount) 5412 action |= UDNS_WAB_REG_QUERY; 5413 5414 5415 // delete elems marked for removal, do queries for elems marked add 5416 while (*p) 5417 { 5418 ptr = *p; 5419 LogInfo("uDNS_SetupWABQueries:action 0x%x: Flags 0x%x, AuthRecs %p, InterfaceID %p %##s", action, ptr->flag, ptr->AuthRecs, ptr->InterfaceID, ptr->domain.c); 5420 // If SLE_DELETE is set, stop all the queries, deregister all the records and free the memory. 5421 // Otherwise, check to see what the "action" requires. If a particular action bit is not set and 5422 // we have started the corresponding queries as indicated by the "flags", stop those queries and 5423 // deregister the records corresponding to them. 5424 if ((ptr->flag & SLE_DELETE) || 5425 (!(action & UDNS_WAB_BROWSE_QUERY) && (ptr->flag & SLE_WAB_BROWSE_QUERY_STARTED)) || 5426 (!(action & UDNS_WAB_LBROWSE_QUERY) && (ptr->flag & SLE_WAB_LBROWSE_QUERY_STARTED)) || 5427 (!(action & UDNS_WAB_REG_QUERY) && (ptr->flag & SLE_WAB_REG_QUERY_STARTED))) 5428 { 5429 if (ptr->flag & SLE_DELETE) 5430 { 5431 ARListElem *arList = ptr->AuthRecs; 5432 ptr->AuthRecs = mDNSNULL; 5433 *p = ptr->next; 5434 5435 // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries 5436 // We suppressed the domain enumeration for scoped search domains below. When we enable that 5437 // enable this. 5438 if ((ptr->flag & SLE_WAB_BROWSE_QUERY_STARTED) && 5439 !SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5440 { 5441 LogInfo("uDNS_SetupWABQueries: DELETE Browse for domain %##s", ptr->domain.c); 5442 mDNS_StopGetDomains(m, &ptr->BrowseQ); 5443 mDNS_StopGetDomains(m, &ptr->DefBrowseQ); 5444 } 5445 if ((ptr->flag & SLE_WAB_LBROWSE_QUERY_STARTED) && 5446 !SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5447 { 5448 LogInfo("uDNS_SetupWABQueries: DELETE Legacy Browse for domain %##s", ptr->domain.c); 5449 mDNS_StopGetDomains(m, &ptr->AutomaticBrowseQ); 5450 } 5451 if ((ptr->flag & SLE_WAB_REG_QUERY_STARTED) && 5452 !SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5453 { 5454 LogInfo("uDNS_SetupWABQueries: DELETE Registration for domain %##s", ptr->domain.c); 5455 mDNS_StopGetDomains(m, &ptr->RegisterQ); 5456 mDNS_StopGetDomains(m, &ptr->DefRegisterQ); 5457 } 5458 5459 mDNSPlatformMemFree(ptr); 5460 5461 // deregister records generated from answers to the query 5462 while (arList) 5463 { 5464 ARListElem *dereg = arList; 5465 arList = arList->next; 5466 LogInfo("uDNS_SetupWABQueries: DELETE Deregistering PTR %##s -> %##s", dereg->ar.resrec.name->c, dereg->ar.resrec.rdata->u.name.c); 5467 err = mDNS_Deregister(m, &dereg->ar); 5468 if (err) LogMsg("uDNS_SetupWABQueries:: ERROR!! mDNS_Deregister returned %d", err); 5469 // Memory will be freed in the FreeARElemCallback 5470 } 5471 continue; 5472 } 5473 5474 // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries 5475 // We suppressed the domain enumeration for scoped search domains below. When we enable that 5476 // enable this. 5477 if (!(action & UDNS_WAB_BROWSE_QUERY) && (ptr->flag & SLE_WAB_BROWSE_QUERY_STARTED) && 5478 !SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5479 { 5480 LogInfo("uDNS_SetupWABQueries: Deleting Browse for domain %##s", ptr->domain.c); 5481 ptr->flag &= ~SLE_WAB_BROWSE_QUERY_STARTED; 5482 uDNS_DeleteWABQueries(m, ptr, UDNS_WAB_BROWSE_QUERY); 5483 } 5484 5485 if (!(action & UDNS_WAB_LBROWSE_QUERY) && (ptr->flag & SLE_WAB_LBROWSE_QUERY_STARTED) && 5486 !SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5487 { 5488 LogInfo("uDNS_SetupWABQueries: Deleting Legacy Browse for domain %##s", ptr->domain.c); 5489 ptr->flag &= ~SLE_WAB_LBROWSE_QUERY_STARTED; 5490 uDNS_DeleteWABQueries(m, ptr, UDNS_WAB_LBROWSE_QUERY); 5491 } 5492 5493 if (!(action & UDNS_WAB_REG_QUERY) && (ptr->flag & SLE_WAB_REG_QUERY_STARTED) && 5494 !SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5495 { 5496 LogInfo("uDNS_SetupWABQueries: Deleting Registration for domain %##s", ptr->domain.c); 5497 ptr->flag &= ~SLE_WAB_REG_QUERY_STARTED; 5498 uDNS_DeleteWABQueries(m, ptr, UDNS_WAB_REG_QUERY); 5499 } 5500 5501 // Fall through to handle the ADDs 5502 } 5503 5504 if ((action & UDNS_WAB_BROWSE_QUERY) && !(ptr->flag & SLE_WAB_BROWSE_QUERY_STARTED)) 5505 { 5506 // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries. 5507 // Also, suppress the domain enumeration for scoped search domains for now until there is a need. 5508 if (!SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5509 { 5510 mStatus err1, err2; 5511 err1 = mDNS_GetDomains(m, &ptr->BrowseQ, mDNS_DomainTypeBrowse, &ptr->domain, ptr->InterfaceID, FoundDomain, ptr); 5512 if (err1) 5513 { 5514 LogMsg("uDNS_SetupWABQueries: GetDomains for domain %##s returned error(s):\n" 5515 "%d (mDNS_DomainTypeBrowse)\n", ptr->domain.c, err1); 5516 } 5517 else 5518 { 5519 LogInfo("uDNS_SetupWABQueries: Starting Browse for domain %##s", ptr->domain.c); 5520 } 5521 err2 = mDNS_GetDomains(m, &ptr->DefBrowseQ, mDNS_DomainTypeBrowseDefault, &ptr->domain, ptr->InterfaceID, FoundDomain, ptr); 5522 if (err2) 5523 { 5524 LogMsg("uDNS_SetupWABQueries: GetDomains for domain %##s returned error(s):\n" 5525 "%d (mDNS_DomainTypeBrowseDefault)\n", ptr->domain.c, err2); 5526 } 5527 else 5528 { 5529 LogInfo("uDNS_SetupWABQueries: Starting Default Browse for domain %##s", ptr->domain.c); 5530 } 5531 // For simplicity, we mark a single bit for denoting that both the browse queries have started. 5532 // It is not clear as to why one would fail to start and the other would succeed in starting up. 5533 // If that happens, we will try to stop both the queries and one of them won't be in the list and 5534 // it is not a hard error. 5535 if (!err1 || !err2) 5536 { 5537 ptr->flag |= SLE_WAB_BROWSE_QUERY_STARTED; 5538 } 5539 } 5540 } 5541 if ((action & UDNS_WAB_LBROWSE_QUERY) && !(ptr->flag & SLE_WAB_LBROWSE_QUERY_STARTED)) 5542 { 5543 // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries. 5544 // Also, suppress the domain enumeration for scoped search domains for now until there is a need. 5545 if (!SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5546 { 5547 mStatus err1; 5548 err1 = mDNS_GetDomains(m, &ptr->AutomaticBrowseQ, mDNS_DomainTypeBrowseAutomatic, &ptr->domain, ptr->InterfaceID, FoundDomain, ptr); 5549 if (err1) 5550 { 5551 LogMsg("uDNS_SetupWABQueries: GetDomains for domain %##s returned error(s):\n" 5552 "%d (mDNS_DomainTypeBrowseAutomatic)\n", 5553 ptr->domain.c, err1); 5554 } 5555 else 5556 { 5557 ptr->flag |= SLE_WAB_LBROWSE_QUERY_STARTED; 5558 LogInfo("uDNS_SetupWABQueries: Starting Legacy Browse for domain %##s", ptr->domain.c); 5559 } 5560 } 5561 } 5562 if ((action & UDNS_WAB_REG_QUERY) && !(ptr->flag & SLE_WAB_REG_QUERY_STARTED)) 5563 { 5564 // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries. 5565 // Also, suppress the domain enumeration for scoped search domains for now until there is a need. 5566 if (!SameDomainName(&ptr->domain, &localdomain) && (ptr->InterfaceID == mDNSInterface_Any)) 5567 { 5568 mStatus err1, err2; 5569 err1 = mDNS_GetDomains(m, &ptr->RegisterQ, mDNS_DomainTypeRegistration, &ptr->domain, ptr->InterfaceID, FoundDomain, ptr); 5570 if (err1) 5571 { 5572 LogMsg("uDNS_SetupWABQueries: GetDomains for domain %##s returned error(s):\n" 5573 "%d (mDNS_DomainTypeRegistration)\n", ptr->domain.c, err1); 5574 } 5575 else 5576 { 5577 LogInfo("uDNS_SetupWABQueries: Starting Registration for domain %##s", ptr->domain.c); 5578 } 5579 err2 = mDNS_GetDomains(m, &ptr->DefRegisterQ, mDNS_DomainTypeRegistrationDefault, &ptr->domain, ptr->InterfaceID, FoundDomain, ptr); 5580 if (err2) 5581 { 5582 LogMsg("uDNS_SetupWABQueries: GetDomains for domain %##s returned error(s):\n" 5583 "%d (mDNS_DomainTypeRegistrationDefault)", ptr->domain.c, err2); 5584 } 5585 else 5586 { 5587 LogInfo("uDNS_SetupWABQueries: Starting Default Registration for domain %##s", ptr->domain.c); 5588 } 5589 if (!err1 || !err2) 5590 { 5591 ptr->flag |= SLE_WAB_REG_QUERY_STARTED; 5592 } 5593 } 5594 } 5595 5596 p = &ptr->next; 5597 } 5598} 5599 5600// mDNS_StartWABQueries is called once per API invocation where normally 5601// one of the bits is set. 5602mDNSexport void uDNS_StartWABQueries(mDNS *const m, int queryType) 5603{ 5604 if (queryType & UDNS_WAB_BROWSE_QUERY) 5605 { 5606 m->WABBrowseQueriesCount++; 5607 LogInfo("uDNS_StartWABQueries: Browse query count %d", m->WABBrowseQueriesCount); 5608 } 5609 if (queryType & UDNS_WAB_LBROWSE_QUERY) 5610 { 5611 m->WABLBrowseQueriesCount++; 5612 LogInfo("uDNS_StartWABQueries: Legacy Browse query count %d", m->WABLBrowseQueriesCount); 5613 } 5614 if (queryType & UDNS_WAB_REG_QUERY) 5615 { 5616 m->WABRegQueriesCount++; 5617 LogInfo("uDNS_StartWABQueries: Reg query count %d", m->WABRegQueriesCount); 5618 } 5619 uDNS_SetupWABQueries(m); 5620} 5621 5622// mDNS_StopWABQueries is called once per API invocation where normally 5623// one of the bits is set. 5624mDNSexport void uDNS_StopWABQueries(mDNS *const m, int queryType) 5625{ 5626 if (queryType & UDNS_WAB_BROWSE_QUERY) 5627 { 5628 m->WABBrowseQueriesCount--; 5629 LogInfo("uDNS_StopWABQueries: Browse query count %d", m->WABBrowseQueriesCount); 5630 } 5631 if (queryType & UDNS_WAB_LBROWSE_QUERY) 5632 { 5633 m->WABLBrowseQueriesCount--; 5634 LogInfo("uDNS_StopWABQueries: Legacy Browse query count %d", m->WABLBrowseQueriesCount); 5635 } 5636 if (queryType & UDNS_WAB_REG_QUERY) 5637 { 5638 m->WABRegQueriesCount--; 5639 LogInfo("uDNS_StopWABQueries: Reg query count %d", m->WABRegQueriesCount); 5640 } 5641 uDNS_SetupWABQueries(m); 5642} 5643 5644mDNSexport domainname *uDNS_GetNextSearchDomain(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSs8 *searchIndex, mDNSBool ignoreDotLocal) 5645{ 5646 SearchListElem *p = SearchList; 5647 int count = *searchIndex; 5648 (void) m; // unused 5649 5650 if (count < 0) { LogMsg("uDNS_GetNextSearchDomain: count %d less than zero", count); return mDNSNULL; } 5651 5652 // Skip the domains that we already looked at before. Guard against "p" 5653 // being NULL. When search domains change we may not set the SearchListIndex 5654 // of the question to zero immediately e.g., domain enumeration query calls 5655 // uDNS_SetupWABQueries which reads in the new search domain but does not 5656 // restart the questions immediately. Questions are restarted as part of 5657 // network change and hence temporarily SearchListIndex may be out of range. 5658 5659 for (; count && p; count--) 5660 p = p->next; 5661 5662 while (p) 5663 { 5664 int labels = CountLabels(&p->domain); 5665 if (labels > 0) 5666 { 5667 const domainname *d = SkipLeadingLabels(&p->domain, labels - 1); 5668 if (SameDomainLabel(d->c, (const mDNSu8 *)"\x4" "arpa")) 5669 { 5670 LogInfo("uDNS_GetNextSearchDomain: skipping search domain %##s, InterfaceID %p", p->domain.c, p->InterfaceID); 5671 (*searchIndex)++; 5672 p = p->next; 5673 continue; 5674 } 5675 if (ignoreDotLocal && SameDomainLabel(d->c, (const mDNSu8 *)"\x5" "local")) 5676 { 5677 LogInfo("uDNS_GetNextSearchDomain: skipping local domain %##s, InterfaceID %p", p->domain.c, p->InterfaceID); 5678 (*searchIndex)++; 5679 p = p->next; 5680 continue; 5681 } 5682 } 5683 // Point to the next one in the list which we will look at next time. 5684 (*searchIndex)++; 5685 // When we are appending search domains in a ActiveDirectory domain, the question's InterfaceID 5686 // set to mDNSInterface_Unicast. Match the unscoped entries in that case. 5687 if (((InterfaceID == mDNSInterface_Unicast) && (p->InterfaceID == mDNSInterface_Any)) || 5688 p->InterfaceID == InterfaceID) 5689 { 5690 LogInfo("uDNS_GetNextSearchDomain returning domain %##s, InterfaceID %p", p->domain.c, p->InterfaceID); 5691 return &p->domain; 5692 } 5693 LogInfo("uDNS_GetNextSearchDomain skipping domain %##s, InterfaceID %p", p->domain.c, p->InterfaceID); 5694 p = p->next; 5695 } 5696 return mDNSNULL; 5697} 5698 5699mDNSlocal void FlushAddressCacheRecords(mDNS *const m) 5700{ 5701 mDNSu32 slot; 5702 CacheGroup *cg; 5703 CacheRecord *cr; 5704 FORALL_CACHERECORDS(slot, cg, cr) 5705 { 5706 if (cr->resrec.InterfaceID) continue; 5707 5708 // If a resource record can answer A or AAAA, they need to be flushed so that we will 5709 // deliver an ADD or RMV 5710 if (RRTypeAnswersQuestionType(&cr->resrec, kDNSType_A) || 5711 RRTypeAnswersQuestionType(&cr->resrec, kDNSType_AAAA)) 5712 { 5713 LogInfo("FlushAddressCacheRecords: Purging Resourcerecord %s", CRDisplayString(m, cr)); 5714 mDNS_PurgeCacheResourceRecord(m, cr); 5715 } 5716 } 5717} 5718 5719// Retry questions which has seach domains appended 5720mDNSexport void RetrySearchDomainQuestions(mDNS *const m) 5721{ 5722 DNSQuestion *q; 5723 mDNSBool found = mDNSfalse; 5724 5725 // Check to see if there are any questions which needs search domains to be applied. 5726 // If there is none, search domains can't possibly affect them. 5727 for (q = m->Questions; q; q = q->next) 5728 { 5729 if (q->AppendSearchDomains) 5730 { 5731 found = mDNStrue; 5732 break; 5733 } 5734 } 5735 if (!found) 5736 { 5737 LogInfo("RetrySearchDomainQuestions: Questions with AppendSearchDomain not found"); 5738 return; 5739 } 5740 LogInfo("RetrySearchDomainQuestions: Question with AppendSearchDomain found %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); 5741 // Purge all the A/AAAA cache records and restart the queries. mDNSCoreRestartAddressQueries 5742 // does this. When we restart the question, we first want to try the new search domains rather 5743 // than use the entries that is already in the cache. When we appended search domains, we might 5744 // have created cache entries which is no longer valid as there are new search domains now 5745 mDNSCoreRestartAddressQueries(m, mDNStrue, FlushAddressCacheRecords, mDNSNULL, mDNSNULL); 5746} 5747 5748// Construction of Default Browse domain list (i.e. when clients pass NULL) is as follows: 5749// 1) query for b._dns-sd._udp.local on LocalOnly interface 5750// (.local manually generated via explicit callback) 5751// 2) for each search domain (from prefs pane), query for b._dns-sd._udp.<searchdomain>. 5752// 3) for each result from (2), register LocalOnly PTR record b._dns-sd._udp.local. -> <result> 5753// 4) result above should generate a callback from question in (1). result added to global list 5754// 5) global list delivered to client via GetSearchDomainList() 5755// 6) client calls to enumerate domains now go over LocalOnly interface 5756// (!!!KRS may add outgoing interface in addition) 5757 5758struct CompileTimeAssertionChecks_uDNS 5759{ 5760 // Check our structures are reasonable sizes. Including overly-large buffers, or embedding 5761 // other overly-large structures instead of having a pointer to them, can inadvertently 5762 // cause structure sizes (and therefore memory usage) to balloon unreasonably. 5763 char sizecheck_tcpInfo_t [(sizeof(tcpInfo_t) <= 9056) ? 1 : -1]; 5764 char sizecheck_SearchListElem[(sizeof(SearchListElem) <= 5000) ? 1 : -1]; 5765}; 5766 5767#else // !UNICAST_DISABLED 5768 5769mDNSexport const domainname *GetServiceTarget(mDNS *m, AuthRecord *const rr) 5770{ 5771 (void) m; 5772 (void) rr; 5773 5774 return mDNSNULL; 5775} 5776 5777mDNSexport DomainAuthInfo *GetAuthInfoForName_internal(mDNS *m, const domainname *const name) 5778{ 5779 (void) m; 5780 (void) name; 5781 5782 return mDNSNULL; 5783} 5784 5785mDNSexport DomainAuthInfo *GetAuthInfoForQuestion(mDNS *m, const DNSQuestion *const q) 5786{ 5787 (void) m; 5788 (void) q; 5789 5790 return mDNSNULL; 5791} 5792 5793mDNSexport void startLLQHandshake(mDNS *m, DNSQuestion *q) 5794{ 5795 (void) m; 5796 (void) q; 5797} 5798 5799mDNSexport void DisposeTCPConn(struct tcpInfo_t *tcp) 5800{ 5801 (void) tcp; 5802} 5803 5804mDNSexport mStatus mDNS_StartNATOperation_internal(mDNS *m, NATTraversalInfo *traversal) 5805{ 5806 (void) m; 5807 (void) traversal; 5808 5809 return mStatus_UnsupportedErr; 5810} 5811 5812mDNSexport mStatus mDNS_StopNATOperation_internal(mDNS *m, NATTraversalInfo *traversal) 5813{ 5814 (void) m; 5815 (void) traversal; 5816 5817 return mStatus_UnsupportedErr; 5818} 5819 5820mDNSexport void sendLLQRefresh(mDNS *m, DNSQuestion *q) 5821{ 5822 (void) m; 5823 (void) q; 5824} 5825 5826mDNSexport ZoneData *StartGetZoneData(mDNS *const m, const domainname *const name, const ZoneService target, ZoneDataCallback callback, void *ZoneDataContext) 5827{ 5828 (void) m; 5829 (void) name; 5830 (void) target; 5831 (void) callback; 5832 (void) ZoneDataContext; 5833 5834 return mDNSNULL; 5835} 5836 5837mDNSexport void RecordRegistrationGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneData) 5838{ 5839 (void) m; 5840 (void) err; 5841 (void) zoneData; 5842} 5843 5844mDNSexport uDNS_LLQType uDNS_recvLLQResponse(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, 5845 const mDNSAddr *const srcaddr, const mDNSIPPort srcport, DNSQuestion **matchQuestion) 5846{ 5847 (void) m; 5848 (void) msg; 5849 (void) end; 5850 (void) srcaddr; 5851 (void) srcport; 5852 (void) matchQuestion; 5853 5854 return uDNS_LLQ_Not; 5855} 5856 5857mDNSexport void PenalizeDNSServer(mDNS *const m, DNSQuestion *q, mDNSOpaque16 responseFlags) 5858{ 5859 (void) m; 5860 (void) q; 5861 (void) responseFlags; 5862} 5863 5864mDNSexport void mDNS_AddSearchDomain(const domainname *const domain, mDNSInterfaceID InterfaceID) 5865{ 5866 (void) domain; 5867 (void) InterfaceID; 5868} 5869 5870mDNSexport void RetrySearchDomainQuestions(mDNS *const m) 5871{ 5872 (void) m; 5873} 5874 5875mDNSexport mStatus mDNS_SetSecretForDomain(mDNS *m, DomainAuthInfo *info, const domainname *domain, const domainname *keyname, const char *b64keydata, const domainname *hostname, mDNSIPPort *port, mDNSBool autoTunnel) 5876{ 5877 (void) m; 5878 (void) info; 5879 (void) domain; 5880 (void) keyname; 5881 (void) b64keydata; 5882 (void) hostname; 5883 (void) port; 5884 (void) autoTunnel; 5885 5886 return mStatus_UnsupportedErr; 5887} 5888 5889mDNSexport domainname *uDNS_GetNextSearchDomain(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSs8 *searchIndex, mDNSBool ignoreDotLocal) 5890{ 5891 (void) m; 5892 (void) InterfaceID; 5893 (void) searchIndex; 5894 (void) ignoreDotLocal; 5895 5896 return mDNSNULL; 5897} 5898 5899mDNSexport DomainAuthInfo *GetAuthInfoForName(mDNS *m, const domainname *const name) 5900{ 5901 (void) m; 5902 (void) name; 5903 5904 return mDNSNULL; 5905} 5906 5907mDNSexport mStatus mDNS_StartNATOperation(mDNS *const m, NATTraversalInfo *traversal) 5908{ 5909 (void) m; 5910 (void) traversal; 5911 5912 return mStatus_UnsupportedErr; 5913} 5914 5915mDNSexport mStatus mDNS_StopNATOperation(mDNS *const m, NATTraversalInfo *traversal) 5916{ 5917 (void) m; 5918 (void) traversal; 5919 5920 return mStatus_UnsupportedErr; 5921} 5922 5923mDNSexport DNSServer *mDNS_AddDNSServer(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, const mDNSs32 serviceID, const mDNSAddr *addr, 5924 const mDNSIPPort port, mDNSu32 scoped, mDNSu32 timeout, mDNSBool cellIntf, mDNSu16 resGroupID, mDNSBool reqA, 5925 mDNSBool reqAAAA, mDNSBool reqDO) 5926{ 5927 (void) m; 5928 (void) d; 5929 (void) interface; 5930 (void) serviceID; 5931 (void) addr; 5932 (void) port; 5933 (void) scoped; 5934 (void) timeout; 5935 (void) cellIntf; 5936 (void) resGroupID; 5937 (void) reqA; 5938 (void) reqAAAA; 5939 (void) reqDO; 5940 5941 return mDNSNULL; 5942} 5943 5944mDNSexport void uDNS_SetupWABQueries(mDNS *const m) 5945{ 5946 (void) m; 5947} 5948 5949mDNSexport void uDNS_StartWABQueries(mDNS *const m, int queryType) 5950{ 5951 (void) m; 5952 (void) queryType; 5953} 5954 5955mDNSexport void uDNS_StopWABQueries(mDNS *const m, int queryType) 5956{ 5957 (void) m; 5958 (void) queryType; 5959} 5960 5961mDNSexport void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *StatusContext) 5962{ 5963 (void) m; 5964 (void) fqdn; 5965 (void) StatusCallback; 5966 (void) StatusContext; 5967} 5968mDNSexport void mDNS_SetPrimaryInterfaceInfo(mDNS *m, const mDNSAddr *v4addr, const mDNSAddr *v6addr, const mDNSAddr *router) 5969{ 5970 (void) m; 5971 (void) v4addr; 5972 (void) v6addr; 5973 (void) router; 5974} 5975 5976mDNSexport void mDNS_RemoveDynDNSHostName(mDNS *m, const domainname *fqdn) 5977{ 5978 (void) m; 5979 (void) fqdn; 5980} 5981 5982mDNSexport void RecreateNATMappings(mDNS *const m, const mDNSu32 waitTicks) 5983{ 5984 (void) m; 5985 (void) waitTicks; 5986} 5987 5988mDNSexport mDNSBool IsGetZoneDataQuestion(DNSQuestion *q) 5989{ 5990 (void)q; 5991 5992 return mDNSfalse; 5993} 5994 5995#endif // !UNICAST_DISABLED 5996