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