]> git.saurik.com Git - apple/mdnsresponder.git/blob - mDNSMacOSX/mDNSMacOSX.c
mDNSResponder-544.tar.gz
[apple/mdnsresponder.git] / mDNSMacOSX / mDNSMacOSX.c
1 /* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2002-2013 Apple Computer, Inc. All rights reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 // ***************************************************************************
19 // mDNSMacOSX.c:
20 // Supporting routines to run mDNS on a CFRunLoop platform
21 // ***************************************************************************
22
23 // For debugging, set LIST_ALL_INTERFACES to 1 to display all found interfaces,
24 // including ones that mDNSResponder chooses not to use.
25 #define LIST_ALL_INTERFACES 0
26
27 #include "mDNSEmbeddedAPI.h" // Defines the interface provided to the client layer above
28 #include "DNSCommon.h"
29 #include "uDNS.h"
30 #include "mDNSMacOSX.h" // Defines the specific types needed to run mDNS on this platform
31 #include "dns_sd.h" // For mDNSInterface_LocalOnly etc.
32 #include "PlatformCommon.h"
33 #include "uds_daemon.h"
34 #include "CryptoSupport.h"
35
36 #include <stdio.h>
37 #include <stdarg.h> // For va_list support
38 #include <stdlib.h> // For arc4random
39 #include <net/if.h>
40 #include <net/if_types.h> // For IFT_ETHER
41 #include <net/if_dl.h>
42 #include <net/bpf.h> // For BIOCSETIF etc.
43 #include <sys/uio.h>
44 #include <sys/param.h>
45 #include <sys/socket.h>
46 #include <sys/sysctl.h>
47 #include <sys/event.h>
48 #include <fcntl.h>
49 #include <sys/ioctl.h>
50 #include <time.h> // platform support for UTC time
51 #include <arpa/inet.h> // for inet_aton
52 #include <pthread.h>
53 #include <netdb.h> // for getaddrinfo
54 #include <sys/sockio.h> // for SIOCGIFEFLAGS
55 #include <notify.h>
56 #include <netinet/in.h> // For IP_RECVTTL
57 #ifndef IP_RECVTTL
58 #define IP_RECVTTL 24 // bool; receive reception TTL w/dgram
59 #endif
60
61 #include <netinet/in_systm.h> // For n_long, required by <netinet/ip.h> below
62 #include <netinet/ip.h> // For IPTOS_LOWDELAY etc.
63 #include <netinet6/in6_var.h> // For IN6_IFF_NOTREADY etc.
64 #include <netinet6/nd6.h> // For ND6_INFINITE_LIFETIME etc.
65
66 #include <netinet/tcp.h>
67
68 #include <DebugServices.h>
69 #include "dnsinfo.h"
70
71 #include <ifaddrs.h>
72
73 #include <IOKit/IOKitLib.h>
74 #include <IOKit/IOMessage.h>
75
76 #include <IOKit/ps/IOPowerSources.h>
77 #include <IOKit/ps/IOPowerSourcesPrivate.h>
78 #include <IOKit/ps/IOPSKeys.h>
79
80 #include <mach/mach_error.h>
81 #include <mach/mach_port.h>
82 #include <mach/mach_time.h>
83 #include "helper.h"
84 #include "P2PPacketFilter.h"
85
86 #include <asl.h>
87 #include <SystemConfiguration/SCPrivate.h>
88
89 // Include definition of opaque_presence_indication for KEV_DL_NODE_PRESENCE handling logic.
90 #include <Kernel/IOKit/apple80211/apple80211_var.h>
91
92 #if APPLE_OSX_mDNSResponder
93 #include <DeviceToDeviceManager/DeviceToDeviceManager.h>
94 #include <AWACS.h>
95 #if !NO_D2D
96 D2DStatus D2DInitialize(CFRunLoopRef runLoop, D2DServiceCallback serviceCallback, void* userData) __attribute__((weak_import));
97 D2DStatus D2DRetain(D2DServiceInstance instanceHandle, D2DTransportType transportType) __attribute__((weak_import));
98 D2DStatus D2DStopAdvertisingPairOnTransport(const Byte *key, const size_t keySize, const Byte *value, const size_t valueSize, D2DTransportType transport) __attribute__((weak_import));
99 D2DStatus D2DRelease(D2DServiceInstance instanceHandle, D2DTransportType transportType) __attribute__((weak_import));
100 D2DStatus D2DStartAdvertisingPairOnTransport(const Byte *key, const size_t keySize, const Byte *value, const size_t valueSize, D2DTransportType transport) __attribute__((weak_import));
101 D2DStatus D2DStartBrowsingForKeyOnTransport(const Byte *key, const size_t keySize, D2DTransportType transport) __attribute__((weak_import));
102 D2DStatus D2DStopBrowsingForKeyOnTransport(const Byte *key, const size_t keySize, D2DTransportType transport) __attribute__((weak_import));
103 void D2DStartResolvingPairOnTransport(const Byte *key, const size_t keySize, const Byte *value, const size_t valueSize, D2DTransportType transport) __attribute__((weak_import));
104 void D2DStopResolvingPairOnTransport(const Byte *key, const size_t keySize, const Byte *value, const size_t valueSize, D2DTransportType transport) __attribute__((weak_import));
105 D2DStatus D2DTerminate() __attribute__((weak_import));
106
107 #endif // ! NO_D2D
108
109 #else
110 #define NO_D2D 1
111 #define NO_AWACS 1
112 #endif // APPLE_OSX_mDNSResponder
113
114 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
115 #include <IOKit/platform/IOPlatformSupportPrivate.h>
116 #endif // APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
117
118
119 #define kInterfaceSpecificOption "interface="
120
121 #define mDNS_IOREG_KEY "mDNS_KEY"
122 #define mDNS_IOREG_VALUE "2009-07-30"
123 #define mDNS_IOREG_KA_KEY "mDNS_Keepalive"
124 #define mDNS_USER_CLIENT_CREATE_TYPE 'mDNS'
125
126 // cache the InterfaceID of the AWDL interface
127 static mDNSInterfaceID AWDLInterfaceID;
128
129 // ***************************************************************************
130 // Globals
131
132 #if COMPILER_LIKES_PRAGMA_MARK
133 #pragma mark - Globals
134 #endif
135
136 // By default we don't offer sleep proxy service
137 // If OfferSleepProxyService is set non-zero (typically via command-line switch),
138 // then we'll offer sleep proxy service on desktop Macs that are set to never sleep.
139 // We currently do not offer sleep proxy service on laptops, or on machines that are set to go to sleep.
140 mDNSexport int OfferSleepProxyService = 0;
141 mDNSexport int DisableSleepProxyClient = 0;
142 mDNSexport int UseInternalSleepProxy = 1; // Set to non-zero to use internal (in-NIC) Sleep Proxy
143
144 mDNSexport int OSXVers, iOSVers;
145 mDNSexport int KQueueFD;
146
147 #ifndef NO_SECURITYFRAMEWORK
148 static CFArrayRef ServerCerts;
149 OSStatus SSLSetAllowAnonymousCiphers(SSLContextRef context, Boolean enable);
150 #endif /* NO_SECURITYFRAMEWORK */
151
152 static CFStringRef NetworkChangedKey_IPv4;
153 static CFStringRef NetworkChangedKey_IPv6;
154 static CFStringRef NetworkChangedKey_Hostnames;
155 static CFStringRef NetworkChangedKey_Computername;
156 static CFStringRef NetworkChangedKey_DNS;
157 static CFStringRef NetworkChangedKey_StateInterfacePrefix;
158 static CFStringRef NetworkChangedKey_DynamicDNS = CFSTR("Setup:/Network/DynamicDNS");
159 static CFStringRef NetworkChangedKey_BackToMyMac = CFSTR("Setup:/Network/BackToMyMac");
160 static CFStringRef NetworkChangedKey_BTMMConnectivity = CFSTR("State:/Network/Connectivity");
161 static CFStringRef NetworkChangedKey_PowerSettings = CFSTR("State:/IOKit/PowerManagement/CurrentSettings");
162
163 static char HINFO_HWstring_buffer[32];
164 static char *HINFO_HWstring = "Device";
165 static int HINFO_HWstring_prefixlen = 6;
166
167 mDNSexport int WatchDogReportingThreshold = 250;
168
169 dispatch_queue_t SSLqueue;
170
171 //To prevent blocking the main queue, all writes to DynamicStore happen on the DynamicStoreQueue
172 static dispatch_queue_t DynamicStoreQueue;
173
174 #if TARGET_OS_EMBEDDED
175 #define kmDNSResponderManagedPrefsID CFSTR("/Library/Managed Preferences/mobile/com.apple.mDNSResponder.plist")
176 #endif
177
178 #if APPLE_OSX_mDNSResponder
179 static mDNSu8 SPMetricPortability = 99;
180 static mDNSu8 SPMetricMarginalPower = 99;
181 static mDNSu8 SPMetricTotalPower = 99;
182 static mDNSu8 SPMetricFeatures = 1; /* The current version supports TCP Keep Alive Feature */
183 mDNSexport domainname ActiveDirectoryPrimaryDomain;
184 mDNSexport int ActiveDirectoryPrimaryDomainLabelCount;
185 mDNSexport mDNSAddr ActiveDirectoryPrimaryDomainServer;
186 #endif // APPLE_OSX_mDNSResponder
187
188 // Don't send triggers too often. We arbitrarily limit it to three minutes.
189 #define DNS_TRIGGER_INTERVAL (180 * mDNSPlatformOneSecond)
190
191 // Used by AutoTunnel
192 const char btmmprefix[] = "btmmdns:";
193 const char dnsprefix[] = "dns:";
194
195 // String Array used to write list of private domains to Dynamic Store
196 static CFArrayRef privateDnsArray = NULL;
197
198 // ***************************************************************************
199 #if COMPILER_LIKES_PRAGMA_MARK
200 #pragma mark -
201 #pragma mark - D2D Support
202 #endif
203
204 #if !NO_D2D
205
206 mDNSexport void D2D_start_advertising_interface(NetworkInterfaceInfo *interface)
207 {
208 // AWDL wants the address and reverse address PTR record communicated
209 // via the D2D interface layer.
210 if (interface->InterfaceID == AWDLInterfaceID)
211 {
212 // only log if we have a valid record to start advertising
213 if (interface->RR_A.resrec.RecordType || interface->RR_PTR.resrec.RecordType)
214 LogInfo("D2D_start_advertising_interface: %s", interface->ifname);
215
216 if (interface->RR_A.resrec.RecordType)
217 external_start_advertising_service(&interface->RR_A.resrec, NULL);
218 if (interface->RR_PTR.resrec.RecordType)
219 external_start_advertising_service(&interface->RR_PTR.resrec, NULL);
220 }
221 }
222
223 mDNSexport void D2D_stop_advertising_interface(NetworkInterfaceInfo *interface)
224 {
225 if (interface->InterfaceID == AWDLInterfaceID)
226 {
227 // only log if we have a valid record to stop advertising
228 if (interface->RR_A.resrec.RecordType || interface->RR_PTR.resrec.RecordType)
229 LogInfo("D2D_stop_advertising_interface: %s", interface->ifname);
230
231 if (interface->RR_A.resrec.RecordType)
232 external_stop_advertising_service(&interface->RR_A.resrec, NULL);
233 if (interface->RR_PTR.resrec.RecordType)
234 external_stop_advertising_service(&interface->RR_PTR.resrec, NULL);
235 }
236 }
237
238 // Name compression items for fake packet version number 1
239 static const mDNSu8 compression_packet_v1 = 0x01;
240
241 static DNSMessage compression_base_msg = { { {{0}}, {{0}}, 2, 0, 0, 0 }, "\x04_tcp\x05local\x00\x00\x0C\x00\x01\x04_udp\xC0\x11\x00\x0C\x00\x01" };
242 static mDNSu8 *const compression_limit = (mDNSu8 *) &compression_base_msg + sizeof(DNSMessage);
243 static mDNSu8 *const compression_lhs = (mDNSu8 *const) compression_base_msg.data + 27;
244
245 mDNSlocal void FreeD2DARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
246 mDNSlocal void PrintHex(mDNSu8 *data, mDNSu16 len);
247
248 typedef struct D2DRecordListElem
249 {
250 struct D2DRecordListElem *next;
251 D2DServiceInstance instanceHandle;
252 D2DTransportType transportType;
253 AuthRecord ar; // must be last in the structure to accomodate extra space
254 // allocated for large records.
255 } D2DRecordListElem;
256
257 static D2DRecordListElem *D2DRecords = NULL; // List of records returned with D2DServiceFound events
258
259 typedef struct D2DBrowseListElem
260 {
261 struct D2DBrowseListElem *next;
262 domainname name;
263 mDNSu16 type;
264 unsigned int refCount;
265 } D2DBrowseListElem;
266
267 D2DBrowseListElem* D2DBrowseList = NULL;
268
269 mDNSlocal mDNSu8 *putVal16(mDNSu8 *ptr, mDNSu16 val)
270 {
271 ptr[0] = (mDNSu8)((val >> 8 ) & 0xFF);
272 ptr[1] = (mDNSu8)((val ) & 0xFF);
273 return ptr + sizeof(mDNSu16);
274 }
275
276 mDNSlocal mDNSu8 *putVal32(mDNSu8 *ptr, mDNSu32 val)
277 {
278 ptr[0] = (mDNSu8)((val >> 24) & 0xFF);
279 ptr[1] = (mDNSu8)((val >> 16) & 0xFF);
280 ptr[2] = (mDNSu8)((val >> 8) & 0xFF);
281 ptr[3] = (mDNSu8)((val ) & 0xFF);
282 return ptr + sizeof(mDNSu32);
283 }
284
285 mDNSlocal void DomainnameToLower(const domainname * const in, domainname * const out)
286 {
287 const mDNSu8 * const start = (const mDNSu8 * const)in;
288 mDNSu8 *ptr = (mDNSu8*)start;
289 while(*ptr)
290 {
291 mDNSu8 c = *ptr;
292 out->c[ptr-start] = *ptr;
293 ptr++;
294 for (; c; c--,ptr++) out->c[ptr-start] = mDNSIsUpperCase(*ptr) ? (*ptr - 'A' + 'a') : *ptr;
295 }
296 out->c[ptr-start] = *ptr;
297 }
298
299 mDNSlocal mStatus DNSNameCompressionParseBytes(mDNS *const m, const mDNSu8 *const lhs, const mDNSu16 lhs_len, const mDNSu8 *const rhs, const mDNSu16 rhs_len, AuthRecord *rr)
300 {
301 if (mDNS_LoggingEnabled)
302 {
303 LogInfo("%s", __func__);
304 LogInfo(" Static Bytes: (%d bytes)", compression_lhs - (mDNSu8*)&compression_base_msg);
305 PrintHex((mDNSu8*)&compression_base_msg, compression_lhs - (mDNSu8*)&compression_base_msg);
306 }
307
308 mDNSu8 *ptr = compression_lhs; // pointer to the end of our fake packet
309
310 // Check to make sure we're not going to go past the end of the DNSMessage data
311 // 7 = 2 for CLASS (-1 for our version) + 4 for TTL + 2 for RDLENGTH
312 if (ptr + lhs_len - 7 + rhs_len >= compression_limit) return mStatus_NoMemoryErr;
313
314 // Copy the LHS onto our fake wire packet
315 mDNSPlatformMemCopy(ptr, lhs, lhs_len);
316 ptr += lhs_len - 1;
317
318 // Check the 'fake packet' version number, to ensure that we know how to decompress this data
319 if (*ptr != compression_packet_v1) return mStatus_Incompatible;
320
321 // two bytes of CLASS
322 ptr = putVal16(ptr, kDNSClass_IN | kDNSClass_UniqueRRSet);
323
324 // four bytes of TTL
325 ptr = putVal32(ptr, 120);
326
327 // Copy the RHS length into the RDLENGTH of our fake wire packet
328 ptr = putVal16(ptr, rhs_len);
329
330 // Copy the RHS onto our fake wire packet
331 mDNSPlatformMemCopy(ptr, rhs, rhs_len);
332 ptr += rhs_len;
333
334 if (mDNS_LoggingEnabled)
335 {
336 LogInfo(" Our Bytes (%d bytes): ", ptr - compression_lhs);
337 PrintHex(compression_lhs, ptr - compression_lhs);
338 }
339
340 ptr = (mDNSu8 *) GetLargeResourceRecord(m, &compression_base_msg, compression_lhs, ptr, mDNSInterface_Any, kDNSRecordTypePacketAns, &m->rec);
341 if (!ptr || m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative)
342 { LogMsg("DNSNameCompressionParseBytes: failed to get large RR"); m->rec.r.resrec.RecordType = 0; return mStatus_UnknownErr; }
343 else LogInfo("DNSNameCompressionParseBytes: got rr: %s", CRDisplayString(m, &m->rec.r));
344
345 mDNS_SetupResourceRecord(rr, mDNSNULL, mDNSInterface_P2P, m->rec.r.resrec.rrtype, 7200, kDNSRecordTypeShared, AuthRecordP2P, FreeD2DARElemCallback, NULL);
346 AssignDomainName(&rr->namestorage, &m->rec.namestorage);
347 rr->resrec.rdlength = m->rec.r.resrec.rdlength;
348 rr->resrec.rdata->MaxRDLength = m->rec.r.resrec.rdlength;
349 mDNSPlatformMemCopy(rr->resrec.rdata->u.data, m->rec.r.resrec.rdata->u.data, m->rec.r.resrec.rdlength);
350 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
351 SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
352
353 m->rec.r.resrec.RecordType = 0; // Mark m->rec as no longer in use
354
355 return mStatus_NoError;
356 }
357
358 mDNSlocal mDNSu8 * DNSNameCompressionBuildLHS(const domainname* typeDomain, DNS_TypeValues qtype)
359 {
360 mDNSu8 *ptr = putDomainNameAsLabels(&compression_base_msg, compression_lhs, compression_limit, typeDomain);
361 if (!ptr) return ptr;
362 *ptr = (qtype >> 8) & 0xff;
363 ptr += 1;
364 *ptr = qtype & 0xff;
365 ptr += 1;
366 *ptr = compression_packet_v1;
367 return ptr + 1;
368 }
369
370 mDNSlocal mDNSu8 * DNSNameCompressionBuildRHS(mDNSu8 *start, const ResourceRecord *const resourceRecord)
371 {
372 return putRData(&compression_base_msg, start, compression_limit, resourceRecord);
373 }
374
375 #define PRINT_DEBUG_BYTES_LIMIT 64 // set limit on number of record bytes printed for debugging
376
377 mDNSlocal void PrintHex(mDNSu8 *data, mDNSu16 len)
378 {
379 mDNSu8 *end;
380 char buffer[49] = {0};
381 char *bufend = buffer + sizeof(buffer);
382
383 if (len > PRINT_DEBUG_BYTES_LIMIT)
384 {
385 LogInfo(" (limiting debug output to %d bytes)", PRINT_DEBUG_BYTES_LIMIT);
386 len = PRINT_DEBUG_BYTES_LIMIT;
387 }
388 end = data + len;
389
390 while(data < end)
391 {
392 char *ptr = buffer;
393 for(; data < end && ptr < bufend-1; ptr+=3,data++)
394 mDNS_snprintf(ptr, bufend - ptr, "%02X ", *data);
395 LogInfo(" %s", buffer);
396 }
397 }
398
399 mDNSlocal void PrintHelper(const char *const tag, mDNSu8 *lhs, mDNSu16 lhs_len, mDNSu8 *rhs, mDNSu16 rhs_len)
400 {
401 if (!mDNS_LoggingEnabled) return;
402
403 LogInfo("%s:", tag);
404 LogInfo(" LHS: (%d bytes)", lhs_len);
405 PrintHex(lhs, lhs_len);
406
407 if (!rhs) return;
408
409 LogInfo(" RHS: (%d bytes)", rhs_len);
410 PrintHex(rhs, rhs_len);
411 }
412
413 mDNSlocal void FreeD2DARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
414 {
415 (void)m; // unused
416 if (result == mStatus_MemFree)
417 {
418 D2DRecordListElem **ptr = &D2DRecords;
419 D2DRecordListElem *tmp;
420 while (*ptr && &(*ptr)->ar != rr) ptr = &(*ptr)->next;
421 if (!*ptr) { LogMsg("FreeD2DARElemCallback: Could not find in D2DRecords: %s", ARDisplayString(m, rr)); return; }
422 LogInfo("FreeD2DARElemCallback: Found in D2DRecords: %s", ARDisplayString(m, rr));
423 tmp = *ptr;
424 *ptr = (*ptr)->next;
425 // Just because we stoppped browsing, doesn't mean we should tear down the PAN connection.
426 mDNSPlatformMemFree(tmp);
427 }
428 }
429
430 mDNSexport void external_connection_release(const domainname *instance)
431 {
432 (void) instance;
433 D2DRecordListElem *ptr = D2DRecords;
434
435 for ( ; ptr ; ptr = ptr->next)
436 {
437 if ((ptr->ar.resrec.rrtype == kDNSServiceType_PTR) &&
438 SameDomainName(&ptr->ar.rdatastorage.u.name, instance))
439 {
440 LogInfo("external_connection_release: Calling D2DRelease(instanceHandle = %p, transportType = %d",
441 ptr->instanceHandle, ptr->transportType);
442 if (D2DRelease) D2DRelease(ptr->instanceHandle, ptr->transportType);
443 }
444 }
445 }
446
447 mDNSlocal void xD2DClearCache(const domainname *regType, DNS_TypeValues qtype)
448 {
449 D2DRecordListElem *ptr = D2DRecords;
450 for ( ; ptr ; ptr = ptr->next)
451 {
452 if ((ptr->ar.resrec.rrtype == qtype) && SameDomainName(&ptr->ar.namestorage, regType))
453 {
454 mDNS_Deregister(&mDNSStorage, &ptr->ar);
455 LogInfo("xD2DClearCache: Clearing cache record and deregistering %s", ARDisplayString(&mDNSStorage, &ptr->ar));
456 }
457 }
458 }
459
460 mDNSlocal D2DBrowseListElem ** D2DFindInBrowseList(const domainname *const name, mDNSu16 type)
461 {
462 D2DBrowseListElem **ptr = &D2DBrowseList;
463
464 for ( ; *ptr; ptr = &(*ptr)->next)
465 if ((*ptr)->type == type && SameDomainName(&(*ptr)->name, name))
466 break;
467
468 return ptr;
469 }
470
471 mDNSlocal unsigned int D2DBrowseListRefCount(const domainname *const name, mDNSu16 type)
472 {
473 D2DBrowseListElem **ptr = D2DFindInBrowseList(name, type);
474 return *ptr ? (*ptr)->refCount : 0;
475 }
476
477 mDNSlocal void D2DBrowseListRetain(const domainname *const name, mDNSu16 type)
478 {
479 D2DBrowseListElem **ptr = D2DFindInBrowseList(name, type);
480
481 if (!*ptr)
482 {
483 *ptr = mDNSPlatformMemAllocate(sizeof(**ptr));
484 mDNSPlatformMemZero(*ptr, sizeof(**ptr));
485 (*ptr)->type = type;
486 AssignDomainName(&(*ptr)->name, name);
487 }
488 (*ptr)->refCount += 1;
489
490 LogInfo("D2DBrowseListRetain: %##s %s refcount now %u", (*ptr)->name.c, DNSTypeName((*ptr)->type), (*ptr)->refCount);
491 }
492
493 mDNSlocal void D2DBrowseListRelease(const domainname *const name, mDNSu16 type)
494 {
495 D2DBrowseListElem **ptr = D2DFindInBrowseList(name, type);
496
497 if (!*ptr) { LogMsg("D2DBrowseListRelease: Didn't find %##s %s in list", name->c, DNSTypeName(type)); return; }
498
499 (*ptr)->refCount -= 1;
500
501 LogInfo("D2DBrowseListRelease: %##s %s refcount now %u", (*ptr)->name.c, DNSTypeName((*ptr)->type), (*ptr)->refCount);
502
503 if (!(*ptr)->refCount)
504 {
505 D2DBrowseListElem *tmp = *ptr;
506 *ptr = (*ptr)->next;
507 mDNSPlatformMemFree(tmp);
508 }
509 }
510
511 mDNSlocal mStatus xD2DParse(mDNS *const m, const mDNSu8 * const lhs, const mDNSu16 lhs_len, const mDNSu8 * const rhs, const mDNSu16 rhs_len, AuthRecord *rr)
512 {
513 if (*(lhs + (lhs_len - 1)) == compression_packet_v1)
514 return DNSNameCompressionParseBytes(m, lhs, lhs_len, rhs, rhs_len, rr);
515 else
516 return mStatus_Incompatible;
517 }
518
519 mDNSlocal void xD2DAddToCache(mDNS *const m, D2DStatus result, D2DServiceInstance instanceHandle, D2DTransportType transportType, const Byte *key, size_t keySize, const Byte *value, size_t valueSize)
520 {
521 if (result == kD2DSuccess)
522 {
523 if ( key == NULL || value == NULL || keySize == 0 || valueSize == 0) { LogMsg("xD2DAddToCache: NULL Byte * passed in or length == 0"); return; }
524
525 mStatus err;
526 D2DRecordListElem *ptr = mDNSPlatformMemAllocate(sizeof(D2DRecordListElem) + (valueSize < sizeof(RData) ? 0 : valueSize - sizeof(RData)));
527
528 if (ptr == NULL) { LogMsg("xD2DAddToCache: memory allocation failure"); return; }
529
530 err = xD2DParse(m, (const mDNSu8 * const)key, (const mDNSu16)keySize, (const mDNSu8 * const)value, (const mDNSu16)valueSize, &ptr->ar);
531 if (err)
532 {
533 LogMsg("xD2DAddToCache: xD2DParse returned error: %d", err);
534 PrintHelper(__func__, (mDNSu8 *)key, (mDNSu16)keySize, (mDNSu8 *)value, (mDNSu16)valueSize);
535 mDNSPlatformMemFree(ptr);
536 return;
537 }
538 err = mDNS_Register(m, &ptr->ar);
539 if (err)
540 {
541 LogMsg("xD2DAddToCache: mDNS_Register returned error %d for %s", err, ARDisplayString(m, &ptr->ar));
542 mDNSPlatformMemFree(ptr);
543 return;
544 }
545
546 LogInfo("xD2DAddToCache: mDNS_Register succeeded for %s", ARDisplayString(m, &ptr->ar));
547 ptr->instanceHandle = instanceHandle;
548 ptr->transportType = transportType;
549 ptr->next = D2DRecords;
550 D2DRecords = ptr;
551 }
552 else
553 LogMsg("xD2DAddToCache: Unexpected result %d", result);
554 }
555
556 mDNSlocal D2DRecordListElem * xD2DFindInList(mDNS *const m, const Byte *const key, const size_t keySize, const Byte *const value, const size_t valueSize)
557 {
558 D2DRecordListElem *ptr = D2DRecords;
559 D2DRecordListElem *arptr;
560
561 if ( key == NULL || value == NULL || keySize == 0 || valueSize == 0) { LogMsg("xD2DFindInList: NULL Byte * passed in or length == 0"); return NULL; }
562
563 arptr = mDNSPlatformMemAllocate(sizeof(D2DRecordListElem) + (valueSize < sizeof(RData) ? 0 : valueSize - sizeof(RData)));
564 if (arptr == NULL) { LogMsg("xD2DFindInList: memory allocation failure"); return NULL; }
565
566 if (xD2DParse(m, (const mDNSu8 *const)key, (const mDNSu16)keySize, (const mDNSu8 *const)value, (const mDNSu16)valueSize, &arptr->ar) != mStatus_NoError)
567 {
568 LogMsg("xD2DFindInList: xD2DParse failed for key: %p (%u) value: %p (%u)", key, keySize, value, valueSize);
569 mDNSPlatformMemFree(arptr);
570 return NULL;
571 }
572
573 while (ptr)
574 {
575 if (IdenticalResourceRecord(&arptr->ar.resrec, &ptr->ar.resrec)) break;
576 ptr = ptr->next;
577 }
578
579 if (!ptr) LogMsg("xD2DFindInList: Could not find in D2DRecords: %s", ARDisplayString(m, &arptr->ar));
580 mDNSPlatformMemFree(arptr);
581 return ptr;
582 }
583
584 mDNSlocal void xD2DRemoveFromCache(mDNS *const m, D2DStatus result, D2DServiceInstance instanceHandle, D2DTransportType transportType, const Byte *key, size_t keySize, const Byte *value, size_t valueSize)
585 {
586 (void)transportType; // We don't care about this, yet.
587 (void)instanceHandle; // We don't care about this, yet.
588
589 if (result == kD2DSuccess)
590 {
591 D2DRecordListElem *ptr = xD2DFindInList(m, key, keySize, value, valueSize);
592 if (ptr)
593 {
594 LogInfo("xD2DRemoveFromCache: Remove from cache: %s", ARDisplayString(m, &ptr->ar));
595 mDNS_Deregister(m, &ptr->ar);
596 }
597 }
598 else
599 LogMsg("xD2DRemoveFromCache: Unexpected result %d", result);
600 }
601
602 mDNSlocal void xD2DServiceResolved(mDNS *const m, D2DStatus result, D2DServiceInstance instanceHandle, D2DTransportType transportType, const Byte *key, size_t keySize, const Byte *value, size_t valueSize)
603 {
604 (void)m;
605 (void)key;
606 (void)keySize;
607 (void)value;
608 (void)valueSize;
609
610 if (result == kD2DSuccess)
611 {
612 LogInfo("xD2DServiceResolved: Starting up PAN connection for %p", instanceHandle);
613 if (D2DRetain) D2DRetain(instanceHandle, transportType);
614 }
615 else LogMsg("xD2DServiceResolved: Unexpected result %d", result);
616 }
617
618 mDNSlocal void xD2DRetainHappened(mDNS *const m, D2DStatus result, D2DServiceInstance instanceHandle, D2DTransportType transportType, const Byte *key, size_t keySize, const Byte *value, size_t valueSize)
619 {
620 (void)m;
621 (void)instanceHandle;
622 (void)transportType;
623 (void)key;
624 (void)keySize;
625 (void)value;
626 (void)valueSize;
627
628 if (result == kD2DSuccess) LogInfo("xD2DRetainHappened: Opening up PAN connection for %p", instanceHandle);
629 else LogMsg("xD2DRetainHappened: Unexpected result %d", result);
630 }
631
632 mDNSlocal void xD2DReleaseHappened(mDNS *const m, D2DStatus result, D2DServiceInstance instanceHandle, D2DTransportType transportType, const Byte *key, size_t keySize, const Byte *value, size_t valueSize)
633 {
634 (void)m;
635 (void)instanceHandle;
636 (void)transportType;
637 (void)key;
638 (void)keySize;
639 (void)value;
640 (void)valueSize;
641
642 if (result == kD2DSuccess) LogInfo("xD2DReleaseHappened: Closing PAN connection for %p", instanceHandle);
643 else LogMsg("xD2DReleaseHappened: Unexpected result %d", result);
644 }
645
646 mDNSlocal void xD2DServiceCallback(D2DServiceEvent event, D2DStatus result, D2DServiceInstance instanceHandle, D2DTransportType transportType, const Byte *key, size_t keySize, const Byte *value, size_t valueSize, void *userData)
647 {
648 mDNS *m = (mDNS *) userData;
649 const char *eventString = "unknown";
650
651 KQueueLock(m);
652
653 if (keySize > 0xFFFF) LogMsg("xD2DServiceCallback: keySize too large: %u", keySize);
654 if (valueSize > 0xFFFF) LogMsg("xD2DServiceCallback: valueSize too large: %u", valueSize);
655
656 switch (event)
657 {
658 case D2DServiceFound:
659 eventString = "D2DServiceFound";
660 break;
661 case D2DServiceLost:
662 eventString = "D2DServiceLost";
663 break;
664 case D2DServiceResolved:
665 eventString = "D2DServiceResolved";
666 break;
667 case D2DServiceRetained:
668 eventString = "D2DServiceRetained";
669 break;
670 case D2DServiceReleased:
671 eventString = "D2DServiceReleased";
672 break;
673 default:
674 break;
675 }
676
677 LogInfo("xD2DServiceCallback: event=%s result=%d instanceHandle=%p transportType=%d LHS=%p (%u) RHS=%p (%u) userData=%p", eventString, result, instanceHandle, transportType, key, keySize, value, valueSize, userData);
678 PrintHelper(__func__, (mDNSu8 *)key, (mDNSu16)keySize, (mDNSu8 *)value, (mDNSu16)valueSize);
679
680 switch (event)
681 {
682 case D2DServiceFound:
683 xD2DAddToCache(m, result, instanceHandle, transportType, key, keySize, value, valueSize);
684 break;
685 case D2DServiceLost:
686 xD2DRemoveFromCache(m, result, instanceHandle, transportType, key, keySize, value, valueSize);
687 break;
688 case D2DServiceResolved:
689 xD2DServiceResolved(m, result, instanceHandle, transportType, key, keySize, value, valueSize);
690 break;
691 case D2DServiceRetained:
692 xD2DRetainHappened(m, result, instanceHandle, transportType, key, keySize, value, valueSize);
693 break;
694 case D2DServiceReleased:
695 xD2DReleaseHappened(m, result, instanceHandle, transportType, key, keySize, value, valueSize);
696 break;
697 default:
698 break;
699 }
700
701 // Need to tickle the main kqueue loop to potentially handle records we removed or added.
702 KQueueUnlock(m, "xD2DServiceCallback");
703 }
704
705 // Map interface index and flags to a specific D2D transport type or D2DTransportMax if all plugins
706 // should be called.
707 // When D2DTransportMax is returned, if a specific transport should not be called, *excludedTransportType
708 // will be set to the excluded transport value, otherwise, it will be set to D2DTransportMax.
709 // If the return value is not D2DTransportMax, excludedTransportType is undefined.
710
711 mDNSlocal D2DTransportType xD2DInterfaceToTransportType(mDNSInterfaceID InterfaceID, DNSServiceFlags flags, D2DTransportType * excludedTransportType)
712 {
713 NetworkInterfaceInfoOSX *info;
714
715 // Default exludes the D2DAWDLTransport when D2DTransportMax is returned.
716 *excludedTransportType = D2DAWDLTransport;
717
718 // Call all D2D plugins when both kDNSServiceFlagsIncludeP2P and kDNSServiceFlagsIncludeAWDL are set.
719 if ((flags & kDNSServiceFlagsIncludeP2P) && (flags & kDNSServiceFlagsIncludeAWDL))
720 {
721 LogInfo("xD2DInterfaceToTransportType: returning D2DTransportMax (including AWDL) since both kDNSServiceFlagsIncludeP2P and kDNSServiceFlagsIncludeAWDL are set");
722 *excludedTransportType = D2DTransportMax;
723 return D2DTransportMax;
724 }
725 // Call all D2D plugins (exlcluding AWDL) when only kDNSServiceFlagsIncludeP2P is set.
726 else if (flags & kDNSServiceFlagsIncludeP2P)
727 {
728 LogInfo("xD2DInterfaceToTransportType: returning D2DTransportMax (excluding AWDL) since only kDNSServiceFlagsIncludeP2P is set");
729 return D2DTransportMax;
730 }
731 // Call AWDL D2D plugin when only kDNSServiceFlagsIncludeAWDL is set.
732 else if (flags & kDNSServiceFlagsIncludeAWDL)
733 {
734 LogInfo("xD2DInterfaceToTransportType: returning D2DAWDLTransport since only kDNSServiceFlagsIncludeAWDL is set");
735 return D2DAWDLTransport;
736 }
737
738 if (InterfaceID == mDNSInterface_P2P)
739 {
740 LogInfo("xD2DInterfaceToTransportType: returning D2DTransportMax (excluding AWDL) for interface index mDNSInterface_P2P");
741 return D2DTransportMax;
742 }
743
744 // Compare to cached AWDL interface ID.
745 if (AWDLInterfaceID && (InterfaceID == AWDLInterfaceID))
746 {
747 LogInfo("xD2DInterfaceToTransportType: returning D2DAWDLTransport for interface index %d", InterfaceID);
748 return D2DAWDLTransport;
749 }
750
751 info = IfindexToInterfaceInfoOSX(&mDNSStorage, InterfaceID);
752 if (info == NULL)
753 {
754 LogInfo("xD2DInterfaceToTransportType: Invalid interface index %d", InterfaceID);
755 return D2DTransportMax;
756 }
757
758 // Recognize AirDrop specific p2p* interface based on interface name.
759 if (strncmp(info->ifinfo.ifname, "p2p", 3) == 0)
760 {
761 LogInfo("xD2DInterfaceToTransportType: returning D2DWifiPeerToPeerTransport for interface index %d", InterfaceID);
762 return D2DWifiPeerToPeerTransport;
763 }
764
765 // Currently there is no way to identify Bluetooth interface by name,
766 // since they use "en*" based name strings.
767
768 LogInfo("xD2DInterfaceToTransportType: returning default D2DTransportMax for interface index %d", InterfaceID);
769 return D2DTransportMax;
770 }
771
772 mDNSexport void external_start_browsing_for_service(mDNSInterfaceID InterfaceID, const domainname *const typeDomain, DNS_TypeValues qtype, DNSServiceFlags flags)
773 {
774 domainname lower;
775
776 if (qtype == kDNSServiceType_A || qtype == kDNSServiceType_AAAA)
777 {
778 LogInfo("external_start_browsing_for_service: ignoring address record");
779 return;
780 }
781
782 DomainnameToLower(typeDomain, &lower);
783
784 if (!D2DBrowseListRefCount(&lower, qtype))
785 {
786 D2DTransportType transportType, excludedTransport;
787
788 LogInfo("external_start_browsing_for_service: Starting browse for: %##s %s", lower.c, DNSTypeName(qtype));
789 mDNSu8 *end = DNSNameCompressionBuildLHS(&lower, qtype);
790 PrintHelper(__func__, compression_lhs, end - compression_lhs, mDNSNULL, 0);
791
792 transportType = xD2DInterfaceToTransportType(InterfaceID, flags, & excludedTransport);
793 if (transportType == D2DTransportMax)
794 {
795 D2DTransportType i;
796 for (i = 0; i < D2DTransportMax; i++)
797 {
798 if (i == excludedTransport) continue;
799 if (D2DStartBrowsingForKeyOnTransport) D2DStartBrowsingForKeyOnTransport(compression_lhs, end - compression_lhs, i);
800 }
801 }
802 else
803 {
804 if (D2DStartBrowsingForKeyOnTransport) D2DStartBrowsingForKeyOnTransport(compression_lhs, end - compression_lhs, transportType);
805 }
806 }
807 D2DBrowseListRetain(&lower, qtype);
808 }
809
810 mDNSexport void external_stop_browsing_for_service(mDNSInterfaceID InterfaceID, const domainname *const typeDomain, DNS_TypeValues qtype, DNSServiceFlags flags)
811 {
812 domainname lower;
813
814 if (qtype == kDNSServiceType_A || qtype == kDNSServiceType_AAAA)
815 {
816 LogInfo("external_stop_browsing_for_service: ignoring address record");
817 return;
818 }
819
820 DomainnameToLower(typeDomain, &lower);
821
822 D2DBrowseListRelease(&lower, qtype);
823 if (!D2DBrowseListRefCount(&lower, qtype))
824 {
825 D2DTransportType transportType, excludedTransport;
826
827 LogInfo("external_stop_browsing_for_service: Stopping browse for: %##s %s", lower.c, DNSTypeName(qtype));
828 mDNSu8 *end = DNSNameCompressionBuildLHS(&lower, qtype);
829 PrintHelper(__func__, compression_lhs, end - compression_lhs, mDNSNULL, 0);
830
831 transportType = xD2DInterfaceToTransportType(InterfaceID, flags, & excludedTransport);
832 if (transportType == D2DTransportMax)
833 {
834 D2DTransportType i;
835 for (i = 0; i < D2DTransportMax; i++)
836 {
837 if (i == excludedTransport) continue;
838 if (D2DStopBrowsingForKeyOnTransport) D2DStopBrowsingForKeyOnTransport(compression_lhs, end - compression_lhs, i);
839 }
840 }
841 else
842 {
843 if (D2DStopBrowsingForKeyOnTransport) D2DStopBrowsingForKeyOnTransport(compression_lhs, end - compression_lhs, transportType);
844 }
845
846 // The D2D driver may not generate the D2DServiceLost event for this key after
847 // the D2DStopBrowsingForKey*() call above. So, we flush the key from the D2D
848 // record cache now.
849 xD2DClearCache(&lower, qtype);
850 }
851 }
852
853 mDNSexport void external_start_advertising_service(const ResourceRecord *const resourceRecord, DNSServiceFlags flags)
854 {
855 domainname lower;
856 mDNSu8 *rhs = NULL;
857 mDNSu8 *end = NULL;
858 D2DTransportType transportType, excludedTransport;
859 DomainnameToLower(resourceRecord->name, &lower);
860
861 LogInfo("external_start_advertising_service: %s", RRDisplayString(&mDNSStorage, resourceRecord));
862 // For SRV records, update packet filter if p2p interface already exists, otherwise,
863 // if will be updated when we get the KEV_DL_IF_ATTACHED event for the interface.
864 if (resourceRecord->rrtype == kDNSType_SRV)
865 mDNSUpdatePacketFilter(NULL);
866
867 rhs = DNSNameCompressionBuildLHS(&lower, resourceRecord->rrtype);
868 end = DNSNameCompressionBuildRHS(rhs, resourceRecord);
869 PrintHelper(__func__, compression_lhs, rhs - compression_lhs, rhs, end - rhs);
870
871 transportType = xD2DInterfaceToTransportType(resourceRecord->InterfaceID, flags, & excludedTransport);
872 if (transportType == D2DTransportMax)
873 {
874 D2DTransportType i;
875 for (i = 0; i < D2DTransportMax; i++)
876 {
877 if (i == excludedTransport) continue;
878 if (D2DStartAdvertisingPairOnTransport) D2DStartAdvertisingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, i);
879 }
880 }
881 else
882 {
883 if (D2DStartAdvertisingPairOnTransport) D2DStartAdvertisingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, transportType);
884 }
885 }
886
887 mDNSexport void external_stop_advertising_service(const ResourceRecord *const resourceRecord, DNSServiceFlags flags)
888 {
889 domainname lower;
890 mDNSu8 *rhs = NULL;
891 mDNSu8 *end = NULL;
892 D2DTransportType transportType, excludedTransport;
893 DomainnameToLower(resourceRecord->name, &lower);
894
895 LogInfo("external_stop_advertising_service: %s", RRDisplayString(&mDNSStorage, resourceRecord));
896
897 // For SRV records, update packet filter to to remove this port from list
898 if (resourceRecord->rrtype == kDNSType_SRV)
899 mDNSUpdatePacketFilter(resourceRecord);
900
901 rhs = DNSNameCompressionBuildLHS(&lower, resourceRecord->rrtype);
902 end = DNSNameCompressionBuildRHS(rhs, resourceRecord);
903 PrintHelper(__func__, compression_lhs, rhs - compression_lhs, rhs, end - rhs);
904
905 transportType = xD2DInterfaceToTransportType(resourceRecord->InterfaceID, flags, & excludedTransport);
906 if (transportType == D2DTransportMax)
907 {
908 D2DTransportType i;
909 for (i = 0; i < D2DTransportMax; i++)
910 {
911 if (i == excludedTransport) continue;
912 if (D2DStopAdvertisingPairOnTransport) D2DStopAdvertisingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, i);
913 }
914 }
915 else
916 {
917 if (D2DStopAdvertisingPairOnTransport) D2DStopAdvertisingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, transportType);
918 }
919 }
920
921 mDNSexport void external_start_resolving_service(mDNSInterfaceID InterfaceID, const domainname *const fqdn, DNSServiceFlags flags)
922 {
923 domainname lower;
924 mDNSu8 *rhs = NULL;
925 mDNSu8 *end = NULL;
926 mDNSBool AWDL_used = false; // whether AWDL was used for this resolve
927 D2DTransportType transportType, excludedTransport;
928 DomainnameToLower(SkipLeadingLabels(fqdn, 1), &lower);
929
930 LogInfo("external_start_resolving_service: %##s", fqdn->c);
931 rhs = DNSNameCompressionBuildLHS(&lower, kDNSType_PTR);
932 end = putDomainNameAsLabels(&compression_base_msg, rhs, compression_limit, fqdn);
933 PrintHelper(__func__, compression_lhs, rhs - compression_lhs, rhs, end - rhs);
934
935 transportType = xD2DInterfaceToTransportType(InterfaceID, flags, & excludedTransport);
936 if (transportType == D2DTransportMax)
937 {
938 // Resolving over all the transports, except for excludedTransport if set.
939 D2DTransportType i;
940 for (i = 0; i < D2DTransportMax; i++)
941 {
942 if (i == excludedTransport) continue;
943 if (D2DStartResolvingPairOnTransport) D2DStartResolvingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, i);
944
945 if (i == D2DAWDLTransport)
946 AWDL_used = true;
947 }
948 }
949 else
950 {
951 // Resolving over one specific transport.
952 if (D2DStartResolvingPairOnTransport) D2DStartResolvingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, transportType);
953
954 if (transportType == D2DAWDLTransport)
955 AWDL_used = true;
956 }
957
958 // AWDL wants the SRV and TXT record queries communicated over the D2D interface.
959 // We only want these records going to AWDL, so use AWDLInterfaceID as the
960 // interface and don't set any other flags.
961 if (AWDL_used && AWDLInterfaceID)
962 {
963 LogInfo("external_start_resolving_service: browse for TXT and SRV over AWDL");
964 external_start_browsing_for_service(AWDLInterfaceID, fqdn, kDNSType_TXT, NULL);
965 external_start_browsing_for_service(AWDLInterfaceID, fqdn, kDNSType_SRV, NULL);
966 }
967 }
968
969 mDNSexport void external_stop_resolving_service(mDNSInterfaceID InterfaceID, const domainname *const fqdn, DNSServiceFlags flags)
970 {
971 domainname lower;
972 mDNSu8 *rhs = NULL;
973 mDNSu8 *end = NULL;
974 mDNSBool AWDL_used = false; // whether AWDL was used for this resolve
975 D2DTransportType transportType, excludedTransport;
976 DomainnameToLower(SkipLeadingLabels(fqdn, 1), &lower);
977
978 LogInfo("external_stop_resolving_service: %##s", fqdn->c);
979 rhs = DNSNameCompressionBuildLHS(&lower, kDNSType_PTR);
980 end = putDomainNameAsLabels(&compression_base_msg, rhs, compression_limit, fqdn);
981 PrintHelper(__func__, compression_lhs, rhs - compression_lhs, rhs, end - rhs);
982
983 transportType = xD2DInterfaceToTransportType(InterfaceID, flags, & excludedTransport);
984 if (transportType == D2DTransportMax)
985 {
986 D2DTransportType i;
987 for (i = 0; i < D2DTransportMax; i++)
988 {
989 if (i == excludedTransport) continue;
990 if (D2DStopResolvingPairOnTransport) D2DStopResolvingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, i);
991
992 if (i == D2DAWDLTransport)
993 AWDL_used = true;
994 }
995 }
996 else
997 {
998 if (D2DStopResolvingPairOnTransport) D2DStopResolvingPairOnTransport(compression_lhs, rhs - compression_lhs, rhs, end - rhs, transportType);
999
1000 if (transportType == D2DAWDLTransport)
1001 AWDL_used = true;
1002 }
1003
1004 // AWDL wants the SRV and TXT record queries communicated over the D2D interface.
1005 // We only want these records going to AWDL, so use AWDLInterfaceID as the
1006 // interface and don't set any other flags.
1007 if (AWDL_used && AWDLInterfaceID)
1008 {
1009 LogInfo("external_stop_resolving_service: stop browse for TXT and SRV on AWDL");
1010 external_stop_browsing_for_service(AWDLInterfaceID, fqdn, kDNSType_TXT, NULL);
1011 external_stop_browsing_for_service(AWDLInterfaceID, fqdn, kDNSType_SRV, NULL);
1012 }
1013 }
1014
1015 #elif APPLE_OSX_mDNSResponder
1016
1017 mDNSexport void external_start_browsing_for_service(mDNS *const m, const domainname *const type, DNS_TypeValues qtype, DNSServiceFlags flags) { (void)m; (void)type; (void)qtype; (void)flags;}
1018 mDNSexport void external_stop_browsing_for_service(mDNS *const m, const domainname *const type, DNS_TypeValues qtype, DNSServiceFlags flags) { (void)m; (void)type; (void)qtype; (void)flags;}
1019 mDNSexport void external_start_advertising_service(const ResourceRecord *const resourceRecord, DNSServiceFlags flags) { (void)resourceRecord; (void)flags;}
1020 mDNSexport void external_stop_advertising_service(const ResourceRecord *const resourceRecord, DNSServiceFlags flags) { (void)resourceRecord; (void)flags;}
1021 mDNSexport void external_start_resolving_service(const domainname *const fqdn, DNSServiceFlags flags) { (void)fqdn; (void)flags;}
1022 mDNSexport void external_stop_resolving_service(const domainname *const fqdn, DNSServiceFlags flags) { (void)fqdn; (void)flags;}
1023
1024 #endif // ! NO_D2D
1025
1026 // ***************************************************************************
1027 // Functions
1028
1029 #if COMPILER_LIKES_PRAGMA_MARK
1030 #pragma mark -
1031 #pragma mark - Utility Functions
1032 #endif
1033
1034 // We only attempt to send and receive multicast packets on interfaces that are
1035 // (a) flagged as multicast-capable
1036 // (b) *not* flagged as point-to-point (e.g. modem)
1037 // Typically point-to-point interfaces are modems (including mobile-phone pseudo-modems), and we don't want
1038 // to run up the user's bill sending multicast traffic over a link where there's only a single device at the
1039 // other end, and that device (e.g. a modem bank) is probably not answering Multicast DNS queries anyway.
1040 #define MulticastInterface(i) (((i)->ifa_flags & IFF_MULTICAST) && !((i)->ifa_flags & IFF_POINTOPOINT))
1041
1042 mDNSexport void NotifyOfElusiveBug(const char *title, const char *msg) // Both strings are UTF-8 text
1043 {
1044 static int notifyCount = 0;
1045 if (notifyCount) return;
1046
1047 // If we display our alert early in the boot process, then it vanishes once the desktop appears.
1048 // To avoid this, we don't try to display alerts in the first three minutes after boot.
1049 if ((mDNSu32)(mDNSPlatformRawTime()) < (mDNSu32)(mDNSPlatformOneSecond * 180)) return;
1050
1051 // Unless ForceAlerts is defined, we only show these bug report alerts on machines that have a 17.x.x.x address
1052 #if !ForceAlerts
1053 {
1054 // Determine if we're at Apple (17.*.*.*)
1055 NetworkInterfaceInfoOSX *i;
1056 for (i = mDNSStorage.p->InterfaceList; i; i = i->next)
1057 if (i->ifinfo.ip.type == mDNSAddrType_IPv4 && i->ifinfo.ip.ip.v4.b[0] == 17)
1058 break;
1059 if (!i) return; // If not at Apple, don't show the alert
1060 }
1061 #endif
1062
1063 LogMsg("%s", title);
1064 LogMsg("%s", msg);
1065 // Display a notification to the user
1066 notifyCount++;
1067
1068 #ifndef NO_CFUSERNOTIFICATION
1069 mDNSNotify(title, msg);
1070 #endif /* NO_CFUSERNOTIFICATION */
1071 }
1072
1073 // Returns true if it is an AppleTV based hardware running iOS, false otherwise
1074 mDNSlocal mDNSBool IsAppleTV(void)
1075 {
1076 #if TARGET_OS_EMBEDDED
1077 static mDNSBool sInitialized = mDNSfalse;
1078 static mDNSBool sIsAppleTV = mDNSfalse;
1079 CFStringRef deviceClass = NULL;
1080
1081 if(!sInitialized)
1082 {
1083 deviceClass = (CFStringRef) MGCopyAnswer(kMGQDeviceClass, NULL);
1084 if(deviceClass)
1085 {
1086 if(CFEqual(deviceClass, kMGDeviceClassAppleTV))
1087 sIsAppleTV = mDNStrue;
1088 CFRelease(deviceClass);
1089 }
1090 sInitialized = mDNStrue;
1091 }
1092 return(sIsAppleTV);
1093 #else
1094 return mDNSfalse;
1095 #endif // TARGET_OS_EMBEDDED
1096 }
1097
1098 mDNSlocal struct ifaddrs *myGetIfAddrs(int refresh)
1099 {
1100 static struct ifaddrs *ifa = NULL;
1101
1102 if (refresh && ifa)
1103 {
1104 freeifaddrs(ifa);
1105 ifa = NULL;
1106 }
1107
1108 if (ifa == NULL)
1109 getifaddrs(&ifa);
1110 return ifa;
1111 }
1112
1113 mDNSlocal void DynamicStoreWrite(int key, const char* subkey, uintptr_t value, signed long valueCnt)
1114 {
1115 CFStringRef sckey = NULL;
1116 Boolean release_sckey = FALSE;
1117 CFDataRef bytes = NULL;
1118 CFPropertyListRef plist = NULL;
1119 SCDynamicStoreRef store = NULL;
1120
1121 switch ((enum mDNSDynamicStoreSetConfigKey)key)
1122 {
1123 case kmDNSMulticastConfig:
1124 sckey = CFSTR("State:/Network/" kDNSServiceCompMulticastDNS);
1125 break;
1126 case kmDNSDynamicConfig:
1127 sckey = CFSTR("State:/Network/DynamicDNS");
1128 break;
1129 case kmDNSPrivateConfig:
1130 sckey = CFSTR("State:/Network/" kDNSServiceCompPrivateDNS);
1131 break;
1132 case kmDNSBackToMyMacConfig:
1133 sckey = CFSTR("State:/Network/BackToMyMac");
1134 break;
1135 case kmDNSSleepProxyServersState:
1136 {
1137 CFMutableStringRef tmp = CFStringCreateMutable(kCFAllocatorDefault, 0);
1138 CFStringAppend(tmp, CFSTR("State:/Network/Interface/"));
1139 CFStringAppendCString(tmp, subkey, kCFStringEncodingUTF8);
1140 CFStringAppend(tmp, CFSTR("/SleepProxyServers"));
1141 sckey = CFStringCreateCopy(kCFAllocatorDefault, tmp);
1142 release_sckey = TRUE;
1143 CFRelease(tmp);
1144 break;
1145 }
1146 case kmDNSDebugState:
1147 sckey = CFSTR("State:/Network/mDNSResponder/DebugState");
1148 break;
1149 default:
1150 LogMsg("unrecognized key %d", key);
1151 goto fin;
1152 }
1153 if (NULL == (bytes = CFDataCreateWithBytesNoCopy(NULL, (void *)value,
1154 valueCnt, kCFAllocatorNull)))
1155 {
1156 LogMsg("CFDataCreateWithBytesNoCopy of value failed");
1157 goto fin;
1158 }
1159 if (NULL == (plist = CFPropertyListCreateFromXMLData(NULL, bytes,
1160 kCFPropertyListImmutable, NULL)))
1161 {
1162 LogMsg("CFPropertyListCreateFromXMLData of bytes failed");
1163 goto fin;
1164 }
1165 CFRelease(bytes);
1166 bytes = NULL;
1167 if (NULL == (store = SCDynamicStoreCreate(NULL,
1168 CFSTR(kmDNSResponderServName), NULL, NULL)))
1169 {
1170 LogMsg("SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
1171 goto fin;
1172 }
1173 SCDynamicStoreSetValue(store, sckey, plist);
1174
1175 fin:
1176 if (NULL != bytes)
1177 CFRelease(bytes);
1178 if (NULL != plist)
1179 CFRelease(plist);
1180 if (NULL != store)
1181 CFRelease(store);
1182 if (release_sckey && sckey)
1183 CFRelease(sckey);
1184 }
1185
1186 mDNSexport void mDNSDynamicStoreSetConfig(int key, const char *subkey, CFPropertyListRef value)
1187 {
1188 CFPropertyListRef valueCopy;
1189 char *subkeyCopy = NULL;
1190 if (!value)
1191 return;
1192
1193 // We need to copy the key and value before we dispatch off the block below as the
1194 // caller will free the memory once we return from this function.
1195 valueCopy = CFPropertyListCreateDeepCopy(NULL, value, kCFPropertyListImmutable);
1196 if (!valueCopy)
1197 {
1198 LogMsg("mDNSDynamicStoreSetConfig: ERROR valueCopy NULL");
1199 return;
1200 }
1201 if (subkey)
1202 {
1203 int len = strlen(subkey);
1204 subkeyCopy = mDNSPlatformMemAllocate(len + 1);
1205 if (!subkeyCopy)
1206 {
1207 LogMsg("mDNSDynamicStoreSetConfig: ERROR subkeyCopy NULL");
1208 return;
1209 }
1210 mDNSPlatformMemCopy(subkeyCopy, subkey, len);
1211 subkeyCopy[len] = 0;
1212 }
1213
1214 dispatch_async(DynamicStoreQueue, ^{
1215 CFWriteStreamRef stream = NULL;
1216 CFDataRef bytes = NULL;
1217 CFStringRef error;
1218 CFIndex ret;
1219
1220 if (NULL == (stream = CFWriteStreamCreateWithAllocatedBuffers(NULL, NULL)))
1221 {
1222 LogMsg("mDNSDynamicStoreSetConfig : CFWriteStreamCreateWithAllocatedBuffers failed (Object creation failed)");
1223 goto END;
1224 }
1225 CFWriteStreamOpen(stream);
1226 ret = CFPropertyListWriteToStream(valueCopy, stream, kCFPropertyListBinaryFormat_v1_0, &error);
1227 if (ret == 0)
1228 {
1229 LogMsg("mDNSDynamicStoreSetConfig : CFPropertyListWriteToStream failed (Could not write property list to stream)");
1230 goto END;
1231 }
1232 if (NULL == (bytes = CFWriteStreamCopyProperty(stream, kCFStreamPropertyDataWritten)))
1233 {
1234 LogMsg("mDNSDynamicStoreSetConfig : CFWriteStreamCopyProperty failed (Object creation failed) ");
1235 goto END;
1236 }
1237 CFWriteStreamClose(stream);
1238 CFRelease(stream);
1239 stream = NULL;
1240 LogInfo("mDNSDynamicStoreSetConfig: key %d subkey %s", key, subkeyCopy);
1241 DynamicStoreWrite(key, subkeyCopy ? subkeyCopy : "", (uintptr_t)CFDataGetBytePtr(bytes), CFDataGetLength(bytes));
1242
1243 END:
1244 CFRelease(valueCopy);
1245 if (NULL != stream)
1246 {
1247 CFWriteStreamClose(stream);
1248 CFRelease(stream);
1249 }
1250 if (NULL != bytes)
1251 CFRelease(bytes);
1252 if (subkeyCopy)
1253 mDNSPlatformMemFree(subkeyCopy);
1254 });
1255 }
1256
1257 // To match *either* a v4 or v6 instance of this interface name, pass AF_UNSPEC for type
1258 mDNSlocal NetworkInterfaceInfoOSX *SearchForInterfaceByName(mDNS *const m, const char *ifname, int type)
1259 {
1260 NetworkInterfaceInfoOSX *i;
1261 for (i = m->p->InterfaceList; i; i = i->next)
1262 if (i->Exists && !strcmp(i->ifinfo.ifname, ifname) &&
1263 ((type == AF_UNSPEC ) ||
1264 (type == AF_INET && i->ifinfo.ip.type == mDNSAddrType_IPv4) ||
1265 (type == AF_INET6 && i->ifinfo.ip.type == mDNSAddrType_IPv6))) return(i);
1266 return(NULL);
1267 }
1268
1269 #if TARGET_OS_EMBEDDED
1270 mDNSlocal SCPreferencesRef mDNSManagedPrefsGet(void)
1271 {
1272 SCPreferencesRef smDNSManagedPrefs = NULL;
1273 smDNSManagedPrefs = SCPreferencesCreate(kCFAllocatorDefault, CFSTR("mDNSManagedPrefs"), kmDNSResponderManagedPrefsID);
1274
1275 return (smDNSManagedPrefs);
1276 }
1277
1278 mDNSlocal mDNSBool GetmDNSManagedPrefKeyVal(SCPreferencesRef prefs, CFStringRef key)
1279 {
1280 mDNSBool val = mDNSfalse;
1281 CFBooleanRef val_cf = NULL;
1282
1283 if (prefs != NULL)
1284 {
1285 val_cf = SCPreferencesGetValue(prefs, key);
1286 if (isA_CFBoolean(val_cf) != NULL)
1287 val = CFBooleanGetValue(val_cf); //When mDNSResponder-Debug-profile is Installed
1288 else
1289 val = mDNSfalse; //When mDNSResponder-Debug-profile is Uninstalled
1290 }
1291 else
1292 {
1293 LogMsg("GetmDNSManagedPrefKeyVal: mDNSManagedPrefs are NULL!");
1294 val = mDNSfalse;
1295 }
1296 if (val_cf)
1297 CFRelease(val_cf);
1298 return (val);
1299 }
1300
1301 mDNSexport mDNSBool GetmDNSManagedPref(CFStringRef key)
1302 {
1303 SCPreferencesRef managed = NULL;
1304 mDNSBool ret_value;
1305
1306 managed = mDNSManagedPrefsGet();
1307 ret_value = GetmDNSManagedPrefKeyVal(managed, key);
1308
1309 if (managed)
1310 CFRelease(managed);
1311 return (ret_value);
1312 }
1313 #endif //TARGET_OS_EMBEDDED
1314
1315 mDNSlocal int myIfIndexToName(u_short ifindex, char *name)
1316 {
1317 struct ifaddrs *ifa;
1318 for (ifa = myGetIfAddrs(0); ifa; ifa = ifa->ifa_next)
1319 if (ifa->ifa_addr->sa_family == AF_LINK)
1320 if (((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index == ifindex)
1321 { strlcpy(name, ifa->ifa_name, IF_NAMESIZE); return 0; }
1322 return -1;
1323 }
1324
1325 mDNSexport NetworkInterfaceInfoOSX *IfindexToInterfaceInfoOSX(const mDNS *const m, mDNSInterfaceID ifindex)
1326 {
1327 mDNSu32 scope_id = (mDNSu32)(uintptr_t)ifindex;
1328 NetworkInterfaceInfoOSX *i;
1329
1330 // Don't get tricked by inactive interfaces
1331 for (i = m->p->InterfaceList; i; i = i->next)
1332 if (i->Registered && i->scope_id == scope_id) return(i);
1333
1334 return mDNSNULL;
1335 }
1336
1337 mDNSexport mDNSInterfaceID mDNSPlatformInterfaceIDfromInterfaceIndex(mDNS *const m, mDNSu32 ifindex)
1338 {
1339 if (ifindex == kDNSServiceInterfaceIndexLocalOnly) return(mDNSInterface_LocalOnly);
1340 if (ifindex == kDNSServiceInterfaceIndexP2P ) return(mDNSInterface_P2P);
1341 if (ifindex == kDNSServiceInterfaceIndexAny ) return(mDNSNULL);
1342
1343 NetworkInterfaceInfoOSX* ifi = IfindexToInterfaceInfoOSX(m, (mDNSInterfaceID)(uintptr_t)ifindex);
1344 if (!ifi)
1345 {
1346 // Not found. Make sure our interface list is up to date, then try again.
1347 LogInfo("mDNSPlatformInterfaceIDfromInterfaceIndex: InterfaceID for interface index %d not found; Updating interface list", ifindex);
1348 mDNSMacOSXNetworkChanged(m);
1349 ifi = IfindexToInterfaceInfoOSX(m, (mDNSInterfaceID)(uintptr_t)ifindex);
1350 }
1351
1352 if (!ifi) return(mDNSNULL);
1353
1354 return(ifi->ifinfo.InterfaceID);
1355 }
1356
1357
1358 mDNSexport mDNSu32 mDNSPlatformInterfaceIndexfromInterfaceID(mDNS *const m, mDNSInterfaceID id, mDNSBool suppressNetworkChange)
1359 {
1360 NetworkInterfaceInfoOSX *i;
1361 if (id == mDNSInterface_LocalOnly) return(kDNSServiceInterfaceIndexLocalOnly);
1362 if (id == mDNSInterface_P2P ) return(kDNSServiceInterfaceIndexP2P);
1363 if (id == mDNSInterface_Any ) return(0);
1364
1365 mDNSu32 scope_id = (mDNSu32)(uintptr_t)id;
1366
1367 // Don't use i->Registered here, because we DO want to find inactive interfaces, which have no Registered set
1368 for (i = m->p->InterfaceList; i; i = i->next)
1369 if (i->scope_id == scope_id) return(i->scope_id);
1370
1371 // If we are supposed to suppress network change, return "id" back
1372 if (suppressNetworkChange) return scope_id;
1373
1374 // Not found. Make sure our interface list is up to date, then try again.
1375 LogInfo("Interface index for InterfaceID %p not found; Updating interface list", id);
1376 mDNSMacOSXNetworkChanged(m);
1377 for (i = m->p->InterfaceList; i; i = i->next)
1378 if (i->scope_id == scope_id) return(i->scope_id);
1379
1380 return(0);
1381 }
1382
1383 #if APPLE_OSX_mDNSResponder
1384 mDNSexport void mDNSASLLog(uuid_t *uuid, const char *subdomain, const char *result, const char *signature, const char *fmt, ...)
1385 {
1386 if (iOSVers)
1387 return; // No ASL on iOS
1388
1389 static char buffer[512];
1390 aslmsg asl_msg = asl_new(ASL_TYPE_MSG);
1391
1392 if (!asl_msg) { LogMsg("mDNSASLLog: asl_new failed"); return; }
1393 if (uuid)
1394 {
1395 char uuidStr[37];
1396 uuid_unparse(*uuid, uuidStr);
1397 asl_set (asl_msg, "com.apple.message.uuid", uuidStr);
1398 }
1399
1400 static char domainBase[] = "com.apple.mDNSResponder.%s";
1401 mDNS_snprintf (buffer, sizeof(buffer), domainBase, subdomain);
1402 asl_set (asl_msg, "com.apple.message.domain", buffer);
1403
1404 if (result) asl_set(asl_msg, "com.apple.message.result", result);
1405 if (signature) asl_set(asl_msg, "com.apple.message.signature", signature);
1406
1407 va_list ptr;
1408 va_start(ptr,fmt);
1409 mDNS_vsnprintf(buffer, sizeof(buffer), fmt, ptr);
1410 va_end(ptr);
1411
1412 int old_filter = asl_set_filter(NULL,ASL_FILTER_MASK_UPTO(ASL_LEVEL_DEBUG));
1413 asl_log(NULL, asl_msg, ASL_LEVEL_DEBUG, "%s", buffer);
1414 asl_set_filter(NULL, old_filter);
1415 asl_free(asl_msg);
1416 }
1417
1418
1419 mDNSlocal void mDNSLogDNSSECStatistics(mDNS *const m)
1420 {
1421 char buffer[16];
1422
1423 aslmsg aslmsg = asl_new(ASL_TYPE_MSG);
1424
1425 // If we failed to allocate an aslmsg structure, keep accumulating
1426 // the statistics and try again at the next log interval.
1427 if (!aslmsg)
1428 {
1429 LogMsg("mDNSLogDNSSECStatistics: asl_new() failed!");
1430 return;
1431 }
1432
1433 asl_set(aslmsg,"com.apple.message.domain", "com.apple.mDNSResponder.DNSSECstatistics");
1434
1435 if (m->rrcache_totalused_unicast)
1436 {
1437 mDNS_snprintf(buffer, sizeof(buffer), "%u", (mDNSu32) ((unsigned long)(m->DNSSECStats.TotalMemUsed * 100))/m->rrcache_totalused_unicast);
1438 }
1439 else
1440 {
1441 LogMsg("mDNSLogDNSSECStatistics: unicast is zero");
1442 buffer[0] = 0;
1443 }
1444 asl_set(aslmsg,"com.apple.message.MemUsage", buffer);
1445
1446 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.Latency0);
1447 asl_set(aslmsg,"com.apple.message.Latency0", buffer);
1448 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.Latency10);
1449 asl_set(aslmsg,"com.apple.message.Latency10", buffer);
1450 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.Latency20);
1451 asl_set(aslmsg,"com.apple.message.Latency20", buffer);
1452 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.Latency50);
1453 asl_set(aslmsg,"com.apple.message.Latency50", buffer);
1454 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.Latency100);
1455 asl_set(aslmsg,"com.apple.message.Latency100", buffer);
1456
1457 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.ExtraPackets0);
1458 asl_set(aslmsg,"com.apple.message.ExtraPackets0", buffer);
1459 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.ExtraPackets3);
1460 asl_set(aslmsg,"com.apple.message.ExtraPackets3", buffer);
1461 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.ExtraPackets7);
1462 asl_set(aslmsg,"com.apple.message.ExtraPackets7", buffer);
1463 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.ExtraPackets10);
1464 asl_set(aslmsg,"com.apple.message.ExtraPackets10", buffer);
1465
1466 // Ignore IndeterminateStatus as we don't log them
1467 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.SecureStatus);
1468 asl_set(aslmsg,"com.apple.message.SecureStatus", buffer);
1469 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.InsecureStatus);
1470 asl_set(aslmsg,"com.apple.message.InsecureStatus", buffer);
1471 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.BogusStatus);
1472 asl_set(aslmsg,"com.apple.message.BogusStatus", buffer);
1473 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.NoResponseStatus);
1474 asl_set(aslmsg,"com.apple.message.NoResponseStatus", buffer);
1475
1476 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.NumProbesSent);
1477 asl_set(aslmsg,"com.apple.message.NumProbesSent", buffer);
1478 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.MsgSize0);
1479 asl_set(aslmsg,"com.apple.message.MsgSize0", buffer);
1480 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.MsgSize1);
1481 asl_set(aslmsg,"com.apple.message.MsgSize1", buffer);
1482 mDNS_snprintf(buffer, sizeof(buffer), "%u", m->DNSSECStats.MsgSize2);
1483 asl_set(aslmsg,"com.apple.message.MsgSize2", buffer);
1484
1485 asl_log(NULL, aslmsg, ASL_LEVEL_NOTICE, "");
1486 asl_free(aslmsg);
1487 }
1488
1489 // Calculate packets per hour given total packet count and interval in seconds.
1490 // Cast one term of multiplication to (long) to use 64-bit arithmetic
1491 // and avoid a potential 32-bit overflow prior to the division.
1492 #define ONE_HOUR 3600
1493 #define PACKET_RATE(PACKETS, INTERVAL) (int)(((long) (PACKETS) * ONE_HOUR)/(INTERVAL))
1494
1495 // Put packet rate data in discrete buckets.
1496 mDNSlocal int mDNSBucketData(int inputData, int interval)
1497 {
1498 if (!interval)
1499 {
1500 LogMsg("mDNSBucketData: interval is zero!");
1501 return 0;
1502 }
1503
1504 int ratePerHour = PACKET_RATE(inputData, interval);
1505 int bucket;
1506
1507 if (ratePerHour == 0)
1508 bucket = 0;
1509 else if (ratePerHour <= 10)
1510 bucket = 10;
1511 else if (ratePerHour <= 100)
1512 bucket = 100;
1513 else if (ratePerHour <= 1000)
1514 bucket = 1000;
1515 else if (ratePerHour <= 5000)
1516 bucket = 5000;
1517 else if (ratePerHour <= 10000)
1518 bucket = 10000;
1519 else if (ratePerHour <= 50000)
1520 bucket = 50000;
1521 else if (ratePerHour <= 100000)
1522 bucket = 100000;
1523 else if (ratePerHour <= 250000)
1524 bucket = 250000;
1525 else if (ratePerHour <= 500000)
1526 bucket = 500000;
1527 else
1528 bucket = 1000000;
1529
1530 return bucket;
1531 }
1532
1533 mDNSlocal void mDNSLogBonjourStatistics(mDNS *const m)
1534 {
1535 static mDNSs32 last_PktNum, last_MPktNum;
1536 static mDNSs32 last_UnicastPacketsSent, last_MulticastPacketsSent;
1537 static mDNSs32 last_RemoteSubnet;
1538
1539 mDNSs32 interval;
1540 char buffer[16];
1541 mDNSs32 inMulticast = m->MPktNum - last_MPktNum;
1542 mDNSs32 inUnicast = m->PktNum - last_PktNum - inMulticast;
1543 mDNSs32 outUnicast = m->UnicastPacketsSent - last_UnicastPacketsSent;
1544 mDNSs32 outMulticast = m->MulticastPacketsSent - last_MulticastPacketsSent;
1545 mDNSs32 remoteSubnet = m->RemoteSubnet - last_RemoteSubnet;
1546
1547
1548 // save starting values for new interval
1549 last_PktNum = m->PktNum;
1550 last_MPktNum = m->MPktNum;
1551 last_UnicastPacketsSent = m->UnicastPacketsSent;
1552 last_MulticastPacketsSent = m->MulticastPacketsSent;
1553 last_RemoteSubnet = m->RemoteSubnet;
1554
1555 // Need a non-zero active time interval.
1556 if (!m->ActiveStatTime)
1557 return;
1558
1559 // Round interval time to nearest hour boundary. Less then 30 minutes rounds to zero.
1560 interval = (m->ActiveStatTime + ONE_HOUR/2)/ONE_HOUR;
1561
1562 // Use a minimum of 30 minutes of awake time to calculate average packet rates.
1563 // The rounded awake interval should not be greater than the rounded reporting
1564 // interval.
1565 if ((interval == 0) || (interval > (kDefaultNextStatsticsLogTime + ONE_HOUR/2)/ONE_HOUR))
1566 return;
1567
1568 aslmsg aslmsg = asl_new(ASL_TYPE_MSG);
1569
1570 if (!aslmsg)
1571 {
1572 LogMsg("mDNSLogBonjourStatistics: asl_new() failed!");
1573 return;
1574 }
1575 // log in MessageTracer format
1576 asl_set(aslmsg,"com.apple.message.domain", "com.apple.mDNSResponder.statistics");
1577
1578 snprintf(buffer, sizeof(buffer), "%d", interval);
1579 asl_set(aslmsg,"com.apple.message.interval", buffer);
1580
1581 // log the packet rates as packets per hour
1582 snprintf(buffer, sizeof(buffer), "%d",
1583 mDNSBucketData(inUnicast, m->ActiveStatTime));
1584 asl_set(aslmsg,"com.apple.message.UnicastIn", buffer);
1585
1586 snprintf(buffer, sizeof(buffer), "%d",
1587 mDNSBucketData(inMulticast, m->ActiveStatTime));
1588 asl_set(aslmsg,"com.apple.message.MulticastIn", buffer);
1589
1590 snprintf(buffer, sizeof(buffer), "%d",
1591 mDNSBucketData(outUnicast, m->ActiveStatTime));
1592 asl_set(aslmsg,"com.apple.message.UnicastOut", buffer);
1593
1594 snprintf(buffer, sizeof(buffer), "%d",
1595 mDNSBucketData(outMulticast, m->ActiveStatTime));
1596 asl_set(aslmsg,"com.apple.message.MulticastOut", buffer);
1597
1598 snprintf(buffer, sizeof(buffer), "%d",
1599 mDNSBucketData(remoteSubnet, m->ActiveStatTime));
1600 asl_set(aslmsg,"com.apple.message.RemoteSubnet", buffer);
1601
1602 asl_log(NULL, aslmsg, ASL_LEVEL_NOTICE, "");
1603
1604 asl_free(aslmsg);
1605 }
1606
1607 // Log multicast and unicast traffic statistics to MessageTracer on OSX
1608 mDNSexport void mDNSLogStatistics(mDNS *const m)
1609 {
1610 // MessageTracer only available on OSX
1611 if (iOSVers)
1612 return;
1613
1614 mDNSs32 currentUTC = mDNSPlatformUTC();
1615
1616 // log runtime statistics
1617 if ((currentUTC - m->NextStatLogTime) >= 0)
1618 {
1619 m->NextStatLogTime = currentUTC + kDefaultNextStatsticsLogTime;
1620 // If StatStartTime is zero, it hasn't been reinitialized yet
1621 // in the wakeup code path.
1622 if (m->StatStartTime)
1623 {
1624 m->ActiveStatTime += currentUTC - m->StatStartTime;
1625 }
1626
1627 // Only log statistics if we have recorded some active time during
1628 // this statistics interval.
1629 if (m->ActiveStatTime)
1630 {
1631 mDNSLogBonjourStatistics(m);
1632 mDNSLogDNSSECStatistics(m);
1633 }
1634
1635 // Start a new statistics gathering interval.
1636 m->StatStartTime = currentUTC;
1637 m->ActiveStatTime = 0;
1638 }
1639 }
1640
1641 #endif // APPLE_OSX_mDNSResponder
1642
1643 #if COMPILER_LIKES_PRAGMA_MARK
1644 #pragma mark -
1645 #pragma mark - UDP & TCP send & receive
1646 #endif
1647
1648 mDNSlocal mDNSBool AddrRequiresPPPConnection(const struct sockaddr *addr)
1649 {
1650 mDNSBool result = mDNSfalse;
1651 SCNetworkConnectionFlags flags;
1652 CFDataRef remote_addr;
1653 CFMutableDictionaryRef options;
1654 SCNetworkReachabilityRef ReachRef = NULL;
1655
1656 options = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1657 remote_addr = CFDataCreate(NULL, (const UInt8 *)addr, addr->sa_len);
1658 CFDictionarySetValue(options, kSCNetworkReachabilityOptionRemoteAddress, remote_addr);
1659 CFDictionarySetValue(options, kSCNetworkReachabilityOptionServerBypass, kCFBooleanTrue);
1660 ReachRef = SCNetworkReachabilityCreateWithOptions(kCFAllocatorDefault, options);
1661 CFRelease(options);
1662 CFRelease(remote_addr);
1663
1664 if (!ReachRef)
1665 {
1666 LogMsg("ERROR: RequiresConnection - SCNetworkReachabilityCreateWithOptions");
1667 goto end;
1668 }
1669 if (!SCNetworkReachabilityGetFlags(ReachRef, &flags))
1670 {
1671 LogMsg("ERROR: AddrRequiresPPPConnection - SCNetworkReachabilityGetFlags");
1672 goto end;
1673 }
1674 result = flags & kSCNetworkFlagsConnectionRequired;
1675
1676 end:
1677 if (ReachRef)
1678 CFRelease(ReachRef);
1679 return result;
1680 }
1681
1682 // Set traffic class for socket
1683 mDNSlocal void setTrafficClass(int socketfd, mDNSBool useBackgroundTrafficClass)
1684 {
1685 int traffic_class;
1686
1687 if (useBackgroundTrafficClass)
1688 traffic_class = SO_TC_BK_SYS;
1689 else
1690 traffic_class = SO_TC_CTL;
1691
1692 (void) setsockopt(socketfd, SOL_SOCKET, SO_TRAFFIC_CLASS, (void *)&traffic_class, sizeof(traffic_class));
1693 }
1694
1695 mDNSexport void mDNSPlatformSetDelegatePID(UDPSocket *src, const mDNSAddr *dst, DNSQuestion *q)
1696 {
1697 if (src)
1698 {
1699 int s;
1700
1701 if (dst->type == mDNSAddrType_IPv4)
1702 {
1703 s = src->ss.sktv4;
1704 }
1705 else
1706 {
1707 s = src->ss.sktv6;
1708 }
1709
1710 if (q->pid)
1711 {
1712 if (setsockopt(s, SOL_SOCKET, SO_DELEGATED, &q->pid, sizeof(q->pid)) == -1)
1713 {
1714 LogInfo("mDNSPlatformSetDelegatePID: Delegate PID failed %s for PID %d", strerror(errno), q->pid);
1715 }
1716 }
1717 else
1718 {
1719 if (setsockopt(s, SOL_SOCKET, SO_DELEGATED_UUID, &q->uuid, sizeof(q->uuid)) == -1)
1720 {
1721 LogInfo("mDNSPlatformSetDelegatePID: Delegate UUID failed %s", strerror(errno));
1722 }
1723 }
1724 }
1725 }
1726
1727 // Note: If InterfaceID is NULL, it means, "send this packet through our anonymous unicast socket"
1728 // Note: If InterfaceID is non-NULL it means, "send this packet through our port 5353 socket on the specified interface"
1729 // OR send via our primary v4 unicast socket
1730 // UPDATE: The UDPSocket *src parameter now allows the caller to specify the source socket
1731 mDNSexport mStatus mDNSPlatformSendUDP(const mDNS *const m, const void *const msg, const mDNSu8 *const end,
1732 mDNSInterfaceID InterfaceID, UDPSocket *src, const mDNSAddr *dst,
1733 mDNSIPPort dstPort, mDNSBool useBackgroundTrafficClass)
1734 {
1735 NetworkInterfaceInfoOSX *info = mDNSNULL;
1736 struct sockaddr_storage to;
1737 int s = -1, err;
1738 mStatus result = mStatus_NoError;
1739
1740 if (InterfaceID)
1741 {
1742 info = IfindexToInterfaceInfoOSX(m, InterfaceID);
1743 if (info == NULL)
1744 {
1745 // We may not have registered interfaces with the "core" as we may not have
1746 // seen any interface notifications yet. This typically happens during wakeup
1747 // where we might try to send DNS requests (non-SuppressUnusable questions internal
1748 // to mDNSResponder) before we receive network notifications.
1749 LogInfo("mDNSPlatformSendUDP: Invalid interface index %p", InterfaceID);
1750 return mStatus_BadParamErr;
1751 }
1752 }
1753
1754 char *ifa_name = InterfaceID ? info->ifinfo.ifname : "unicast";
1755
1756 if (dst->type == mDNSAddrType_IPv4)
1757 {
1758 struct sockaddr_in *sin_to = (struct sockaddr_in*)&to;
1759 sin_to->sin_len = sizeof(*sin_to);
1760 sin_to->sin_family = AF_INET;
1761 sin_to->sin_port = dstPort.NotAnInteger;
1762 sin_to->sin_addr.s_addr = dst->ip.v4.NotAnInteger;
1763 s = (src ? src->ss : m->p->permanentsockets).sktv4;
1764
1765 if (info) // Specify outgoing interface
1766 {
1767 if (!mDNSAddrIsDNSMulticast(dst))
1768 {
1769 #ifdef IP_BOUND_IF
1770 if (info->scope_id == 0)
1771 LogInfo("IP_BOUND_IF socket option not set -- info %p (%s) scope_id is zero", info, ifa_name);
1772 else
1773 setsockopt(s, IPPROTO_IP, IP_BOUND_IF, &info->scope_id, sizeof(info->scope_id));
1774 #else
1775 {
1776 static int displayed = 0;
1777 if (displayed < 1000)
1778 {
1779 displayed++;
1780 LogInfo("IP_BOUND_IF socket option not defined -- cannot specify interface for unicast packets");
1781 }
1782 }
1783 #endif
1784 }
1785 else
1786 #ifdef IP_MULTICAST_IFINDEX
1787 {
1788 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_IFINDEX, &info->scope_id, sizeof(info->scope_id));
1789 // We get an error when we compile on a machine that supports this option and run the binary on
1790 // a different machine that does not support it
1791 if (err < 0)
1792 {
1793 if (errno != ENOPROTOOPT) LogInfo("mDNSPlatformSendUDP: setsockopt: IP_MUTLTICAST_IFINDEX returned %d", errno);
1794 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, &info->ifa_v4addr, sizeof(info->ifa_v4addr));
1795 if (err < 0 && !m->p->NetworkChanged)
1796 LogMsg("setsockopt - IP_MULTICAST_IF error %.4a %d errno %d (%s)", &info->ifa_v4addr, err, errno, strerror(errno));
1797 }
1798 }
1799 #else
1800 {
1801 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, &info->ifa_v4addr, sizeof(info->ifa_v4addr));
1802 if (err < 0 && !m->p->NetworkChanged)
1803 LogMsg("setsockopt - IP_MULTICAST_IF error %.4a %d errno %d (%s)", &info->ifa_v4addr, err, errno, strerror(errno));
1804
1805 }
1806 #endif
1807 }
1808 }
1809
1810 else if (dst->type == mDNSAddrType_IPv6)
1811 {
1812 struct sockaddr_in6 *sin6_to = (struct sockaddr_in6*)&to;
1813 sin6_to->sin6_len = sizeof(*sin6_to);
1814 sin6_to->sin6_family = AF_INET6;
1815 sin6_to->sin6_port = dstPort.NotAnInteger;
1816 sin6_to->sin6_flowinfo = 0;
1817 sin6_to->sin6_addr = *(struct in6_addr*)&dst->ip.v6;
1818 sin6_to->sin6_scope_id = info ? info->scope_id : 0;
1819 s = (src ? src->ss : m->p->permanentsockets).sktv6;
1820 if (info && mDNSAddrIsDNSMulticast(dst)) // Specify outgoing interface
1821 {
1822 err = setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_IF, &info->scope_id, sizeof(info->scope_id));
1823 if (err < 0)
1824 {
1825 char name[IFNAMSIZ];
1826 if (if_indextoname(info->scope_id, name) != NULL)
1827 LogMsg("setsockopt - IPV6_MULTICAST_IF error %d errno %d (%s)", err, errno, strerror(errno));
1828 else
1829 LogInfo("setsockopt - IPV6_MUTLICAST_IF scopeid %d, not a valid interface", info->scope_id);
1830 }
1831 }
1832 }
1833
1834 else
1835 {
1836 LogMsg("mDNSPlatformSendUDP: dst is not an IPv4 or IPv6 address!");
1837 #if ForceAlerts
1838 *(long*)0 = 0;
1839 #endif
1840 return mStatus_BadParamErr;
1841 }
1842
1843 if (s >= 0)
1844 verbosedebugf("mDNSPlatformSendUDP: sending on InterfaceID %p %5s/%ld to %#a:%d skt %d",
1845 InterfaceID, ifa_name, dst->type, dst, mDNSVal16(dstPort), s);
1846 else
1847 verbosedebugf("mDNSPlatformSendUDP: NOT sending on InterfaceID %p %5s/%ld (socket of this type not available)",
1848 InterfaceID, ifa_name, dst->type, dst, mDNSVal16(dstPort));
1849
1850 // Note: When sending, mDNSCore may often ask us to send both a v4 multicast packet and then a v6 multicast packet
1851 // If we don't have the corresponding type of socket available, then return mStatus_Invalid
1852 if (s < 0) return(mStatus_Invalid);
1853
1854 // switch to background traffic class for this message if requested
1855 if (useBackgroundTrafficClass)
1856 setTrafficClass(s, useBackgroundTrafficClass);
1857
1858 err = sendto(s, msg, (UInt8*)end - (UInt8*)msg, 0, (struct sockaddr *)&to, to.ss_len);
1859
1860 // set traffic class back to default value
1861 if (useBackgroundTrafficClass)
1862 setTrafficClass(s, mDNSfalse);
1863
1864 if (err < 0)
1865 {
1866 static int MessageCount = 0;
1867 // Don't report EHOSTDOWN (i.e. ARP failure), ENETDOWN, or no route to host for unicast destinations
1868 if (!mDNSAddressIsAllDNSLinkGroup(dst))
1869 if (errno == EHOSTDOWN || errno == ENETDOWN || errno == EHOSTUNREACH || errno == ENETUNREACH) return(mStatus_TransientErr);
1870 // Don't report EHOSTUNREACH in the first three minutes after boot
1871 // This is because mDNSResponder intentionally starts up early in the boot process (See <rdar://problem/3409090>)
1872 // but this means that sometimes it starts before configd has finished setting up the multicast routing entries.
1873 if (errno == EHOSTUNREACH && (mDNSu32)(mDNSPlatformRawTime()) < (mDNSu32)(mDNSPlatformOneSecond * 180)) return(mStatus_TransientErr);
1874 // Don't report EADDRNOTAVAIL ("Can't assign requested address") if we're in the middle of a network configuration change
1875 if (errno == EADDRNOTAVAIL && m->p->NetworkChanged) return(mStatus_TransientErr);
1876 if (errno == EHOSTUNREACH || errno == EADDRNOTAVAIL || errno == ENETDOWN)
1877 LogInfo("mDNSPlatformSendUDP sendto(%d) failed to send packet on InterfaceID %p %5s/%d to %#a:%d skt %d error %d errno %d (%s) %lu",
1878 s, InterfaceID, ifa_name, dst->type, dst, mDNSVal16(dstPort), s, err, errno, strerror(errno), (mDNSu32)(m->timenow));
1879 else
1880 {
1881 MessageCount++;
1882 if (MessageCount < 50) // Cap and ensure NO spamming of LogMsgs
1883 LogMsg("mDNSPlatformSendUDP: sendto(%d) failed to send packet on InterfaceID %p %5s/%d to %#a:%d skt %d error %d errno %d (%s) %lu MessageCount is %d",
1884 s, InterfaceID, ifa_name, dst->type, dst, mDNSVal16(dstPort), s, err, errno, strerror(errno), (mDNSu32)(m->timenow), MessageCount);
1885 else // If logging is enabled, remove the cap and log aggressively
1886 LogInfo("mDNSPlatformSendUDP: sendto(%d) failed to send packet on InterfaceID %p %5s/%d to %#a:%d skt %d error %d errno %d (%s) %lu MessageCount is %d",
1887 s, InterfaceID, ifa_name, dst->type, dst, mDNSVal16(dstPort), s, err, errno, strerror(errno), (mDNSu32)(m->timenow), MessageCount);
1888 }
1889
1890 result = mStatus_UnknownErr;
1891 }
1892
1893 #ifdef IP_BOUND_IF
1894 if (dst->type == mDNSAddrType_IPv4 && info && !mDNSAddrIsDNSMulticast(dst))
1895 {
1896 static const mDNSu32 ifindex = 0;
1897 setsockopt(s, IPPROTO_IP, IP_BOUND_IF, &ifindex, sizeof(ifindex));
1898 }
1899 #endif
1900
1901 return(result);
1902 }
1903
1904 mDNSexport ssize_t myrecvfrom(const int s, void *const buffer, const size_t max,
1905 struct sockaddr *const from, size_t *const fromlen, mDNSAddr *dstaddr, char ifname[IF_NAMESIZE], mDNSu8 *ttl)
1906 {
1907 static unsigned int numLogMessages = 0;
1908 struct iovec databuffers = { (char *)buffer, max };
1909 struct msghdr msg;
1910 ssize_t n;
1911 struct cmsghdr *cmPtr;
1912 char ancillary[1024];
1913
1914 *ttl = 255; // If kernel fails to provide TTL data (e.g. Jaguar doesn't) then assume the TTL was 255 as it should be
1915
1916 // Set up the message
1917 msg.msg_name = (caddr_t)from;
1918 msg.msg_namelen = *fromlen;
1919 msg.msg_iov = &databuffers;
1920 msg.msg_iovlen = 1;
1921 msg.msg_control = (caddr_t)&ancillary;
1922 msg.msg_controllen = sizeof(ancillary);
1923 msg.msg_flags = 0;
1924
1925 // Receive the data
1926 n = recvmsg(s, &msg, 0);
1927 if (n<0)
1928 {
1929 if (errno != EWOULDBLOCK && numLogMessages++ < 100) LogMsg("mDNSMacOSX.c: recvmsg(%d) returned error %d errno %d", s, n, errno);
1930 return(-1);
1931 }
1932 if (msg.msg_controllen < (int)sizeof(struct cmsghdr))
1933 {
1934 if (numLogMessages++ < 100) LogMsg("mDNSMacOSX.c: recvmsg(%d) returned %d msg.msg_controllen %d < sizeof(struct cmsghdr) %lu, errno %d",
1935 s, n, msg.msg_controllen, sizeof(struct cmsghdr), errno);
1936 return(-1);
1937 }
1938 if (msg.msg_flags & MSG_CTRUNC)
1939 {
1940 if (numLogMessages++ < 100) LogMsg("mDNSMacOSX.c: recvmsg(%d) msg.msg_flags & MSG_CTRUNC", s);
1941 return(-1);
1942 }
1943
1944 *fromlen = msg.msg_namelen;
1945
1946 // Parse each option out of the ancillary data.
1947 for (cmPtr = CMSG_FIRSTHDR(&msg); cmPtr; cmPtr = CMSG_NXTHDR(&msg, cmPtr))
1948 {
1949 // debugf("myrecvfrom cmsg_level %d cmsg_type %d", cmPtr->cmsg_level, cmPtr->cmsg_type);
1950 if (cmPtr->cmsg_level == IPPROTO_IP && cmPtr->cmsg_type == IP_RECVDSTADDR)
1951 {
1952 dstaddr->type = mDNSAddrType_IPv4;
1953 dstaddr->ip.v4 = *(mDNSv4Addr*)CMSG_DATA(cmPtr);
1954 //LogMsg("mDNSMacOSX.c: recvmsg IP_RECVDSTADDR %.4a", &dstaddr->ip.v4);
1955 }
1956 if (cmPtr->cmsg_level == IPPROTO_IP && cmPtr->cmsg_type == IP_RECVIF)
1957 {
1958 struct sockaddr_dl *sdl = (struct sockaddr_dl *)CMSG_DATA(cmPtr);
1959 if (sdl->sdl_nlen < IF_NAMESIZE)
1960 {
1961 mDNSPlatformMemCopy(ifname, sdl->sdl_data, sdl->sdl_nlen);
1962 ifname[sdl->sdl_nlen] = 0;
1963 // debugf("IP_RECVIF sdl_index %d, sdl_data %s len %d", sdl->sdl_index, ifname, sdl->sdl_nlen);
1964 }
1965 }
1966 if (cmPtr->cmsg_level == IPPROTO_IP && cmPtr->cmsg_type == IP_RECVTTL)
1967 *ttl = *(u_char*)CMSG_DATA(cmPtr);
1968 if (cmPtr->cmsg_level == IPPROTO_IPV6 && cmPtr->cmsg_type == IPV6_PKTINFO)
1969 {
1970 struct in6_pktinfo *ip6_info = (struct in6_pktinfo*)CMSG_DATA(cmPtr);
1971 dstaddr->type = mDNSAddrType_IPv6;
1972 dstaddr->ip.v6 = *(mDNSv6Addr*)&ip6_info->ipi6_addr;
1973 myIfIndexToName(ip6_info->ipi6_ifindex, ifname);
1974 }
1975 if (cmPtr->cmsg_level == IPPROTO_IPV6 && cmPtr->cmsg_type == IPV6_HOPLIMIT)
1976 *ttl = *(int*)CMSG_DATA(cmPtr);
1977 }
1978
1979 return(n);
1980 }
1981
1982 mDNSlocal mDNSInterfaceID FindMyInterface(mDNS *const m, const mDNSAddr *addr)
1983 {
1984 NetworkInterfaceInfo *intf;
1985
1986 if (addr->type == mDNSAddrType_IPv4)
1987 {
1988 for (intf = m->HostInterfaces; intf; intf = intf->next)
1989 {
1990 if (intf->ip.type == addr->type && intf->McastTxRx)
1991 {
1992 if ((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) == 0)
1993 {
1994 return(intf->InterfaceID);
1995 }
1996 }
1997 }
1998 }
1999
2000 if (addr->type == mDNSAddrType_IPv6)
2001 {
2002 for (intf = m->HostInterfaces; intf; intf = intf->next)
2003 {
2004 if (intf->ip.type == addr->type && intf->McastTxRx)
2005 {
2006 if (((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) == 0) &&
2007 ((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) == 0) &&
2008 ((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) == 0) &&
2009 (((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) == 0)))
2010 {
2011 return(intf->InterfaceID);
2012 }
2013 }
2014 }
2015 }
2016 return(mDNSInterface_Any);
2017 }
2018
2019 mDNSexport mDNSBool mDNSPlatformPeekUDP(mDNS *const m, UDPSocket *src)
2020 {
2021 // We should have a DNSMessage header followed by the question and an answer
2022 // which also includes a CNAME (that's when this function is called). To keep it
2023 // simple, we expect at least the size of DNSMessage header(12) and size of "A"
2024 // record (14 bytes).
2025 char buffer[26];
2026 int ret;
2027
2028 (void) m;
2029
2030 if (!src)
2031 return mDNSfalse;
2032
2033 ret = recv(src->ss.sktv4, buffer, sizeof(buffer), MSG_PEEK);
2034 if (ret > 0)
2035 return mDNStrue;
2036 else
2037 return mDNSfalse;
2038 }
2039
2040 mDNSexport void myKQSocketCallBack(int s1, short filter, void *context)
2041 {
2042 KQSocketSet *const ss = (KQSocketSet *)context;
2043 mDNS *const m = ss->m;
2044 int err = 0, count = 0, closed = 0;
2045
2046 if (filter != EVFILT_READ)
2047 LogMsg("myKQSocketCallBack: Why is filter %d not EVFILT_READ (%d)?", filter, EVFILT_READ);
2048
2049 if (s1 != ss->sktv4 && s1 != ss->sktv6)
2050 {
2051 LogMsg("myKQSocketCallBack: native socket %d", s1);
2052 LogMsg("myKQSocketCallBack: sktv4 %d sktv6 %d", ss->sktv4, ss->sktv6);
2053 }
2054
2055 while (!closed)
2056 {
2057 mDNSAddr senderAddr, destAddr;
2058 mDNSIPPort senderPort;
2059 struct sockaddr_storage from;
2060 size_t fromlen = sizeof(from);
2061 char packetifname[IF_NAMESIZE] = "";
2062 mDNSu8 ttl;
2063 err = myrecvfrom(s1, &m->imsg, sizeof(m->imsg), (struct sockaddr *)&from, &fromlen, &destAddr, packetifname, &ttl);
2064 if (err < 0) break;
2065
2066 count++;
2067 if (from.ss_family == AF_INET)
2068 {
2069 struct sockaddr_in *s = (struct sockaddr_in*)&from;
2070 senderAddr.type = mDNSAddrType_IPv4;
2071 senderAddr.ip.v4.NotAnInteger = s->sin_addr.s_addr;
2072 senderPort.NotAnInteger = s->sin_port;
2073 //LogInfo("myKQSocketCallBack received IPv4 packet from %#-15a to %#-15a on skt %d %s", &senderAddr, &destAddr, s1, packetifname);
2074 }
2075 else if (from.ss_family == AF_INET6)
2076 {
2077 struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&from;
2078 senderAddr.type = mDNSAddrType_IPv6;
2079 senderAddr.ip.v6 = *(mDNSv6Addr*)&sin6->sin6_addr;
2080 senderPort.NotAnInteger = sin6->sin6_port;
2081 //LogInfo("myKQSocketCallBack received IPv6 packet from %#-15a to %#-15a on skt %d %s", &senderAddr, &destAddr, s1, packetifname);
2082 }
2083 else
2084 {
2085 LogMsg("myKQSocketCallBack from is unknown address family %d", from.ss_family);
2086 return;
2087 }
2088
2089 // Note: When handling multiple packets in a batch, MUST reset InterfaceID before handling each packet
2090 mDNSInterfaceID InterfaceID = mDNSNULL;
2091 NetworkInterfaceInfoOSX *intf = m->p->InterfaceList;
2092 while (intf)
2093 {
2094 if (intf->Exists && !strcmp(intf->ifinfo.ifname, packetifname))
2095 break;
2096 intf = intf->next;
2097 }
2098
2099 // When going to sleep we deregister all our interfaces, but if the machine
2100 // takes a few seconds to sleep we may continue to receive multicasts
2101 // during that time, which would confuse mDNSCoreReceive, because as far
2102 // as it's concerned, we should have no active interfaces any more.
2103 // Hence we ignore multicasts for which we can find no matching InterfaceID.
2104 if (intf)
2105 InterfaceID = intf->ifinfo.InterfaceID;
2106 else if (mDNSAddrIsDNSMulticast(&destAddr))
2107 continue;
2108
2109 if (!InterfaceID)
2110 {
2111 InterfaceID = FindMyInterface(m, &destAddr);
2112 }
2113
2114 // LogMsg("myKQSocketCallBack got packet from %#a to %#a on interface %#a/%s",
2115 // &senderAddr, &destAddr, &ss->info->ifinfo.ip, ss->info->ifinfo.ifname);
2116
2117 // mDNSCoreReceive may close the socket we're reading from. We must break out of our
2118 // loop when that happens, or we may try to read from an invalid FD. We do this by
2119 // setting the closeFlag pointer in the socketset, so CloseSocketSet can inform us
2120 // if it closes the socketset.
2121 ss->closeFlag = &closed;
2122
2123 if (ss->proxy)
2124 {
2125 m->p->UDPProxyCallback(m, &m->p->UDPProxy, (unsigned char *)&m->imsg, (unsigned char*)&m->imsg + err, &senderAddr,
2126 senderPort, &destAddr, ss->port, InterfaceID, NULL);
2127 }
2128 else
2129 {
2130 mDNSCoreReceive(m, &m->imsg, (unsigned char*)&m->imsg + err, &senderAddr, senderPort, &destAddr, ss->port, InterfaceID);
2131 }
2132
2133 // if we didn't close, we can safely dereference the socketset, and should to
2134 // reset the closeFlag, since it points to something on the stack
2135 if (!closed) ss->closeFlag = mDNSNULL;
2136 }
2137
2138 if (err < 0 && (errno != EWOULDBLOCK || count == 0))
2139 {
2140 // Something is busted here.
2141 // kqueue says there is a packet, but myrecvfrom says there is not.
2142 // Try calling select() to get another opinion.
2143 // Find out about other socket parameter that can help understand why select() says the socket is ready for read
2144 // All of this is racy, as data may have arrived after the call to select()
2145 static unsigned int numLogMessages = 0;
2146 int save_errno = errno;
2147 int so_error = -1;
2148 int so_nread = -1;
2149 int fionread = -1;
2150 socklen_t solen = sizeof(int);
2151 fd_set readfds;
2152 struct timeval timeout;
2153 int selectresult;
2154 FD_ZERO(&readfds);
2155 FD_SET(s1, &readfds);
2156 timeout.tv_sec = 0;
2157 timeout.tv_usec = 0;
2158 selectresult = select(s1+1, &readfds, NULL, NULL, &timeout);
2159 if (getsockopt(s1, SOL_SOCKET, SO_ERROR, &so_error, &solen) == -1)
2160 LogMsg("myKQSocketCallBack getsockopt(SO_ERROR) error %d", errno);
2161 if (getsockopt(s1, SOL_SOCKET, SO_NREAD, &so_nread, &solen) == -1)
2162 LogMsg("myKQSocketCallBack getsockopt(SO_NREAD) error %d", errno);
2163 if (ioctl(s1, FIONREAD, &fionread) == -1)
2164 LogMsg("myKQSocketCallBack ioctl(FIONREAD) error %d", errno);
2165 if (numLogMessages++ < 100)
2166 LogMsg("myKQSocketCallBack recvfrom skt %d error %d errno %d (%s) select %d (%spackets waiting) so_error %d so_nread %d fionread %d count %d",
2167 s1, err, save_errno, strerror(save_errno), selectresult, FD_ISSET(s1, &readfds) ? "" : "*NO* ", so_error, so_nread, fionread, count);
2168 if (numLogMessages > 5)
2169 NotifyOfElusiveBug("Flaw in Kernel (select/recvfrom mismatch)",
2170 "Congratulations, you've reproduced an elusive bug.\r"
2171 "Please contact the current assignee of <rdar://problem/3375328>.\r"
2172 "Alternatively, you can send email to radar-3387020@group.apple.com. (Note number is different.)\r"
2173 "If possible, please leave your machine undisturbed so that someone can come to investigate the problem.");
2174
2175 sleep(1); // After logging this error, rate limit so we don't flood syslog
2176 }
2177 }
2178
2179 mDNSlocal void doTcpSocketCallback(TCPSocket *sock)
2180 {
2181 mDNSBool c = !sock->connected;
2182 sock->connected = mDNStrue;
2183 sock->callback(sock, sock->context, c, sock->err);
2184 // Note: the callback may call CloseConnection here, which frees the context structure!
2185 }
2186
2187 #ifndef NO_SECURITYFRAMEWORK
2188
2189 mDNSlocal OSStatus tlsWriteSock(SSLConnectionRef connection, const void *data, size_t *dataLength)
2190 {
2191 int ret = send(((TCPSocket *)connection)->fd, data, *dataLength, 0);
2192 if (ret >= 0 && (size_t)ret < *dataLength) { *dataLength = ret; return(errSSLWouldBlock); }
2193 if (ret >= 0) { *dataLength = ret; return(noErr); }
2194 *dataLength = 0;
2195 if (errno == EAGAIN ) return(errSSLWouldBlock);
2196 if (errno == ENOENT ) return(errSSLClosedGraceful);
2197 if (errno == EPIPE || errno == ECONNRESET) return(errSSLClosedAbort);
2198 LogMsg("ERROR: tlsWriteSock: %d error %d (%s)\n", ((TCPSocket *)connection)->fd, errno, strerror(errno));
2199 return(errSSLClosedAbort);
2200 }
2201
2202 mDNSlocal OSStatus tlsReadSock(SSLConnectionRef connection, void *data, size_t *dataLength)
2203 {
2204 int ret = recv(((TCPSocket *)connection)->fd, data, *dataLength, 0);
2205 if (ret > 0 && (size_t)ret < *dataLength) { *dataLength = ret; return(errSSLWouldBlock); }
2206 if (ret > 0) { *dataLength = ret; return(noErr); }
2207 *dataLength = 0;
2208 if (ret == 0 || errno == ENOENT ) return(errSSLClosedGraceful);
2209 if ( errno == EAGAIN ) return(errSSLWouldBlock);
2210 if ( errno == ECONNRESET) return(errSSLClosedAbort);
2211 LogMsg("ERROR: tlsSockRead: error %d (%s)\n", errno, strerror(errno));
2212 return(errSSLClosedAbort);
2213 }
2214
2215 mDNSlocal OSStatus tlsSetupSock(TCPSocket *sock, SSLProtocolSide pside, SSLConnectionType ctype)
2216 {
2217 char domname_cstr[MAX_ESCAPED_DOMAIN_NAME];
2218
2219 sock->tlsContext = SSLCreateContext(kCFAllocatorDefault, pside, ctype);
2220 if (!sock->tlsContext)
2221 {
2222 LogMsg("ERROR: tlsSetupSock: SSLCreateContext failed");
2223 return(mStatus_UnknownErr);
2224 }
2225
2226 mStatus err = SSLSetIOFuncs(sock->tlsContext, tlsReadSock, tlsWriteSock);
2227 if (err)
2228 {
2229 LogMsg("ERROR: tlsSetupSock: SSLSetIOFuncs failed with error code: %d", err);
2230 goto fail;
2231 }
2232
2233 err = SSLSetConnection(sock->tlsContext, (SSLConnectionRef) sock);
2234 if (err)
2235 {
2236 LogMsg("ERROR: tlsSetupSock: SSLSetConnection failed with error code: %d", err);
2237 goto fail;
2238 }
2239
2240 // Instead of listing all the acceptable ciphers, we just disable the bad ciphers. It does not disable
2241 // all the bad ciphers like RC4_MD5, but it assumes that the servers don't offer them.
2242 err = SSLSetAllowAnonymousCiphers(sock->tlsContext, 0);
2243 if (err)
2244 {
2245 LogMsg("ERROR: tlsSetupSock: SSLSetAllowAnonymousCiphers failed with error code: %d", err);
2246 goto fail;
2247 }
2248
2249 // We already checked for NULL in hostname and this should never happen. Hence, returning -1
2250 // (error not in OSStatus space) is okay.
2251 if (!sock->hostname.c[0])
2252 {
2253 LogMsg("ERROR: tlsSetupSock: hostname NULL");
2254 err = -1;
2255 goto fail;
2256 }
2257
2258 ConvertDomainNameToCString(&sock->hostname, domname_cstr);
2259 err = SSLSetPeerDomainName(sock->tlsContext, domname_cstr, strlen(domname_cstr));
2260 if (err)
2261 {
2262 LogMsg("ERROR: tlsSetupSock: SSLSetPeerDomainname: %s failed with error code: %d", domname_cstr, err);
2263 goto fail;
2264 }
2265
2266 return(err);
2267
2268 fail:
2269 if (sock->tlsContext)
2270 CFRelease(sock->tlsContext);
2271 return(err);
2272 }
2273
2274 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2275 mDNSlocal void doSSLHandshake(TCPSocket *sock)
2276 {
2277 mStatus err = SSLHandshake(sock->tlsContext);
2278
2279 //Can't have multiple threads in mDNS core. When MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM is
2280 //defined, KQueueLock is a noop. Hence we need to serialize here
2281 //
2282 //NOTE: We just can't serialize doTcpSocketCallback alone on the main queue.
2283 //We need the rest of the logic also. Otherwise, we can enable the READ
2284 //events below, dispatch a doTcpSocketCallback on the main queue. Assume it is
2285 //ConnFailed which means we are going to free the tcpInfo. While it
2286 //is waiting to be dispatched, another read event can come into tcpKQSocketCallback
2287 //and potentially call doTCPCallback with error which can close the fd and free the
2288 //tcpInfo. Later when the thread gets dispatched it will crash because the tcpInfo
2289 //is already freed.
2290
2291 dispatch_async(dispatch_get_main_queue(), ^{
2292
2293 LogInfo("doSSLHandshake %p: got lock", sock); // Log *after* we get the lock
2294
2295 if (sock->handshake == handshake_to_be_closed)
2296 {
2297 LogInfo("SSLHandshake completed after close");
2298 mDNSPlatformTCPCloseConnection(sock);
2299 }
2300 else
2301 {
2302 if (sock->fd != -1) KQueueSet(sock->fd, EV_ADD, EVFILT_READ, sock->kqEntry);
2303 else LogMsg("doSSLHandshake: sock->fd is -1");
2304
2305 if (err == errSSLWouldBlock)
2306 sock->handshake = handshake_required;
2307 else
2308 {
2309 if (err)
2310 {
2311 LogMsg("SSLHandshake failed: %d%s", err, err == errSSLPeerInternalError ? " (server busy)" : "");
2312 CFRelease(sock->tlsContext);
2313 sock->tlsContext = NULL;
2314 }
2315
2316 sock->err = err ? mStatus_ConnFailed : 0;
2317 sock->handshake = handshake_completed;
2318
2319 LogInfo("doSSLHandshake: %p calling doTcpSocketCallback fd %d", sock, sock->fd);
2320 doTcpSocketCallback(sock);
2321 }
2322 }
2323
2324 LogInfo("SSLHandshake %p: dropping lock for fd %d", sock, sock->fd);
2325 return;
2326 });
2327 }
2328 #else // MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2329 mDNSlocal void *doSSLHandshake(TCPSocket *sock)
2330 {
2331 // Warning: Touching sock without the kqueue lock!
2332 // We're protected because sock->handshake == handshake_in_progress
2333 mDNS * const m = sock->m; // Get m now, as we may free sock if marked to be closed while we're waiting on SSLHandshake
2334 mStatus err = SSLHandshake(sock->tlsContext);
2335
2336 KQueueLock(m);
2337 debugf("doSSLHandshake %p: got lock", sock); // Log *after* we get the lock
2338
2339 if (sock->handshake == handshake_to_be_closed)
2340 {
2341 LogInfo("SSLHandshake completed after close");
2342 mDNSPlatformTCPCloseConnection(sock);
2343 }
2344 else
2345 {
2346 if (sock->fd != -1) KQueueSet(sock->fd, EV_ADD, EVFILT_READ, sock->kqEntry);
2347 else LogMsg("doSSLHandshake: sock->fd is -1");
2348
2349 if (err == errSSLWouldBlock)
2350 sock->handshake = handshake_required;
2351 else
2352 {
2353 if (err)
2354 {
2355 LogMsg("SSLHandshake failed: %d%s", err, err == errSSLPeerInternalError ? " (server busy)" : "");
2356 CFRelease(sock->tlsContext);
2357 sock->tlsContext = NULL;
2358 }
2359
2360 sock->err = err ? mStatus_ConnFailed : 0;
2361 sock->handshake = handshake_completed;
2362
2363 debugf("doSSLHandshake: %p calling doTcpSocketCallback fd %d", sock, sock->fd);
2364 doTcpSocketCallback(sock);
2365 }
2366 }
2367
2368 debugf("SSLHandshake %p: dropping lock for fd %d", sock, sock->fd);
2369 KQueueUnlock(m, "doSSLHandshake");
2370 return NULL;
2371 }
2372 #endif // MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2373
2374 mDNSlocal void spawnSSLHandshake(TCPSocket* sock)
2375 {
2376 debugf("spawnSSLHandshake %p: entry", sock);
2377
2378 if (sock->handshake != handshake_required) LogMsg("spawnSSLHandshake: handshake status not required: %d", sock->handshake);
2379 sock->handshake = handshake_in_progress;
2380 KQueueSet(sock->fd, EV_DELETE, EVFILT_READ, sock->kqEntry);
2381
2382 // Dispatch it on a separate queue to help avoid blocking other threads/queues, and
2383 // to limit the number of threads used for SSLHandshake
2384 dispatch_async(SSLqueue, ^{doSSLHandshake(sock);});
2385
2386 debugf("spawnSSLHandshake %p: done for %d", sock, sock->fd);
2387 }
2388
2389 #endif /* NO_SECURITYFRAMEWORK */
2390
2391 mDNSlocal void tcpKQSocketCallback(__unused int fd, short filter, void *context)
2392 {
2393 TCPSocket *sock = context;
2394 sock->err = mStatus_NoError;
2395
2396 //if (filter == EVFILT_READ ) LogMsg("myKQSocketCallBack: tcpKQSocketCallback %d is EVFILT_READ", filter);
2397 //if (filter == EVFILT_WRITE) LogMsg("myKQSocketCallBack: tcpKQSocketCallback %d is EVFILT_WRITE", filter);
2398 // EV_ONESHOT doesn't seem to work, so we add the filter with EV_ADD, and explicitly delete it here with EV_DELETE
2399 if (filter == EVFILT_WRITE)
2400 KQueueSet(sock->fd, EV_DELETE, EVFILT_WRITE, sock->kqEntry);
2401
2402 if (sock->flags & kTCPSocketFlags_UseTLS)
2403 {
2404 #ifndef NO_SECURITYFRAMEWORK
2405 if (!sock->setup)
2406 {
2407 sock->setup = mDNStrue;
2408 sock->err = tlsSetupSock(sock, kSSLClientSide, kSSLStreamType);
2409 if (sock->err)
2410 {
2411 LogMsg("ERROR: tcpKQSocketCallback: tlsSetupSock failed with error code: %d", sock->err);
2412 return;
2413 }
2414 }
2415 if (sock->handshake == handshake_required)
2416 {
2417 spawnSSLHandshake(sock);
2418 return;
2419 }
2420 else if (sock->handshake == handshake_in_progress || sock->handshake == handshake_to_be_closed)
2421 {
2422 return;
2423 }
2424 else if (sock->handshake != handshake_completed)
2425 {
2426 if (!sock->err)
2427 sock->err = mStatus_UnknownErr;
2428 LogMsg("tcpKQSocketCallback called with unexpected SSLHandshake status: %d", sock->handshake);
2429 }
2430 #else /* NO_SECURITYFRAMEWORK */
2431 sock->err = mStatus_UnsupportedErr;
2432 #endif /* NO_SECURITYFRAMEWORK */
2433 }
2434
2435 doTcpSocketCallback(sock);
2436 }
2437
2438 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2439 mDNSexport int KQueueSet(int fd, u_short flags, short filter, KQueueEntry *const entryRef)
2440 {
2441 dispatch_queue_t queue = dispatch_get_main_queue();
2442 dispatch_source_t source;
2443 if (flags == EV_DELETE)
2444 {
2445 if (filter == EVFILT_READ)
2446 {
2447 dispatch_source_cancel(entryRef->readSource);
2448 dispatch_release(entryRef->readSource);
2449 entryRef->readSource = mDNSNULL;
2450 debugf("KQueueSet: source cancel for read %p, %p", entryRef->readSource, entryRef->writeSource);
2451 }
2452 else if (filter == EVFILT_WRITE)
2453 {
2454 dispatch_source_cancel(entryRef->writeSource);
2455 dispatch_release(entryRef->writeSource);
2456 entryRef->writeSource = mDNSNULL;
2457 debugf("KQueueSet: source cancel for write %p, %p", entryRef->readSource, entryRef->writeSource);
2458 }
2459 else
2460 LogMsg("KQueueSet: ERROR: Wrong filter value %d for EV_DELETE", filter);
2461 return 0;
2462 }
2463 if (flags != EV_ADD) LogMsg("KQueueSet: Invalid flags %d", flags);
2464
2465 if (filter == EVFILT_READ)
2466 {
2467 source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, fd, 0, queue);
2468 }
2469 else if (filter == EVFILT_WRITE)
2470 {
2471 source = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, fd, 0, queue);
2472 }
2473 else
2474 {
2475 LogMsg("KQueueSet: ERROR: Wrong filter value %d for EV_ADD", filter);
2476 return -1;
2477 }
2478 if (!source) return -1;
2479 dispatch_source_set_event_handler(source, ^{
2480
2481 mDNSs32 stime = mDNSPlatformRawTime();
2482 entryRef->KQcallback(fd, filter, entryRef->KQcontext);
2483 mDNSs32 etime = mDNSPlatformRawTime();
2484 if (etime - stime >= WatchDogReportingThreshold)
2485 LogInfo("KQEntryCallback Block: WARNING: took %dms to complete", etime - stime);
2486
2487 // Trigger the event delivery to the application. Even though we trigger the
2488 // event completion after handling every event source, these all will hopefully
2489 // get merged
2490 TriggerEventCompletion();
2491
2492 });
2493 dispatch_source_set_cancel_handler(source, ^{
2494 if (entryRef->fdClosed)
2495 {
2496 //LogMsg("CancelHandler: closing fd %d", fd);
2497 close(fd);
2498 }
2499 });
2500 dispatch_resume(source);
2501 if (filter == EVFILT_READ)
2502 entryRef->readSource = source;
2503 else
2504 entryRef->writeSource = source;
2505
2506 return 0;
2507 }
2508
2509 mDNSexport void KQueueLock(mDNS *const m)
2510 {
2511 (void)m; //unused
2512 }
2513 mDNSexport void KQueueUnlock(mDNS *const m, const char const *task)
2514 {
2515 (void)m; //unused
2516 (void)task; //unused
2517 }
2518 #else
2519 mDNSexport int KQueueSet(int fd, u_short flags, short filter, const KQueueEntry *const entryRef)
2520 {
2521 struct kevent new_event;
2522 EV_SET(&new_event, fd, filter, flags, 0, 0, (void*)entryRef);
2523 return (kevent(KQueueFD, &new_event, 1, NULL, 0, NULL) < 0) ? errno : 0;
2524 }
2525
2526 mDNSexport void KQueueLock(mDNS *const m)
2527 {
2528 pthread_mutex_lock(&m->p->BigMutex);
2529 m->p->BigMutexStartTime = mDNSPlatformRawTime();
2530 }
2531
2532 mDNSexport void KQueueUnlock(mDNS *const m, const char* task)
2533 {
2534 mDNSs32 end = mDNSPlatformRawTime();
2535 (void)task;
2536 if (end - m->p->BigMutexStartTime >= WatchDogReportingThreshold)
2537 LogInfo("WARNING: %s took %dms to complete", task, end - m->p->BigMutexStartTime);
2538
2539 pthread_mutex_unlock(&m->p->BigMutex);
2540
2541 char wake = 1;
2542 if (send(m->p->WakeKQueueLoopFD, &wake, sizeof(wake), 0) == -1)
2543 LogMsg("ERROR: KQueueWake: send failed with error code: %d (%s)", errno, strerror(errno));
2544 }
2545 #endif
2546
2547 mDNSexport void mDNSPlatformCloseFD(KQueueEntry *kq, int fd)
2548 {
2549 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2550 (void) fd; //unused
2551 if (kq->readSource)
2552 {
2553 dispatch_source_cancel(kq->readSource);
2554 kq->readSource = mDNSNULL;
2555 }
2556 if (kq->writeSource)
2557 {
2558 dispatch_source_cancel(kq->writeSource);
2559 kq->writeSource = mDNSNULL;
2560 }
2561 // Close happens in the cancellation handler
2562 debugf("mDNSPlatformCloseFD: resetting sources for %d", fd);
2563 kq->fdClosed = mDNStrue;
2564 #else
2565 (void)kq; //unused
2566 close(fd);
2567 #endif
2568 }
2569
2570 mDNSlocal mStatus SetupTCPSocket(TCPSocket *sock, u_short sa_family, mDNSIPPort *port, mDNSBool useBackgroundTrafficClass)
2571 {
2572 KQSocketSet *cp = &sock->ss;
2573 int *s = (sa_family == AF_INET) ? &cp->sktv4 : &cp->sktv6;
2574 KQueueEntry *k = (sa_family == AF_INET) ? &cp->kqsv4 : &cp->kqsv6;
2575 const int on = 1; // "on" for setsockopt
2576 mStatus err;
2577
2578 int skt = socket(sa_family, SOCK_STREAM, IPPROTO_TCP);
2579 if (skt < 3) { if (errno != EAFNOSUPPORT) LogMsg("SetupTCPSocket: socket error %d errno %d (%s)", skt, errno, strerror(errno));return(skt); }
2580
2581 // for TCP sockets, the traffic class is set once and not changed
2582 setTrafficClass(skt, useBackgroundTrafficClass);
2583
2584 if (sa_family == AF_INET)
2585 {
2586 // Bind it
2587 struct sockaddr_in addr;
2588 mDNSPlatformMemZero(&addr, sizeof(addr));
2589 addr.sin_family = AF_INET;
2590 addr.sin_port = port->NotAnInteger;
2591 err = bind(skt, (struct sockaddr*) &addr, sizeof(addr));
2592 if (err < 0) { LogMsg("ERROR: bind %s", strerror(errno)); return err; }
2593
2594 // Receive interface identifiers
2595 err = setsockopt(skt, IPPROTO_IP, IP_RECVIF, &on, sizeof(on));
2596 if (err < 0) { LogMsg("setsockopt IP_RECVIF - %s", strerror(errno)); return err; }
2597
2598 mDNSPlatformMemZero(&addr, sizeof(addr));
2599 socklen_t len = sizeof(addr);
2600 err = getsockname(skt, (struct sockaddr*) &addr, &len);
2601 if (err < 0) { LogMsg("getsockname - %s", strerror(errno)); return err; }
2602
2603 port->NotAnInteger = addr.sin_port;
2604 }
2605 else
2606 {
2607 // Bind it
2608 struct sockaddr_in6 addr6;
2609 mDNSPlatformMemZero(&addr6, sizeof(addr6));
2610 addr6.sin6_family = AF_INET6;
2611 addr6.sin6_port = port->NotAnInteger;
2612 err = bind(skt, (struct sockaddr*) &addr6, sizeof(addr6));
2613 if (err < 0) { LogMsg("ERROR: bind6 %s", strerror(errno)); return err; }
2614
2615 // We want to receive destination addresses and receive interface identifiers
2616 err = setsockopt(skt, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on));
2617 if (err < 0) { LogMsg("ERROR: setsockopt IPV6_RECVPKTINFO %s", strerror(errno)); return err; }
2618
2619 mDNSPlatformMemZero(&addr6, sizeof(addr6));
2620 socklen_t len = sizeof(addr6);
2621 err = getsockname(skt, (struct sockaddr *) &addr6, &len);
2622 if (err < 0) { LogMsg("getsockname6 - %s", strerror(errno)); return err; }
2623
2624 port->NotAnInteger = addr6.sin6_port;
2625
2626 }
2627 *s = skt;
2628 k->KQcallback = tcpKQSocketCallback;
2629 k->KQcontext = sock;
2630 k->KQtask = "mDNSPlatformTCPSocket";
2631 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2632 k->readSource = mDNSNULL;
2633 k->writeSource = mDNSNULL;
2634 k->fdClosed = mDNSfalse;
2635 #endif
2636 return mStatus_NoError;
2637 }
2638
2639 mDNSexport TCPSocket *mDNSPlatformTCPSocket(mDNS *const m, TCPSocketFlags flags, mDNSIPPort *port, mDNSBool useBackgroundTrafficClass)
2640 {
2641 mStatus err;
2642 (void) m;
2643
2644 TCPSocket *sock = mallocL("TCPSocket/mDNSPlatformTCPSocket", sizeof(TCPSocket));
2645 if (!sock) { LogMsg("mDNSPlatformTCPSocket: memory allocation failure"); return(mDNSNULL); }
2646
2647 mDNSPlatformMemZero(sock, sizeof(TCPSocket));
2648
2649 sock->ss.m = m;
2650 sock->ss.sktv4 = -1;
2651 sock->ss.sktv6 = -1;
2652 err = SetupTCPSocket(sock, AF_INET, port, useBackgroundTrafficClass);
2653
2654 if (!err)
2655 {
2656 err = SetupTCPSocket(sock, AF_INET6, port, useBackgroundTrafficClass);
2657 if (err) { mDNSPlatformCloseFD(&sock->ss.kqsv4, sock->ss.sktv4); sock->ss.sktv4 = -1; }
2658 }
2659 if (err)
2660 {
2661 LogMsg("mDNSPlatformTCPSocket: socket error %d errno %d (%s)", sock->fd, errno, strerror(errno));
2662 freeL("TCPSocket/mDNSPlatformTCPSocket", sock);
2663 return(mDNSNULL);
2664 }
2665 // sock->fd is used as the default fd if the caller does not call mDNSPlatformTCPConnect
2666 sock->fd = sock->ss.sktv4;
2667 sock->callback = mDNSNULL;
2668 sock->flags = flags;
2669 sock->context = mDNSNULL;
2670 sock->setup = mDNSfalse;
2671 sock->connected = mDNSfalse;
2672 sock->handshake = handshake_required;
2673 sock->m = m;
2674 sock->err = mStatus_NoError;
2675
2676 return sock;
2677 }
2678
2679 mDNSexport mStatus mDNSPlatformTCPConnect(TCPSocket *sock, const mDNSAddr *dst, mDNSOpaque16 dstport, domainname *hostname, mDNSInterfaceID InterfaceID, TCPConnectionCallback callback, void *context)
2680 {
2681 KQSocketSet *cp = &sock->ss;
2682 int *s = (dst->type == mDNSAddrType_IPv4) ? &cp->sktv4 : &cp->sktv6;
2683 KQueueEntry *k = (dst->type == mDNSAddrType_IPv4) ? &cp->kqsv4 : &cp->kqsv6;
2684 mStatus err = mStatus_NoError;
2685 struct sockaddr_storage ss;
2686
2687 sock->callback = callback;
2688 sock->context = context;
2689 sock->setup = mDNSfalse;
2690 sock->connected = mDNSfalse;
2691 sock->handshake = handshake_required;
2692 sock->err = mStatus_NoError;
2693
2694 if (hostname) { debugf("mDNSPlatformTCPConnect: hostname %##s", hostname->c); AssignDomainName(&sock->hostname, hostname); }
2695
2696 if (dst->type == mDNSAddrType_IPv4)
2697 {
2698 struct sockaddr_in *saddr = (struct sockaddr_in *)&ss;
2699 mDNSPlatformMemZero(saddr, sizeof(*saddr));
2700 saddr->sin_family = AF_INET;
2701 saddr->sin_port = dstport.NotAnInteger;
2702 saddr->sin_len = sizeof(*saddr);
2703 saddr->sin_addr.s_addr = dst->ip.v4.NotAnInteger;
2704 }
2705 else
2706 {
2707 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)&ss;
2708 mDNSPlatformMemZero(saddr6, sizeof(*saddr6));
2709 saddr6->sin6_family = AF_INET6;
2710 saddr6->sin6_port = dstport.NotAnInteger;
2711 saddr6->sin6_len = sizeof(*saddr6);
2712 saddr6->sin6_addr = *(struct in6_addr *)&dst->ip.v6;
2713 }
2714
2715 // Watch for connect complete (write is ready)
2716 // EV_ONESHOT doesn't seem to work, so we add the filter with EV_ADD, and explicitly delete it in tcpKQSocketCallback using EV_DELETE
2717 if (KQueueSet(*s, EV_ADD /* | EV_ONESHOT */, EVFILT_WRITE, k))
2718 {
2719 LogMsg("ERROR: mDNSPlatformTCPConnect - KQueueSet failed");
2720 return errno;
2721 }
2722
2723 // Watch for incoming data
2724 if (KQueueSet(*s, EV_ADD, EVFILT_READ, k))
2725 {
2726 LogMsg("ERROR: mDNSPlatformTCPConnect - KQueueSet failed");
2727 return errno;
2728 }
2729
2730 if (fcntl(*s, F_SETFL, fcntl(*s, F_GETFL, 0) | O_NONBLOCK) < 0) // set non-blocking
2731 {
2732 LogMsg("ERROR: setsockopt O_NONBLOCK - %s", strerror(errno));
2733 return mStatus_UnknownErr;
2734 }
2735
2736 // We bind to the interface and all subsequent packets including the SYN will be sent out
2737 // on this interface
2738 //
2739 // Note: If we are in Active Directory domain, we may try TCP (if the response can't fit in
2740 // UDP). mDNSInterface_Unicast indicates this case and not a valid interface.
2741 if (InterfaceID && InterfaceID != mDNSInterface_Unicast)
2742 {
2743 NetworkInterfaceInfoOSX *info = IfindexToInterfaceInfoOSX(&mDNSStorage, InterfaceID);
2744 if (dst->type == mDNSAddrType_IPv4)
2745 {
2746 #ifdef IP_BOUND_IF
2747 if (info) setsockopt(*s, IPPROTO_IP, IP_BOUND_IF, &info->scope_id, sizeof(info->scope_id));
2748 else { LogMsg("mDNSPlatformTCPConnect: Invalid interface index %p", InterfaceID); return mStatus_BadParamErr; }
2749 #else
2750 (void)InterfaceID; // Unused
2751 (void)info; // Unused
2752 #endif
2753 }
2754 else
2755 {
2756 #ifdef IPV6_BOUND_IF
2757 if (info) setsockopt(*s, IPPROTO_IPV6, IPV6_BOUND_IF, &info->scope_id, sizeof(info->scope_id));
2758 else { LogMsg("mDNSPlatformTCPConnect: Invalid interface index %p", InterfaceID); return mStatus_BadParamErr; }
2759 #else
2760 (void)InterfaceID; // Unused
2761 (void)info; // Unused
2762 #endif
2763 }
2764 }
2765
2766 // mDNSPlatformReadTCP/WriteTCP (unlike the UDP counterpart) does not provide the destination address
2767 // from which we can infer the destination address family. Hence we need to remember that here.
2768 // Instead of remembering the address family, we remember the right fd.
2769 sock->fd = *s;
2770 sock->kqEntry = k;
2771 // initiate connection wth peer
2772 if (connect(*s, (struct sockaddr *)&ss, ss.ss_len) < 0)
2773 {
2774 if (errno == EINPROGRESS) return mStatus_ConnPending;
2775 if (errno == EHOSTUNREACH || errno == EADDRNOTAVAIL || errno == ENETDOWN)
2776 LogInfo("ERROR: mDNSPlatformTCPConnect - connect failed: socket %d: Error %d (%s)", sock->fd, errno, strerror(errno));
2777 else
2778 LogMsg("ERROR: mDNSPlatformTCPConnect - connect failed: socket %d: Error %d (%s) length %d", sock->fd, errno, strerror(errno), ss.ss_len);
2779 return mStatus_ConnFailed;
2780 }
2781
2782 LogMsg("NOTE: mDNSPlatformTCPConnect completed synchronously");
2783 // kQueue should notify us, but this LogMsg is to help track down if it doesn't
2784 return err;
2785 }
2786
2787 // Why doesn't mDNSPlatformTCPAccept actually call accept() ?
2788 mDNSexport TCPSocket *mDNSPlatformTCPAccept(TCPSocketFlags flags, int fd)
2789 {
2790 mStatus err = mStatus_NoError;
2791
2792 TCPSocket *sock = mallocL("TCPSocket/mDNSPlatformTCPAccept", sizeof(TCPSocket));
2793 if (!sock) return(mDNSNULL);
2794
2795 mDNSPlatformMemZero(sock, sizeof(*sock));
2796 sock->fd = fd;
2797 sock->flags = flags;
2798
2799 if (flags & kTCPSocketFlags_UseTLS)
2800 {
2801 #ifndef NO_SECURITYFRAMEWORK
2802 if (!ServerCerts) { LogMsg("ERROR: mDNSPlatformTCPAccept: unable to find TLS certificates"); err = mStatus_UnknownErr; goto exit; }
2803
2804 err = tlsSetupSock(sock, kSSLServerSide, kSSLStreamType);
2805 if (err) { LogMsg("ERROR: mDNSPlatformTCPAccept: tlsSetupSock failed with error code: %d", err); goto exit; }
2806
2807 err = SSLSetCertificate(sock->tlsContext, ServerCerts);
2808 if (err) { LogMsg("ERROR: mDNSPlatformTCPAccept: SSLSetCertificate failed with error code: %d", err); goto exit; }
2809 #else
2810 err = mStatus_UnsupportedErr;
2811 #endif /* NO_SECURITYFRAMEWORK */
2812 }
2813 #ifndef NO_SECURITYFRAMEWORK
2814 exit:
2815 #endif
2816
2817 if (err) { freeL("TCPSocket/mDNSPlatformTCPAccept", sock); return(mDNSNULL); }
2818 return(sock);
2819 }
2820
2821 mDNSexport mDNSu16 mDNSPlatformGetUDPPort(UDPSocket *sock)
2822 {
2823 mDNSu16 port;
2824
2825 port = -1;
2826 if (sock)
2827 {
2828 port = sock->ss.port.NotAnInteger;
2829 }
2830 return port;
2831 }
2832
2833 mDNSlocal void CloseSocketSet(KQSocketSet *ss)
2834 {
2835 if (ss->sktv4 != -1)
2836 {
2837 mDNSPlatformCloseFD(&ss->kqsv4, ss->sktv4);
2838 ss->sktv4 = -1;
2839 }
2840 if (ss->sktv6 != -1)
2841 {
2842 mDNSPlatformCloseFD(&ss->kqsv6, ss->sktv6);
2843 ss->sktv6 = -1;
2844 }
2845 if (ss->closeFlag) *ss->closeFlag = 1;
2846 }
2847
2848 mDNSexport void mDNSPlatformTCPCloseConnection(TCPSocket *sock)
2849 {
2850 if (sock)
2851 {
2852 #ifndef NO_SECURITYFRAMEWORK
2853 if (sock->tlsContext)
2854 {
2855 if (sock->handshake == handshake_in_progress) // SSLHandshake thread using this sock (esp. tlsContext)
2856 {
2857 LogInfo("mDNSPlatformTCPCloseConnection: called while handshake in progress");
2858 // When we come back from SSLHandshake, we will notice that a close was here and
2859 // call this function again which will do the cleanup then.
2860 sock->handshake = handshake_to_be_closed;
2861 return;
2862 }
2863
2864 SSLClose(sock->tlsContext);
2865 CFRelease(sock->tlsContext);
2866 sock->tlsContext = NULL;
2867 }
2868 #endif /* NO_SECURITYFRAMEWORK */
2869 if (sock->ss.sktv4 != -1)
2870 shutdown(sock->ss.sktv4, 2);
2871 if (sock->ss.sktv6 != -1)
2872 shutdown(sock->ss.sktv6, 2);
2873 CloseSocketSet(&sock->ss);
2874 sock->fd = -1;
2875
2876 freeL("TCPSocket/mDNSPlatformTCPCloseConnection", sock);
2877 }
2878 }
2879
2880 mDNSexport long mDNSPlatformReadTCP(TCPSocket *sock, void *buf, unsigned long buflen, mDNSBool *closed)
2881 {
2882 ssize_t nread = 0;
2883 *closed = mDNSfalse;
2884
2885 if (sock->flags & kTCPSocketFlags_UseTLS)
2886 {
2887 #ifndef NO_SECURITYFRAMEWORK
2888 if (sock->handshake == handshake_required) { LogMsg("mDNSPlatformReadTCP called while handshake required"); return 0; }
2889 else if (sock->handshake == handshake_in_progress) return 0;
2890 else if (sock->handshake != handshake_completed) LogMsg("mDNSPlatformReadTCP called with unexpected SSLHandshake status: %d", sock->handshake);
2891
2892 //LogMsg("Starting SSLRead %d %X", sock->fd, fcntl(sock->fd, F_GETFL, 0));
2893 mStatus err = SSLRead(sock->tlsContext, buf, buflen, (size_t *)&nread);
2894 //LogMsg("SSLRead returned %d (%d) nread %d buflen %d", err, errSSLWouldBlock, nread, buflen);
2895 if (err == errSSLClosedGraceful) { nread = 0; *closed = mDNStrue; }
2896 else if (err && err != errSSLWouldBlock)
2897 { LogMsg("ERROR: mDNSPlatformReadTCP - SSLRead: %d", err); nread = -1; *closed = mDNStrue; }
2898 #else
2899 nread = -1;
2900 *closed = mDNStrue;
2901 #endif /* NO_SECURITYFRAMEWORK */
2902 }
2903 else
2904 {
2905 static int CLOSEDcount = 0;
2906 static int EAGAINcount = 0;
2907 nread = recv(sock->fd, buf, buflen, 0);
2908
2909 if (nread > 0)
2910 {
2911 CLOSEDcount = 0;
2912 EAGAINcount = 0;
2913 } // On success, clear our error counters
2914 else if (nread == 0)
2915 {
2916 *closed = mDNStrue;
2917 if ((++CLOSEDcount % 1000) == 0)
2918 {
2919 LogMsg("ERROR: mDNSPlatformReadTCP - recv %d got CLOSED %d times", sock->fd, CLOSEDcount);
2920 assert(CLOSEDcount < 1000);
2921 // Recovery Mechanism to bail mDNSResponder out of trouble: Instead of logging the same error msg multiple times,
2922 // crash mDNSResponder using assert() and restart fresh. See advantages below:
2923 // 1.Better User Experience
2924 // 2.CrashLogs frequency can be monitored
2925 // 3.StackTrace can be used for more info
2926 }
2927 }
2928 // else nread is negative -- see what kind of error we got
2929 else if (errno == ECONNRESET) { nread = 0; *closed = mDNStrue; }
2930 else if (errno != EAGAIN) { LogMsg("ERROR: mDNSPlatformReadTCP - recv: %d (%s)", errno, strerror(errno)); nread = -1; }
2931 else // errno is EAGAIN (EWOULDBLOCK) -- no data available
2932 {
2933 nread = 0;
2934 if ((++EAGAINcount % 1000) == 0) { LogMsg("ERROR: mDNSPlatformReadTCP - recv %d got EAGAIN %d times", sock->fd, EAGAINcount); sleep(1); }
2935 }
2936 }
2937
2938 return nread;
2939 }
2940
2941 mDNSexport long mDNSPlatformWriteTCP(TCPSocket *sock, const char *msg, unsigned long len)
2942 {
2943 int nsent;
2944
2945 if (sock->flags & kTCPSocketFlags_UseTLS)
2946 {
2947 #ifndef NO_SECURITYFRAMEWORK
2948 size_t processed;
2949 if (sock->handshake == handshake_required) { LogMsg("mDNSPlatformWriteTCP called while handshake required"); return 0; }
2950 if (sock->handshake == handshake_in_progress) return 0;
2951 else if (sock->handshake != handshake_completed) LogMsg("mDNSPlatformWriteTCP called with unexpected SSLHandshake status: %d", sock->handshake);
2952
2953 mStatus err = SSLWrite(sock->tlsContext, msg, len, &processed);
2954
2955 if (!err) nsent = (int) processed;
2956 else if (err == errSSLWouldBlock) nsent = 0;
2957 else { LogMsg("ERROR: mDNSPlatformWriteTCP - SSLWrite returned %d", err); nsent = -1; }
2958 #else
2959 nsent = -1;
2960 #endif /* NO_SECURITYFRAMEWORK */
2961 }
2962 else
2963 {
2964 nsent = send(sock->fd, msg, len, 0);
2965 if (nsent < 0)
2966 {
2967 if (errno == EAGAIN) nsent = 0;
2968 else { LogMsg("ERROR: mDNSPlatformWriteTCP - send %s", strerror(errno)); nsent = -1; }
2969 }
2970 }
2971
2972 return nsent;
2973 }
2974
2975 mDNSexport int mDNSPlatformTCPGetFD(TCPSocket *sock)
2976 {
2977 return sock->fd;
2978 }
2979
2980 // If mDNSIPPort port is non-zero, then it's a multicast socket on the specified interface
2981 // If mDNSIPPort port is zero, then it's a randomly assigned port number, used for sending unicast queries
2982 mDNSlocal mStatus SetupSocket(KQSocketSet *cp, const mDNSIPPort port, u_short sa_family, mDNSIPPort *const outport)
2983 {
2984 int *s = (sa_family == AF_INET) ? &cp->sktv4 : &cp->sktv6;
2985 KQueueEntry *k = (sa_family == AF_INET) ? &cp->kqsv4 : &cp->kqsv6;
2986 const int on = 1;
2987 const int twofivefive = 255;
2988 mStatus err = mStatus_NoError;
2989 char *errstr = mDNSNULL;
2990 const int mtu = 0;
2991
2992 cp->closeFlag = mDNSNULL;
2993
2994 int skt = socket(sa_family, SOCK_DGRAM, IPPROTO_UDP);
2995 if (skt < 3) { if (errno != EAFNOSUPPORT) LogMsg("SetupSocket: socket error %d errno %d (%s)", skt, errno, strerror(errno));return(skt); }
2996
2997 // set default traffic class
2998 setTrafficClass(skt, mDNSfalse);
2999
3000 #ifdef SO_RECV_ANYIF
3001 // Enable inbound packets on IFEF_AWDL interface.
3002 // Only done for multicast sockets, since we don't expect unicast socket operations
3003 // on the IFEF_AWDL interface. Operation is a no-op for other interface types.
3004 if (mDNSSameIPPort(port, MulticastDNSPort))
3005 {
3006 err = setsockopt(skt, SOL_SOCKET, SO_RECV_ANYIF, &on, sizeof(on));
3007 if (err < 0) { errstr = "setsockopt - SO_RECV_ANYIF"; goto fail; }
3008 }
3009 #endif // SO_RECV_ANYIF
3010
3011 // ... with a shared UDP port, if it's for multicast receiving
3012 if (mDNSSameIPPort(port, MulticastDNSPort) || mDNSSameIPPort(port, NATPMPAnnouncementPort)) err = setsockopt(skt, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
3013 if (err < 0) { errstr = "setsockopt - SO_REUSEPORT"; goto fail; }
3014
3015 if (sa_family == AF_INET)
3016 {
3017 // We want to receive destination addresses
3018 err = setsockopt(skt, IPPROTO_IP, IP_RECVDSTADDR, &on, sizeof(on));
3019 if (err < 0) { errstr = "setsockopt - IP_RECVDSTADDR"; goto fail; }
3020
3021 // We want to receive interface identifiers
3022 err = setsockopt(skt, IPPROTO_IP, IP_RECVIF, &on, sizeof(on));
3023 if (err < 0) { errstr = "setsockopt - IP_RECVIF"; goto fail; }
3024
3025 // We want to receive packet TTL value so we can check it
3026 err = setsockopt(skt, IPPROTO_IP, IP_RECVTTL, &on, sizeof(on));
3027 // We ignore errors here -- we already know Jaguar doesn't support this, but we can get by without it
3028
3029 // Send unicast packets with TTL 255
3030 err = setsockopt(skt, IPPROTO_IP, IP_TTL, &twofivefive, sizeof(twofivefive));
3031 if (err < 0) { errstr = "setsockopt - IP_TTL"; goto fail; }
3032
3033 // And multicast packets with TTL 255 too
3034 err = setsockopt(skt, IPPROTO_IP, IP_MULTICAST_TTL, &twofivefive, sizeof(twofivefive));
3035 if (err < 0) { errstr = "setsockopt - IP_MULTICAST_TTL"; goto fail; }
3036
3037 // And start listening for packets
3038 struct sockaddr_in listening_sockaddr;
3039 listening_sockaddr.sin_family = AF_INET;
3040 listening_sockaddr.sin_port = port.NotAnInteger; // Pass in opaque ID without any byte swapping
3041 listening_sockaddr.sin_addr.s_addr = mDNSSameIPPort(port, NATPMPAnnouncementPort) ? AllHosts_v4.NotAnInteger : 0;
3042 err = bind(skt, (struct sockaddr *) &listening_sockaddr, sizeof(listening_sockaddr));
3043 if (err) { errstr = "bind"; goto fail; }
3044 if (outport) outport->NotAnInteger = listening_sockaddr.sin_port;
3045 }
3046 else if (sa_family == AF_INET6)
3047 {
3048 // NAT-PMP Announcements make no sense on IPv6, and we don't support IPv6 for PCP, so bail early w/o error
3049 if (mDNSSameIPPort(port, NATPMPAnnouncementPort)) { if (outport) *outport = zeroIPPort;return mStatus_NoError; }
3050
3051 // We want to receive destination addresses and receive interface identifiers
3052 err = setsockopt(skt, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on));
3053 if (err < 0) { errstr = "setsockopt - IPV6_RECVPKTINFO"; goto fail; }
3054
3055 // We want to receive packet hop count value so we can check it
3056 err = setsockopt(skt, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof(on));
3057 if (err < 0) { errstr = "setsockopt - IPV6_RECVHOPLIMIT"; goto fail; }
3058
3059 // We want to receive only IPv6 packets. Without this option we get IPv4 packets too,
3060 // with mapped addresses of the form 0:0:0:0:0:FFFF:xxxx:xxxx, where xxxx:xxxx is the IPv4 address
3061 err = setsockopt(skt, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
3062 if (err < 0) { errstr = "setsockopt - IPV6_V6ONLY"; goto fail; }
3063
3064 // Send unicast packets with TTL 255
3065 err = setsockopt(skt, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &twofivefive, sizeof(twofivefive));
3066 if (err < 0) { errstr = "setsockopt - IPV6_UNICAST_HOPS"; goto fail; }
3067
3068 // And multicast packets with TTL 255 too
3069 err = setsockopt(skt, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &twofivefive, sizeof(twofivefive));
3070 if (err < 0) { errstr = "setsockopt - IPV6_MULTICAST_HOPS"; goto fail; }
3071
3072 // Want to receive our own packets
3073 err = setsockopt(skt, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &on, sizeof(on));
3074 if (err < 0) { errstr = "setsockopt - IPV6_MULTICAST_LOOP"; goto fail; }
3075
3076 // Disable default option to send mDNSv6 packets at min IPv6 MTU: RFC 3542, Sec 11
3077 err = setsockopt(skt, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &mtu, sizeof(mtu));
3078 if (err < 0) // Since it is an optimization if we fail just log the err, no need to close the skt
3079 LogMsg("SetupSocket: setsockopt - IPV6_USE_MIN_MTU: IP6PO_MINMTU_DISABLE socket %d err %d errno %d (%s)",
3080 skt, err, errno, strerror(errno));
3081
3082 // And start listening for packets
3083 struct sockaddr_in6 listening_sockaddr6;
3084 mDNSPlatformMemZero(&listening_sockaddr6, sizeof(listening_sockaddr6));
3085 listening_sockaddr6.sin6_len = sizeof(listening_sockaddr6);
3086 listening_sockaddr6.sin6_family = AF_INET6;
3087 listening_sockaddr6.sin6_port = port.NotAnInteger; // Pass in opaque ID without any byte swapping
3088 listening_sockaddr6.sin6_flowinfo = 0;
3089 listening_sockaddr6.sin6_addr = in6addr_any; // Want to receive multicasts AND unicasts on this socket
3090 listening_sockaddr6.sin6_scope_id = 0;
3091 err = bind(skt, (struct sockaddr *) &listening_sockaddr6, sizeof(listening_sockaddr6));
3092 if (err) { errstr = "bind"; goto fail; }
3093 if (outport) outport->NotAnInteger = listening_sockaddr6.sin6_port;
3094 }
3095
3096 fcntl(skt, F_SETFL, fcntl(skt, F_GETFL, 0) | O_NONBLOCK); // set non-blocking
3097 fcntl(skt, F_SETFD, 1); // set close-on-exec
3098 *s = skt;
3099 k->KQcallback = myKQSocketCallBack;
3100 k->KQcontext = cp;
3101 k->KQtask = "UDP packet reception";
3102 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
3103 k->readSource = mDNSNULL;
3104 k->writeSource = mDNSNULL;
3105 k->fdClosed = mDNSfalse;
3106 #endif
3107 KQueueSet(*s, EV_ADD, EVFILT_READ, k);
3108
3109 return(err);
3110
3111 fail:
3112 // For "bind" failures, only write log messages for our shared mDNS port, or for binding to zero
3113 if (strcmp(errstr, "bind") || mDNSSameIPPort(port, MulticastDNSPort) || mDNSIPPortIsZero(port))
3114 LogMsg("%s skt %d port %d error %d errno %d (%s)", errstr, skt, mDNSVal16(port), err, errno, strerror(errno));
3115
3116 // If we got a "bind" failure of EADDRINUSE, inform the caller as it might need to try another random port
3117 if (!strcmp(errstr, "bind") && errno == EADDRINUSE)
3118 {
3119 err = EADDRINUSE;
3120 if (mDNSSameIPPort(port, MulticastDNSPort))
3121 NotifyOfElusiveBug("Setsockopt SO_REUSEPORT failed",
3122 "Congratulations, you've reproduced an elusive bug.\r"
3123 "Please contact the current assignee of <rdar://problem/3814904>.\r"
3124 "Alternatively, you can send email to radar-3387020@group.apple.com. (Note number is different.)\r"
3125 "If possible, please leave your machine undisturbed so that someone can come to investigate the problem.");
3126 }
3127
3128 mDNSPlatformCloseFD(k, skt);
3129 return(err);
3130 }
3131
3132 mDNSexport UDPSocket *mDNSPlatformUDPSocket(mDNS *const m, const mDNSIPPort requestedport)
3133 {
3134 mStatus err;
3135 mDNSIPPort port = requestedport;
3136 mDNSBool randomizePort = mDNSIPPortIsZero(requestedport);
3137 int i = 10000; // Try at most 10000 times to get a unique random port
3138 UDPSocket *p = mallocL("UDPSocket", sizeof(UDPSocket));
3139 if (!p) { LogMsg("mDNSPlatformUDPSocket: memory exhausted"); return(mDNSNULL); }
3140 mDNSPlatformMemZero(p, sizeof(UDPSocket));
3141 p->ss.port = zeroIPPort;
3142 p->ss.m = m;
3143 p->ss.sktv4 = -1;
3144 p->ss.sktv6 = -1;
3145 p->ss.proxy = mDNSfalse;
3146
3147 do
3148 {
3149 // The kernel doesn't do cryptographically strong random port allocation, so we do it ourselves here
3150 if (randomizePort) port = mDNSOpaque16fromIntVal(0xC000 + mDNSRandom(0x3FFF));
3151 err = SetupSocket(&p->ss, port, AF_INET, &p->ss.port);
3152 if (!err)
3153 {
3154 err = SetupSocket(&p->ss, port, AF_INET6, &p->ss.port);
3155 if (err) { mDNSPlatformCloseFD(&p->ss.kqsv4, p->ss.sktv4); p->ss.sktv4 = -1; }
3156 }
3157 i--;
3158 } while (err == EADDRINUSE && randomizePort && i);
3159
3160 if (err)
3161 {
3162 // In customer builds we don't want to log failures with port 5351, because this is a known issue
3163 // of failing to bind to this port when Internet Sharing has already bound to it
3164 // We also don't want to log about port 5350, due to a known bug when some other
3165 // process is bound to it.
3166 if (mDNSSameIPPort(requestedport, NATPMPPort) || mDNSSameIPPort(requestedport, NATPMPAnnouncementPort))
3167 LogInfo("mDNSPlatformUDPSocket: SetupSocket %d failed error %d errno %d (%s)", mDNSVal16(requestedport), err, errno, strerror(errno));
3168 else LogMsg("mDNSPlatformUDPSocket: SetupSocket %d failed error %d errno %d (%s)", mDNSVal16(requestedport), err, errno, strerror(errno));
3169 freeL("UDPSocket", p);
3170 return(mDNSNULL);
3171 }
3172 return(p);
3173 }
3174
3175 mDNSexport void mDNSPlatformUDPClose(UDPSocket *sock)
3176 {
3177 CloseSocketSet(&sock->ss);
3178 freeL("UDPSocket", sock);
3179 }
3180
3181 #if COMPILER_LIKES_PRAGMA_MARK
3182 #pragma mark -
3183 #pragma mark - BPF Raw packet sending/receiving
3184 #endif
3185
3186 #if APPLE_OSX_mDNSResponder
3187
3188 mDNSexport void mDNSPlatformSendRawPacket(const void *const msg, const mDNSu8 *const end, mDNSInterfaceID InterfaceID)
3189 {
3190 if (!InterfaceID) { LogMsg("mDNSPlatformSendRawPacket: No InterfaceID specified"); return; }
3191 NetworkInterfaceInfoOSX *info;
3192
3193 info = IfindexToInterfaceInfoOSX(&mDNSStorage, InterfaceID);
3194 if (info == NULL)
3195 {
3196 LogMsg("mDNSPlatformSendUDP: Invalid interface index %p", InterfaceID);
3197 return;
3198 }
3199 if (info->BPF_fd < 0)
3200 LogMsg("mDNSPlatformSendRawPacket: %s BPF_fd %d not ready", info->ifinfo.ifname, info->BPF_fd);
3201 else
3202 {
3203 //LogMsg("mDNSPlatformSendRawPacket %d bytes on %s", end - (mDNSu8 *)msg, info->ifinfo.ifname);
3204 if (write(info->BPF_fd, msg, end - (mDNSu8 *)msg) < 0)
3205 LogMsg("mDNSPlatformSendRawPacket: BPF write(%d) failed %d (%s)", info->BPF_fd, errno, strerror(errno));
3206 }
3207 }
3208
3209 mDNSexport void mDNSPlatformSetLocalAddressCacheEntry(mDNS *const m, const mDNSAddr *const tpa, const mDNSEthAddr *const tha, mDNSInterfaceID InterfaceID)
3210 {
3211 if (!InterfaceID) { LogMsg("mDNSPlatformSetLocalAddressCacheEntry: No InterfaceID specified"); return; }
3212 NetworkInterfaceInfoOSX *info;
3213 info = IfindexToInterfaceInfoOSX(m, InterfaceID);
3214 if (info == NULL) { LogMsg("mDNSPlatformSetLocalAddressCacheEntry: Invalid interface index %p", InterfaceID); return; }
3215 // Manually inject an entry into our local ARP cache.
3216 // (We can't do this by sending an ARP broadcast, because the kernel only pays attention to incoming ARP packets, not outgoing.)
3217 if (!mDNS_AddressIsLocalSubnet(m, InterfaceID, tpa, mDNSNULL))
3218 LogSPS("Don't need address cache entry for %s %#a %.6a", info->ifinfo.ifname, tpa, tha);
3219 else
3220 {
3221 int result = mDNSSetLocalAddressCacheEntry(info->scope_id, tpa->type, tpa->ip.v6.b, tha->b);
3222 if (result) LogMsg("Set local address cache entry for %s %#a %.6a failed: %d", info->ifinfo.ifname, tpa, tha, result);
3223 else LogSPS("Set local address cache entry for %s %#a %.6a", info->ifinfo.ifname, tpa, tha);
3224 }
3225 }
3226
3227 mDNSlocal void CloseBPF(NetworkInterfaceInfoOSX *const i)
3228 {
3229 LogSPS("%s closing BPF fd %d", i->ifinfo.ifname, i->BPF_fd);
3230 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
3231 // close will happen in the cancel handler
3232 dispatch_source_cancel(i->BPF_source);
3233 #else
3234
3235 // Note: MUST NOT close() the underlying native BSD sockets.
3236 // CFSocketInvalidate() will do that for us, in its own good time, which may not necessarily be immediately, because
3237 // it first has to unhook the sockets from its select() call on its other thread, before it can safely close them.
3238 CFRunLoopRemoveSource(i->m->p->CFRunLoop, i->BPF_rls, kCFRunLoopDefaultMode);
3239 CFRelease(i->BPF_rls);
3240 CFSocketInvalidate(i->BPF_cfs);
3241 CFRelease(i->BPF_cfs);
3242 #endif
3243 i->BPF_fd = -1;
3244 if (i->BPF_mcfd >= 0) { close(i->BPF_mcfd); i->BPF_mcfd = -1; }
3245 }
3246
3247 mDNSlocal void bpf_callback_common(NetworkInterfaceInfoOSX *info)
3248 {
3249 KQueueLock(info->m);
3250
3251 // Now we've got the lock, make sure the kqueue thread didn't close the fd out from under us (will not be a problem once the OS X
3252 // kernel has a mechanism for dispatching all events to a single thread, but for now we have to guard against this race condition).
3253 if (info->BPF_fd < 0) goto exit;
3254
3255 ssize_t n = read(info->BPF_fd, &info->m->imsg, info->BPF_len);
3256 const mDNSu8 *ptr = (const mDNSu8 *)&info->m->imsg;
3257 const mDNSu8 *end = (const mDNSu8 *)&info->m->imsg + n;
3258 debugf("%3d: bpf_callback got %d bytes on %s", info->BPF_fd, n, info->ifinfo.ifname);
3259
3260 if (n<0)
3261 {
3262 /* <rdar://problem/10287386>
3263 * sometimes there can be a race condition btw when the bpf socket
3264 * gets data and the callback get scheduled and when we call BIOCSETF (which
3265 * clears the socket). this can cause the read to hang for a really long time
3266 * and effectively prevent us from responding to requests for long periods of time.
3267 * to prevent this make the socket non blocking and just bail if we dont get anything
3268 */
3269 if (errno == EAGAIN)
3270 {
3271 LogMsg("bpf_callback got EAGAIN bailing");
3272 goto exit;
3273 }
3274 LogMsg("Closing %s BPF fd %d due to error %d (%s)", info->ifinfo.ifname, info->BPF_fd, errno, strerror(errno));
3275 CloseBPF(info);
3276 goto exit;
3277 }
3278
3279 while (ptr < end)
3280 {
3281 const struct bpf_hdr *const bh = (const struct bpf_hdr *)ptr;
3282 debugf("%3d: bpf_callback ptr %p bh_hdrlen %d data %p bh_caplen %4d bh_datalen %4d next %p remaining %4d",
3283 info->BPF_fd, ptr, bh->bh_hdrlen, ptr + bh->bh_hdrlen, bh->bh_caplen, bh->bh_datalen,
3284 ptr + BPF_WORDALIGN(bh->bh_hdrlen + bh->bh_caplen), end - (ptr + BPF_WORDALIGN(bh->bh_hdrlen + bh->bh_caplen)));
3285 // Note that BPF guarantees that the NETWORK LAYER header will be word aligned, not the link-layer header.
3286 // Given that An Ethernet header is 14 bytes, this means that if the network layer header (e.g. IP header,
3287 // ARP message, etc.) is 4-byte aligned, then necessarily the Ethernet header will be NOT be 4-byte aligned.
3288 mDNSCoreReceiveRawPacket(info->m, ptr + bh->bh_hdrlen, ptr + bh->bh_hdrlen + bh->bh_caplen, info->ifinfo.InterfaceID);
3289 ptr += BPF_WORDALIGN(bh->bh_hdrlen + bh->bh_caplen);
3290 }
3291 exit:
3292 KQueueUnlock(info->m, "bpf_callback");
3293 }
3294 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
3295 mDNSlocal void bpf_callback_dispatch(NetworkInterfaceInfoOSX *const info)
3296 {
3297 bpf_callback_common(info);
3298 }
3299 #else
3300 mDNSlocal void bpf_callback(const CFSocketRef cfs, const CFSocketCallBackType CallBackType, const CFDataRef address, const void *const data, void *const context)
3301 {
3302 (void)cfs;
3303 (void)CallBackType;
3304 (void)address;
3305 (void)data;
3306 bpf_callback_common((NetworkInterfaceInfoOSX *)context);
3307 }
3308 #endif
3309
3310 mDNSexport void mDNSPlatformSendKeepalive(mDNSAddr *sadd, mDNSAddr *dadd, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu32 seq, mDNSu32 ack, mDNSu16 win)
3311 {
3312 LogMsg("mDNSPlatformSendKeepalive called\n");
3313 mDNSSendKeepalive(sadd->ip.v6.b, dadd->ip.v6.b, lport->NotAnInteger, rport->NotAnInteger, seq, ack, win);
3314 }
3315
3316 mDNSexport mStatus mDNSPlatformClearSPSMACAddr(void)
3317 {
3318 SCDynamicStoreRef store = NULL;
3319 CFStringRef entityname = NULL;
3320
3321 if ((store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:ClearSPSMACAddress"), NULL, NULL)))
3322 {
3323 if ((entityname = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%s%s%s"), "State:/Network/Interface/", "[^/]", "/BonjourSleepProxyAddress")))
3324 {
3325 if (SCDynamicStoreRemoveValue(store, entityname) == false)
3326 LogMsg("mDNSPlatformClearSPSMACAddr: Unable to remove key");
3327 }
3328 }
3329
3330 if (entityname) CFRelease(entityname);
3331 if (store) CFRelease(store);
3332 return KERN_SUCCESS;
3333 }
3334
3335 mDNSexport mStatus mDNSPlatformStoreSPSMACAddr(mDNSAddr *spsaddr, char *ifname)
3336 {
3337 int family = (spsaddr->type == mDNSAddrType_IPv4) ? AF_INET : AF_INET6;
3338 LogSPS("mDNSPlatformStoreSPSMACAddr : Storing %#a on interface %s", spsaddr, ifname);
3339 mDNSStoreSPSMACAddress(family, spsaddr->ip.v6.b, ifname);
3340 return KERN_SUCCESS;
3341 }
3342
3343 mDNSexport mStatus mDNSPlatformGetRemoteMacAddr(mDNS *const m, mDNSAddr *raddr)
3344 {
3345 int family = (raddr->type == mDNSAddrType_IPv4) ? AF_INET : AF_INET6;
3346
3347 mDNSGetRemoteMAC(m, family, raddr->ip.v6.b);
3348 return KERN_SUCCESS;
3349 }
3350
3351 mDNSexport mStatus mDNSPlatformRetrieveTCPInfo(mDNS *const m, mDNSAddr *laddr, mDNSIPPort *lport, mDNSAddr *raddr, mDNSIPPort *rport, mDNSTCPInfo *mti)
3352 {
3353 mDNSs32 intfid;
3354 mDNSs32 error = 0;
3355 int family = (laddr->type == mDNSAddrType_IPv4) ? AF_INET : AF_INET6;
3356
3357 error = mDNSRetrieveTCPInfo(family, laddr->ip.v6.b, lport->NotAnInteger, raddr->ip.v6.b, rport->NotAnInteger, (uint32_t *)&(mti->seq), (uint32_t *)&(mti->ack), (uint16_t *)&(mti->window), (int32_t*)&intfid);
3358 if (error != KERN_SUCCESS)
3359 {
3360 LogMsg("%s: mDNSRetrieveTCPInfo returned : %d", __func__, error);
3361 return error;
3362 }
3363 mti->IntfId = mDNSPlatformInterfaceIDfromInterfaceIndex(m, intfid);
3364 return error;
3365 }
3366
3367 #define BPF_SetOffset(from, cond, to) (from)->cond = (to) - 1 - (from)
3368
3369 mDNSlocal int CountProxyTargets(mDNS *const m, NetworkInterfaceInfoOSX *x, int *p4, int *p6)
3370 {
3371 int numv4 = 0, numv6 = 0;
3372 AuthRecord *rr;
3373
3374 for (rr = m->ResourceRecords; rr; rr=rr->next)
3375 if (rr->resrec.InterfaceID == x->ifinfo.InterfaceID && rr->AddressProxy.type == mDNSAddrType_IPv4)
3376 {
3377 if (p4) LogSPS("CountProxyTargets: fd %d %-7s IP%2d %.4a", x->BPF_fd, x->ifinfo.ifname, numv4, &rr->AddressProxy.ip.v4);
3378 numv4++;
3379 }
3380
3381 for (rr = m->ResourceRecords; rr; rr=rr->next)
3382 if (rr->resrec.InterfaceID == x->ifinfo.InterfaceID && rr->AddressProxy.type == mDNSAddrType_IPv6)
3383 {
3384 if (p6) LogSPS("CountProxyTargets: fd %d %-7s IP%2d %.16a", x->BPF_fd, x->ifinfo.ifname, numv6, &rr->AddressProxy.ip.v6);
3385 numv6++;
3386 }
3387
3388 if (p4) *p4 = numv4;
3389 if (p6) *p6 = numv6;
3390 return(numv4 + numv6);
3391 }
3392
3393 mDNSexport void mDNSPlatformUpdateProxyList(mDNS *const m, const mDNSInterfaceID InterfaceID)
3394 {
3395 NetworkInterfaceInfoOSX *x;
3396
3397 // Note: We can't use IfIndexToInterfaceInfoOSX because that looks for Registered also.
3398 for (x = m->p->InterfaceList; x; x = x->next) if (x->ifinfo.InterfaceID == InterfaceID) break;
3399
3400 if (!x) { LogMsg("mDNSPlatformUpdateProxyList: ERROR InterfaceID %p not found", InterfaceID); return; }
3401
3402 #define MAX_BPF_ADDRS 250
3403 int numv4 = 0, numv6 = 0;
3404
3405 if (CountProxyTargets(m, x, &numv4, &numv6) > MAX_BPF_ADDRS)
3406 {
3407 LogMsg("mDNSPlatformUpdateProxyList: ERROR Too many address proxy records v4 %d v6 %d", numv4, numv6);
3408 if (numv4 > MAX_BPF_ADDRS) numv4 = MAX_BPF_ADDRS;
3409 numv6 = MAX_BPF_ADDRS - numv4;
3410 }
3411
3412 LogSPS("mDNSPlatformUpdateProxyList: fd %d %-7s MAC %.6a %d v4 %d v6", x->BPF_fd, x->ifinfo.ifname, &x->ifinfo.MAC, numv4, numv6);
3413
3414 // Caution: This is a static structure, so we need to be careful that any modifications we make to it
3415 // are done in such a way that they work correctly when mDNSPlatformUpdateProxyList is called multiple times
3416 static struct bpf_insn filter[17 + MAX_BPF_ADDRS] =
3417 {
3418 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 12), // 0 Read Ethertype (bytes 12,13)
3419
3420 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0806, 0, 1), // 1 If Ethertype == ARP goto next, else 3
3421 BPF_STMT(BPF_RET + BPF_K, 42), // 2 Return 42-byte ARP
3422
3423 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0800, 4, 0), // 3 If Ethertype == IPv4 goto 8 (IPv4 address list check) else next
3424
3425 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x86DD, 0, 9), // 4 If Ethertype == IPv6 goto next, else exit
3426 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20), // 5 Read Protocol and Hop Limit (bytes 20,21)
3427 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x3AFF, 0, 9), // 6 If (Prot,TTL) == (3A,FF) goto next, else IPv6 address list check
3428 BPF_STMT(BPF_RET + BPF_K, 86), // 7 Return 86-byte ND
3429
3430 // Is IPv4 packet; check if it's addressed to any IPv4 address we're proxying for
3431 BPF_STMT(BPF_LD + BPF_W + BPF_ABS, 30), // 8 Read IPv4 Dst (bytes 30,31,32,33)
3432 };
3433
3434 struct bpf_insn *pc = &filter[9];
3435 struct bpf_insn *chk6 = pc + numv4 + 1; // numv4 address checks, plus a "return 0"
3436 struct bpf_insn *fail = chk6 + 1 + numv6; // Get v6 Dst LSW, plus numv6 address checks
3437 struct bpf_insn *ret4 = fail + 1;
3438 struct bpf_insn *ret6 = ret4 + 4;
3439
3440 static const struct bpf_insn rf = BPF_STMT(BPF_RET + BPF_K, 0); // No match: Return nothing
3441
3442 static const struct bpf_insn g6 = BPF_STMT(BPF_LD + BPF_W + BPF_ABS, 50); // Read IPv6 Dst LSW (bytes 50,51,52,53)
3443
3444 static const struct bpf_insn r4a = BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 14); // Get IP Header length (normally 20)
3445 static const struct bpf_insn r4b = BPF_STMT(BPF_LD + BPF_IMM, 54); // A = 54 (14-byte Ethernet plus 20-byte TCP + 20 bytes spare)
3446 static const struct bpf_insn r4c = BPF_STMT(BPF_ALU + BPF_ADD + BPF_X, 0); // A += IP Header length
3447 static const struct bpf_insn r4d = BPF_STMT(BPF_RET + BPF_A, 0); // Success: Return Ethernet + IP + TCP + 20 bytes spare (normally 74)
3448
3449 static const struct bpf_insn r6a = BPF_STMT(BPF_RET + BPF_K, 94); // Success: Return Eth + IPv6 + TCP + 20 bytes spare
3450
3451 BPF_SetOffset(&filter[4], jf, fail); // If Ethertype not ARP, IPv4, or IPv6, fail
3452 BPF_SetOffset(&filter[6], jf, chk6); // If IPv6 but not ICMPv6, go to IPv6 address list check
3453
3454 // BPF Byte-Order Note
3455 // The BPF API designers apparently thought that programmers would not be smart enough to use htons
3456 // and htonl correctly to convert numeric values to network byte order on little-endian machines,
3457 // so instead they chose to make the API implicitly byte-swap *ALL* values, even literal byte strings
3458 // that shouldn't be byte-swapped, like ASCII text, Ethernet addresses, IP addresses, etc.
3459 // As a result, if we put Ethernet addresses and IP addresses in the right byte order, the BPF API
3460 // will byte-swap and make them backwards, and then our filter won't work. So, we have to arrange
3461 // that on little-endian machines we deliberately put addresses in memory with the bytes backwards,
3462 // so that when the BPF API goes through and swaps them all, they end up back as they should be.
3463 // In summary, if we byte-swap all the non-numeric fields that shouldn't be swapped, and we *don't*
3464 // swap any of the numeric values that *should* be byte-swapped, then the filter will work correctly.
3465
3466 // IPSEC capture size notes:
3467 // 8 bytes UDP header
3468 // 4 bytes Non-ESP Marker
3469 // 28 bytes IKE Header
3470 // --
3471 // 40 Total. Capturing TCP Header + 20 gets us enough bytes to receive the IKE Header in a UDP-encapsulated IKE packet.
3472
3473 AuthRecord *rr;
3474 for (rr = m->ResourceRecords; rr; rr=rr->next)
3475 if (rr->resrec.InterfaceID == InterfaceID && rr->AddressProxy.type == mDNSAddrType_IPv4)
3476 {
3477 mDNSv4Addr a = rr->AddressProxy.ip.v4;
3478 pc->code = BPF_JMP + BPF_JEQ + BPF_K;
3479 BPF_SetOffset(pc, jt, ret4);
3480 pc->jf = 0;
3481 pc->k = (bpf_u_int32)a.b[0] << 24 | (bpf_u_int32)a.b[1] << 16 | (bpf_u_int32)a.b[2] << 8 | (bpf_u_int32)a.b[3];
3482 pc++;
3483 }
3484 *pc++ = rf;
3485
3486 if (pc != chk6) LogMsg("mDNSPlatformUpdateProxyList: pc %p != chk6 %p", pc, chk6);
3487 *pc++ = g6; // chk6 points here
3488
3489 // First cancel any previous ND group memberships we had, then create a fresh socket
3490 if (x->BPF_mcfd >= 0) close(x->BPF_mcfd);
3491 x->BPF_mcfd = socket(AF_INET6, SOCK_DGRAM, 0);
3492
3493 for (rr = m->ResourceRecords; rr; rr=rr->next)
3494 if (rr->resrec.InterfaceID == InterfaceID && rr->AddressProxy.type == mDNSAddrType_IPv6)
3495 {
3496 const mDNSv6Addr *const a = &rr->AddressProxy.ip.v6;
3497 pc->code = BPF_JMP + BPF_JEQ + BPF_K;
3498 BPF_SetOffset(pc, jt, ret6);
3499 pc->jf = 0;
3500 pc->k = (bpf_u_int32)a->b[0x0C] << 24 | (bpf_u_int32)a->b[0x0D] << 16 | (bpf_u_int32)a->b[0x0E] << 8 | (bpf_u_int32)a->b[0x0F];
3501 pc++;
3502
3503 struct ipv6_mreq i6mr;
3504 i6mr.ipv6mr_interface = x->scope_id;
3505 i6mr.ipv6mr_multiaddr = *(const struct in6_addr*)&NDP_prefix;
3506 i6mr.ipv6mr_multiaddr.s6_addr[0xD] = a->b[0xD];
3507 i6mr.ipv6mr_multiaddr.s6_addr[0xE] = a->b[0xE];
3508 i6mr.ipv6mr_multiaddr.s6_addr[0xF] = a->b[0xF];
3509
3510 // Do precautionary IPV6_LEAVE_GROUP first, necessary to clear stale kernel state
3511 mStatus err = setsockopt(x->BPF_mcfd, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &i6mr, sizeof(i6mr));
3512 if (err < 0 && (errno != EADDRNOTAVAIL))
3513 LogMsg("mDNSPlatformUpdateProxyList: IPV6_LEAVE_GROUP error %d errno %d (%s) group %.16a on %u", err, errno, strerror(errno), &i6mr.ipv6mr_multiaddr, i6mr.ipv6mr_interface);
3514
3515 err = setsockopt(x->BPF_mcfd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &i6mr, sizeof(i6mr));
3516 if (err < 0 && (errno != EADDRINUSE)) // Joining same group twice can give "Address already in use" error -- no need to report that
3517 LogMsg("mDNSPlatformUpdateProxyList: IPV6_JOIN_GROUP error %d errno %d (%s) group %.16a on %u", err, errno, strerror(errno), &i6mr.ipv6mr_multiaddr, i6mr.ipv6mr_interface);
3518
3519 LogSPS("Joined IPv6 ND multicast group %.16a for %.16a", &i6mr.ipv6mr_multiaddr, a);
3520 }
3521
3522 if (pc != fail) LogMsg("mDNSPlatformUpdateProxyList: pc %p != fail %p", pc, fail);
3523 *pc++ = rf; // fail points here
3524
3525 if (pc != ret4) LogMsg("mDNSPlatformUpdateProxyList: pc %p != ret4 %p", pc, ret4);
3526 *pc++ = r4a; // ret4 points here
3527 *pc++ = r4b;
3528 *pc++ = r4c;
3529 *pc++ = r4d;
3530
3531 if (pc != ret6) LogMsg("mDNSPlatformUpdateProxyList: pc %p != ret6 %p", pc, ret6);
3532 *pc++ = r6a; // ret6 points here
3533
3534 struct bpf_program prog = { pc - filter, filter };
3535
3536 #if 0
3537 // For debugging BPF filter program
3538 unsigned int q;
3539 for (q=0; q<prog.bf_len; q++)
3540 LogSPS("mDNSPlatformUpdateProxyList: %2d { 0x%02x, %d, %d, 0x%08x },", q, prog.bf_insns[q].code, prog.bf_insns[q].jt, prog.bf_insns[q].jf, prog.bf_insns[q].k);
3541 #endif
3542
3543 if (!numv4 && !numv6)
3544 {
3545 LogSPS("mDNSPlatformUpdateProxyList: No need for filter");
3546 if (m->timenow == 0) LogMsg("mDNSPlatformUpdateProxyList: m->timenow == 0");
3547 // Schedule check to see if we can close this BPF_fd now
3548 if (!m->p->NetworkChanged) m->p->NetworkChanged = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 2);
3549 // prog.bf_len = 0; This seems to panic the kernel
3550 if (x->BPF_fd < 0) return; // If we've already closed our BPF_fd, no need to generate an error message below
3551 }
3552
3553 if (ioctl(x->BPF_fd, BIOCSETFNR, &prog) < 0) LogMsg("mDNSPlatformUpdateProxyList: BIOCSETFNR(%d) failed %d (%s)", prog.bf_len, errno, strerror(errno));
3554 else LogSPS("mDNSPlatformUpdateProxyList: BIOCSETFNR(%d) successful", prog.bf_len);
3555 }
3556
3557 mDNSexport void mDNSPlatformReceiveBPF_fd(mDNS *const m, int fd)
3558 {
3559 mDNS_Lock(m);
3560
3561 NetworkInterfaceInfoOSX *i;
3562 for (i = m->p->InterfaceList; i; i = i->next) if (i->BPF_fd == -2) break;
3563 if (!i) { LogSPS("mDNSPlatformReceiveBPF_fd: No Interfaces awaiting BPF fd %d; closing", fd); close(fd); }
3564 else
3565 {
3566 LogSPS("%s using BPF fd %d", i->ifinfo.ifname, fd);
3567
3568 struct bpf_version v;
3569 if (ioctl(fd, BIOCVERSION, &v) < 0)
3570 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCVERSION failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3571 else if (BPF_MAJOR_VERSION != v.bv_major || BPF_MINOR_VERSION != v.bv_minor)
3572 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCVERSION header %d.%d kernel %d.%d",
3573 fd, i->ifinfo.ifname, BPF_MAJOR_VERSION, BPF_MINOR_VERSION, v.bv_major, v.bv_minor);
3574
3575 if (ioctl(fd, BIOCGBLEN, &i->BPF_len) < 0)
3576 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCGBLEN failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3577
3578 if (i->BPF_len > sizeof(m->imsg))
3579 {
3580 i->BPF_len = sizeof(m->imsg);
3581 if (ioctl(fd, BIOCSBLEN, &i->BPF_len) < 0)
3582 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCSBLEN failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3583 else
3584 LogSPS("mDNSPlatformReceiveBPF_fd: %d %s BIOCSBLEN %d", fd, i->ifinfo.ifname, i->BPF_len);
3585 }
3586
3587 static const u_int opt_one = 1;
3588 if (ioctl(fd, BIOCIMMEDIATE, &opt_one) < 0)
3589 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCIMMEDIATE failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3590
3591 //if (ioctl(fd, BIOCPROMISC, &opt_one) < 0)
3592 // LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCPROMISC failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3593
3594 //if (ioctl(fd, BIOCSHDRCMPLT, &opt_one) < 0)
3595 // LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCSHDRCMPLT failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3596
3597 /* <rdar://problem/10287386>
3598 * make socket non blocking see comments in bpf_callback_common for more info
3599 */
3600 if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) < 0) // set non-blocking
3601 {
3602 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s O_NONBLOCK failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno));
3603 }
3604
3605 struct ifreq ifr;
3606 mDNSPlatformMemZero(&ifr, sizeof(ifr));
3607 strlcpy(ifr.ifr_name, i->ifinfo.ifname, sizeof(ifr.ifr_name));
3608 if (ioctl(fd, BIOCSETIF, &ifr) < 0)
3609 { LogMsg("mDNSPlatformReceiveBPF_fd: %d %s BIOCSETIF failed %d (%s)", fd, i->ifinfo.ifname, errno, strerror(errno)); i->BPF_fd = -3; }
3610 else
3611 {
3612 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
3613 i->BPF_fd = fd;
3614 i->BPF_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, fd, 0, dispatch_get_main_queue());
3615 if (!i->BPF_source) {LogMsg("mDNSPlatformReceiveBPF_fd: dispatch source create failed"); return;}
3616 dispatch_source_set_event_handler(i->BPF_source, ^{bpf_callback_dispatch(i);});
3617 dispatch_source_set_cancel_handler(i->BPF_source, ^{close(fd);});
3618 dispatch_resume(i->BPF_source);
3619 #else
3620 CFSocketContext myCFSocketContext = { 0, i, NULL, NULL, NULL };
3621 i->BPF_fd = fd;
3622 i->BPF_cfs = CFSocketCreateWithNative(kCFAllocatorDefault, fd, kCFSocketReadCallBack, bpf_callback, &myCFSocketContext);
3623 i->BPF_rls = CFSocketCreateRunLoopSource(kCFAllocatorDefault, i->BPF_cfs, 0);
3624 CFRunLoopAddSource(i->m->p->CFRunLoop, i->BPF_rls, kCFRunLoopDefaultMode);
3625 #endif
3626 mDNSPlatformUpdateProxyList(m, i->ifinfo.InterfaceID);
3627 }
3628 }
3629
3630 mDNS_Unlock(m);
3631 }
3632
3633 #endif // APPLE_OSX_mDNSResponder
3634
3635 #if COMPILER_LIKES_PRAGMA_MARK
3636 #pragma mark -
3637 #pragma mark - Key Management
3638 #endif
3639
3640 #ifndef NO_SECURITYFRAMEWORK
3641 mDNSlocal CFArrayRef GetCertChain(SecIdentityRef identity)
3642 {
3643 CFMutableArrayRef certChain = NULL;
3644 if (!identity) { LogMsg("getCertChain: identity is NULL"); return(NULL); }
3645 SecCertificateRef cert;
3646 OSStatus err = SecIdentityCopyCertificate(identity, &cert);
3647 if (err || !cert) LogMsg("getCertChain: SecIdentityCopyCertificate() returned %d", (int) err);
3648 else
3649 {
3650 SecPolicySearchRef searchRef;
3651 err = SecPolicySearchCreate(CSSM_CERT_X_509v3, &CSSMOID_APPLE_X509_BASIC, NULL, &searchRef);
3652 if (err || !searchRef) LogMsg("getCertChain: SecPolicySearchCreate() returned %d", (int) err);
3653 else
3654 {
3655 SecPolicyRef policy;
3656 err = SecPolicySearchCopyNext(searchRef, &policy);
3657 if (err || !policy) LogMsg("getCertChain: SecPolicySearchCopyNext() returned %d", (int) err);
3658 else
3659 {
3660 CFArrayRef wrappedCert = CFArrayCreate(NULL, (const void**) &cert, 1, &kCFTypeArrayCallBacks);
3661 if (!wrappedCert) LogMsg("getCertChain: wrappedCert is NULL");
3662 else
3663 {
3664 SecTrustRef trust;
3665 err = SecTrustCreateWithCertificates(wrappedCert, policy, &trust);
3666 if (err || !trust) LogMsg("getCertChain: SecTrustCreateWithCertificates() returned %d", (int) err);
3667 else
3668 {
3669 err = SecTrustEvaluate(trust, NULL);
3670 if (err) LogMsg("getCertChain: SecTrustEvaluate() returned %d", (int) err);
3671 else
3672 {
3673 CFArrayRef rawCertChain;
3674 CSSM_TP_APPLE_EVIDENCE_INFO *statusChain = NULL;
3675 err = SecTrustGetResult(trust, NULL, &rawCertChain, &statusChain);
3676 if (err || !rawCertChain || !statusChain) LogMsg("getCertChain: SecTrustGetResult() returned %d", (int) err);
3677 else
3678 {
3679 certChain = CFArrayCreateMutableCopy(NULL, 0, rawCertChain);
3680 if (!certChain) LogMsg("getCertChain: certChain is NULL");
3681 else
3682 {
3683 // Replace the SecCertificateRef at certChain[0] with a SecIdentityRef per documentation for SSLSetCertificate:
3684 // <http://devworld.apple.com/documentation/Security/Reference/secureTransportRef/index.html>
3685 CFArraySetValueAtIndex(certChain, 0, identity);
3686 // Remove root from cert chain, but keep any and all intermediate certificates that have been signed by the root certificate
3687 if (CFArrayGetCount(certChain) > 1) CFArrayRemoveValueAtIndex(certChain, CFArrayGetCount(certChain) - 1);
3688 }
3689 CFRelease(rawCertChain);
3690 // Do not free statusChain:
3691 // <http://developer.apple.com/documentation/Security/Reference/certifkeytrustservices/Reference/reference.html> says:
3692 // certChain: Call the CFRelease function to release this object when you are finished with it.
3693 // statusChain: Do not attempt to free this pointer; it remains valid until the trust management object is released...
3694 }
3695 }
3696 CFRelease(trust);
3697 }
3698 CFRelease(wrappedCert);
3699 }
3700 CFRelease(policy);
3701 }
3702 CFRelease(searchRef);
3703 }
3704 CFRelease(cert);
3705 }
3706 return certChain;
3707 }
3708 #endif /* NO_SECURITYFRAMEWORK */
3709
3710 mDNSexport mStatus mDNSPlatformTLSSetupCerts(void)
3711 {
3712 #ifdef NO_SECURITYFRAMEWORK
3713 return mStatus_UnsupportedErr;
3714 #else
3715 SecIdentityRef identity = nil;
3716 SecIdentitySearchRef srchRef = nil;
3717 OSStatus err;
3718
3719 // search for "any" identity matching specified key use
3720 // In this app, we expect there to be exactly one
3721 err = SecIdentitySearchCreate(NULL, CSSM_KEYUSE_DECRYPT, &srchRef);
3722 if (err) { LogMsg("ERROR: mDNSPlatformTLSSetupCerts: SecIdentitySearchCreate returned %d", (int) err); return err; }
3723
3724 err = SecIdentitySearchCopyNext(srchRef, &identity);
3725 if (err) { LogMsg("ERROR: mDNSPlatformTLSSetupCerts: SecIdentitySearchCopyNext returned %d", (int) err); return err; }
3726
3727 if (CFGetTypeID(identity) != SecIdentityGetTypeID())
3728 { LogMsg("ERROR: mDNSPlatformTLSSetupCerts: SecIdentitySearchCopyNext CFTypeID failure"); return mStatus_UnknownErr; }
3729
3730 // Found one. Call getCertChain to create the correct certificate chain.
3731 ServerCerts = GetCertChain(identity);
3732 if (ServerCerts == nil) { LogMsg("ERROR: mDNSPlatformTLSSetupCerts: getCertChain error"); return mStatus_UnknownErr; }
3733
3734 return mStatus_NoError;
3735 #endif /* NO_SECURITYFRAMEWORK */
3736 }
3737
3738 mDNSexport void mDNSPlatformTLSTearDownCerts(void)
3739 {
3740 #ifndef NO_SECURITYFRAMEWORK
3741 if (ServerCerts) { CFRelease(ServerCerts); ServerCerts = NULL; }
3742 #endif /* NO_SECURITYFRAMEWORK */
3743 }
3744
3745 // This gets the text of the field currently labelled "Computer Name" in the Sharing Prefs Control Panel
3746 mDNSlocal void GetUserSpecifiedFriendlyComputerName(domainlabel *const namelabel)
3747 {
3748 CFStringEncoding encoding = kCFStringEncodingUTF8;
3749 CFStringRef cfs = SCDynamicStoreCopyComputerName(NULL, &encoding);
3750 if (cfs)
3751 {
3752 CFStringGetPascalString(cfs, namelabel->c, sizeof(*namelabel), kCFStringEncodingUTF8);
3753 CFRelease(cfs);
3754 }
3755 }
3756
3757 // This gets the text of the field currently labelled "Local Hostname" in the Sharing Prefs Control Panel
3758 mDNSlocal void GetUserSpecifiedLocalHostName(domainlabel *const namelabel)
3759 {
3760 CFStringRef cfs = SCDynamicStoreCopyLocalHostName(NULL);
3761 if (cfs)
3762 {
3763 CFStringGetPascalString(cfs, namelabel->c, sizeof(*namelabel), kCFStringEncodingUTF8);
3764 CFRelease(cfs);
3765 }
3766 }
3767
3768 mDNSexport mDNSBool DictionaryIsEnabled(CFDictionaryRef dict)
3769 {
3770 mDNSs32 val;
3771 CFNumberRef state = (CFNumberRef)CFDictionaryGetValue(dict, CFSTR("Enabled"));
3772 if (!state) return mDNSfalse;
3773 if (!CFNumberGetValue(state, kCFNumberSInt32Type, &val))
3774 { LogMsg("ERROR: DictionaryIsEnabled - CFNumberGetValue"); return mDNSfalse; }
3775 return val ? mDNStrue : mDNSfalse;
3776 }
3777
3778 mDNSlocal mStatus SetupAddr(mDNSAddr *ip, const struct sockaddr *const sa)
3779 {
3780 if (!sa) { LogMsg("SetupAddr ERROR: NULL sockaddr"); return(mStatus_Invalid); }
3781
3782 if (sa->sa_family == AF_INET)
3783 {
3784 struct sockaddr_in *ifa_addr = (struct sockaddr_in *)sa;
3785 ip->type = mDNSAddrType_IPv4;
3786 ip->ip.v4.NotAnInteger = ifa_addr->sin_addr.s_addr;
3787 return(mStatus_NoError);
3788 }
3789
3790 if (sa->sa_family == AF_INET6)
3791 {
3792 struct sockaddr_in6 *ifa_addr = (struct sockaddr_in6 *)sa;
3793 // Inside the BSD kernel they use a hack where they stuff the sin6->sin6_scope_id
3794 // value into the second word of the IPv6 link-local address, so they can just
3795 // pass around IPv6 address structures instead of full sockaddr_in6 structures.
3796 // Those hacked IPv6 addresses aren't supposed to escape the kernel in that form, but they do.
3797 // To work around this we always whack the second word of any IPv6 link-local address back to zero.
3798 if (IN6_IS_ADDR_LINKLOCAL(&ifa_addr->sin6_addr)) ifa_addr->sin6_addr.__u6_addr.__u6_addr16[1] = 0;
3799 ip->type = mDNSAddrType_IPv6;
3800 ip->ip.v6 = *(mDNSv6Addr*)&ifa_addr->sin6_addr;
3801 return(mStatus_NoError);
3802 }
3803
3804 LogMsg("SetupAddr invalid sa_family %d", sa->sa_family);
3805 return(mStatus_Invalid);
3806 }
3807
3808 mDNSlocal mDNSEthAddr GetBSSID(char *ifa_name)
3809 {
3810 mDNSEthAddr eth = zeroEthAddr;
3811 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:GetBSSID"), NULL, NULL);
3812 if (!store)
3813 LogMsg("GetBSSID: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
3814 else
3815 {
3816 CFStringRef entityname = CFStringCreateWithFormat(NULL, NULL, CFSTR("State:/Network/Interface/%s/AirPort"), ifa_name);
3817 if (entityname)
3818 {
3819 CFDictionaryRef dict = SCDynamicStoreCopyValue(store, entityname);
3820 if (dict)
3821 {
3822 CFRange range = { 0, 6 }; // Offset, length
3823 CFDataRef data = CFDictionaryGetValue(dict, CFSTR("BSSID"));
3824 if (data && CFDataGetLength(data) == 6) CFDataGetBytes(data, range, eth.b);
3825 CFRelease(dict);
3826 }
3827 CFRelease(entityname);
3828 }
3829 CFRelease(store);
3830 }
3831 return(eth);
3832 }
3833
3834 mDNSlocal int GetMAC(mDNSEthAddr *eth, u_short ifindex)
3835 {
3836 struct ifaddrs *ifa;
3837 for (ifa = myGetIfAddrs(0); ifa; ifa = ifa->ifa_next)
3838 if (ifa->ifa_addr->sa_family == AF_LINK)
3839 {
3840 const struct sockaddr_dl *const sdl = (const struct sockaddr_dl *)ifa->ifa_addr;
3841 if (sdl->sdl_index == ifindex)
3842 { mDNSPlatformMemCopy(eth->b, sdl->sdl_data + sdl->sdl_nlen, 6); return 0; }
3843 }
3844 *eth = zeroEthAddr;
3845 return -1;
3846 }
3847
3848 #ifndef SIOCGIFWAKEFLAGS
3849 #define SIOCGIFWAKEFLAGS _IOWR('i', 136, struct ifreq) /* get interface wake property flags */
3850 #endif
3851
3852 #ifndef IF_WAKE_ON_MAGIC_PACKET
3853 #define IF_WAKE_ON_MAGIC_PACKET 0x01
3854 #endif
3855
3856 #ifndef ifr_wake_flags
3857 #define ifr_wake_flags ifr_ifru.ifru_intval
3858 #endif
3859
3860 mDNSlocal mDNSBool CheckInterfaceSupport(NetworkInterfaceInfo *const intf, const char *key)
3861 {
3862 io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, IOBSDNameMatching(kIOMasterPortDefault, 0, intf->ifname));
3863 if (!service)
3864 {
3865 LogSPS("CheckInterfaceSupport: No service for interface %s", intf->ifname);
3866 return mDNSfalse;
3867 }
3868
3869 io_name_t n1, n2;
3870 IOObjectGetClass(service, n1);
3871 io_object_t parent;
3872 mDNSBool ret = mDNSfalse;
3873 kern_return_t kr = IORegistryEntryGetParentEntry(service, kIOServicePlane, &parent);
3874 if (kr == KERN_SUCCESS)
3875 {
3876 CFStringRef keystr = CFStringCreateWithCString(NULL, key, kCFStringEncodingUTF8);
3877 IOObjectGetClass(parent, n2);
3878 LogSPS("CheckInterfaceSupport: Interface %s service %s parent %s", intf->ifname, n1, n2);
3879 const CFTypeRef ref = IORegistryEntryCreateCFProperty(parent, keystr, kCFAllocatorDefault, mDNSNULL);
3880 if (!ref)
3881 {
3882 LogSPS("CheckInterfaceSupport: No mDNS_IOREG_KEY for interface %s/%s/%s", intf->ifname, n1, n2);
3883 ret = mDNSfalse;
3884 }
3885 else
3886 {
3887 ret = mDNStrue;
3888 CFRelease(ref);
3889 }
3890 IOObjectRelease(parent);
3891 CFRelease(keystr);
3892 }
3893 else
3894 {
3895 LogSPS("CheckInterfaceSupport: IORegistryEntryGetParentEntry for %s/%s failed %d", intf->ifname, n1, kr);
3896 ret = mDNSfalse;
3897 }
3898 IOObjectRelease(service);
3899 return ret;
3900 }
3901
3902
3903 mDNSlocal mDNSBool InterfaceSupportsKeepAlive(NetworkInterfaceInfo *const intf)
3904 {
3905 return CheckInterfaceSupport(intf, mDNS_IOREG_KA_KEY);
3906 }
3907
3908 mDNSlocal mDNSBool NetWakeInterface(NetworkInterfaceInfoOSX *i)
3909 {
3910 if (!MulticastInterface(i) ) return(mDNSfalse); // We only use Sleep Proxy Service on multicast-capable interfaces
3911 if (i->ifa_flags & IFF_LOOPBACK) return(mDNSfalse); // except loopback
3912
3913 // If the interface supports TCPKeepalive, it is capable of waking up for a magic packet
3914 // This check is needed since the SIOCGIFWAKEFLAGS ioctl returns wrong values for WOMP capability
3915 // when the power source is not AC Power.
3916 if (InterfaceSupportsKeepAlive(&i->ifinfo))
3917 {
3918 LogSPS("NetWakeInterface: %s supports TCP Keepalive returning true", i->ifinfo.ifname);
3919 return mDNStrue;
3920 }
3921
3922 int s = socket(AF_INET, SOCK_DGRAM, 0);
3923 if (s < 0) { LogMsg("NetWakeInterface socket failed %s error %d errno %d (%s)", i->ifinfo.ifname, s, errno, strerror(errno)); return(mDNSfalse); }
3924
3925 struct ifreq ifr;
3926 strlcpy(ifr.ifr_name, i->ifinfo.ifname, sizeof(ifr.ifr_name));
3927 if (ioctl(s, SIOCGIFWAKEFLAGS, &ifr) < 0)
3928 {
3929 // For some strange reason, in /usr/include/sys/errno.h, EOPNOTSUPP is defined to be
3930 // 102 when compiling kernel code, and 45 when compiling user-level code. Since this
3931 // error code is being returned from the kernel, we need to use the kernel version.
3932 #define KERNEL_EOPNOTSUPP 102
3933 if (errno != KERNEL_EOPNOTSUPP) // "Operation not supported on socket", the expected result on Leopard and earlier
3934 LogMsg("NetWakeInterface SIOCGIFWAKEFLAGS %s errno %d (%s)", i->ifinfo.ifname, errno, strerror(errno));
3935 // If on Leopard or earlier, we get EOPNOTSUPP, so in that case
3936 // we enable WOL if this interface is not AirPort and "Wake for Network access" is turned on.
3937 ifr.ifr_wake_flags = (errno == KERNEL_EOPNOTSUPP && !(i)->BSSID.l[0] && i->m->SystemWakeOnLANEnabled) ? IF_WAKE_ON_MAGIC_PACKET : 0;
3938 }
3939
3940 close(s);
3941
3942 // ifr.ifr_wake_flags = IF_WAKE_ON_MAGIC_PACKET; // For testing with MacBook Air, using a USB dongle that doesn't actually support Wake-On-LAN
3943
3944 LogSPS("%-6s %#-14a %s WOMP", i->ifinfo.ifname, &i->ifinfo.ip, (ifr.ifr_wake_flags & IF_WAKE_ON_MAGIC_PACKET) ? "supports" : "no");
3945
3946 return((ifr.ifr_wake_flags & IF_WAKE_ON_MAGIC_PACKET) != 0);
3947 }
3948
3949 mDNSlocal u_int64_t getExtendedFlags(char * ifa_name)
3950 {
3951 int sockFD;
3952 struct ifreq ifr;
3953
3954 sockFD = socket(AF_INET, SOCK_DGRAM, 0);
3955 if (sockFD < 0)
3956 {
3957 LogMsg("getExtendedFlags: socket() call failed, errno = %d (%s)", errno, strerror(errno));
3958 return 0;
3959 }
3960
3961 ifr.ifr_addr.sa_family = AF_INET;
3962 strlcpy(ifr.ifr_name, ifa_name, sizeof(ifr.ifr_name));
3963
3964 if (ioctl(sockFD, SIOCGIFEFLAGS, (caddr_t)&ifr) == -1)
3965 {
3966 LogMsg("getExtendedFlags: SIOCGIFEFLAGS failed, errno = %d (%s)", errno, strerror(errno));
3967 ifr.ifr_eflags = 0;
3968 }
3969 LogInfo("getExtendedFlags: %s ifr_eflags = 0x%x", ifa_name, ifr.ifr_eflags);
3970
3971 close(sockFD);
3972 return ifr.ifr_eflags;
3973 }
3974
3975 // Returns pointer to newly created NetworkInterfaceInfoOSX object, or
3976 // pointer to already-existing NetworkInterfaceInfoOSX object found in list, or
3977 // may return NULL if out of memory (unlikely) or parameters are invalid for some reason
3978 // (e.g. sa_family not AF_INET or AF_INET6)
3979 mDNSlocal NetworkInterfaceInfoOSX *AddInterfaceToList(mDNS *const m, struct ifaddrs *ifa, mDNSs32 utc)
3980 {
3981 mDNSu32 scope_id = if_nametoindex(ifa->ifa_name);
3982 mDNSEthAddr bssid = GetBSSID(ifa->ifa_name);
3983 u_int64_t eflags = getExtendedFlags(ifa->ifa_name);
3984
3985 mDNSAddr ip, mask;
3986 if (SetupAddr(&ip, ifa->ifa_addr ) != mStatus_NoError) return(NULL);
3987 if (SetupAddr(&mask, ifa->ifa_netmask) != mStatus_NoError) return(NULL);
3988
3989 NetworkInterfaceInfoOSX **p;
3990 for (p = &m->p->InterfaceList; *p; p = &(*p)->next)
3991 if (scope_id == (*p)->scope_id &&
3992 mDNSSameAddress(&ip, &(*p)->ifinfo.ip) &&
3993 mDNSSameEthAddress(&bssid, &(*p)->BSSID))
3994 {
3995 debugf("AddInterfaceToList: Found existing interface %lu %.6a with address %#a at %p, ifname before %s, after %s", scope_id, &bssid, &ip, *p, (*p)->ifinfo.ifname, ifa->ifa_name);
3996 // The name should be updated to the new name so that we don't report a wrong name in our SIGINFO output.
3997 // When interfaces are created with same MAC address, kernel resurrects the old interface.
3998 // Even though the interface index is the same (which should be sufficient), when we receive a UDP packet
3999 // we get the corresponding name for the interface index on which the packet was received and check against
4000 // the InterfaceList for a matching name. So, keep the name in sync
4001 strlcpy((*p)->ifinfo.ifname, ifa->ifa_name, sizeof((*p)->ifinfo.ifname));
4002 (*p)->Exists = mDNStrue;
4003 // If interface was not in getifaddrs list last time we looked, but it is now, update 'AppearanceTime' for this record
4004 if ((*p)->LastSeen != utc) (*p)->AppearanceTime = utc;
4005
4006 // If Wake-on-LAN capability of this interface has changed (e.g. because power cable on laptop has been disconnected)
4007 // we may need to start or stop or sleep proxy browse operation
4008 const mDNSBool NetWake = NetWakeInterface(*p);
4009 if ((*p)->ifinfo.NetWake != NetWake)
4010 {
4011 (*p)->ifinfo.NetWake = NetWake;
4012 // If this interface is already registered with mDNSCore, then we need to start or stop its NetWake browse on-the-fly.
4013 // If this interface is not already registered (i.e. it's a dormant interface we had in our list
4014 // from when we previously saw it) then we mustn't do that, because mDNSCore doesn't know about it yet.
4015 // In this case, the mDNS_RegisterInterface() call will take care of starting the NetWake browse if necessary.
4016 if ((*p)->Registered)
4017 {
4018 mDNS_Lock(m);
4019 if (NetWake) mDNS_ActivateNetWake_internal (m, &(*p)->ifinfo);
4020 else mDNS_DeactivateNetWake_internal(m, &(*p)->ifinfo);
4021 mDNS_Unlock(m);
4022 }
4023 }
4024 // Reset the flag if it has changed this time.
4025 (*p)->ifinfo.IgnoreIPv4LL = ((eflags & IFEF_ARPLL) != 0) ? mDNSfalse : mDNStrue;
4026
4027 return(*p);
4028 }
4029
4030 NetworkInterfaceInfoOSX *i = (NetworkInterfaceInfoOSX *)mallocL("NetworkInterfaceInfoOSX", sizeof(*i));
4031 debugf("AddInterfaceToList: Making new interface %lu %.6a with address %#a at %p", scope_id, &bssid, &ip, i);
4032 if (!i) return(mDNSNULL);
4033 mDNSPlatformMemZero(i, sizeof(NetworkInterfaceInfoOSX));
4034 i->ifinfo.InterfaceID = (mDNSInterfaceID)(uintptr_t)scope_id;
4035 i->ifinfo.ip = ip;
4036 i->ifinfo.mask = mask;
4037 strlcpy(i->ifinfo.ifname, ifa->ifa_name, sizeof(i->ifinfo.ifname));
4038 i->ifinfo.ifname[sizeof(i->ifinfo.ifname)-1] = 0;
4039 // We can be configured to disable multicast advertisement, but we want to to support
4040 // local-only services, which need a loopback address record.
4041 i->ifinfo.Advertise = m->DivertMulticastAdvertisements ? ((ifa->ifa_flags & IFF_LOOPBACK) ? mDNStrue : mDNSfalse) : m->AdvertiseLocalAddresses;
4042 i->ifinfo.McastTxRx = mDNSfalse; // For now; will be set up later at the end of UpdateInterfaceList
4043 i->ifinfo.Loopback = ((ifa->ifa_flags & IFF_LOOPBACK) != 0) ? mDNStrue : mDNSfalse;
4044 i->ifinfo.IgnoreIPv4LL = ((eflags & IFEF_ARPLL) != 0) ? mDNSfalse : mDNStrue;
4045 i->ifinfo.DirectLink = (eflags & IFEF_DIRECTLINK) ? mDNStrue: mDNSfalse;
4046
4047 i->next = mDNSNULL;
4048 i->m = m;
4049 i->Exists = mDNStrue;
4050 i->Flashing = mDNSfalse;
4051 i->Occulting = mDNSfalse;
4052 i->D2DInterface = (eflags & IFEF_LOCALNET_PRIVATE) ? mDNStrue: mDNSfalse;
4053 if (eflags & IFEF_AWDL)
4054 {
4055 AWDLInterfaceID = i->ifinfo.InterfaceID;
4056 LogInfo("AddInterfaceToList: AWDLInterfaceID = %d", (int) AWDLInterfaceID);
4057 }
4058 i->AppearanceTime = utc; // Brand new interface; AppearanceTime is now
4059 i->LastSeen = utc;
4060 i->ifa_flags = ifa->ifa_flags;
4061 i->scope_id = scope_id;
4062 i->BSSID = bssid;
4063 i->sa_family = ifa->ifa_addr->sa_family;
4064 i->BPF_fd = -1;
4065 i->BPF_mcfd = -1;
4066 i->BPF_len = 0;
4067 i->Registered = mDNSNULL;
4068
4069 // Do this AFTER i->BSSID has been set up
4070 i->ifinfo.NetWake = NetWakeInterface(i);
4071 GetMAC(&i->ifinfo.MAC, scope_id);
4072 if (i->ifinfo.NetWake && !i->ifinfo.MAC.l[0])
4073 LogMsg("AddInterfaceToList: Bad MAC address %.6a for %d %s %#a", &i->ifinfo.MAC, scope_id, i->ifinfo.ifname, &ip);
4074
4075 *p = i;
4076 return(i);
4077 }
4078
4079 #if APPLE_OSX_mDNSResponder
4080
4081 #if COMPILER_LIKES_PRAGMA_MARK
4082 #pragma mark -
4083 #pragma mark - AutoTunnel
4084 #endif
4085
4086 #define kRacoonPort 4500
4087
4088 static DomainAuthInfo* AnonymousRacoonConfig = mDNSNULL;
4089
4090 #ifndef NO_SECURITYFRAMEWORK
4091
4092 static CFMutableDictionaryRef domainStatusDict = NULL;
4093
4094 mDNSlocal mStatus CheckQuestionForStatus(const DNSQuestion *const q)
4095 {
4096 if (q->LongLived)
4097 {
4098 if (q->servAddr.type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsOnes(q->servAddr.ip.v4))
4099 return mStatus_NoSuchRecord;
4100 else if (q->state == LLQ_Poll)
4101 return mStatus_PollingMode;
4102 else if (q->state != LLQ_Established && !q->DuplicateOf)
4103 return mStatus_TransientErr;
4104 }
4105
4106 return mStatus_NoError;
4107 }
4108
4109 mDNSlocal mStatus UpdateLLQStatus(const mDNS *const m, char *buffer, int bufsz, const DomainAuthInfo *const info)
4110 {
4111 mStatus status = mStatus_NoError;
4112 DNSQuestion* q, *worst_q = mDNSNULL;
4113 for (q = m->Questions; q; q=q->next)
4114 if (q->AuthInfo == info)
4115 {
4116 mStatus newStatus = CheckQuestionForStatus(q);
4117 if (newStatus == mStatus_NoSuchRecord) { status = newStatus; worst_q = q; break; }
4118 else if (newStatus == mStatus_PollingMode) { status = newStatus; worst_q = q; }
4119 else if (newStatus == mStatus_TransientErr && status == mStatus_NoError) { status = newStatus; worst_q = q; }
4120 }
4121
4122 if (status == mStatus_NoError) mDNS_snprintf(buffer, bufsz, "Success");
4123 else if (status == mStatus_NoSuchRecord) mDNS_snprintf(buffer, bufsz, "GetZoneData %s: %##s", worst_q->nta ? "not yet complete" : "failed", worst_q->qname.c);
4124 else if (status == mStatus_PollingMode) mDNS_snprintf(buffer, bufsz, "Query polling %##s", worst_q->qname.c);
4125 else if (status == mStatus_TransientErr) mDNS_snprintf(buffer, bufsz, "Query not yet established %##s", worst_q->qname.c);
4126 return status;
4127 }
4128
4129 mDNSlocal mStatus UpdateRRStatus(const mDNS *const m, char *buffer, int bufsz, const DomainAuthInfo *const info)
4130 {
4131 AuthRecord *r;
4132
4133 if (info->deltime) return mStatus_NoError;
4134 for (r = m->ResourceRecords; r; r = r->next)
4135 {
4136 // This function is called from UpdateAutoTunnelDomainStatus which in turn may be called from
4137 // a callback e.g., CheckNATMappings. GetAuthInfoFor_internal does not like that (reentrancy being 1),
4138 // hence we inline the code here. We just need the lock to walk the list of AuthInfos which the caller
4139 // has already checked
4140 const domainname *n = r->resrec.name;
4141 while (n->c[0])
4142 {
4143 DomainAuthInfo *ptr;
4144 for (ptr = m->AuthInfoList; ptr; ptr = ptr->next)
4145 if (SameDomainName(&ptr->domain, n))
4146 {
4147 if (ptr == info && (r->updateError == mStatus_BadSig || r->updateError == mStatus_BadKey || r->updateError == mStatus_BadTime))
4148 {
4149 mDNS_snprintf(buffer, bufsz, "Resource record update failed for %##s", r->resrec.name);
4150 return r->updateError;
4151 }
4152 }
4153 n = (const domainname *)(n->c + 1 + n->c[0]);
4154 }
4155 }
4156 return mStatus_NoError;
4157 }
4158
4159 #endif // ndef NO_SECURITYFRAMEWORK
4160
4161 // MUST be called with lock held
4162 mDNSlocal void UpdateAutoTunnelDomainStatus(const mDNS *const m, const DomainAuthInfo *const info)
4163 {
4164 #ifdef NO_SECURITYFRAMEWORK
4165 (void) m;
4166 (void)info;
4167 #else
4168 // Note that in the LLQNAT, the clientCallback being non-zero means it's in use,
4169 // whereas in the AutoTunnelNAT, the clientContext being non-zero means it's in use
4170 const NATTraversalInfo *const llq = m->LLQNAT.clientCallback ? &m->LLQNAT : mDNSNULL;
4171 const NATTraversalInfo *const tun = m->AutoTunnelNAT.clientContext ? &m->AutoTunnelNAT : mDNSNULL;
4172 char buffer[1024];
4173 mDNSu32 buflen = 0;
4174 CFMutableDictionaryRef dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
4175 CFStringRef domain = NULL;
4176 CFStringRef tmp = NULL;
4177 CFNumberRef num = NULL;
4178 mStatus status = mStatus_NoError;
4179 mStatus llqStatus = mStatus_NoError;
4180 char llqBuffer[1024];
4181
4182 mDNS_CheckLock(m);
4183
4184 if (!domainStatusDict)
4185 {
4186 domainStatusDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
4187 if (!domainStatusDict) { LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFDictionary domainStatusDict"); return; }
4188 }
4189
4190 if (!dict) { LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFDictionary dict"); return; }
4191
4192 buflen = mDNS_snprintf(buffer, sizeof(buffer), "%##s", info->domain.c);
4193 domain = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
4194 if (!domain) { LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString domain"); return; }
4195
4196 if (info->deltime)
4197 {
4198 if (CFDictionaryContainsKey(domainStatusDict, domain))
4199 {
4200 CFDictionaryRemoveValue(domainStatusDict, domain);
4201 if (!m->ShutdownTime) mDNSDynamicStoreSetConfig(kmDNSBackToMyMacConfig, mDNSNULL, domainStatusDict);
4202 }
4203 CFRelease(domain);
4204 CFRelease(dict);
4205
4206 return;
4207 }
4208
4209 mDNS_snprintf(buffer, sizeof(buffer), "%#a", &m->Router);
4210 tmp = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
4211 if (!tmp)
4212 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString RouterAddress");
4213 else
4214 {
4215 CFDictionarySetValue(dict, CFSTR("RouterAddress"), tmp);
4216 CFRelease(tmp);
4217 }
4218
4219 if (llq)
4220 {
4221 mDNSu32 port = mDNSVal16(llq->ExternalPort);
4222
4223 num = CFNumberCreate(NULL, kCFNumberSInt32Type, &port);
4224 if (!num)
4225 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber LLQExternalPort");
4226 else
4227 {
4228 CFDictionarySetValue(dict, CFSTR("LLQExternalPort"), num);
4229 CFRelease(num);
4230 }
4231
4232 if (llq->Result)
4233 {
4234 num = CFNumberCreate(NULL, kCFNumberSInt32Type, &llq->Result);
4235 if (!num)
4236 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber LLQNPMStatus");
4237 else
4238 {
4239 CFDictionarySetValue(dict, CFSTR("LLQNPMStatus"), num);
4240 CFRelease(num);
4241 }
4242 }
4243 }
4244
4245 if (tun)
4246 {
4247 mDNSu32 port = mDNSVal16(tun->ExternalPort);
4248
4249 num = CFNumberCreate(NULL, kCFNumberSInt32Type, &port);
4250 if (!num)
4251 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber AutoTunnelExternalPort");
4252 else
4253 {
4254 CFDictionarySetValue(dict, CFSTR("AutoTunnelExternalPort"), num);
4255 CFRelease(num);
4256 }
4257
4258 mDNS_snprintf(buffer, sizeof(buffer), "%.4a", &tun->ExternalAddress);
4259 tmp = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
4260 if (!tmp)
4261 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString ExternalAddress");
4262 else
4263 {
4264 CFDictionarySetValue(dict, CFSTR("ExternalAddress"), tmp);
4265 CFRelease(tmp);
4266 }
4267
4268 if (tun->Result)
4269 {
4270 num = CFNumberCreate(NULL, kCFNumberSInt32Type, &tun->Result);
4271 if (!num)
4272 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber AutoTunnelNPMStatus");
4273 else
4274 {
4275 CFDictionarySetValue(dict, CFSTR("AutoTunnelNPMStatus"), num);
4276 CFRelease(num);
4277 }
4278 }
4279 }
4280 if (tun || llq)
4281 {
4282 mDNSu32 code = m->LastNATMapResultCode;
4283
4284 num = CFNumberCreate(NULL, kCFNumberSInt32Type, &code);
4285 if (!num)
4286 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber LastNATMapResultCode");
4287 else
4288 {
4289 CFDictionarySetValue(dict, CFSTR("LastNATMapResultCode"), num);
4290 CFRelease(num);
4291 }
4292 }
4293
4294 mDNS_snprintf(buffer, sizeof(buffer), "Success");
4295 llqStatus = UpdateLLQStatus(m, llqBuffer, sizeof(llqBuffer), info);
4296 status = UpdateRRStatus(m, buffer, sizeof(buffer), info);
4297
4298 // If we have a bad signature error updating a RR, it overrides any error as it needs to be
4299 // reported so that it can be fixed automatically (or the user needs to be notified)
4300 if (status != mStatus_NoError)
4301 {
4302 LogInfo("UpdateAutoTunnelDomainStatus: RR Status %d, %s", status, buffer);
4303 }
4304 else if (m->Router.type == mDNSAddrType_None)
4305 {
4306 status = mStatus_NoRouter;
4307 mDNS_snprintf(buffer, sizeof(buffer), "No network connection - none");
4308 }
4309 else if (m->Router.type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsZero(m->Router.ip.v4))
4310 {
4311 status = mStatus_NoRouter;
4312 mDNS_snprintf(buffer, sizeof(buffer), "No network connection - v4 zero");
4313 }
4314 else if (mDNSIPv6AddressIsZero(info->AutoTunnelInnerAddress))
4315 {
4316 status = mStatus_ServiceNotRunning;
4317 mDNS_snprintf(buffer, sizeof(buffer), "No inner address");
4318 }
4319 else if (!llq && !tun)
4320 {
4321 status = mStatus_NotInitializedErr;
4322 mDNS_snprintf(buffer, sizeof(buffer), "Neither LLQ nor AutoTunnel NAT port mapping is currently active");
4323 }
4324 else if (llqStatus == mStatus_NoSuchRecord)
4325 {
4326 status = llqStatus;
4327 mDNS_snprintf(buffer, sizeof(buffer), llqBuffer);
4328 }
4329 else if ((llq && llq->Result == mStatus_DoubleNAT) || (tun && tun->Result == mStatus_DoubleNAT))
4330 {
4331 status = mStatus_DoubleNAT;
4332 mDNS_snprintf(buffer, sizeof(buffer), "Double NAT: Router is reporting a private address");
4333 }
4334 else if ((llq && llq->Result == mStatus_NATPortMappingDisabled) ||
4335 (tun && tun->Result == mStatus_NATPortMappingDisabled) ||
4336 (m->LastNATMapResultCode == NATErr_Refused && ((llq && !llq->Result && mDNSIPPortIsZero(llq->ExternalPort)) || (tun && !tun->Result && mDNSIPPortIsZero(tun->ExternalPort)))))
4337 {
4338 status = mStatus_NATPortMappingDisabled;
4339 mDNS_snprintf(buffer, sizeof(buffer), "PCP/NAT-PMP is disabled on the router");
4340 }
4341 else if ((llq && llq->Result) || (tun && tun->Result))
4342 {
4343 status = mStatus_NATTraversal;
4344 mDNS_snprintf(buffer, sizeof(buffer), "Error obtaining NAT port mapping from router");
4345 }
4346 else if ((llq && mDNSIPPortIsZero(llq->ExternalPort)) || (tun && mDNSIPPortIsZero(tun->ExternalPort)))
4347 {
4348 status = mStatus_NATTraversal;
4349 mDNS_snprintf(buffer, sizeof(buffer), "Unable to obtain NAT port mapping from router");
4350 }
4351 else
4352 {
4353 status = llqStatus;
4354 mDNS_snprintf(buffer, sizeof(buffer), llqBuffer);
4355 LogInfo("UpdateAutoTunnelDomainStatus: LLQ Status %d, %s", status, buffer);
4356 }
4357
4358 num = CFNumberCreate(NULL, kCFNumberSInt32Type, &status);
4359 if (!num)
4360 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber StatusCode");
4361 else
4362 {
4363 CFDictionarySetValue(dict, CFSTR("StatusCode"), num);
4364 CFRelease(num);
4365 }
4366
4367 tmp = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
4368 if (!tmp)
4369 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString StatusMessage");
4370 else
4371 {
4372 CFDictionarySetValue(dict, CFSTR("StatusMessage"), tmp);
4373 CFRelease(tmp);
4374 }
4375
4376 if (!CFDictionaryContainsKey(domainStatusDict, domain) ||
4377 !CFEqual(dict, (CFMutableDictionaryRef)CFDictionaryGetValue(domainStatusDict, domain)))
4378 {
4379 CFDictionarySetValue(domainStatusDict, domain, dict);
4380 if (!m->ShutdownTime)
4381 {
4382 static char statusBuf[16];
4383 mDNS_snprintf(statusBuf, sizeof(statusBuf), "%d", (int)status);
4384 mDNSASLLog((uuid_t *)&m->asl_uuid, "autotunnel.domainstatus", status ? "failure" : "success", statusBuf, "");
4385 mDNSDynamicStoreSetConfig(kmDNSBackToMyMacConfig, mDNSNULL, domainStatusDict);
4386 }
4387 }
4388
4389 CFRelease(domain);
4390 CFRelease(dict);
4391
4392 debugf("UpdateAutoTunnelDomainStatus: %s", buffer);
4393 #endif // def NO_SECURITYFRAMEWORK
4394 }
4395
4396 // MUST be called with lock held
4397 mDNSexport void UpdateAutoTunnelDomainStatuses(const mDNS *const m)
4398 {
4399 #ifdef NO_SECURITYFRAMEWORK
4400 (void) m;
4401 #else
4402 mDNS_CheckLock(m);
4403 DomainAuthInfo* info;
4404 for (info = m->AuthInfoList; info; info = info->next)
4405 if (info->AutoTunnel && !info->deltime)
4406 UpdateAutoTunnelDomainStatus(m, info);
4407 #endif // def NO_SECURITYFRAMEWORK
4408 }
4409
4410 mDNSlocal void UpdateAnonymousRacoonConfig(mDNS *m) // Determine whether we need racoon to accept incoming connections
4411 {
4412 DomainAuthInfo *info;
4413
4414 for (info = m->AuthInfoList; info; info = info->next)
4415 if (info->AutoTunnel && !info->deltime && (!mDNSIPPortIsZero(m->AutoTunnelNAT.ExternalPort) || !mDNSIPv6AddressIsZero(m->AutoTunnelRelayAddr)))
4416 break;
4417
4418 if (info != AnonymousRacoonConfig)
4419 {
4420 AnonymousRacoonConfig = info;
4421 // Create or revert configuration file, and start (or SIGHUP) Racoon
4422 (void)mDNSConfigureServer(AnonymousRacoonConfig ? kmDNSUp : kmDNSDown, AnonymousRacoonConfig ? btmmprefix : mDNSNULL, AnonymousRacoonConfig ? &AnonymousRacoonConfig->domain : mDNSNULL);
4423 }
4424 }
4425
4426 mDNSlocal void AutoTunnelRecordCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
4427
4428 // Caller must hold the lock
4429 mDNSlocal mDNSBool DeregisterAutoTunnelRecord(mDNS *m, DomainAuthInfo *info, AuthRecord* record)
4430 {
4431 mDNS_CheckLock(m);
4432
4433 LogInfo("DeregisterAutoTunnelRecord %##s %##s", &info->domain.c, record->namestorage.c);
4434
4435 if (record->resrec.RecordType > kDNSRecordTypeDeregistering)
4436 {
4437 mStatus err = mDNS_Deregister_internal(m, record, mDNS_Dereg_normal);
4438 if (err)
4439 {
4440 record->resrec.RecordType = kDNSRecordTypeUnregistered;
4441 LogMsg("DeregisterAutoTunnelRecord error %d deregistering %##s %##s", err, info->domain.c, record->namestorage.c);
4442 return mDNSfalse;
4443 }
4444 else LogInfo("DeregisterAutoTunnelRecord: Deregistered");
4445 }
4446 else LogInfo("DeregisterAutoTunnelRecord: Not deregistering, state:%d", record->resrec.RecordType);
4447
4448 return mDNStrue;
4449 }
4450
4451 // Caller must hold the lock
4452 mDNSlocal void DeregisterAutoTunnelHostRecord(mDNS *m, DomainAuthInfo *info)
4453 {
4454 if (!DeregisterAutoTunnelRecord(m, info, &info->AutoTunnelHostRecord))
4455 {
4456 info->AutoTunnelHostRecord.namestorage.c[0] = 0;
4457 m->NextSRVUpdate = NonZeroTime(m->timenow);
4458 }
4459 }
4460
4461 // Caller must hold the lock
4462 mDNSlocal void UpdateAutoTunnelHostRecord(mDNS *m, DomainAuthInfo *info)
4463 {
4464 mStatus err;
4465 mDNSBool NATProblem = mDNSIPPortIsZero(m->AutoTunnelNAT.ExternalPort) || m->AutoTunnelNAT.Result;
4466
4467 mDNS_CheckLock(m);
4468
4469 if (!info->AutoTunnelServiceStarted || info->deltime || m->ShutdownTime || mDNSIPv6AddressIsZero(info->AutoTunnelInnerAddress) || (m->SleepState != SleepState_Awake && NATProblem))
4470 {
4471 LogInfo("UpdateAutoTunnelHostRecord: Dereg %##s : AutoTunnelServiceStarted(%d) deltime(%d) address(%.16a) sleepstate(%d)",
4472 info->domain.c, info->AutoTunnelServiceStarted, info->deltime, &info->AutoTunnelInnerAddress, m->SleepState);
4473 DeregisterAutoTunnelHostRecord(m, info);
4474 }
4475 else if (info->AutoTunnelHostRecord.resrec.RecordType == kDNSRecordTypeUnregistered)
4476 {
4477 mDNS_SetupResourceRecord(&info->AutoTunnelHostRecord, mDNSNULL, mDNSInterface_Any, kDNSType_AAAA, kHostNameTTL,
4478 kDNSRecordTypeUnregistered, AuthRecordAny, AutoTunnelRecordCallback, info);
4479 info->AutoTunnelHostRecord.namestorage.c[0] = 0;
4480 AppendDomainLabel(&info->AutoTunnelHostRecord.namestorage, &m->hostlabel);
4481 AppendDomainName (&info->AutoTunnelHostRecord.namestorage, &info->domain);
4482 info->AutoTunnelHostRecord.resrec.rdata->u.ipv6 = info->AutoTunnelInnerAddress;
4483 info->AutoTunnelHostRecord.resrec.RecordType = kDNSRecordTypeKnownUnique;
4484
4485 err = mDNS_Register_internal(m, &info->AutoTunnelHostRecord);
4486 if (err) LogMsg("UpdateAutoTunnelHostRecord error %d registering %##s", err, info->AutoTunnelHostRecord.namestorage.c);
4487 else
4488 {
4489 // Make sure we trigger the registration of all SRV records in regState_NoTarget again
4490 m->NextSRVUpdate = NonZeroTime(m->timenow);
4491 LogInfo("UpdateAutoTunnelHostRecord registering %##s", info->AutoTunnelHostRecord.namestorage.c);
4492 }
4493 }
4494 else LogInfo("UpdateAutoTunnelHostRecord: Type %d", info->AutoTunnelHostRecord.resrec.RecordType);
4495 }
4496
4497 // Caller must hold the lock
4498 mDNSlocal void DeregisterAutoTunnelServiceRecords(mDNS *m, DomainAuthInfo *info)
4499 {
4500 LogInfo("DeregisterAutoTunnelServiceRecords %##s", info->domain.c);
4501
4502 DeregisterAutoTunnelRecord(m, info, &info->AutoTunnelTarget);
4503 DeregisterAutoTunnelRecord(m, info, &info->AutoTunnelService);
4504 UpdateAutoTunnelHostRecord(m, info);
4505 }
4506
4507 // Caller must hold the lock
4508 mDNSlocal void UpdateAutoTunnelServiceRecords(mDNS *m, DomainAuthInfo *info)
4509 {
4510 mDNS_CheckLock(m);
4511
4512 if (!info->AutoTunnelServiceStarted || info->deltime || m->ShutdownTime || mDNSIPPortIsZero(m->AutoTunnelNAT.ExternalPort) || m->AutoTunnelNAT.Result)
4513 {
4514 LogInfo("UpdateAutoTunnelServiceRecords: Dereg %##s : AutoTunnelServiceStarted(%d) deltime(%d) ExtPort(%d) NATResult(%d)", info->domain.c, info->AutoTunnelServiceStarted, info->deltime, mDNSVal16(m->AutoTunnelNAT.ExternalPort), m->AutoTunnelNAT.Result);
4515 DeregisterAutoTunnelServiceRecords(m, info);
4516 }
4517 else
4518 {
4519 if (info->AutoTunnelTarget.resrec.RecordType == kDNSRecordTypeUnregistered)
4520 {
4521 // 1. Set up our address record for the external tunnel address
4522 // (Constructed name, not generally user-visible, used as target in IKE tunnel's SRV record)
4523 mDNS_SetupResourceRecord(&info->AutoTunnelTarget, mDNSNULL, mDNSInterface_Any, kDNSType_A, kHostNameTTL,
4524 kDNSRecordTypeUnregistered, AuthRecordAny, AutoTunnelRecordCallback, info);
4525 AssignDomainName (&info->AutoTunnelTarget.namestorage, (const domainname*) "\x0B" "_autotunnel");
4526 AppendDomainLabel(&info->AutoTunnelTarget.namestorage, &m->hostlabel);
4527 AppendDomainName (&info->AutoTunnelTarget.namestorage, &info->domain);
4528 info->AutoTunnelTarget.resrec.rdata->u.ipv4 = m->AutoTunnelNAT.ExternalAddress;
4529 info->AutoTunnelTarget.resrec.RecordType = kDNSRecordTypeKnownUnique;
4530
4531 mStatus err = mDNS_Register_internal(m, &info->AutoTunnelTarget);
4532 if (err) LogMsg("UpdateAutoTunnelServiceRecords error %d registering %##s", err, info->AutoTunnelTarget.namestorage.c);
4533 else LogInfo("UpdateAutoTunnelServiceRecords registering %##s", info->AutoTunnelTarget.namestorage.c);
4534 }
4535 else LogInfo("UpdateAutoTunnelServiceRecords: NOOP Target state(%d)", info->AutoTunnelTarget.resrec.RecordType);
4536
4537 if (info->AutoTunnelService.resrec.RecordType == kDNSRecordTypeUnregistered)
4538 {
4539 // 2. Set up IKE tunnel's SRV record: _autotunnel._udp.AutoTunnelHost SRV 0 0 port AutoTunnelTarget
4540 mDNS_SetupResourceRecord(&info->AutoTunnelService, mDNSNULL, mDNSInterface_Any, kDNSType_SRV, kHostNameTTL,
4541 kDNSRecordTypeUnregistered, AuthRecordAny, AutoTunnelRecordCallback, info);
4542 AssignDomainName (&info->AutoTunnelService.namestorage, (const domainname*) "\x0B" "_autotunnel" "\x04" "_udp");
4543 AppendDomainLabel(&info->AutoTunnelService.namestorage, &m->hostlabel);
4544 AppendDomainName (&info->AutoTunnelService.namestorage, &info->domain);
4545 info->AutoTunnelService.resrec.rdata->u.srv.priority = 0;
4546 info->AutoTunnelService.resrec.rdata->u.srv.weight = 0;
4547 info->AutoTunnelService.resrec.rdata->u.srv.port = m->AutoTunnelNAT.ExternalPort;
4548 AssignDomainName(&info->AutoTunnelService.resrec.rdata->u.srv.target, &info->AutoTunnelTarget.namestorage);
4549 info->AutoTunnelService.resrec.RecordType = kDNSRecordTypeKnownUnique;
4550
4551 mStatus err = mDNS_Register_internal(m, &info->AutoTunnelService);
4552 if (err) LogMsg("UpdateAutoTunnelServiceRecords error %d registering %##s", err, info->AutoTunnelService.namestorage.c);
4553 else LogInfo("UpdateAutoTunnelServiceRecords registering %##s", info->AutoTunnelService.namestorage.c);
4554 }
4555 else LogInfo("UpdateAutoTunnelServiceRecords: NOOP Service state(%d)", info->AutoTunnelService.resrec.RecordType);
4556
4557 UpdateAutoTunnelHostRecord(m, info);
4558
4559 LogInfo("AutoTunnel server listening for connections on %##s[%.4a]:%d:%##s[%.16a]",
4560 info->AutoTunnelTarget.namestorage.c, &m->AdvertisedV4.ip.v4, mDNSVal16(m->AutoTunnelNAT.IntPort),
4561 info->AutoTunnelHostRecord.namestorage.c, &info->AutoTunnelInnerAddress);
4562
4563 }
4564 }
4565
4566 // Caller must hold the lock
4567 mDNSlocal void DeregisterAutoTunnelDeviceInfoRecord(mDNS *m, DomainAuthInfo *info)
4568 {
4569 DeregisterAutoTunnelRecord(m, info, &info->AutoTunnelDeviceInfo);
4570 }
4571
4572 // Caller must hold the lock
4573 mDNSlocal void UpdateAutoTunnelDeviceInfoRecord(mDNS *m, DomainAuthInfo *info)
4574 {
4575 mDNS_CheckLock(m);
4576
4577 if (!info->AutoTunnelServiceStarted || info->deltime || m->ShutdownTime)
4578 DeregisterAutoTunnelDeviceInfoRecord(m, info);
4579 else if (info->AutoTunnelDeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered)
4580 {
4581 mDNS_SetupResourceRecord(&info->AutoTunnelDeviceInfo, mDNSNULL, mDNSInterface_Any, kDNSType_TXT, kStandardTTL, kDNSRecordTypeUnregistered, AuthRecordAny, AutoTunnelRecordCallback, info);
4582 ConstructServiceName(&info->AutoTunnelDeviceInfo.namestorage, &m->nicelabel, &DeviceInfoName, &info->domain);
4583
4584 info->AutoTunnelDeviceInfo.resrec.rdlength = initializeDeviceInfoTXT(m, info->AutoTunnelDeviceInfo.resrec.rdata->u.data);
4585 info->AutoTunnelDeviceInfo.resrec.RecordType = kDNSRecordTypeKnownUnique;
4586
4587 mStatus err = mDNS_Register_internal(m, &info->AutoTunnelDeviceInfo);
4588 if (err) LogMsg("UpdateAutoTunnelDeviceInfoRecord error %d registering %##s", err, info->AutoTunnelDeviceInfo.namestorage.c);
4589 else LogInfo("UpdateAutoTunnelDeviceInfoRecord registering %##s", info->AutoTunnelDeviceInfo.namestorage.c);
4590 }
4591 else
4592 LogInfo("UpdateAutoTunnelDeviceInfoRecord: not in Unregistered state: %d",info->AutoTunnelDeviceInfo.resrec.RecordType);
4593 }
4594
4595 // Caller must hold the lock
4596 mDNSlocal void DeregisterAutoTunnel6Record(mDNS *m, DomainAuthInfo *info)
4597 {
4598 LogInfo("DeregisterAutoTunnel6Record %##s", info->domain.c);
4599
4600 DeregisterAutoTunnelRecord(m, info, &info->AutoTunnel6Record);
4601 UpdateAutoTunnelHostRecord(m, info);
4602 UpdateAutoTunnelDomainStatus(m, info);
4603 }
4604
4605 // Caller must hold the lock
4606 mDNSlocal void UpdateAutoTunnel6Record(mDNS *m, DomainAuthInfo *info)
4607 {
4608 mDNS_CheckLock(m);
4609
4610 if (!info->AutoTunnelServiceStarted || info->deltime || m->ShutdownTime || mDNSIPv6AddressIsZero(m->AutoTunnelRelayAddr) || m->SleepState != SleepState_Awake)
4611 DeregisterAutoTunnel6Record(m, info);
4612 else if (info->AutoTunnel6Record.resrec.RecordType == kDNSRecordTypeUnregistered)
4613 {
4614 mDNS_SetupResourceRecord(&info->AutoTunnel6Record, mDNSNULL, mDNSInterface_Any, kDNSType_AAAA, kHostNameTTL,
4615 kDNSRecordTypeUnregistered, AuthRecordAny, AutoTunnelRecordCallback, info);
4616 AssignDomainName (&info->AutoTunnel6Record.namestorage, (const domainname*) "\x0C" "_autotunnel6");
4617 AppendDomainLabel(&info->AutoTunnel6Record.namestorage, &m->hostlabel);
4618 AppendDomainName (&info->AutoTunnel6Record.namestorage, &info->domain);
4619 info->AutoTunnel6Record.resrec.rdata->u.ipv6 = m->AutoTunnelRelayAddr;
4620 info->AutoTunnel6Record.resrec.RecordType = kDNSRecordTypeKnownUnique;
4621
4622 mStatus err = mDNS_Register_internal(m, &info->AutoTunnel6Record);
4623 if (err) LogMsg("UpdateAutoTunnel6Record error %d registering %##s", err, info->AutoTunnel6Record.namestorage.c);
4624 else LogInfo("UpdateAutoTunnel6Record registering %##s", info->AutoTunnel6Record.namestorage.c);
4625
4626 UpdateAutoTunnelHostRecord(m, info);
4627
4628 LogInfo("AutoTunnel6 server listening for connections on %##s[%.16a] :%##s[%.16a]",
4629 info->AutoTunnel6Record.namestorage.c, &m->AutoTunnelRelayAddr,
4630 info->AutoTunnelHostRecord.namestorage.c, &info->AutoTunnelInnerAddress);
4631
4632 }
4633 else LogInfo("UpdateAutoTunnel6Record NOOP state(%d)",info->AutoTunnel6Record.resrec.RecordType);
4634 }
4635
4636 mDNSlocal void AutoTunnelRecordCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
4637 {
4638 DomainAuthInfo *info = (DomainAuthInfo *)rr->RecordContext;
4639 if (result == mStatus_MemFree)
4640 {
4641 LogInfo("AutoTunnelRecordCallback MemFree %s", ARDisplayString(m, rr));
4642
4643 mDNS_Lock(m);
4644
4645 // Reset the host record namestorage to force high-level PTR/SRV/TXT to deregister
4646 if (rr == &info->AutoTunnelHostRecord)
4647 {
4648 rr->namestorage.c[0] = 0;
4649 m->NextSRVUpdate = NonZeroTime(m->timenow);
4650 LogInfo("AutoTunnelRecordCallback: NextSRVUpdate in %d %d", m->NextSRVUpdate - m->timenow, m->timenow);
4651 }
4652 if (m->ShutdownTime)
4653 {
4654 LogInfo("AutoTunnelRecordCallback: Shutdown, returning");
4655 mDNS_Unlock(m);
4656 return;
4657 }
4658 if (rr == &info->AutoTunnelHostRecord)
4659 {
4660 LogInfo("AutoTunnelRecordCallback: calling UpdateAutoTunnelHostRecord");
4661 UpdateAutoTunnelHostRecord(m,info);
4662 }
4663 else if (rr == &info->AutoTunnelDeviceInfo)
4664 {
4665 LogInfo("AutoTunnelRecordCallback: Calling UpdateAutoTunnelDeviceInfoRecord");
4666 UpdateAutoTunnelDeviceInfoRecord(m,info);
4667 }
4668 else if (rr == &info->AutoTunnelService || rr == &info->AutoTunnelTarget)
4669 {
4670 LogInfo("AutoTunnelRecordCallback: Calling UpdateAutoTunnelServiceRecords");
4671 UpdateAutoTunnelServiceRecords(m,info);
4672 }
4673 else if (rr == &info->AutoTunnel6Record)
4674 {
4675 LogInfo("AutoTunnelRecordCallback: Calling UpdateAutoTunnel6Record");
4676 UpdateAutoTunnel6Record(m,info);
4677 }
4678
4679 mDNS_Unlock(m);
4680 }
4681 }
4682
4683 mDNSlocal void AutoTunnelNATCallback(mDNS *m, NATTraversalInfo *n)
4684 {
4685 DomainAuthInfo *info;
4686
4687 LogInfo("AutoTunnelNATCallback Result %d %.4a Internal %d External %d",
4688 n->Result, &n->ExternalAddress, mDNSVal16(n->IntPort), mDNSVal16(n->ExternalPort));
4689
4690 mDNS_Lock(m);
4691
4692 m->NextSRVUpdate = NonZeroTime(m->timenow);
4693 LogInfo("AutoTunnelNATCallback: NextSRVUpdate in %d %d", m->NextSRVUpdate - m->timenow, m->timenow);
4694
4695 for (info = m->AuthInfoList; info; info = info->next)
4696 if (info->AutoTunnel)
4697 UpdateAutoTunnelServiceRecords(m, info);
4698
4699 UpdateAnonymousRacoonConfig(m); // Determine whether we need racoon to accept incoming connections
4700
4701 UpdateAutoTunnelDomainStatuses(m);
4702
4703 mDNS_Unlock(m);
4704 }
4705
4706 mDNSlocal void AutoTunnelHostNameChanged(mDNS *m, DomainAuthInfo *info)
4707 {
4708 LogInfo("AutoTunnelHostNameChanged %#s.%##s", m->hostlabel.c, info->domain.c);
4709
4710 mDNS_Lock(m);
4711 // We forcibly deregister the records that are based on the hostname.
4712 // When deregistration of each completes, the MemFree callback will make the
4713 // appropriate Update* call to use the new name to reregister.
4714 DeregisterAutoTunnelHostRecord(m, info);
4715 DeregisterAutoTunnelDeviceInfoRecord(m, info);
4716 DeregisterAutoTunnelServiceRecords(m, info);
4717 DeregisterAutoTunnel6Record(m, info);
4718 m->NextSRVUpdate = NonZeroTime(m->timenow);
4719 mDNS_Unlock(m);
4720 }
4721
4722 // Must be called with the lock held
4723 mDNSexport void StartServerTunnel(mDNS *const m, DomainAuthInfo *const info)
4724 {
4725 if (info->deltime) return;
4726
4727 if (info->AutoTunnelServiceStarted)
4728 {
4729 // On wake from sleep, this function will be called when determining SRV targets,
4730 // and needs to re-register the host record for the target to be set correctly
4731 UpdateAutoTunnelHostRecord(m, info);
4732 return;
4733 }
4734
4735 info->AutoTunnelServiceStarted = mDNStrue;
4736
4737 // Now that we have a service in this domain, we need to try to register the
4738 // AutoTunnel records, because the relay connection & NAT-T may have already been
4739 // started for another domain. If the relay connection is not up or the NAT-T has not
4740 // yet succeeded, the Update* functions are smart enough to not register the records.
4741 // Note: This should be done after we set AutoTunnelServiceStarted, as that variable is used to
4742 // decide whether to register the AutoTunnel records in the calls below.
4743 UpdateAutoTunnelServiceRecords(m, info);
4744 UpdateAutoTunnel6Record(m, info);
4745 UpdateAutoTunnelDeviceInfoRecord(m, info);
4746 UpdateAutoTunnelHostRecord(m, info);
4747
4748 // If the global AutoTunnel NAT-T is not yet started, start it.
4749 if (!m->AutoTunnelNAT.clientContext)
4750 {
4751 m->AutoTunnelNAT.clientCallback = AutoTunnelNATCallback;
4752 m->AutoTunnelNAT.clientContext = (void*)1; // Means AutoTunnelNAT Traversal is active;
4753 m->AutoTunnelNAT.Protocol = NATOp_MapUDP;
4754 m->AutoTunnelNAT.IntPort = IPSECPort;
4755 m->AutoTunnelNAT.RequestedPort = IPSECPort;
4756 m->AutoTunnelNAT.NATLease = 0;
4757 mStatus err = mDNS_StartNATOperation_internal(m, &m->AutoTunnelNAT);
4758 if (err) LogMsg("StartServerTunnel: error %d starting NAT mapping", err);
4759 }
4760 }
4761
4762 mDNSlocal mStatus AutoTunnelSetKeys(ClientTunnel *tun, mDNSBool AddNew)
4763 {
4764 mDNSv6Addr loc_outer6;
4765 mDNSv6Addr rmt_outer6;
4766
4767 // When we are tunneling over IPv6 Relay address, the port number is zero
4768 if (mDNSIPPortIsZero(tun->rmt_outer_port))
4769 {
4770 loc_outer6 = tun->loc_outer6;
4771 rmt_outer6 = tun->rmt_outer6;
4772 }
4773 else
4774 {
4775 loc_outer6 = zerov6Addr;
4776 loc_outer6.b[0] = tun->loc_outer.b[0];
4777 loc_outer6.b[1] = tun->loc_outer.b[1];
4778 loc_outer6.b[2] = tun->loc_outer.b[2];
4779 loc_outer6.b[3] = tun->loc_outer.b[3];
4780
4781 rmt_outer6 = zerov6Addr;
4782 rmt_outer6.b[0] = tun->rmt_outer.b[0];
4783 rmt_outer6.b[1] = tun->rmt_outer.b[1];
4784 rmt_outer6.b[2] = tun->rmt_outer.b[2];
4785 rmt_outer6.b[3] = tun->rmt_outer.b[3];
4786 }
4787
4788 return(mDNSAutoTunnelSetKeys(AddNew ? kmDNSAutoTunnelSetKeysReplace : kmDNSAutoTunnelSetKeysDelete, tun->loc_inner.b, loc_outer6.b, kRacoonPort, tun->rmt_inner.b, rmt_outer6.b, mDNSVal16(tun->rmt_outer_port), btmmprefix, SkipLeadingLabels(&tun->dstname, 1)));
4789 }
4790
4791 // If the EUI-64 part of the IPv6 ULA matches, then that means the two addresses point to the same machine
4792 #define mDNSSameClientTunnel(A,B) ((A)->l[2] == (B)->l[2] && (A)->l[3] == (B)->l[3])
4793
4794 mDNSlocal void ReissueBlockedQuestionWithType(mDNS *const m, domainname *d, mDNSBool success, mDNSu16 qtype)
4795 {
4796 DNSQuestion *q = m->Questions;
4797 while (q)
4798 {
4799 if (q->NoAnswer == NoAnswer_Suspended && q->qtype == qtype && q->AuthInfo && q->AuthInfo->AutoTunnel && SameDomainName(&q->qname, d))
4800 {
4801 LogInfo("Restart %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
4802 mDNSQuestionCallback *tmp = q->QuestionCallback;
4803 q->QuestionCallback = AutoTunnelCallback; // Set QuestionCallback to suppress another call back to AddNewClientTunnel
4804 mDNS_StopQuery(m, q);
4805 mDNS_StartQuery(m, q);
4806 q->QuestionCallback = tmp; // Restore QuestionCallback back to the real value
4807 if (!success) q->NoAnswer = NoAnswer_Fail;
4808 // When we call mDNS_StopQuery, it's possible for other subordinate questions like the GetZoneData query to be cancelled too.
4809 // In general we have to assume that the question list might have changed in arbitrary ways.
4810 // This code is itself called from a question callback, so the m->CurrentQuestion mechanism is
4811 // already in use. The safest solution is just to go back to the start of the list and start again.
4812 // In principle this sounds like an n^2 algorithm, but in practice we almost always activate
4813 // just one suspended question, so it's really a 2n algorithm.
4814 q = m->Questions;
4815 }
4816 else
4817 q = q->next;
4818 }
4819 }
4820
4821 mDNSlocal void ReissueBlockedQuestions(mDNS *const m, domainname *d, mDNSBool success)
4822 {
4823 // 1. We deliberately restart AAAA queries before A queries, because in the common case where a BTTM host has
4824 // a v6 address but no v4 address, we prefer the caller to get the positive AAAA response before the A NXDOMAIN.
4825 // 2. In the case of AAAA queries, if our tunnel setup failed, then we return a deliberate failure indication to the caller --
4826 // even if the name does have a valid AAAA record, we don't want clients trying to connect to it without a properly encrypted tunnel.
4827 // 3. For A queries we never fabricate failures -- if a BTTM service is really using raw IPv4, then it doesn't need the IPv6 tunnel.
4828 ReissueBlockedQuestionWithType(m, d, success, kDNSType_AAAA);
4829 ReissueBlockedQuestionWithType(m, d, mDNStrue, kDNSType_A);
4830 }
4831
4832 mDNSlocal void UnlinkAndReissueBlockedQuestions(mDNS *const m, ClientTunnel *tun, mDNSBool success)
4833 {
4834 ClientTunnel **p = &m->TunnelClients;
4835 while (*p != tun && *p) p = &(*p)->next;
4836 if (*p) *p = tun->next;
4837 ReissueBlockedQuestions(m, &tun->dstname, success);
4838 LogInfo("UnlinkAndReissueBlockedQuestions: Disposing ClientTunnel %p", tun);
4839 freeL("ClientTunnel", tun);
4840 }
4841
4842 mDNSlocal mDNSBool TunnelClientDeleteMatching(mDNS *const m, ClientTunnel *tun, mDNSBool v6Tunnel)
4843 {
4844 ClientTunnel **p;
4845 mDNSBool needSetKeys = mDNStrue;
4846
4847 p = &tun->next;
4848 while (*p)
4849 {
4850 // Is this a tunnel to the same host that we are trying to setup now?
4851 if (!mDNSSameClientTunnel(&(*p)->rmt_inner, &tun->rmt_inner)) p = &(*p)->next;
4852 else
4853 {
4854 ClientTunnel *old = *p;
4855 if (v6Tunnel)
4856 {
4857 if (!mDNSIPPortIsZero(old->rmt_outer_port)) { p = &old->next; continue; }
4858 LogInfo("TunnelClientDeleteMatching: Found existing IPv6 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4859 if (old->q.ThisQInterval >= 0)
4860 {
4861 LogInfo("TunnelClientDeleteMatching: Stopping query on IPv6 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4862 mDNS_StopQuery(m, &old->q);
4863 }
4864 else if (!mDNSSameIPv6Address((*p)->rmt_inner, tun->rmt_inner) ||
4865 !mDNSSameIPv6Address(old->loc_inner, tun->loc_inner) ||
4866 !mDNSSameIPv6Address(old->loc_outer6, tun->loc_outer6) ||
4867 !mDNSSameIPv6Address(old->rmt_outer6, tun->rmt_outer6))
4868 {
4869 // Delete the old tunnel if the current tunnel to the same host does not have the same ULA or
4870 // the other parameters of the tunnel are different
4871 LogInfo("TunnelClientDeleteMatching: Deleting existing IPv6 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4872 AutoTunnelSetKeys(old, mDNSfalse);
4873 }
4874 else
4875 {
4876 // Reusing the existing tunnel means that we reuse the IPsec SAs and the policies. We delete the old
4877 // as "tun" and "old" are identical
4878 LogInfo("TunnelClientDeleteMatching: Reusing the existing IPv6 AutoTunnel for %##s %.16a", old->dstname.c,
4879 &old->rmt_inner);
4880 needSetKeys = mDNSfalse;
4881 }
4882 }
4883 else
4884 {
4885 if (mDNSIPPortIsZero(old->rmt_outer_port)) { p = &old->next; continue; }
4886 LogInfo("TunnelClientDeleteMatching: Found existing IPv4 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4887 if (old->q.ThisQInterval >= 0)
4888 {
4889 LogInfo("TunnelClientDeleteMatching: Stopping query on IPv4 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4890 mDNS_StopQuery(m, &old->q);
4891 }
4892 else if (!mDNSSameIPv6Address((*p)->rmt_inner, tun->rmt_inner) ||
4893 !mDNSSameIPv6Address(old->loc_inner, tun->loc_inner) ||
4894 !mDNSSameIPv4Address(old->loc_outer, tun->loc_outer) ||
4895 !mDNSSameIPv4Address(old->rmt_outer, tun->rmt_outer) ||
4896 !mDNSSameIPPort(old->rmt_outer_port, tun->rmt_outer_port))
4897 {
4898 // Delete the old tunnel if the current tunnel to the same host does not have the same ULA or
4899 // the other parameters of the tunnel are different
4900 LogInfo("TunnelClientDeleteMatching: Deleting existing IPv4 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4901 AutoTunnelSetKeys(old, mDNSfalse);
4902 }
4903 else
4904 {
4905 // Reusing the existing tunnel means that we reuse the IPsec SAs and the policies. We delete the old
4906 // as "tun" and "old" are identical
4907 LogInfo("TunnelClientDeleteMatching: Reusing the existing IPv4 AutoTunnel for %##s %.16a", old->dstname.c,
4908 &old->rmt_inner);
4909 needSetKeys = mDNSfalse;
4910 }
4911 }
4912
4913 *p = old->next;
4914 LogInfo("TunnelClientDeleteMatching: Disposing ClientTunnel %p", old);
4915 freeL("ClientTunnel", old);
4916 }
4917 }
4918 return needSetKeys;
4919 }
4920
4921 // v6Tunnel indicates whether to delete a tunnel whose outer header is IPv6. If false, outer IPv4
4922 // tunnel will be deleted
4923 mDNSlocal void TunnelClientDeleteAny(mDNS *const m, ClientTunnel *tun, mDNSBool v6Tunnel)
4924 {
4925 ClientTunnel **p;
4926
4927 p = &tun->next;
4928 while (*p)
4929 {
4930 // If there is more than one client tunnel to the same host, delete all of them.
4931 // We do this by just checking against the EUI64 rather than the full address
4932 if (!mDNSSameClientTunnel(&(*p)->rmt_inner, &tun->rmt_inner)) p = &(*p)->next;
4933 else
4934 {
4935 ClientTunnel *old = *p;
4936 if (v6Tunnel)
4937 {
4938 if (!mDNSIPPortIsZero(old->rmt_outer_port)) { p = &old->next; continue;}
4939 LogInfo("TunnelClientDeleteAny: Found existing IPv6 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4940 }
4941 else
4942 {
4943 if (mDNSIPPortIsZero(old->rmt_outer_port)) { p = &old->next; continue;}
4944 LogInfo("TunnelClientDeleteAny: Found existing IPv4 AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4945 }
4946 if (old->q.ThisQInterval >= 0)
4947 {
4948 LogInfo("TunnelClientDeleteAny: Stopping query on AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4949 mDNS_StopQuery(m, &old->q);
4950 }
4951 else
4952 {
4953 LogInfo("TunnelClientDeleteAny: Deleting existing AutoTunnel for %##s %.16a", old->dstname.c, &old->rmt_inner);
4954 AutoTunnelSetKeys(old, mDNSfalse);
4955 }
4956 *p = old->next;
4957 LogInfo("TunnelClientDeleteAny: Disposing ClientTunnel %p", old);
4958 freeL("ClientTunnel", old);
4959 }
4960 }
4961 }
4962
4963 mDNSlocal void TunnelClientFinish(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer)
4964 {
4965 mDNSBool needSetKeys = mDNStrue;
4966 ClientTunnel *tun = (ClientTunnel *)question->QuestionContext;
4967 mDNSBool v6Tunnel = mDNSfalse;
4968 DomainAuthInfo *info;
4969
4970 // If the port is zero, then we have a relay address of the peer
4971 if (mDNSIPPortIsZero(tun->rmt_outer_port))
4972 v6Tunnel = mDNStrue;
4973
4974 if (v6Tunnel)
4975 {
4976 LogInfo("TunnelClientFinish: Relay address %.16a", &answer->rdata->u.ipv6);
4977 tun->rmt_outer6 = answer->rdata->u.ipv6;
4978 tun->loc_outer6 = m->AutoTunnelRelayAddr;
4979 }
4980 else
4981 {
4982 LogInfo("TunnelClientFinish: SRV target address %.4a", &answer->rdata->u.ipv4);
4983 tun->rmt_outer = answer->rdata->u.ipv4;
4984 mDNSAddr tmpDst = { mDNSAddrType_IPv4, {{{0}}} };
4985 tmpDst.ip.v4 = tun->rmt_outer;
4986 mDNSAddr tmpSrc = zeroAddr;
4987 mDNSPlatformSourceAddrForDest(&tmpSrc, &tmpDst);
4988 if (tmpSrc.type == mDNSAddrType_IPv4) tun->loc_outer = tmpSrc.ip.v4;
4989 else tun->loc_outer = m->AdvertisedV4.ip.v4;
4990 }
4991
4992 question->ThisQInterval = -1; // So we know this tunnel setup has completed
4993
4994 info = GetAuthInfoForName(m, &tun->dstname);
4995 if (!info)
4996 {
4997 LogMsg("TunnelClientFinish: Could not get AuthInfo for %##s", tun->dstname.c);
4998 ReissueBlockedQuestions(m, &tun->dstname, mDNSfalse);
4999 return;
5000 }
5001
5002 tun->loc_inner = info->AutoTunnelInnerAddress;
5003
5004 // If we found a v6Relay address for our peer, delete all the v4Tunnels for our peer and
5005 // look for existing tunnels to see whether they have the same information for our peer.
5006 // If not, delete them and need to create a new tunnel. If they are same, just use the
5007 // same tunnel. Do the similar thing if we found a v4Tunnel end point for our peer.
5008 TunnelClientDeleteAny(m, tun, !v6Tunnel);
5009 needSetKeys = TunnelClientDeleteMatching(m, tun, v6Tunnel);
5010
5011 if (needSetKeys) LogInfo("TunnelClientFinish: New %s AutoTunnel for %##s %.16a", (v6Tunnel ? "IPv6" : "IPv4"), tun->dstname.c, &tun->rmt_inner);
5012 else LogInfo("TunnelClientFinish: Reusing exiting %s AutoTunnel for %##s %.16a", (v6Tunnel ? "IPv6" : "IPv4"), tun->dstname.c, &tun->rmt_inner);
5013
5014 mStatus result = needSetKeys ? AutoTunnelSetKeys(tun, mDNStrue) : mStatus_NoError;
5015 static char msgbuf[32];
5016 mDNS_snprintf(msgbuf, sizeof(msgbuf), "Tunnel setup - %d", result);
5017 mDNSASLLog((uuid_t *)&m->asl_uuid, "autotunnel.config", result ? "failure" : "success", msgbuf, "");
5018 // Kick off any questions that were held pending this tunnel setup
5019 ReissueBlockedQuestions(m, &tun->dstname, (result == mStatus_NoError) ? mDNStrue : mDNSfalse);
5020 }
5021
5022 mDNSexport void AutoTunnelCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
5023 {
5024 ClientTunnel *tun = (ClientTunnel *)question->QuestionContext;
5025 DomainAuthInfo *info;
5026
5027 LogInfo("AutoTunnelCallback tun %p AddRecord %d rdlength %d qtype %d", tun, AddRecord, answer->rdlength, question->qtype);
5028
5029 if (!AddRecord) return;
5030 mDNS_StopQuery(m, question);
5031
5032 // If we are looking up the AAAA record for _autotunnel6, don't consider it as failure.
5033 // The code below will look for _autotunnel._udp SRV record followed by A record
5034 if (tun->tc_state != TC_STATE_AAAA_PEER_RELAY && !answer->rdlength)
5035 {
5036 LogInfo("AutoTunnelCallback NXDOMAIN %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
5037 static char msgbuf[16];
5038 mDNS_snprintf(msgbuf, sizeof(msgbuf), "%s lookup", DNSTypeName(question->qtype));
5039 mDNSASLLog((uuid_t *)&m->asl_uuid, "autotunnel.config", "failure", msgbuf, "");
5040 UnlinkAndReissueBlockedQuestions(m, tun, mDNSfalse);
5041 return;
5042 }
5043
5044 switch (tun->tc_state)
5045 {
5046 case TC_STATE_AAAA_PEER:
5047 if (question->qtype != kDNSType_AAAA)
5048 {
5049 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_AAAA_PEER", question->qtype);
5050 }
5051 info = GetAuthInfoForName(m, &tun->dstname);
5052 if (!info)
5053 {
5054 LogMsg("AutoTunnelCallback: Could not get AuthInfo for %##s", tun->dstname.c);
5055 UnlinkAndReissueBlockedQuestions(m, tun, mDNStrue);
5056 return;
5057 }
5058 if (mDNSSameIPv6Address(answer->rdata->u.ipv6, info->AutoTunnelInnerAddress))
5059 {
5060 LogInfo("AutoTunnelCallback: suppressing tunnel to self %.16a", &answer->rdata->u.ipv6);
5061 UnlinkAndReissueBlockedQuestions(m, tun, mDNStrue);
5062 return;
5063 }
5064 if (info && mDNSSameIPv6NetworkPart(answer->rdata->u.ipv6, info->AutoTunnelInnerAddress))
5065 {
5066 LogInfo("AutoTunnelCallback: suppressing tunnel to peer %.16a", &answer->rdata->u.ipv6);
5067 UnlinkAndReissueBlockedQuestions(m, tun, mDNStrue);
5068 return;
5069 }
5070 tun->rmt_inner = answer->rdata->u.ipv6;
5071 LogInfo("AutoTunnelCallback:TC_STATE_AAAA_PEER: dst host %.16a", &tun->rmt_inner);
5072 if (!mDNSIPv6AddressIsZero(m->AutoTunnelRelayAddr))
5073 {
5074 LogInfo("AutoTunnelCallback: Looking up _autotunnel6 AAAA");
5075 tun->tc_state = TC_STATE_AAAA_PEER_RELAY;
5076 question->qtype = kDNSType_AAAA;
5077 AssignDomainName(&question->qname, (const domainname*) "\x0C" "_autotunnel6");
5078 }
5079 else
5080 {
5081 LogInfo("AutoTunnelCallback: Looking up _autotunnel._udp SRV");
5082 tun->tc_state = TC_STATE_SRV_PEER;
5083 question->qtype = kDNSType_SRV;
5084 AssignDomainName(&question->qname, (const domainname*) "\x0B" "_autotunnel" "\x04" "_udp");
5085 }
5086 AppendDomainName(&question->qname, &tun->dstname);
5087 mDNS_StartQuery(m, &tun->q);
5088 return;
5089 case TC_STATE_AAAA_PEER_RELAY:
5090 if (question->qtype != kDNSType_AAAA)
5091 {
5092 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_AAAA_PEER_RELAY", question->qtype);
5093 }
5094 // If it failed, look for the SRV record.
5095 if (!answer->rdlength)
5096 {
5097 LogInfo("AutoTunnelCallback: Looking up _autotunnel6 AAAA failed, trying SRV");
5098 tun->tc_state = TC_STATE_SRV_PEER;
5099 AssignDomainName(&question->qname, (const domainname*) "\x0B" "_autotunnel" "\x04" "_udp");
5100 AppendDomainName(&question->qname, &tun->dstname);
5101 question->qtype = kDNSType_SRV;
5102 mDNS_StartQuery(m, &tun->q);
5103 return;
5104 }
5105 TunnelClientFinish(m, question, answer);
5106 return;
5107 case TC_STATE_SRV_PEER:
5108 if (question->qtype != kDNSType_SRV)
5109 {
5110 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_SRV_PEER", question->qtype);
5111 }
5112 LogInfo("AutoTunnelCallback: SRV target name %##s", answer->rdata->u.srv.target.c);
5113 tun->tc_state = TC_STATE_ADDR_PEER;
5114 AssignDomainName(&tun->q.qname, &answer->rdata->u.srv.target);
5115 tun->rmt_outer_port = answer->rdata->u.srv.port;
5116 question->qtype = kDNSType_A;
5117 mDNS_StartQuery(m, &tun->q);
5118 return;
5119 case TC_STATE_ADDR_PEER:
5120 if (question->qtype != kDNSType_A)
5121 {
5122 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_ADDR_PEER", question->qtype);
5123 }
5124 TunnelClientFinish(m, question, answer);
5125 return;
5126 default:
5127 LogMsg("AutoTunnelCallback: Unknown question %p", question);
5128 }
5129 }
5130
5131 // Must be called with the lock held
5132 mDNSexport void AddNewClientTunnel(mDNS *const m, DNSQuestion *const q)
5133 {
5134 ClientTunnel *p = mallocL("ClientTunnel", sizeof(ClientTunnel));
5135 if (!p) return;
5136 AssignDomainName(&p->dstname, &q->qname);
5137 p->MarkedForDeletion = mDNSfalse;
5138 p->loc_inner = zerov6Addr;
5139 p->loc_outer = zerov4Addr;
5140 p->loc_outer6 = zerov6Addr;
5141 p->rmt_inner = zerov6Addr;
5142 p->rmt_outer = zerov4Addr;
5143 p->rmt_outer6 = zerov6Addr;
5144 p->rmt_outer_port = zeroIPPort;
5145 p->tc_state = TC_STATE_AAAA_PEER;
5146 p->next = m->TunnelClients;
5147 m->TunnelClients = p; // We intentionally build list in reverse order
5148
5149 p->q.InterfaceID = mDNSInterface_Any;
5150 p->q.flags = 0;
5151 p->q.Target = zeroAddr;
5152 AssignDomainName(&p->q.qname, &q->qname);
5153 p->q.qtype = kDNSType_AAAA;
5154 p->q.qclass = kDNSClass_IN;
5155 p->q.LongLived = mDNSfalse;
5156 p->q.ExpectUnique = mDNStrue;
5157 p->q.ForceMCast = mDNSfalse;
5158 p->q.ReturnIntermed = mDNStrue;
5159 p->q.SuppressUnusable = mDNSfalse;
5160 p->q.SearchListIndex = 0;
5161 p->q.AppendSearchDomains = 0;
5162 p->q.RetryWithSearchDomains = mDNSfalse;
5163 p->q.TimeoutQuestion = 0;
5164 p->q.WakeOnResolve = 0;
5165 p->q.UseBackgroundTrafficClass = mDNSfalse;
5166 p->q.ValidationRequired = 0;
5167 p->q.ValidatingResponse = 0;
5168 p->q.ProxyQuestion = 0;
5169 p->q.qnameOrig = mDNSNULL;
5170 p->q.AnonInfo = mDNSNULL;
5171 p->q.pid = mDNSPlatformGetPID();
5172 p->q.QuestionCallback = AutoTunnelCallback;
5173 p->q.QuestionContext = p;
5174
5175 LogInfo("AddNewClientTunnel start tun %p %##s (%s)%s", p, &q->qname.c, DNSTypeName(q->qtype), q->LongLived ? " LongLived" : "");
5176 mDNS_StartQuery_internal(m, &p->q);
5177 }
5178
5179 #endif // APPLE_OSX_mDNSResponder
5180
5181 #if COMPILER_LIKES_PRAGMA_MARK
5182 #pragma mark -
5183 #pragma mark - Power State & Configuration Change Management
5184 #endif
5185
5186 mDNSlocal mStatus UpdateInterfaceList(mDNS *const m, mDNSs32 utc)
5187 {
5188 mDNSBool foundav4 = mDNSfalse;
5189 mDNSBool foundav6 = mDNSfalse;
5190 struct ifaddrs *ifa = myGetIfAddrs(1);
5191 struct ifaddrs *v4Loopback = NULL;
5192 struct ifaddrs *v6Loopback = NULL;
5193 char defaultname[64];
5194 int InfoSocket = socket(AF_INET6, SOCK_DGRAM, 0);
5195 if (InfoSocket < 3 && errno != EAFNOSUPPORT)
5196 LogMsg("UpdateInterfaceList: InfoSocket error %d errno %d (%s)", InfoSocket, errno, strerror(errno));
5197
5198 while (ifa)
5199 {
5200 #if LIST_ALL_INTERFACES
5201 if (ifa->ifa_addr->sa_family == AF_APPLETALK)
5202 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d is AF_APPLETALK",
5203 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5204 else if (ifa->ifa_addr->sa_family == AF_LINK)
5205 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d is AF_LINK",
5206 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5207 else if (ifa->ifa_addr->sa_family != AF_INET && ifa->ifa_addr->sa_family != AF_INET6)
5208 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d not AF_INET (2) or AF_INET6 (30)",
5209 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5210 if (!(ifa->ifa_flags & IFF_UP))
5211 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d Interface not IFF_UP",
5212 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5213 if (!(ifa->ifa_flags & IFF_MULTICAST))
5214 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d Interface not IFF_MULTICAST",
5215 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5216 if (ifa->ifa_flags & IFF_POINTOPOINT)
5217 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d Interface IFF_POINTOPOINT",
5218 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5219 if (ifa->ifa_flags & IFF_LOOPBACK)
5220 LogMsg("UpdateInterfaceList: %5s(%d) Flags %04X Family %2d Interface IFF_LOOPBACK",
5221 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family);
5222 #endif
5223
5224 if (ifa->ifa_addr->sa_family == AF_LINK)
5225 {
5226 struct sockaddr_dl *sdl = (struct sockaddr_dl *)ifa->ifa_addr;
5227 if (sdl->sdl_type == IFT_ETHER && sdl->sdl_alen == sizeof(m->PrimaryMAC) && mDNSSameEthAddress(&m->PrimaryMAC, &zeroEthAddr))
5228 mDNSPlatformMemCopy(m->PrimaryMAC.b, sdl->sdl_data + sdl->sdl_nlen, 6);
5229 }
5230
5231 if (ifa->ifa_flags & IFF_UP && ifa->ifa_addr)
5232 if (ifa->ifa_addr->sa_family == AF_INET || ifa->ifa_addr->sa_family == AF_INET6)
5233 {
5234 if (!ifa->ifa_netmask)
5235 {
5236 mDNSAddr ip;
5237 SetupAddr(&ip, ifa->ifa_addr);
5238 LogMsg("getifaddrs: ifa_netmask is NULL for %5s(%d) Flags %04X Family %2d %#a",
5239 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family, &ip);
5240 }
5241 // Apparently it's normal for the sa_family of an ifa_netmask to sometimes be zero, so we don't complain about that
5242 // <rdar://problem/5492035> getifaddrs is returning invalid netmask family for fw0 and vmnet
5243 else if (ifa->ifa_netmask->sa_family != ifa->ifa_addr->sa_family && ifa->ifa_netmask->sa_family != 0)
5244 {
5245 mDNSAddr ip;
5246 SetupAddr(&ip, ifa->ifa_addr);
5247 LogMsg("getifaddrs ifa_netmask for %5s(%d) Flags %04X Family %2d %#a has different family: %d",
5248 ifa->ifa_name, if_nametoindex(ifa->ifa_name), ifa->ifa_flags, ifa->ifa_addr->sa_family, &ip, ifa->ifa_netmask->sa_family);
5249 }
5250 // Currently we use a few internal ones like mDNSInterfaceID_LocalOnly etc. that are negative values (0, -1, -2).
5251 else if ((int)if_nametoindex(ifa->ifa_name) <= 0)
5252 {
5253 LogMsg("UpdateInterfaceList: if_nametoindex returned zero/negative value for %5s(%d)", ifa->ifa_name, if_nametoindex(ifa->ifa_name));
5254 }
5255 else
5256 {
5257 // Make sure ifa_netmask->sa_family is set correctly
5258 // <rdar://problem/5492035> getifaddrs is returning invalid netmask family for fw0 and vmnet
5259 ifa->ifa_netmask->sa_family = ifa->ifa_addr->sa_family;
5260 int ifru_flags6 = 0;
5261
5262 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
5263 if (ifa->ifa_addr->sa_family == AF_INET6 && InfoSocket >= 0)
5264 {
5265 struct in6_ifreq ifr6;
5266 mDNSPlatformMemZero((char *)&ifr6, sizeof(ifr6));
5267 strlcpy(ifr6.ifr_name, ifa->ifa_name, sizeof(ifr6.ifr_name));
5268 ifr6.ifr_addr = *sin6;
5269 if (ioctl(InfoSocket, SIOCGIFAFLAG_IN6, &ifr6) != -1)
5270 ifru_flags6 = ifr6.ifr_ifru.ifru_flags6;
5271 verbosedebugf("%s %.16a %04X %04X", ifa->ifa_name, &sin6->sin6_addr, ifa->ifa_flags, ifru_flags6);
5272 }
5273
5274 if (!(ifru_flags6 & (IN6_IFF_NOTREADY | IN6_IFF_DETACHED | IN6_IFF_DEPRECATED | IN6_IFF_TEMPORARY)))
5275 {
5276 if (ifa->ifa_flags & IFF_LOOPBACK)
5277 {
5278 if (ifa->ifa_addr->sa_family == AF_INET)
5279 v4Loopback = ifa;
5280 else if (sin6->sin6_addr.s6_addr[0] != 0xFD)
5281 v6Loopback = ifa;
5282 }
5283 else
5284 {
5285 NetworkInterfaceInfoOSX *i = AddInterfaceToList(m, ifa, utc);
5286 if (i && MulticastInterface(i) && i->ifinfo.Advertise)
5287 {
5288 if (ifa->ifa_addr->sa_family == AF_INET)
5289 foundav4 = mDNStrue;
5290 else
5291 foundav6 = mDNStrue;
5292 }
5293 }
5294 }
5295 }
5296 }
5297 ifa = ifa->ifa_next;
5298 }
5299
5300 // For efficiency, we don't register a loopback interface when other interfaces of that family are available and advertising
5301 if (!foundav4 && v4Loopback) AddInterfaceToList(m, v4Loopback, utc);
5302 if (!foundav6 && v6Loopback) AddInterfaceToList(m, v6Loopback, utc);
5303
5304 // Now the list is complete, set the McastTxRx setting for each interface.
5305 NetworkInterfaceInfoOSX *i;
5306 for (i = m->p->InterfaceList; i; i = i->next)
5307 if (i->Exists)
5308 {
5309 mDNSBool txrx = MulticastInterface(i);
5310 if (i->ifinfo.McastTxRx != txrx)
5311 {
5312 i->ifinfo.McastTxRx = txrx;
5313 i->Exists = 2; // State change; need to deregister and reregister this interface
5314 }
5315 }
5316
5317 if (InfoSocket >= 0)
5318 close(InfoSocket);
5319
5320 mDNS_snprintf(defaultname, sizeof(defaultname), "%.*s-%02X%02X%02X%02X%02X%02X", HINFO_HWstring_prefixlen, HINFO_HWstring,
5321 m->PrimaryMAC.b[0], m->PrimaryMAC.b[1], m->PrimaryMAC.b[2], m->PrimaryMAC.b[3], m->PrimaryMAC.b[4], m->PrimaryMAC.b[5]);
5322
5323 // Set up the nice label
5324 domainlabel nicelabel;
5325 nicelabel.c[0] = 0;
5326 GetUserSpecifiedFriendlyComputerName(&nicelabel);
5327 if (nicelabel.c[0] == 0)
5328 {
5329 debugf("Couldn’t read user-specified Computer Name; using default “%s” instead", defaultname);
5330 MakeDomainLabelFromLiteralString(&nicelabel, defaultname);
5331 }
5332
5333 // Set up the RFC 1034-compliant label
5334 domainlabel hostlabel;
5335 hostlabel.c[0] = 0;
5336 GetUserSpecifiedLocalHostName(&hostlabel);
5337 if (hostlabel.c[0] == 0)
5338 {
5339 debugf("Couldn’t read user-specified Local Hostname; using default “%s.local” instead", defaultname);
5340 MakeDomainLabelFromLiteralString(&hostlabel, defaultname);
5341 }
5342
5343 mDNSBool namechange = mDNSfalse;
5344
5345 // We use a case-sensitive comparison here because even though changing the capitalization
5346 // of the name alone is not significant to DNS, it's still a change from the user's point of view
5347 if (SameDomainLabelCS(m->p->usernicelabel.c, nicelabel.c))
5348 debugf("Usernicelabel (%#s) unchanged since last time; not changing m->nicelabel (%#s)", m->p->usernicelabel.c, m->nicelabel.c);
5349 else
5350 {
5351 if (m->p->usernicelabel.c[0]) // Don't show message first time through, when we first read name from prefs on boot
5352 LogMsg("User updated Computer Name from “%#s” to “%#s”", m->p->usernicelabel.c, nicelabel.c);
5353 m->p->usernicelabel = m->nicelabel = nicelabel;
5354 namechange = mDNStrue;
5355 }
5356
5357 if (SameDomainLabelCS(m->p->userhostlabel.c, hostlabel.c))
5358 debugf("Userhostlabel (%#s) unchanged since last time; not changing m->hostlabel (%#s)", m->p->userhostlabel.c, m->hostlabel.c);
5359 else
5360 {
5361 if (m->p->userhostlabel.c[0]) // Don't show message first time through, when we first read name from prefs on boot
5362 LogMsg("User updated Local Hostname from “%#s” to “%#s”", m->p->userhostlabel.c, hostlabel.c);
5363 m->p->userhostlabel = m->hostlabel = hostlabel;
5364 mDNS_SetFQDN(m);
5365 namechange = mDNStrue;
5366 }
5367
5368 #if APPLE_OSX_mDNSResponder
5369 if (namechange) // If either name has changed, we need to tickle our AutoTunnel state machine to update its registered records
5370 {
5371 DomainAuthInfo *info;
5372 for (info = m->AuthInfoList; info; info = info->next)
5373 if (info->AutoTunnel) AutoTunnelHostNameChanged(m, info);
5374 }
5375 #endif // APPLE_OSX_mDNSResponder
5376
5377 return(mStatus_NoError);
5378 }
5379
5380 // Returns number of leading one-bits in mask: 0-32 for IPv4, 0-128 for IPv6
5381 // Returns -1 if all the one-bits are not contiguous
5382 mDNSlocal int CountMaskBits(mDNSAddr *mask)
5383 {
5384 int i = 0, bits = 0;
5385 int bytes = mask->type == mDNSAddrType_IPv4 ? 4 : mask->type == mDNSAddrType_IPv6 ? 16 : 0;
5386 while (i < bytes)
5387 {
5388 mDNSu8 b = mask->ip.v6.b[i++];
5389 while (b & 0x80) { bits++; b <<= 1; }
5390 if (b) return(-1);
5391 }
5392 while (i < bytes) if (mask->ip.v6.b[i++]) return(-1);
5393 return(bits);
5394 }
5395
5396 // returns count of non-link local V4 addresses registered
5397 mDNSlocal int SetupActiveInterfaces(mDNS *const m, mDNSs32 utc)
5398 {
5399 NetworkInterfaceInfoOSX *i;
5400 int count = 0;
5401 for (i = m->p->InterfaceList; i; i = i->next)
5402 if (i->Exists)
5403 {
5404 NetworkInterfaceInfo *const n = &i->ifinfo;
5405 NetworkInterfaceInfoOSX *primary = SearchForInterfaceByName(m, i->ifinfo.ifname, AF_UNSPEC);
5406 if (!primary) LogMsg("SetupActiveInterfaces ERROR! SearchForInterfaceByName didn't find %s", i->ifinfo.ifname);
5407
5408 if (i->Registered && i->Registered != primary) // Sanity check
5409 {
5410 LogMsg("SetupActiveInterfaces ERROR! n->Registered %p != primary %p", i->Registered, primary);
5411 i->Registered = mDNSNULL;
5412 }
5413
5414 if (!i->Registered)
5415 {
5416 // Note: If i->Registered is set, that means we've called mDNS_RegisterInterface() for this interface,
5417 // so we need to make sure we call mDNS_DeregisterInterface() before disposing it.
5418 // If i->Registered is NOT set, then we haven't registered it and we should not try to deregister it
5419 //
5420
5421 i->Registered = primary;
5422
5423 // If i->LastSeen == utc, then this is a brand-new interface, just created, or an interface that never went away.
5424 // If i->LastSeen != utc, then this is an old interface, previously seen, that went away for (utc - i->LastSeen) seconds.
5425 // If the interface is an old one that went away and came back in less than a minute, then we're in a flapping scenario.
5426 i->Occulting = !(i->ifa_flags & IFF_LOOPBACK) && (utc - i->LastSeen > 0 && utc - i->LastSeen < 60);
5427
5428 // Temporary fix to handle P2P flapping. P2P reuses the scope-id, mac address and the IP address
5429 // everytime it creates a new interface. We think it is a duplicate and hence consider it
5430 // as flashing and occulting, that is, flapping. If an interface is marked as flapping,
5431 // mDNS_RegisterInterface() changes the probe delay from 1/2 second to 5 seconds and
5432 // logs a warning message to system.log noting frequent interface transitions.
5433 // Same logic applies when IFEF_DIRECTLINK flag is set on the interface.
5434 if ((strncmp(i->ifinfo.ifname, "p2p", 3) == 0) || i->ifinfo.DirectLink)
5435 {
5436 LogInfo("SetupActiveInterfaces: %s interface registering %s %s", i->ifinfo.ifname,
5437 i->Flashing ? " (Flashing)" : "",
5438 i->Occulting ? " (Occulting)" : "");
5439 mDNS_RegisterInterface(m, n, 0);
5440 }
5441 else
5442 {
5443 mDNS_RegisterInterface(m, n, i->Flashing && i->Occulting);
5444 }
5445
5446 if (!mDNSAddressIsLinkLocal(&n->ip)) count++;
5447 LogInfo("SetupActiveInterfaces: Registered %5s(%lu) %.6a InterfaceID %p(%p), primary %p, %#a/%d%s%s%s",
5448 i->ifinfo.ifname, i->scope_id, &i->BSSID, i->ifinfo.InterfaceID, i, primary, &n->ip, CountMaskBits(&n->mask),
5449 i->Flashing ? " (Flashing)" : "",
5450 i->Occulting ? " (Occulting)" : "",
5451 n->InterfaceActive ? " (Primary)" : "");
5452
5453 if (!n->McastTxRx)
5454 debugf("SetupActiveInterfaces: No Tx/Rx on %5s(%lu) %.6a InterfaceID %p %#a", i->ifinfo.ifname, i->scope_id, &i->BSSID, i->ifinfo.InterfaceID, &n->ip);
5455 else
5456 {
5457 if (i->sa_family == AF_INET)
5458 {
5459 struct ip_mreq imr;
5460 primary->ifa_v4addr.s_addr = n->ip.ip.v4.NotAnInteger;
5461 imr.imr_multiaddr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
5462 imr.imr_interface = primary->ifa_v4addr;
5463
5464 // If this is our *first* IPv4 instance for this interface name, we need to do a IP_DROP_MEMBERSHIP first,
5465 // before trying to join the group, to clear out stale kernel state which may be lingering.
5466 // In particular, this happens with removable network interfaces like USB Ethernet adapters -- the kernel has stale state
5467 // from the last time the USB Ethernet adapter was connected, and part of the kernel thinks we've already joined the group
5468 // on that interface (so we get EADDRINUSE when we try to join again) but a different part of the kernel thinks we haven't
5469 // joined the group (so we receive no multicasts). Doing an IP_DROP_MEMBERSHIP before joining seems to flush the stale state.
5470 // Also, trying to make the code leave the group when the adapter is removed doesn't work either,
5471 // because by the time we get the configuration change notification, the interface is already gone,
5472 // so attempts to unsubscribe fail with EADDRNOTAVAIL (errno 49 "Can't assign requested address").
5473 // <rdar://problem/5585972> IP_ADD_MEMBERSHIP fails for previously-connected removable interfaces
5474 if (SearchForInterfaceByName(m, i->ifinfo.ifname, AF_INET) == i)
5475 {
5476 LogInfo("SetupActiveInterfaces: %5s(%lu) Doing precautionary IP_DROP_MEMBERSHIP for %.4a on %.4a", i->ifinfo.ifname, i->scope_id, &imr.imr_multiaddr, &imr.imr_interface);
5477 mStatus err = setsockopt(m->p->permanentsockets.sktv4, IPPROTO_IP, IP_DROP_MEMBERSHIP, &imr, sizeof(imr));
5478 if (err < 0 && (errno != EADDRNOTAVAIL))
5479 LogMsg("setsockopt - IP_DROP_MEMBERSHIP error %d errno %d (%s)", err, errno, strerror(errno));
5480 }
5481
5482 LogInfo("SetupActiveInterfaces: %5s(%lu) joining IPv4 mcast group %.4a on %.4a", i->ifinfo.ifname, i->scope_id, &imr.imr_multiaddr, &imr.imr_interface);
5483 mStatus err = setsockopt(m->p->permanentsockets.sktv4, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, sizeof(imr));
5484 // Joining same group twice can give "Address already in use" error -- no need to report that
5485 if (err < 0 && (errno != EADDRINUSE))
5486 LogMsg("setsockopt - IP_ADD_MEMBERSHIP error %d errno %d (%s) group %.4a on %.4a", err, errno, strerror(errno), &imr.imr_multiaddr, &imr.imr_interface);
5487 }
5488 if (i->sa_family == AF_INET6)
5489 {
5490 struct ipv6_mreq i6mr;
5491 i6mr.ipv6mr_interface = primary->scope_id;
5492 i6mr.ipv6mr_multiaddr = *(struct in6_addr*)&AllDNSLinkGroup_v6.ip.v6;
5493
5494 if (SearchForInterfaceByName(m, i->ifinfo.ifname, AF_INET6) == i)
5495 {
5496 LogInfo("SetupActiveInterfaces: %5s(%lu) Doing precautionary IPV6_LEAVE_GROUP for %.16a on %u", i->ifinfo.ifname, i->scope_id, &i6mr.ipv6mr_multiaddr, i6mr.ipv6mr_interface);
5497 mStatus err = setsockopt(m->p->permanentsockets.sktv6, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &i6mr, sizeof(i6mr));
5498 if (err < 0 && (errno != EADDRNOTAVAIL))
5499 LogMsg("setsockopt - IPV6_LEAVE_GROUP error %d errno %d (%s) group %.16a on %u", err, errno, strerror(errno), &i6mr.ipv6mr_multiaddr, i6mr.ipv6mr_interface);
5500 }
5501
5502 LogInfo("SetupActiveInterfaces: %5s(%lu) joining IPv6 mcast group %.16a on %u", i->ifinfo.ifname, i->scope_id, &i6mr.ipv6mr_multiaddr, i6mr.ipv6mr_interface);
5503 mStatus err = setsockopt(m->p->permanentsockets.sktv6, IPPROTO_IPV6, IPV6_JOIN_GROUP, &i6mr, sizeof(i6mr));
5504 // Joining same group twice can give "Address already in use" error -- no need to report that
5505 if (err < 0 && (errno != EADDRINUSE))
5506 LogMsg("setsockopt - IPV6_JOIN_GROUP error %d errno %d (%s) group %.16a on %u", err, errno, strerror(errno), &i6mr.ipv6mr_multiaddr, i6mr.ipv6mr_interface);
5507 }
5508 }
5509 }
5510 }
5511
5512 return count;
5513 }
5514
5515 mDNSlocal void MarkAllInterfacesInactive(mDNS *const m, mDNSs32 utc)
5516 {
5517 NetworkInterfaceInfoOSX *i;
5518 for (i = m->p->InterfaceList; i; i = i->next)
5519 {
5520 if (i->Exists) i->LastSeen = utc;
5521 i->Exists = mDNSfalse;
5522 }
5523 }
5524
5525 // returns count of non-link local V4 addresses deregistered
5526 mDNSlocal int ClearInactiveInterfaces(mDNS *const m, mDNSs32 utc)
5527 {
5528 // First pass:
5529 // If an interface is going away, then deregister this from the mDNSCore.
5530 // We also have to deregister it if the primary interface that it's using for its InterfaceID is going away.
5531 // We have to do this because mDNSCore will use that InterfaceID when sending packets, and if the memory
5532 // it refers to has gone away we'll crash.
5533 NetworkInterfaceInfoOSX *i;
5534 int count = 0;
5535 for (i = m->p->InterfaceList; i; i = i->next)
5536 {
5537 // If this interface is no longer active, or its InterfaceID is changing, deregister it
5538 NetworkInterfaceInfoOSX *primary = SearchForInterfaceByName(m, i->ifinfo.ifname, AF_UNSPEC);
5539 if (i->Registered)
5540 if (i->Exists == 0 || i->Exists == 2 || i->Registered != primary)
5541 {
5542 i->Flashing = !(i->ifa_flags & IFF_LOOPBACK) && (utc - i->AppearanceTime < 60);
5543 LogInfo("ClearInactiveInterfaces: Deregistering %5s(%lu) %.6a InterfaceID %p(%p), primary %p, %#a/%d%s%s%s",
5544 i->ifinfo.ifname, i->scope_id, &i->BSSID, i->ifinfo.InterfaceID, i, primary,
5545 &i->ifinfo.ip, CountMaskBits(&i->ifinfo.mask),
5546 i->Flashing ? " (Flashing)" : "",
5547 i->Occulting ? " (Occulting)" : "",
5548 i->ifinfo.InterfaceActive ? " (Primary)" : "");
5549
5550 // Temporary fix to handle P2P flapping. P2P reuses the scope-id, mac address and the IP address
5551 // everytime it creates a new interface. We think it is a duplicate and hence consider it
5552 // as flashing and occulting. The "core" does not flush the cache for this case. This leads to
5553 // stale data returned to the application even after the interface is removed. The application
5554 // then starts to send data but the new interface is not yet created.
5555 // Same logic applies when IFEF_DIRECTLINK flag is set on the interface.
5556 if ((strncmp(i->ifinfo.ifname, "p2p", 3) == 0) || i->ifinfo.DirectLink)
5557 {
5558 LogInfo("ClearInactiveInterfaces: %s interface deregistering %s %s", i->ifinfo.ifname,
5559 i->Flashing ? " (Flashing)" : "",
5560 i->Occulting ? " (Occulting)" : "");
5561 mDNS_DeregisterInterface(m, &i->ifinfo, 0);
5562 }
5563 else
5564 {
5565 mDNS_DeregisterInterface(m, &i->ifinfo, i->Flashing && i->Occulting);
5566 }
5567 if (!mDNSAddressIsLinkLocal(&i->ifinfo.ip)) count++;
5568 i->Registered = mDNSNULL;
5569 // Note: If i->Registered is set, that means we've called mDNS_RegisterInterface() for this interface,
5570 // so we need to make sure we call mDNS_DeregisterInterface() before disposing it.
5571 // If i->Registered is NOT set, then it's not registered and we should not call mDNS_DeregisterInterface() on it.
5572
5573 // Caution: If we ever decide to add code here to leave the multicast group, we need to make sure that this
5574 // is the LAST representative of this physical interface, or we'll unsubscribe from the group prematurely.
5575 }
5576 }
5577
5578 // Second pass:
5579 // Now that everything that's going to deregister has done so, we can clean up and free the memory
5580 NetworkInterfaceInfoOSX **p = &m->p->InterfaceList;
5581 while (*p)
5582 {
5583 i = *p;
5584 // If no longer active, delete interface from list and free memory
5585 if (!i->Exists)
5586 {
5587 if (i->LastSeen == utc) i->LastSeen = utc - 1;
5588 mDNSBool delete = (NumCacheRecordsForInterfaceID(m, i->ifinfo.InterfaceID) == 0) && (utc - i->LastSeen >= 60);
5589 LogInfo("ClearInactiveInterfaces: %-13s %5s(%lu) %.6a InterfaceID %p(%p) %#a/%d Age %d%s", delete ? "Deleting" : "Holding",
5590 i->ifinfo.ifname, i->scope_id, &i->BSSID, i->ifinfo.InterfaceID, i,
5591 &i->ifinfo.ip, CountMaskBits(&i->ifinfo.mask), utc - i->LastSeen,
5592 i->ifinfo.InterfaceActive ? " (Primary)" : "");
5593 #if APPLE_OSX_mDNSResponder
5594 if (i->BPF_fd >= 0) CloseBPF(i);
5595 #endif // APPLE_OSX_mDNSResponder
5596 if (delete)
5597 {
5598 *p = i->next;
5599 freeL("NetworkInterfaceInfoOSX", i);
5600 continue; // After deleting this object, don't want to do the "p = &i->next;" thing at the end of the loop
5601 }
5602 }
5603 p = &i->next;
5604 }
5605 return count;
5606 }
5607
5608 mDNSlocal void AppendDNameListElem(DNameListElem ***List, mDNSu32 uid, domainname *name)
5609 {
5610 DNameListElem *dnle = (DNameListElem*) mallocL("DNameListElem/AppendDNameListElem", sizeof(DNameListElem));
5611 if (!dnle) LogMsg("ERROR: AppendDNameListElem: memory exhausted");
5612 else
5613 {
5614 dnle->next = mDNSNULL;
5615 dnle->uid = uid;
5616 AssignDomainName(&dnle->name, name);
5617 **List = dnle;
5618 *List = &dnle->next;
5619 }
5620 }
5621
5622 mDNSlocal int compare_dns_configs(const void *aa, const void *bb)
5623 {
5624 dns_resolver_t *a = *(dns_resolver_t**)aa;
5625 dns_resolver_t *b = *(dns_resolver_t**)bb;
5626
5627 return (a->search_order < b->search_order) ? -1 : (a->search_order == b->search_order) ? 0 : 1;
5628 }
5629
5630 mDNSlocal void UpdateSearchDomainHash(mDNS *const m, MD5_CTX *sdc, char *domain, mDNSInterfaceID InterfaceID)
5631 {
5632 char *buf = ".";
5633 mDNSu32 scopeid = 0;
5634 char ifid_buf[16];
5635
5636 if (domain)
5637 buf = domain;
5638 //
5639 // Hash the search domain name followed by the InterfaceID.
5640 // As we have scoped search domains, we also included InterfaceID. If either of them change,
5641 // we will detect it. Even if the order of them change, we will detect it.
5642 //
5643 // Note: We have to handle a few of these tricky cases.
5644 //
5645 // 1) Current: com, apple.com Changing to: comapple.com
5646 // 2) Current: a.com,b.com Changing to a.comb.com
5647 // 3) Current: a.com,b.com (ifid 8), Changing to a.com8b.com (ifid 8)
5648 // 4) Current: a.com (ifid 12), Changing to a.com1 (ifid: 2)
5649 //
5650 // There are more variants of the above. The key thing is if we include the null in each case
5651 // at the end of name and the InterfaceID, it will prevent a new name (which can't include
5652 // NULL as part of the name) to be mistakenly thought of as a old name.
5653
5654 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, InterfaceID, mDNStrue);
5655 // mDNS_snprintf always null terminates
5656 if (mDNS_snprintf(ifid_buf, sizeof(ifid_buf), "%u", scopeid) >= sizeof(ifid_buf))
5657 LogMsg("UpdateSearchDomainHash: mDNS_snprintf failed for scopeid %u", scopeid);
5658
5659 LogInfo("UpdateSearchDomainHash: buf %s, ifid_buf %s", buf, ifid_buf);
5660 MD5_Update(sdc, buf, strlen(buf) + 1);
5661 MD5_Update(sdc, ifid_buf, strlen(ifid_buf) + 1);
5662 }
5663
5664 mDNSlocal void FinalizeSearchDomainHash(mDNS *const m, MD5_CTX *sdc)
5665 {
5666 mDNSu8 md5_hash[MD5_LEN];
5667
5668 MD5_Final(md5_hash, sdc);
5669
5670 if (memcmp(md5_hash, m->SearchDomainsHash, MD5_LEN))
5671 {
5672 // If the hash is different, either the search domains have changed or
5673 // the ordering between them has changed. Restart the questions that
5674 // would be affected by this.
5675 LogInfo("FinalizeSearchDomains: The hash is different");
5676 memcpy(m->SearchDomainsHash, md5_hash, MD5_LEN);
5677 RetrySearchDomainQuestions(m);
5678 }
5679 else { LogInfo("FinalizeSearchDomains: The hash is same"); }
5680 }
5681
5682 mDNSexport const char *DNSScopeToString(mDNSu32 scope)
5683 {
5684 switch (scope)
5685 {
5686 case kScopeNone:
5687 return "Unscoped";
5688 case kScopeInterfaceID:
5689 return "InterfaceScoped";
5690 case kScopeServiceID:
5691 return "ServiceScoped";
5692 default:
5693 return "Unknown";
5694 }
5695 }
5696
5697 mDNSlocal void ConfigSearchDomains(mDNS *const m, dns_resolver_t *resolver, mDNSInterfaceID interface, mDNSu32 scope, MD5_CTX *sdc)
5698 {
5699 const char *scopeString = DNSScopeToString(scope);
5700 int j;
5701
5702 if (scope != kScopeNone)
5703 {
5704 LogInfo("ConfigSearchDomains: (%s) Ignoring search domain for Interface %p", scopeString, interface);
5705 return;
5706 }
5707 for (j = 0; j < resolver->n_search; j++)
5708 {
5709 LogInfo("ConfigSearchDomains: (%s) configuring search list %s", scopeString, resolver->search[j]);
5710 UpdateSearchDomainHash(m, sdc, resolver->search[j], NULL);
5711 mDNS_AddSearchDomain_CString(resolver->search[j], NULL);
5712 }
5713 }
5714
5715 mDNSlocal mDNSInterfaceID ConfigParseInterfaceID(mDNS *const m, mDNSu32 ifindex)
5716 {
5717 NetworkInterfaceInfoOSX *ni;
5718 mDNSInterfaceID interface;
5719
5720 for (ni = m->p->InterfaceList; ni; ni = ni->next)
5721 {
5722 if (ni->ifinfo.InterfaceID && ni->scope_id == ifindex)
5723 break;
5724 }
5725 if (ni != NULL)
5726 {
5727 interface = ni->ifinfo.InterfaceID;
5728 }
5729 else
5730 {
5731 // In rare circumstances, we could potentially hit this case where we cannot parse the InterfaceID
5732 // (see <rdar://problem/13214785>). At this point, we still accept the DNS Config from configd
5733 // Note: We currently ack the whole dns configuration and not individual resolvers or DNS servers.
5734 // As the caller is going to ack the configuration always, we have to add all the DNS servers
5735 // in the configuration. Otherwise, we won't have any DNS servers up until the network change.
5736
5737 LogMsg("ConfigParseInterfaceID: interface specific index %d not found (interface may not be UP)",ifindex);
5738
5739 // Set the correct interface from configd before passing this to mDNS_AddDNSServer() below
5740 interface = (mDNSInterfaceID)(unsigned long)ifindex;
5741 }
5742 return interface;
5743 }
5744
5745 mDNSlocal void ConfigNonUnicastResolver(mDNS *const m, dns_resolver_t *r)
5746 {
5747 char *opt = r->options;
5748 domainname d;
5749
5750 if (opt && !strncmp(opt, "mdns", strlen(opt)))
5751 {
5752 if (!MakeDomainNameFromDNSNameString(&d, r->domain))
5753 {
5754 LogMsg("ConfigNonUnicastResolver: config->resolver bad domain %s", r->domain);
5755 return;
5756 }
5757 mDNS_AddMcastResolver(m, &d, mDNSInterface_Any, r->timeout);
5758 }
5759 }
5760
5761 mDNSlocal void ConfigDNSServers(mDNS *const m, dns_resolver_t *r, mDNSInterfaceID interface, mDNSu32 scope, mDNSu16 resGroupID)
5762 {
5763 int n;
5764 domainname d;
5765 int serviceID = 0;
5766 mDNSBool cellIntf = mDNSfalse;
5767 mDNSBool scopedDNS = mDNSfalse;
5768 mDNSBool reqA, reqAAAA;
5769
5770 if (!r->domain || !*r->domain)
5771 {
5772 d.c[0] = 0;
5773 }
5774 else if (!MakeDomainNameFromDNSNameString(&d, r->domain))
5775 {
5776 LogMsg("ConfigDNSServers: bad domain %s", r->domain);
5777 return;
5778 }
5779 // Parse the resolver specific attributes that affects all the DNS servers.
5780 if (scope == kScopeInterfaceID)
5781 {
5782 scopedDNS = mDNStrue;
5783 }
5784 else if (scope == kScopeServiceID)
5785 {
5786 serviceID = r->service_identifier;
5787 }
5788
5789 #if TARGET_OS_IPHONE
5790 cellIntf = (r->reach_flags & kSCNetworkReachabilityFlagsIsWWAN) ? mDNStrue : mDNSfalse;
5791 #endif
5792 reqA = (r->flags & DNS_RESOLVER_FLAGS_REQUEST_A_RECORDS ? mDNStrue : mDNSfalse);
5793 reqAAAA = (r->flags & DNS_RESOLVER_FLAGS_REQUEST_AAAA_RECORDS ? mDNStrue : mDNSfalse);
5794
5795 for (n = 0; n < r->n_nameserver; n++)
5796 {
5797 mDNSAddr saddr;
5798 DNSServer *s;
5799
5800 if (r->nameserver[n]->sa_family != AF_INET && r->nameserver[n]->sa_family != AF_INET6)
5801 continue;
5802
5803 if (SetupAddr(&saddr, r->nameserver[n]))
5804 {
5805 LogMsg("ConfigDNSServers: Bad address");
5806 continue;
5807 }
5808
5809 // The timeout value is for all the DNS servers in a given resolver, hence we pass
5810 // the timeout value only for the first DNSServer. If we don't have a value in the
5811 // resolver, then use the core's default value
5812 //
5813 // Note: this assumes that when the core picks a list of DNSServers for a question,
5814 // it takes the sum of all the timeout values for all DNS servers. By doing this, it
5815 // tries all the DNS servers in a specified timeout
5816 s = mDNS_AddDNSServer(m, &d, interface, serviceID, &saddr, r->port ? mDNSOpaque16fromIntVal(r->port) : UnicastDNSPort, scope,
5817 (n == 0 ? (r->timeout ? r->timeout : DEFAULT_UDNS_TIMEOUT) : 0), cellIntf, resGroupID, reqA, reqAAAA, mDNStrue);
5818 if (s)
5819 {
5820 LogInfo("ConfigDNSServers(%s): DNS server %#a:%d for domain %##s", DNSScopeToString(scope), &s->addr, mDNSVal16(s->port), d.c);
5821 }
5822 }
5823 }
5824
5825 // ConfigResolvers is called for different types of resolvers: Unscoped resolver, Interface scope resolver and
5826 // Service scope resolvers. This is indicated by the scope argument.
5827 //
5828 // "resolver" has entries that should only be used for unscoped questions.
5829 //
5830 // "scoped_resolver" has entries that should only be used for Interface scoped question i.e., questions that specify an
5831 // interface index (q->InterfaceID)
5832 //
5833 // "service_specific_resolver" has entries that should be used for Service scoped question i.e., questions that specify
5834 // a service identifier (q->ServiceID)
5835 //
5836 mDNSlocal void ConfigResolvers(mDNS *const m, dns_config_t *config, mDNSu32 scope, mDNSBool setsearch, mDNSBool setservers, MD5_CTX *sdc, mDNSu16 resGroupID)
5837 {
5838 int i;
5839 dns_resolver_t **resolver;
5840 int nresolvers;
5841 const char *scopeString = DNSScopeToString(scope);
5842 mDNSInterfaceID interface;
5843
5844 switch (scope)
5845 {
5846 case kScopeNone:
5847 resolver = config->resolver;
5848 nresolvers = config->n_resolver;
5849 break;
5850 case kScopeInterfaceID:
5851 resolver = config->scoped_resolver;
5852 nresolvers = config->n_scoped_resolver;
5853 break;
5854 case kScopeServiceID:
5855 resolver = config->service_specific_resolver;
5856 nresolvers = config->n_service_specific_resolver;
5857 break;
5858 default:
5859 return;
5860 }
5861 qsort(resolver, nresolvers, sizeof(dns_resolver_t*), compare_dns_configs);
5862
5863 for (i = 0; i < nresolvers; i++)
5864 {
5865 dns_resolver_t *r = resolver[i];
5866
5867 LogInfo("ConfigResolvers: %s resolver[%d] domain %s n_nameserver %d", scopeString, i, r->domain, r->n_nameserver);
5868
5869 interface = mDNSInterface_Any;
5870
5871 // Parse the interface index
5872 if (r->if_index != 0)
5873 {
5874 interface = ConfigParseInterfaceID(m, r->if_index);
5875 }
5876
5877 if (setsearch)
5878 {
5879 ConfigSearchDomains(m, resolver[i], interface, scope, sdc);
5880 // Parse other scoped resolvers for search lists
5881 if (!setservers)
5882 continue;
5883 }
5884
5885 if (r->port == 5353 || r->n_nameserver == 0)
5886 {
5887 ConfigNonUnicastResolver(m, r);
5888 }
5889 else
5890 {
5891 // Each scoped resolver gets its own ID (i.e., they are in their own group) so that responses from the
5892 // scoped resolver are not used by other non-scoped or scoped resolvers.
5893 if (scope != kScopeNone)
5894 resGroupID++;
5895
5896 ConfigDNSServers(m, r, interface, scope, resGroupID);
5897 }
5898 }
5899 }
5900
5901 #if APPLE_OSX_mDNSResponder
5902 mDNSlocal mDNSBool QuestionValidForDNSTrigger(DNSQuestion *q)
5903 {
5904 if (QuerySuppressed(q))
5905 {
5906 debugf("QuestionValidForDNSTrigger: Suppressed: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
5907 return mDNSfalse;
5908 }
5909 if (mDNSOpaque16IsZero(q->TargetQID))
5910 {
5911 debugf("QuestionValidForDNSTrigger: Multicast: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
5912 return mDNSfalse;
5913 }
5914 // If we answered using LocalOnly records e.g., /etc/hosts, don't consider that a valid response
5915 // for trigger.
5916 if (q->LOAddressAnswers)
5917 {
5918 debugf("QuestionValidForDNSTrigger: LocalOnly answers: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
5919 return mDNSfalse;
5920 }
5921 return mDNStrue;
5922 }
5923 #endif
5924
5925 // This function is called if we are not delivering unicast answers to "A" or "AAAA" questions.
5926 // We set our state appropriately so that if we start receiving answers, trigger the
5927 // upper layer to retry DNS questions.
5928 #if APPLE_OSX_mDNSResponder
5929 mDNSexport void mDNSPlatformUpdateDNSStatus(mDNS *const m, DNSQuestion *q)
5930 {
5931 if (!QuestionValidForDNSTrigger(q))
5932 return;
5933
5934 // Ignore applications that start and stop queries for no reason before we ever talk
5935 // to any DNS server.
5936 if (!q->triedAllServersOnce)
5937 {
5938 LogInfo("QuestionValidForDNSTrigger: question %##s (%s) stopped too soon", q->qname.c, DNSTypeName(q->qtype));
5939 return;
5940 }
5941 if (q->qtype == kDNSType_A)
5942 m->p->v4answers = 0;
5943 if (q->qtype == kDNSType_AAAA)
5944 m->p->v6answers = 0;
5945 if (!m->p->v4answers || !m->p->v6answers)
5946 {
5947 LogInfo("mDNSPlatformUpdateDNSStatus: Trigger needed v4 %d, v6 %d, quesiton %##s (%s)", m->p->v4answers, m->p->v6answers, q->qname.c,
5948 DNSTypeName(q->qtype));
5949 }
5950 }
5951 #endif
5952
5953 mDNSlocal void AckConfigd(mDNS *const m, dns_config_t *config)
5954 {
5955 mDNS_CheckLock(m);
5956
5957 // Acking the configuration triggers configd to reissue the reachability queries
5958 m->p->DNSTrigger = NonZeroTime(m->timenow);
5959 _dns_configuration_ack(config, "com.apple.mDNSResponder");
5960 }
5961
5962 // If v4q is non-NULL, it means we have received some answers for "A" type questions
5963 // If v6q is non-NULL, it means we have received some answers for "AAAA" type questions
5964 #if APPLE_OSX_mDNSResponder
5965 mDNSexport void mDNSPlatformTriggerDNSRetry(mDNS *const m, DNSQuestion *v4q, DNSQuestion *v6q)
5966 {
5967 mDNSBool trigger = mDNSfalse;
5968 mDNSs32 timenow;
5969
5970 // Don't send triggers too often.
5971 // If we have started delivering answers to questions, we should send a trigger
5972 // if the time permits. If we are delivering answers, we should set the state
5973 // of v4answers/v6answers to 1 and avoid sending a trigger. But, we don't know
5974 // whether the answers that are being delivered currently is for configd or some
5975 // other application. If we set the v4answers/v6answers to 1 and not deliver a trigger,
5976 // then we won't deliver the trigger later when it is okay to send one as the
5977 // "answers" are already set to 1. Hence, don't affect the state of v4answers and
5978 // v6answers if we are not delivering triggers.
5979 mDNS_Lock(m);
5980 timenow = m->timenow;
5981 if (m->p->DNSTrigger && (timenow - m->p->DNSTrigger) < DNS_TRIGGER_INTERVAL)
5982 {
5983 if (!m->p->v4answers || !m->p->v6answers)
5984 {
5985 debugf("mDNSPlatformTriggerDNSRetry: not triggering, time since last trigger %d ms, v4ans %d, v6ans %d",
5986 (timenow - m->p->DNSTrigger), m->p->v4answers, m->p->v6answers);
5987 }
5988 mDNS_Unlock(m);
5989 return;
5990 }
5991 mDNS_Unlock(m);
5992 if (v4q != NULL && QuestionValidForDNSTrigger(v4q))
5993 {
5994 int old = m->p->v4answers;
5995
5996 m->p->v4answers = 1;
5997
5998 // If there are IPv4 answers now and previously we did not have
5999 // any answers, trigger a DNS change so that reachability
6000 // can retry the queries again.
6001 if (!old)
6002 {
6003 LogInfo("mDNSPlatformTriggerDNSRetry: Triggering because of IPv4, last trigger %d ms, %##s (%s)", (timenow - m->p->DNSTrigger),
6004 v4q->qname.c, DNSTypeName(v4q->qtype));
6005 trigger = mDNStrue;
6006 }
6007 }
6008 if (v6q != NULL && QuestionValidForDNSTrigger(v6q))
6009 {
6010 int old = m->p->v6answers;
6011
6012 m->p->v6answers = 1;
6013 // If there are IPv6 answers now and previously we did not have
6014 // any answers, trigger a DNS change so that reachability
6015 // can retry the queries again.
6016 if (!old)
6017 {
6018 LogInfo("mDNSPlatformTriggerDNSRetry: Triggering because of IPv6, last trigger %d ms, %##s (%s)", (timenow - m->p->DNSTrigger),
6019 v6q->qname.c, DNSTypeName(v6q->qtype));
6020 trigger = mDNStrue;
6021 }
6022 }
6023 if (trigger)
6024 {
6025 dns_config_t *config = dns_configuration_copy();
6026 if (config)
6027 {
6028 mDNS_Lock(m);
6029 AckConfigd(m, config);
6030 mDNS_Unlock(m);
6031 dns_configuration_free(config);
6032 }
6033 else
6034 {
6035 LogMsg("mDNSPlatformTriggerDNSRetry: ERROR!! configd did not return config");
6036 }
6037 }
6038 }
6039
6040 mDNSlocal void SetupActiveDirectoryDomain(dns_config_t *config)
6041 {
6042 // Record the so-called "primary" domain, which we use as a hint to tell if the user is on a network set up
6043 // by someone using Microsoft Active Directory using "local" as a private internal top-level domain
6044 if (config->n_resolver && config->resolver[0]->domain && config->resolver[0]->n_nameserver &&
6045 config->resolver[0]->nameserver[0])
6046 {
6047 MakeDomainNameFromDNSNameString(&ActiveDirectoryPrimaryDomain, config->resolver[0]->domain);
6048 }
6049 else
6050 {
6051 ActiveDirectoryPrimaryDomain.c[0] = 0;
6052 }
6053
6054 //MakeDomainNameFromDNSNameString(&ActiveDirectoryPrimaryDomain, "test.local");
6055 ActiveDirectoryPrimaryDomainLabelCount = CountLabels(&ActiveDirectoryPrimaryDomain);
6056 if (config->n_resolver && config->resolver[0]->n_nameserver &&
6057 SameDomainName(SkipLeadingLabels(&ActiveDirectoryPrimaryDomain, ActiveDirectoryPrimaryDomainLabelCount - 1), &localdomain))
6058 {
6059 SetupAddr(&ActiveDirectoryPrimaryDomainServer, config->resolver[0]->nameserver[0]);
6060 }
6061 else
6062 {
6063 AssignDomainName(&ActiveDirectoryPrimaryDomain, (const domainname *)"");
6064 ActiveDirectoryPrimaryDomainLabelCount = 0;
6065 ActiveDirectoryPrimaryDomainServer = zeroAddr;
6066 }
6067 }
6068 #endif
6069
6070 mDNSlocal void SetupDDNSDomains(domainname *const fqdn, DNameListElem **RegDomains, DNameListElem **BrowseDomains)
6071 {
6072 int i;
6073 char buf[MAX_ESCAPED_DOMAIN_NAME]; // Max legal C-string name, including terminating NUL
6074 domainname d;
6075
6076 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:mDNSPlatformSetDNSConfig"), NULL, NULL);
6077 if (!store)
6078 {
6079 LogMsg("SetupDDNSDomains: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6080 }
6081 else
6082 {
6083 CFDictionaryRef ddnsdict = SCDynamicStoreCopyValue(store, NetworkChangedKey_DynamicDNS);
6084 if (ddnsdict)
6085 {
6086 if (fqdn)
6087 {
6088 CFArrayRef fqdnArray = CFDictionaryGetValue(ddnsdict, CFSTR("HostNames"));
6089 if (fqdnArray && CFArrayGetCount(fqdnArray) > 0)
6090 {
6091 // for now, we only look at the first array element. if we ever support multiple configurations, we will walk the list
6092 CFDictionaryRef fqdnDict = CFArrayGetValueAtIndex(fqdnArray, 0);
6093 if (fqdnDict && DictionaryIsEnabled(fqdnDict))
6094 {
6095 CFStringRef name = CFDictionaryGetValue(fqdnDict, CFSTR("Domain"));
6096 if (name)
6097 {
6098 if (!CFStringGetCString(name, buf, sizeof(buf), kCFStringEncodingUTF8) ||
6099 !MakeDomainNameFromDNSNameString(fqdn, buf) || !fqdn->c[0])
6100 LogMsg("GetUserSpecifiedDDNSConfig SCDynamicStore bad DDNS host name: %s", buf[0] ? buf : "(unknown)");
6101 else debugf("GetUserSpecifiedDDNSConfig SCDynamicStore DDNS host name: %s", buf);
6102 }
6103 }
6104 }
6105 }
6106
6107 if (RegDomains)
6108 {
6109 CFArrayRef regArray = CFDictionaryGetValue(ddnsdict, CFSTR("RegistrationDomains"));
6110 if (regArray && CFArrayGetCount(regArray) > 0)
6111 {
6112 CFDictionaryRef regDict = CFArrayGetValueAtIndex(regArray, 0);
6113 if (regDict && DictionaryIsEnabled(regDict))
6114 {
6115 CFStringRef name = CFDictionaryGetValue(regDict, CFSTR("Domain"));
6116 if (name)
6117 {
6118 if (!CFStringGetCString(name, buf, sizeof(buf), kCFStringEncodingUTF8) ||
6119 !MakeDomainNameFromDNSNameString(&d, buf) || !d.c[0])
6120 LogMsg("GetUserSpecifiedDDNSConfig SCDynamicStore bad DDNS registration domain: %s", buf[0] ? buf : "(unknown)");
6121 else
6122 {
6123 debugf("GetUserSpecifiedDDNSConfig SCDynamicStore DDNS registration domain: %s", buf);
6124 AppendDNameListElem(&RegDomains, 0, &d);
6125 }
6126 }
6127 }
6128 }
6129 }
6130
6131 if (BrowseDomains)
6132 {
6133 CFArrayRef browseArray = CFDictionaryGetValue(ddnsdict, CFSTR("BrowseDomains"));
6134 if (browseArray)
6135 {
6136 for (i = 0; i < CFArrayGetCount(browseArray); i++)
6137 {
6138 CFDictionaryRef browseDict = CFArrayGetValueAtIndex(browseArray, i);
6139 if (browseDict && DictionaryIsEnabled(browseDict))
6140 {
6141 CFStringRef name = CFDictionaryGetValue(browseDict, CFSTR("Domain"));
6142 if (name)
6143 {
6144 if (!CFStringGetCString(name, buf, sizeof(buf), kCFStringEncodingUTF8) ||
6145 !MakeDomainNameFromDNSNameString(&d, buf) || !d.c[0])
6146 LogMsg("GetUserSpecifiedDDNSConfig SCDynamicStore bad DDNS browsing domain: %s", buf[0] ? buf : "(unknown)");
6147 else
6148 {
6149 debugf("GetUserSpecifiedDDNSConfig SCDynamicStore DDNS browsing domain: %s", buf);
6150 AppendDNameListElem(&BrowseDomains, 0, &d);
6151 }
6152 }
6153 }
6154 }
6155 }
6156 }
6157 CFRelease(ddnsdict);
6158 }
6159
6160 if (RegDomains)
6161 {
6162 CFDictionaryRef btmm = SCDynamicStoreCopyValue(store, NetworkChangedKey_BackToMyMac);
6163 if (btmm)
6164 {
6165 CFIndex size = CFDictionaryGetCount(btmm);
6166 const void *key[size];
6167 const void *val[size];
6168 CFDictionaryGetKeysAndValues(btmm, key, val);
6169 for (i = 0; i < size; i++)
6170 {
6171 LogInfo("BackToMyMac %d", i);
6172 if (!CFStringGetCString(key[i], buf, sizeof(buf), kCFStringEncodingUTF8))
6173 LogMsg("Can't read BackToMyMac %d key %s", i, buf);
6174 else
6175 {
6176 mDNSu32 uid = atoi(buf);
6177 if (!CFStringGetCString(val[i], buf, sizeof(buf), kCFStringEncodingUTF8))
6178 LogMsg("Can't read BackToMyMac %d val %s", i, buf);
6179 else if (MakeDomainNameFromDNSNameString(&d, buf) && d.c[0])
6180 {
6181 LogInfo("BackToMyMac %d %d %##s", i, uid, d.c);
6182 AppendDNameListElem(&RegDomains, uid, &d);
6183 }
6184 }
6185 }
6186 CFRelease(btmm);
6187 }
6188 }
6189 CFRelease(store);
6190 }
6191 }
6192
6193 // Returns mDNSfalse, if it does not set the configuration i.e., if the DNS configuration did not change
6194 mDNSexport mDNSBool mDNSPlatformSetDNSConfig(mDNS *const m, mDNSBool setservers, mDNSBool setsearch, domainname *const fqdn,
6195 DNameListElem **RegDomains, DNameListElem **BrowseDomains, mDNSBool ackConfig)
6196 {
6197 MD5_CTX sdc; // search domain context
6198 static mDNSu16 resolverGroupID = 0;
6199
6200 // Need to set these here because we need to do this even if SCDynamicStoreCreate() or SCDynamicStoreCopyValue() below don't succeed
6201 if (fqdn) fqdn->c[0] = 0;
6202 if (RegDomains ) *RegDomains = NULL;
6203 if (BrowseDomains) *BrowseDomains = NULL;
6204
6205 LogInfo("mDNSPlatformSetDNSConfig:%s%s%s%s%s",
6206 setservers ? " setservers" : "",
6207 setsearch ? " setsearch" : "",
6208 fqdn ? " fqdn" : "",
6209 RegDomains ? " RegDomains" : "",
6210 BrowseDomains ? " BrowseDomains" : "");
6211
6212 if (setsearch) MD5_Init(&sdc);
6213
6214 // Add the inferred address-based configuration discovery domains
6215 // (should really be in core code I think, not platform-specific)
6216 if (setsearch)
6217 {
6218 struct ifaddrs *ifa = mDNSNULL;
6219 struct sockaddr_in saddr;
6220 mDNSPlatformMemZero(&saddr, sizeof(saddr));
6221 saddr.sin_len = sizeof(saddr);
6222 saddr.sin_family = AF_INET;
6223 saddr.sin_port = 0;
6224 saddr.sin_addr.s_addr = *(in_addr_t *)&m->Router.ip.v4;
6225
6226 // Don't add any reverse-IP search domains if doing the WAB bootstrap queries would cause dial-on-demand connection initiation
6227 if (!AddrRequiresPPPConnection((struct sockaddr *)&saddr)) ifa = myGetIfAddrs(1);
6228
6229 while (ifa)
6230 {
6231 mDNSAddr a, n;
6232 char buf[64];
6233
6234 if (ifa->ifa_addr->sa_family == AF_INET &&
6235 ifa->ifa_netmask &&
6236 !(ifa->ifa_flags & IFF_LOOPBACK) &&
6237 !SetupAddr(&a, ifa->ifa_addr) &&
6238 !mDNSv4AddressIsLinkLocal(&a.ip.v4) )
6239 {
6240 // Apparently it's normal for the sa_family of an ifa_netmask to sometimes be incorrect, so we explicitly fix it here before calling SetupAddr
6241 // <rdar://problem/5492035> getifaddrs is returning invalid netmask family for fw0 and vmnet
6242 ifa->ifa_netmask->sa_family = ifa->ifa_addr->sa_family; // Make sure ifa_netmask->sa_family is set correctly
6243 SetupAddr(&n, ifa->ifa_netmask);
6244 // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code
6245 mDNS_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa.", a.ip.v4.b[3] & n.ip.v4.b[3],
6246 a.ip.v4.b[2] & n.ip.v4.b[2],
6247 a.ip.v4.b[1] & n.ip.v4.b[1],
6248 a.ip.v4.b[0] & n.ip.v4.b[0]);
6249 UpdateSearchDomainHash(m, &sdc, buf, NULL);
6250 mDNS_AddSearchDomain_CString(buf, mDNSNULL);
6251 }
6252 ifa = ifa->ifa_next;
6253 }
6254 }
6255
6256 #ifndef MDNS_NO_DNSINFO
6257 if (setservers || setsearch)
6258 {
6259 dns_config_t *config = dns_configuration_copy();
6260 if (!config)
6261 {
6262 // When running on 10.3 (build 7xxx) and earlier, we don't expect dns_configuration_copy() to succeed
6263 // On 10.4, calls to dns_configuration_copy() early in the boot process often fail.
6264 // Apparently this is expected behaviour -- "not a bug".
6265 // Accordingly, we suppress syslog messages for the first three minutes after boot.
6266 // If we are still getting failures after three minutes, then we log them.
6267 if ((mDNSu32)mDNSPlatformRawTime() > (mDNSu32)(mDNSPlatformOneSecond * 180))
6268 LogMsg("mDNSPlatformSetDNSConfig: Error: dns_configuration_copy returned NULL");
6269 }
6270 else
6271 {
6272 LogInfo("mDNSPlatformSetDNSConfig: config->n_resolver = %d, generation %llu", config->n_resolver, config->generation);
6273 if (m->p->LastConfigGeneration == config->generation)
6274 {
6275 LogInfo("mDNSPlatformSetDNSConfig: generation number %llu same, not processing", config->generation);
6276 dns_configuration_free(config);
6277 SetupDDNSDomains(fqdn, RegDomains, BrowseDomains);
6278 return mDNSfalse;
6279 }
6280 #if APPLE_OSX_mDNSResponder
6281 SetupActiveDirectoryDomain(config);
6282 #endif
6283
6284 // With scoped DNS, we don't want to answer a non-scoped question using a scoped cache entry
6285 // and vice-versa. As we compare resolverGroupID for matching cache entry with question, we need
6286 // to make sure that they don't match. We ensure this by always bumping up resolverGroupID between
6287 // the two calls to ConfigResolvers DNSServers for scoped and non-scoped can never have the
6288 // same resolverGroupID.
6289 //
6290 // All non-scoped resolvers use the same resolverGroupID i.e, we treat them all equally.
6291 ConfigResolvers(m, config, kScopeNone, setsearch, setservers, &sdc, ++resolverGroupID);
6292 resolverGroupID += config->n_resolver;
6293
6294 ConfigResolvers(m, config, kScopeInterfaceID, setsearch, setservers, &sdc, resolverGroupID);
6295 resolverGroupID += config->n_scoped_resolver;
6296
6297 ConfigResolvers(m, config, kScopeServiceID, setsearch, setservers, &sdc, resolverGroupID);
6298
6299 // Acking provides a hint that we processed this current configuration and
6300 // we will use that from now on, assuming we don't get another one immediately
6301 // after we return from here.
6302 if (ackConfig)
6303 {
6304 // Note: We have to set the generation number here when we are acking.
6305 // For every DNS configuration change, we do the following:
6306 //
6307 // 1) Copy dns configuration, handle search domains change
6308 // 2) Copy dns configuration, handle dns server change
6309 //
6310 // If we update the generation number at step (1), we won't process the
6311 // DNS servers the second time because generation number would be the same.
6312 // As we ack only when we process dns servers, we set the generation number
6313 // during acking.
6314 m->p->LastConfigGeneration = config->generation;
6315 LogInfo("mDNSPlatformSetDNSConfig: Acking configuration setservers %d, setsearch %d", setservers, setsearch);
6316 AckConfigd(m, config);
6317 }
6318 dns_configuration_free(config);
6319 if (setsearch) FinalizeSearchDomainHash(m, &sdc);
6320 setservers = mDNSfalse; // Done these now -- no need to fetch the same data from SCDynamicStore
6321 setsearch = mDNSfalse;
6322 }
6323 }
6324 #endif // MDNS_NO_DNSINFO
6325 SetupDDNSDomains(fqdn, RegDomains, BrowseDomains);
6326 return mDNStrue;
6327 }
6328
6329
6330 mDNSexport mStatus mDNSPlatformGetPrimaryInterface(mDNS *const m, mDNSAddr *v4, mDNSAddr *v6, mDNSAddr *r)
6331 {
6332 char buf[256];
6333 (void)m; // Unused
6334
6335 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:mDNSPlatformGetPrimaryInterface"), NULL, NULL);
6336 if (!store)
6337 LogMsg("mDNSPlatformGetPrimaryInterface: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6338 else
6339 {
6340 CFDictionaryRef dict = SCDynamicStoreCopyValue(store, NetworkChangedKey_IPv4);
6341 if (dict)
6342 {
6343 r->type = mDNSAddrType_IPv4;
6344 r->ip.v4 = zerov4Addr;
6345 CFStringRef string = CFDictionaryGetValue(dict, kSCPropNetIPv4Router);
6346 if (string)
6347 {
6348 if (!CFStringGetCString(string, buf, 256, kCFStringEncodingUTF8))
6349 LogMsg("Could not convert router to CString");
6350 else
6351 {
6352 struct sockaddr_in saddr;
6353 saddr.sin_len = sizeof(saddr);
6354 saddr.sin_family = AF_INET;
6355 saddr.sin_port = 0;
6356 inet_aton(buf, &saddr.sin_addr);
6357
6358 *(in_addr_t *)&r->ip.v4 = saddr.sin_addr.s_addr;
6359 }
6360 }
6361
6362 string = CFDictionaryGetValue(dict, kSCDynamicStorePropNetPrimaryInterface);
6363 if (string)
6364 {
6365 mDNSBool HavePrimaryGlobalv6 = mDNSfalse; // does the primary interface have a global v6 address?
6366 struct ifaddrs *ifa = myGetIfAddrs(1);
6367
6368 *v4 = *v6 = zeroAddr;
6369
6370 if (!CFStringGetCString(string, buf, 256, kCFStringEncodingUTF8)) { LogMsg("Could not convert router to CString"); goto exit; }
6371
6372 // find primary interface in list
6373 while (ifa && (mDNSIPv4AddressIsZero(v4->ip.v4) || mDNSv4AddressIsLinkLocal(&v4->ip.v4) || !HavePrimaryGlobalv6))
6374 {
6375 mDNSAddr tmp6 = zeroAddr;
6376 if (!strcmp(buf, ifa->ifa_name))
6377 {
6378 if (ifa->ifa_addr->sa_family == AF_INET)
6379 {
6380 if (mDNSIPv4AddressIsZero(v4->ip.v4) || mDNSv4AddressIsLinkLocal(&v4->ip.v4)) SetupAddr(v4, ifa->ifa_addr);
6381 }
6382 else if (ifa->ifa_addr->sa_family == AF_INET6)
6383 {
6384 SetupAddr(&tmp6, ifa->ifa_addr);
6385 if (tmp6.ip.v6.b[0] >> 5 == 1) // global prefix: 001
6386 { HavePrimaryGlobalv6 = mDNStrue; *v6 = tmp6; }
6387 }
6388 }
6389 else
6390 {
6391 // We'll take a V6 address from the non-primary interface if the primary interface doesn't have a global V6 address
6392 if (!HavePrimaryGlobalv6 && ifa->ifa_addr->sa_family == AF_INET6 && !v6->ip.v6.b[0])
6393 {
6394 SetupAddr(&tmp6, ifa->ifa_addr);
6395 if (tmp6.ip.v6.b[0] >> 5 == 1) *v6 = tmp6;
6396 }
6397 }
6398 ifa = ifa->ifa_next;
6399 }
6400
6401 // Note that while we advertise v6, we still require v4 (possibly NAT'd, but not link-local) because we must use
6402 // V4 to communicate w/ our DNS server
6403 }
6404
6405 exit:
6406 CFRelease(dict);
6407 }
6408 CFRelease(store);
6409 }
6410 return mStatus_NoError;
6411 }
6412
6413 mDNSexport void mDNSPlatformDynDNSHostNameStatusChanged(const domainname *const dname, const mStatus status)
6414 {
6415 LogInfo("mDNSPlatformDynDNSHostNameStatusChanged %d %##s", status, dname->c);
6416 char uname[MAX_ESCAPED_DOMAIN_NAME]; // Max legal C-string name, including terminating NUL
6417 ConvertDomainNameToCString(dname, uname);
6418
6419 char *p = uname;
6420 while (*p)
6421 {
6422 *p = tolower(*p);
6423 if (!(*(p+1)) && *p == '.') *p = 0; // if last character, strip trailing dot
6424 p++;
6425 }
6426
6427 // We need to make a CFDictionary called "State:/Network/DynamicDNS" containing (at present) a single entity.
6428 // That single entity is a CFDictionary with name "HostNames".
6429 // The "HostNames" CFDictionary contains a set of name/value pairs, where the each name is the FQDN
6430 // in question, and the corresponding value is a CFDictionary giving the state for that FQDN.
6431 // (At present we only support a single FQDN, so this dictionary holds just a single name/value pair.)
6432 // The CFDictionary for each FQDN holds (at present) a single name/value pair,
6433 // where the name is "Status" and the value is a CFNumber giving an errror code (with zero meaning success).
6434
6435 const CFStringRef StateKeys [1] = { CFSTR("HostNames") };
6436 const CFStringRef HostKeys [1] = { CFStringCreateWithCString(NULL, uname, kCFStringEncodingUTF8) };
6437 const CFStringRef StatusKeys[1] = { CFSTR("Status") };
6438 if (!HostKeys[0]) LogMsg("SetDDNSNameStatus: CFStringCreateWithCString(%s) failed", uname);
6439 else
6440 {
6441 const CFNumberRef StatusVals[1] = { CFNumberCreate(NULL, kCFNumberSInt32Type, &status) };
6442 if (!StatusVals[0]) LogMsg("SetDDNSNameStatus: CFNumberCreate(%d) failed", status);
6443 else
6444 {
6445 const CFDictionaryRef HostVals[1] = { CFDictionaryCreate(NULL, (void*)StatusKeys, (void*)StatusVals, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) };
6446 if (HostVals[0])
6447 {
6448 const CFDictionaryRef StateVals[1] = { CFDictionaryCreate(NULL, (void*)HostKeys, (void*)HostVals, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) };
6449 if (StateVals[0])
6450 {
6451 CFDictionaryRef StateDict = CFDictionaryCreate(NULL, (void*)StateKeys, (void*)StateVals, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
6452 if (StateDict)
6453 {
6454 mDNSDynamicStoreSetConfig(kmDNSDynamicConfig, mDNSNULL, StateDict);
6455 CFRelease(StateDict);
6456 }
6457 CFRelease(StateVals[0]);
6458 }
6459 CFRelease(HostVals[0]);
6460 }
6461 CFRelease(StatusVals[0]);
6462 }
6463 CFRelease(HostKeys[0]);
6464 }
6465 }
6466
6467 #if APPLE_OSX_mDNSResponder
6468 #if !NO_AWACS
6469
6470 // checks whether a domain is present in Setup:/Network/BackToMyMac. Just because there is a key in the
6471 // keychain for a domain, it does not become a valid BTMM domain. If things get inconsistent, this will
6472 // help catch it
6473 mDNSlocal mDNSBool IsBTMMDomain(domainname *d)
6474 {
6475 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:IsBTMMDomain"), NULL, NULL);
6476 if (!store)
6477 {
6478 LogMsg("IsBTMMDomain: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6479 return mDNSfalse;
6480 }
6481 CFDictionaryRef btmm = SCDynamicStoreCopyValue(store, NetworkChangedKey_BackToMyMac);
6482 if (btmm)
6483 {
6484 CFIndex size = CFDictionaryGetCount(btmm);
6485 char buf[MAX_ESCAPED_DOMAIN_NAME]; // Max legal C-string name, including terminating NUL
6486 const void *key[size];
6487 const void *val[size];
6488 domainname dom;
6489 int i;
6490 CFDictionaryGetKeysAndValues(btmm, key, val);
6491 for (i = 0; i < size; i++)
6492 {
6493 LogInfo("BackToMyMac %d", i);
6494 if (!CFStringGetCString(key[i], buf, sizeof(buf), kCFStringEncodingUTF8))
6495 LogMsg("IsBTMMDomain: ERROR!! Can't read BackToMyMac %d key %s", i, buf);
6496 else
6497 {
6498 mDNSu32 uid = atoi(buf);
6499 if (!CFStringGetCString(val[i], buf, sizeof(buf), kCFStringEncodingUTF8))
6500 LogMsg("IsBTMMDomain: Can't read BackToMyMac %d val %s", i, buf);
6501 else if (MakeDomainNameFromDNSNameString(&dom, buf) && dom.c[0])
6502 {
6503 if (SameDomainName(&dom, d))
6504 {
6505 LogInfo("IsBTMMDomain: Domain %##s is a btmm domain, uid %u", d->c, uid);
6506 CFRelease(btmm);
6507 CFRelease(store);
6508 return mDNStrue;
6509 }
6510 }
6511 }
6512 }
6513 CFRelease(btmm);
6514 }
6515 CFRelease(store);
6516 LogInfo("IsBTMMDomain: Domain %##s not a btmm domain", d->c);
6517 return mDNSfalse;
6518 }
6519
6520 // Appends data to the buffer
6521 mDNSlocal int AddOneItem(char *buf, int bufsz, char *data, int *currlen)
6522 {
6523 int len;
6524
6525 len = strlcpy(buf + *currlen, data, bufsz - *currlen);
6526 if (len >= (bufsz - *currlen))
6527 {
6528 // if we have exceeded the space in buf, it has already been NULL terminated
6529 // and we have nothing more to do. Set currlen to the last byte so that the caller
6530 // knows to do the right thing
6531 LogMsg("AddOneItem: Exceeded the max buffer size currlen %d, len %d", *currlen, len);
6532 *currlen = bufsz - 1;
6533 return -1;
6534 }
6535 else { (*currlen) += len; }
6536
6537 buf[*currlen] = ',';
6538 if (*currlen >= bufsz)
6539 {
6540 LogMsg("AddOneItem: ERROR!! How can currlen be %d", *currlen);
6541 *currlen = bufsz - 1;
6542 buf[*currlen] = 0;
6543 return -1;
6544 }
6545 // if we have filled up the buffer exactly, then there is no more work to do
6546 if (*currlen == bufsz - 1) { buf[*currlen] = 0; return -1; }
6547 (*currlen)++;
6548 return *currlen;
6549 }
6550
6551 // If we have at least one BTMM domain, then trigger the connection to the relay. If we have no
6552 // BTMM domains, then bring down the connection to the relay.
6553 mDNSlocal void UpdateBTMMRelayConnection(mDNS *const m)
6554 {
6555 DomainAuthInfo *BTMMDomain = mDNSNULL;
6556 DomainAuthInfo *FoundInList;
6557 static mDNSBool AWACSDConnected = mDNSfalse;
6558 char AllUsers[1024]; // maximum size of mach message
6559 char AllPass[1024]; // maximum size of mach message
6560 char username[MAX_DOMAIN_LABEL + 1];
6561 int currulen = 0;
6562 int currplen = 0;
6563
6564 // if a domain is being deleted, we want to send a disconnect. If we send a disconnect now,
6565 // we may not be able to send the dns queries over the relay connection which may be needed
6566 // for sending the deregistrations. Hence, we need to delay sending the disconnect. But we
6567 // need to make sure that we send the disconnect before attempting the next connect as the
6568 // awacs connections are redirected based on usernames.
6569 //
6570 // For now we send a disconnect immediately. When we start sending dns queries over the relay
6571 // connection, we will need to fix this.
6572
6573 for (FoundInList = m->AuthInfoList; FoundInList; FoundInList = FoundInList->next)
6574 if (!FoundInList->deltime && FoundInList->AutoTunnel && IsBTMMDomain(&FoundInList->domain))
6575 {
6576 // We need the passwd from the first domain.
6577 BTMMDomain = FoundInList;
6578 ConvertDomainLabelToCString_unescaped((domainlabel *)BTMMDomain->domain.c, username);
6579 LogInfo("UpdateBTMMRelayConnection: user %s for domain %##s", username, BTMMDomain->domain.c);
6580 if (AddOneItem(AllUsers, sizeof(AllUsers), username, &currulen) == -1) break;
6581 if (AddOneItem(AllPass, sizeof(AllPass), BTMMDomain->b64keydata, &currplen) == -1) break;
6582 }
6583
6584 if (BTMMDomain)
6585 {
6586 // In the normal case (where we neither exceed the buffer size nor write bytes that
6587 // fit exactly into the buffer), currulen/currplen should be a different size than
6588 // (AllUsers - 1) / (AllPass - 1). In that case, we need to override the "," with a NULL byte.
6589
6590 if (currulen != (int)(sizeof(AllUsers) - 1)) AllUsers[currulen - 1] = 0;
6591 if (currplen != (int)(sizeof(AllPass) - 1)) AllPass[currplen - 1] = 0;
6592
6593 LogInfo("UpdateBTMMRelayConnection: AWS_Connect for user %s", AllUsers);
6594 AWACS_Connect(AllUsers, AllPass, "hello.connectivity.me.com");
6595 AWACSDConnected = mDNStrue;
6596 }
6597 else
6598 {
6599 // Disconnect only if we connected previously
6600 if (AWACSDConnected)
6601 {
6602 LogInfo("UpdateBTMMRelayConnection: AWS_Disconnect");
6603 AWACS_Disconnect();
6604 AWACSDConnected = mDNSfalse;
6605 }
6606 else LogInfo("UpdateBTMMRelayConnection: Not calling AWS_Disconnect");
6607 }
6608 }
6609 #else
6610 mDNSlocal void UpdateBTMMRelayConnection(mDNS *const m)
6611 {
6612 (void) m; // Unused
6613 LogInfo("UpdateBTMMRelayConnection: AWACS connection not started, no AWACS library");
6614 }
6615 #endif // ! NO_AWACS
6616
6617 mDNSlocal void ProcessConndConfigChanges(mDNS *const m);
6618
6619 #endif // APPLE_OSX_mDNSResponder
6620
6621 // MUST be called holding the lock
6622 mDNSexport void SetDomainSecrets(mDNS *m)
6623 {
6624 #ifdef NO_SECURITYFRAMEWORK
6625 (void) m;
6626 LogMsg("Note: SetDomainSecrets: no keychain support");
6627 #else
6628 mDNSBool haveAutoTunnels = mDNSfalse;
6629
6630 LogInfo("SetDomainSecrets");
6631
6632 // Rather than immediately deleting all keys now, we mark them for deletion in ten seconds.
6633 // In the case where the user simultaneously removes their DDNS host name and the key
6634 // for it, this gives mDNSResponder ten seconds to gracefully delete the name from the
6635 // server before it loses access to the necessary key. Otherwise, we'd leave orphaned
6636 // address records behind that we no longer have permission to delete.
6637 DomainAuthInfo *ptr;
6638 for (ptr = m->AuthInfoList; ptr; ptr = ptr->next)
6639 ptr->deltime = NonZeroTime(m->timenow + mDNSPlatformOneSecond*10);
6640
6641 #if APPLE_OSX_mDNSResponder
6642 {
6643 // Mark all TunnelClients for deletion
6644 ClientTunnel *client;
6645 for (client = m->TunnelClients; client; client = client->next)
6646 {
6647 LogInfo("SetDomainSecrets: tunnel to %##s marked for deletion", client->dstname.c);
6648 client->MarkedForDeletion = mDNStrue;
6649 }
6650 }
6651 #endif // APPLE_OSX_mDNSResponder
6652
6653 // String Array used to write list of private domains to Dynamic Store
6654 CFMutableArrayRef sa = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
6655 if (!sa) { LogMsg("SetDomainSecrets: CFArrayCreateMutable failed"); return; }
6656 CFIndex i;
6657 CFDataRef data = NULL;
6658 const int itemsPerEntry = 4; // domain name, key name, key value, Name value
6659 CFArrayRef secrets = NULL;
6660 int err = mDNSKeychainGetSecrets(&secrets);
6661 if (err || !secrets)
6662 LogMsg("SetDomainSecrets: mDNSKeychainGetSecrets failed error %d CFArrayRef %p", err, secrets);
6663 else
6664 {
6665 CFIndex ArrayCount = CFArrayGetCount(secrets);
6666 // Iterate through the secrets
6667 for (i = 0; i < ArrayCount; ++i)
6668 {
6669 mDNSBool AutoTunnel;
6670 int j, offset;
6671 CFArrayRef entry = CFArrayGetValueAtIndex(secrets, i);
6672 if (CFArrayGetTypeID() != CFGetTypeID(entry) || itemsPerEntry != CFArrayGetCount(entry))
6673 { LogMsg("SetDomainSecrets: malformed entry %d, itemsPerEntry %d", i, itemsPerEntry); continue; }
6674 for (j = 0; j < CFArrayGetCount(entry); ++j)
6675 if (CFDataGetTypeID() != CFGetTypeID(CFArrayGetValueAtIndex(entry, j)))
6676 { LogMsg("SetDomainSecrets: malformed entry item %d", j); continue; }
6677
6678 // The names have already been vetted by the helper, but checking them again here helps humans and automated tools verify correctness
6679
6680 // Max legal domainname as C-string, including space for btmmprefix and terminating NUL
6681 // Get DNS domain this key is for (kmDNSKcWhere)
6682 char stringbuf[MAX_ESCAPED_DOMAIN_NAME + sizeof(btmmprefix)];
6683 data = CFArrayGetValueAtIndex(entry, kmDNSKcWhere);
6684 if (CFDataGetLength(data) >= (int)sizeof(stringbuf))
6685 { LogMsg("SetDomainSecrets: Bad kSecServiceItemAttr length %d", CFDataGetLength(data)); continue; }
6686 CFDataGetBytes(data, CFRangeMake(0, CFDataGetLength(data)), (UInt8 *)stringbuf);
6687 stringbuf[CFDataGetLength(data)] = '\0';
6688
6689 AutoTunnel = mDNSfalse;
6690 offset = 0;
6691 if (!strncmp(stringbuf, dnsprefix, strlen(dnsprefix)))
6692 offset = strlen(dnsprefix);
6693 else if (!strncmp(stringbuf, btmmprefix, strlen(btmmprefix)))
6694 {
6695 AutoTunnel = mDNStrue;
6696 offset = strlen(btmmprefix);
6697 }
6698 domainname domain;
6699 if (!MakeDomainNameFromDNSNameString(&domain, stringbuf + offset)) { LogMsg("SetDomainSecrets: bad key domain %s", stringbuf); continue; }
6700
6701 // Get key name (kmDNSKcAccount)
6702 data = CFArrayGetValueAtIndex(entry, kmDNSKcAccount);
6703 if (CFDataGetLength(data) >= (int)sizeof(stringbuf))
6704 { LogMsg("SetDomainSecrets: Bad kSecAccountItemAttr length %d", CFDataGetLength(data)); continue; }
6705 CFDataGetBytes(data, CFRangeMake(0,CFDataGetLength(data)), (UInt8 *)stringbuf);
6706 stringbuf[CFDataGetLength(data)] = '\0';
6707
6708 domainname keyname;
6709 if (!MakeDomainNameFromDNSNameString(&keyname, stringbuf)) { LogMsg("SetDomainSecrets: bad key name %s", stringbuf); continue; }
6710
6711 // Get key data (kmDNSKcKey)
6712 data = CFArrayGetValueAtIndex(entry, kmDNSKcKey);
6713 if (CFDataGetLength(data) >= (int)sizeof(stringbuf))
6714 {
6715 LogMsg("SetDomainSecrets: Shared secret too long: %d", CFDataGetLength(data));
6716 continue;
6717 }
6718 CFDataGetBytes(data, CFRangeMake(0, CFDataGetLength(data)), (UInt8 *)stringbuf);
6719 stringbuf[CFDataGetLength(data)] = '\0'; // mDNS_SetSecretForDomain requires NULL-terminated C string for key
6720
6721 // Get the Name of the keychain entry (kmDNSKcName) host or host:port
6722 // The hostname also has the port number and ":". It should take a maximum of 6 bytes.
6723 char hostbuf[MAX_ESCAPED_DOMAIN_NAME + 6]; // Max legal domainname as C-string, including terminating NUL
6724 data = CFArrayGetValueAtIndex(entry, kmDNSKcName);
6725 if (CFDataGetLength(data) >= (int)sizeof(hostbuf))
6726 {
6727 LogMsg("SetDomainSecrets: host:port data too long: %d", CFDataGetLength(data));
6728 continue;
6729 }
6730 CFDataGetBytes(data, CFRangeMake(0,CFDataGetLength(data)), (UInt8 *)hostbuf);
6731 hostbuf[CFDataGetLength(data)] = '\0';
6732
6733 domainname hostname;
6734 mDNSIPPort port;
6735 char *hptr;
6736 hptr = strchr(hostbuf, ':');
6737
6738 port.NotAnInteger = 0;
6739 if (hptr)
6740 {
6741 mDNSu8 *p;
6742 mDNSu16 val = 0;
6743
6744 *hptr++ = '\0';
6745 while(hptr && *hptr != 0)
6746 {
6747 if (*hptr < '0' || *hptr > '9')
6748 { LogMsg("SetDomainSecrets: Malformed Port number %d, val %d", *hptr, val); val = 0; break;}
6749 val = val * 10 + *hptr - '0';
6750 hptr++;
6751 }
6752 if (!val) continue;
6753 p = (mDNSu8 *)&val;
6754 port.NotAnInteger = p[0] << 8 | p[1];
6755 }
6756 // The hostbuf is of the format dsid@hostname:port. We don't care about the dsid.
6757 hptr = strchr(hostbuf, '@');
6758 if (hptr)
6759 hptr++;
6760 else
6761 hptr = hostbuf;
6762 if (!MakeDomainNameFromDNSNameString(&hostname, hptr)) { LogMsg("SetDomainSecrets: bad host name %s", hptr); continue; }
6763
6764 DomainAuthInfo *FoundInList;
6765 for (FoundInList = m->AuthInfoList; FoundInList; FoundInList = FoundInList->next)
6766 if (SameDomainName(&FoundInList->domain, &domain)) break;
6767
6768 #if APPLE_OSX_mDNSResponder
6769 if (FoundInList)
6770 {
6771 // If any client tunnel destination is in this domain, set deletion flag to false
6772 ClientTunnel *client;
6773 for (client = m->TunnelClients; client; client = client->next)
6774 if (FoundInList == GetAuthInfoForName_internal(m, &client->dstname))
6775 {
6776 LogInfo("SetDomainSecrets: tunnel to %##s no longer marked for deletion", client->dstname.c);
6777 client->MarkedForDeletion = mDNSfalse;
6778 }
6779 }
6780
6781 #endif // APPLE_OSX_mDNSResponder
6782
6783 // Uncomment the line below to view the keys as they're read out of the system keychain
6784 // DO NOT SHIP CODE THIS WAY OR YOU'LL LEAK SECRET DATA INTO A PUBLICLY READABLE FILE!
6785 //LogInfo("SetDomainSecrets: domain %##s keyname %##s key %s hostname %##s port %d", &domain.c, &keyname.c, stringbuf, hostname.c, (port.b[0] << 8 | port.b[1]));
6786 LogInfo("SetDomainSecrets: domain %##s keyname %##s hostname %##s port %d", &domain.c, &keyname.c, hostname.c, (port.b[0] << 8 | port.b[1]));
6787
6788 // If didn't find desired domain in the list, make a new entry
6789 ptr = FoundInList;
6790 if (FoundInList && FoundInList->AutoTunnel && haveAutoTunnels == mDNSfalse) haveAutoTunnels = mDNStrue;
6791 if (!FoundInList)
6792 {
6793 ptr = (DomainAuthInfo*)mallocL("DomainAuthInfo", sizeof(*ptr));
6794 if (!ptr) { LogMsg("SetDomainSecrets: No memory"); continue; }
6795 }
6796
6797 //LogInfo("SetDomainSecrets: %d of %d %##s", i, ArrayCount, &domain);
6798
6799 // It is an AutoTunnel if the keychains tells us so (with btmm prefix) or if it is a TunnelModeDomain
6800 if (mDNS_SetSecretForDomain(m, ptr, &domain, &keyname, stringbuf, &hostname, &port, AutoTunnel) == mStatus_BadParamErr)
6801 {
6802 if (!FoundInList) mDNSPlatformMemFree(ptr); // If we made a new DomainAuthInfo here, and it turned out bad, dispose it immediately
6803 continue;
6804 }
6805
6806 ConvertDomainNameToCString(&domain, stringbuf);
6807 CFStringRef cfs = CFStringCreateWithCString(NULL, stringbuf, kCFStringEncodingUTF8);
6808 if (cfs) { CFArrayAppendValue(sa, cfs); CFRelease(cfs); }
6809 }
6810 CFRelease(secrets);
6811 }
6812
6813 if (!privateDnsArray || !CFEqual(privateDnsArray, sa))
6814 {
6815 if (privateDnsArray)
6816 CFRelease(privateDnsArray);
6817
6818 privateDnsArray = sa;
6819 CFRetain(privateDnsArray);
6820 mDNSDynamicStoreSetConfig(kmDNSPrivateConfig, mDNSNULL, privateDnsArray);
6821 }
6822 CFRelease(sa);
6823
6824 #if APPLE_OSX_mDNSResponder
6825 {
6826 // clean up ClientTunnels
6827 ClientTunnel **pp = &m->TunnelClients;
6828 while (*pp)
6829 {
6830 if ((*pp)->MarkedForDeletion)
6831 {
6832 ClientTunnel *cur = *pp;
6833 LogInfo("SetDomainSecrets: removing client %p %##s from list", cur, cur->dstname.c);
6834 if (cur->q.ThisQInterval >= 0) mDNS_StopQuery(m, &cur->q);
6835 AutoTunnelSetKeys(cur, mDNSfalse);
6836 *pp = cur->next;
6837 freeL("ClientTunnel", cur);
6838 }
6839 else
6840 pp = &(*pp)->next;
6841 }
6842
6843 mDNSBool needAutoTunnelNAT = mDNSfalse;
6844 DomainAuthInfo *info;
6845 for (info = m->AuthInfoList; info; info = info->next)
6846 {
6847 if (info->AutoTunnel)
6848 {
6849 UpdateAutoTunnelDeviceInfoRecord(m, info);
6850 UpdateAutoTunnelHostRecord(m, info);
6851 UpdateAutoTunnelServiceRecords(m, info);
6852 UpdateAutoTunnel6Record(m, info);
6853 if (info->deltime)
6854 {
6855 if (info->AutoTunnelServiceStarted) info->AutoTunnelServiceStarted = mDNSfalse;
6856 }
6857 else if (info->AutoTunnelServiceStarted)
6858 needAutoTunnelNAT = true;
6859
6860 UpdateAutoTunnelDomainStatus(m, info);
6861 }
6862 }
6863
6864 // If the AutoTunnel NAT-T is no longer needed (& is currently running), stop it
6865 if (!needAutoTunnelNAT && m->AutoTunnelNAT.clientContext)
6866 {
6867 // stop the NAT operation, reset port, cleanup state
6868 mDNS_StopNATOperation_internal(m, &m->AutoTunnelNAT);
6869 m->AutoTunnelNAT.ExternalAddress = zerov4Addr;
6870 m->AutoTunnelNAT.NewAddress = zerov4Addr;
6871 m->AutoTunnelNAT.ExternalPort = zeroIPPort;
6872 m->AutoTunnelNAT.RequestedPort = zeroIPPort;
6873 m->AutoTunnelNAT.Lifetime = 0;
6874 m->AutoTunnelNAT.Result = mStatus_NoError;
6875 m->AutoTunnelNAT.clientContext = mDNSNULL;
6876 }
6877
6878 UpdateAnonymousRacoonConfig(m); // Determine whether we need racoon to accept incoming connections
6879 ProcessConndConfigChanges(m); // Update AutoTunnelInnerAddress values and default ipsec policies as necessary
6880 }
6881 #endif // APPLE_OSX_mDNSResponder
6882
6883 CheckSuppressUnusableQuestions(m);
6884
6885 #endif /* NO_SECURITYFRAMEWORK */
6886 }
6887
6888 mDNSlocal void SetLocalDomains(void)
6889 {
6890 CFMutableArrayRef sa = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
6891 if (!sa) { LogMsg("SetLocalDomains: CFArrayCreateMutable failed"); return; }
6892
6893 CFArrayAppendValue(sa, CFSTR("local"));
6894 CFArrayAppendValue(sa, CFSTR("254.169.in-addr.arpa"));
6895 CFArrayAppendValue(sa, CFSTR("8.e.f.ip6.arpa"));
6896 CFArrayAppendValue(sa, CFSTR("9.e.f.ip6.arpa"));
6897 CFArrayAppendValue(sa, CFSTR("a.e.f.ip6.arpa"));
6898 CFArrayAppendValue(sa, CFSTR("b.e.f.ip6.arpa"));
6899
6900 mDNSDynamicStoreSetConfig(kmDNSMulticastConfig, mDNSNULL, sa);
6901 CFRelease(sa);
6902 }
6903
6904 mDNSlocal void GetCurrentPMSetting(const CFStringRef name, mDNSs32 *val)
6905 {
6906 #if USE_IOPMCOPYACTIVEPMPREFERENCES
6907 CFTypeRef blob = NULL;
6908 CFStringRef str = NULL;
6909 CFDictionaryRef odict = NULL;
6910 CFDictionaryRef idict = NULL;
6911 CFNumberRef number = NULL;
6912
6913 blob = IOPSCopyPowerSourcesInfo();
6914 if (!blob) { LogMsg("GetCurrentPMSetting: IOPSCopyPowerSourcesInfo failed!"); goto end; }
6915
6916 odict = IOPMCopyActivePMPreferences();
6917 if (!odict) { LogMsg("GetCurrentPMSetting: IOPMCopyActivePMPreferences failed!"); goto end; }
6918
6919 str = IOPSGetProvidingPowerSourceType(blob);
6920 if (!str) { LogMsg("GetCurrentPMSetting: IOPSGetProvidingPowerSourceType failed!"); goto end; }
6921
6922 idict = CFDictionaryGetValue(odict, str);
6923 if (!idict)
6924 {
6925 char buf[256];
6926 if (!CFStringGetCString(str, buf, sizeof(buf), kCFStringEncodingUTF8)) buf[0] = 0;
6927 LogMsg("GetCurrentPMSetting: CFDictionaryGetValue (%s) failed!", buf);
6928 goto end;
6929 }
6930
6931 number = CFDictionaryGetValue(idict, name);
6932 if (!number || CFGetTypeID(number) != CFNumberGetTypeID() || !CFNumberGetValue(number, kCFNumberSInt32Type, val))
6933 *val = 0;
6934 end:
6935 if (blob) CFRelease(blob);
6936 if (odict) CFRelease(odict);
6937
6938 #else
6939
6940 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:GetCurrentPMSetting"), NULL, NULL);
6941 if (!store) LogMsg("GetCurrentPMSetting: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6942 else
6943 {
6944 CFDictionaryRef dict = SCDynamicStoreCopyValue(store, NetworkChangedKey_PowerSettings);
6945 if (!dict) LogSPS("GetCurrentPMSetting: Could not get IOPM CurrentSettings dict");
6946 else
6947 {
6948 CFNumberRef number = CFDictionaryGetValue(dict, name);
6949 if (!number || CFGetTypeID(number) != CFNumberGetTypeID() || !CFNumberGetValue(number, kCFNumberSInt32Type, val))
6950 *val = 0;
6951 CFRelease(dict);
6952 }
6953 CFRelease(store);
6954 }
6955
6956 #endif
6957 }
6958
6959 #if APPLE_OSX_mDNSResponder
6960
6961 static CFMutableDictionaryRef spsStatusDict = NULL;
6962 static const CFStringRef kMetricRef = CFSTR("Metric");
6963
6964 mDNSlocal void SPSStatusPutNumber(CFMutableDictionaryRef dict, const mDNSu8* const ptr, CFStringRef key)
6965 {
6966 mDNSu8 tmp = (ptr[0] - '0') * 10 + ptr[1] - '0';
6967 CFNumberRef num = CFNumberCreate(NULL, kCFNumberSInt8Type, &tmp);
6968 if (!num)
6969 LogMsg("SPSStatusPutNumber: Could not create CFNumber");
6970 else
6971 {
6972 CFDictionarySetValue(dict, key, num);
6973 CFRelease(num);
6974 }
6975 }
6976
6977 mDNSlocal CFMutableDictionaryRef SPSCreateDict(const mDNSu8* const ptr)
6978 {
6979 CFMutableDictionaryRef dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
6980 if (!dict) { LogMsg("SPSCreateDict: Could not create CFDictionary dict"); return dict; }
6981
6982 char buffer[1024];
6983 buffer[mDNS_snprintf(buffer, sizeof(buffer), "%##s", ptr) - 1] = 0;
6984 CFStringRef spsname = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
6985 if (!spsname) { LogMsg("SPSCreateDict: Could not create CFString spsname full"); CFRelease(dict); return NULL; }
6986 CFDictionarySetValue(dict, CFSTR("FullName"), spsname);
6987 CFRelease(spsname);
6988
6989 if (ptr[0] >= 2) SPSStatusPutNumber(dict, ptr + 1, CFSTR("Type"));
6990 if (ptr[0] >= 5) SPSStatusPutNumber(dict, ptr + 4, CFSTR("Portability"));
6991 if (ptr[0] >= 8) SPSStatusPutNumber(dict, ptr + 7, CFSTR("MarginalPower"));
6992 if (ptr[0] >= 11) SPSStatusPutNumber(dict, ptr +10, CFSTR("TotalPower"));
6993
6994 mDNSu32 tmp = SPSMetric(ptr);
6995 CFNumberRef num = CFNumberCreate(NULL, kCFNumberSInt32Type, &tmp);
6996 if (!num)
6997 LogMsg("SPSCreateDict: Could not create CFNumber");
6998 else
6999 {
7000 CFDictionarySetValue(dict, kMetricRef, num);
7001 CFRelease(num);
7002 }
7003
7004 if (ptr[0] >= 12)
7005 {
7006 memcpy(buffer, ptr + 13, ptr[0] - 12);
7007 buffer[ptr[0] - 12] = 0;
7008 spsname = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
7009 if (!spsname) { LogMsg("SPSCreateDict: Could not create CFString spsname"); CFRelease(dict); return NULL; }
7010 else
7011 {
7012 CFDictionarySetValue(dict, CFSTR("PrettyName"), spsname);
7013 CFRelease(spsname);
7014 }
7015 }
7016
7017 return dict;
7018 }
7019
7020 mDNSlocal CFComparisonResult CompareSPSEntries(const void *val1, const void *val2, void *context)
7021 {
7022 (void)context;
7023 return CFNumberCompare((CFNumberRef)CFDictionaryGetValue((CFDictionaryRef)val1, kMetricRef),
7024 (CFNumberRef)CFDictionaryGetValue((CFDictionaryRef)val2, kMetricRef),
7025 NULL);
7026 }
7027
7028 mDNSlocal void UpdateSPSStatus(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
7029 {
7030 NetworkInterfaceInfo* info = (NetworkInterfaceInfo*)question->QuestionContext;
7031 debugf("UpdateSPSStatus: %s %##s %s %s", info->ifname, question->qname.c, AddRecord ? "Add" : "Rmv", answer ? RRDisplayString(m, answer) : "<null>");
7032
7033 mDNS_Lock(m);
7034 mDNS_UpdateAllowSleep(m);
7035 mDNS_Unlock(m);
7036
7037 if (answer && SPSMetric(answer->rdata->u.name.c) > 999999) return; // Ignore instances with invalid names
7038
7039 if (!spsStatusDict)
7040 {
7041 spsStatusDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
7042 if (!spsStatusDict) { LogMsg("UpdateSPSStatus: Could not create CFDictionary spsStatusDict"); return; }
7043 }
7044
7045 CFStringRef ifname = CFStringCreateWithCString(NULL, info->ifname, kCFStringEncodingUTF8);
7046 if (!ifname) { LogMsg("UpdateSPSStatus: Could not create CFString ifname"); return; }
7047
7048 CFMutableArrayRef array = NULL;
7049
7050 if (!CFDictionaryGetValueIfPresent(spsStatusDict, ifname, (const void**) &array))
7051 {
7052 array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
7053 if (!array) { LogMsg("UpdateSPSStatus: Could not create CFMutableArray"); CFRelease(ifname); return; }
7054 CFDictionarySetValue(spsStatusDict, ifname, array);
7055 CFRelease(array); // let go of our reference, now that the dict has one
7056 }
7057 else
7058 if (!array) { LogMsg("UpdateSPSStatus: Could not get CFMutableArray for %s", info->ifname); CFRelease(ifname); return; }
7059
7060 if (!answer) // special call that means the question has been stopped (because the interface is going away)
7061 CFArrayRemoveAllValues(array);
7062 else
7063 {
7064 CFMutableDictionaryRef dict = SPSCreateDict(answer->rdata->u.name.c);
7065 if (!dict) { CFRelease(ifname); return; }
7066
7067 if (AddRecord)
7068 {
7069 if (!CFArrayContainsValue(array, CFRangeMake(0, CFArrayGetCount(array)), dict))
7070 {
7071 int i=0;
7072 for (i=0; i<CFArrayGetCount(array); i++)
7073 if (CompareSPSEntries(CFArrayGetValueAtIndex(array, i), dict, NULL) != kCFCompareLessThan)
7074 break;
7075 CFArrayInsertValueAtIndex(array, i, dict);
7076 }
7077 else LogMsg("UpdateSPSStatus: %s array already contains %##s", info->ifname, answer->rdata->u.name.c);
7078 }
7079 else
7080 {
7081 CFIndex i = CFArrayGetFirstIndexOfValue(array, CFRangeMake(0, CFArrayGetCount(array)), dict);
7082 if (i != -1) CFArrayRemoveValueAtIndex(array, i);
7083 else LogMsg("UpdateSPSStatus: %s array does not contain %##s", info->ifname, answer->rdata->u.name.c);
7084 }
7085
7086 CFRelease(dict);
7087 }
7088
7089 if (!m->ShutdownTime) mDNSDynamicStoreSetConfig(kmDNSSleepProxyServersState, info->ifname, array);
7090
7091 CFRelease(ifname);
7092 }
7093
7094 mDNSlocal mDNSs32 GetSystemSleepTimerSetting(void)
7095 {
7096 mDNSs32 val = -1;
7097 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:GetSystemSleepTimerSetting"), NULL, NULL);
7098 if (!store)
7099 LogMsg("GetSystemSleepTimerSetting: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
7100 else
7101 {
7102 CFDictionaryRef dict = SCDynamicStoreCopyValue(store, NetworkChangedKey_PowerSettings);
7103 if (dict)
7104 {
7105 CFNumberRef number = CFDictionaryGetValue(dict, CFSTR("System Sleep Timer"));
7106 if (number) CFNumberGetValue(number, kCFNumberSInt32Type, &val);
7107 CFRelease(dict);
7108 }
7109 CFRelease(store);
7110 }
7111 return val;
7112 }
7113
7114 mDNSlocal void SetSPS(mDNS *const m)
7115 {
7116
7117 // If we ever want to know InternetSharing status in the future, use DNSXEnableProxy()
7118 mDNSu8 sps = (OfferSleepProxyService && GetSystemSleepTimerSetting() == 0) ? mDNSSleepProxyMetric_IncidentalSoftware : 0;
7119
7120 // For devices that are not running NAT, but are set to never sleep, we may choose to act
7121 // as a Sleep Proxy, but only for non-portable Macs (Portability > 35 means nominal weight < 3kg)
7122 //if (sps > mDNSSleepProxyMetric_PrimarySoftware && SPMetricPortability > 35) sps = 0;
7123
7124 // If we decide to let laptops act as Sleep Proxy, we should do it only when running on AC power, not on battery
7125
7126 // For devices that are unable to sleep at all to save power, or save 1W or less by sleeping,
7127 // it makes sense for them to offer low-priority Sleep Proxy service on the network.
7128 // We rate such a device as metric 70 ("Incidentally Available Hardware")
7129 if (SPMetricMarginalPower <= 60 && !sps) sps = mDNSSleepProxyMetric_IncidentalHardware;
7130
7131 // If the launchd plist specifies an explicit value for the Intent Metric, then use that instead of the
7132 // computed value (currently 40 "Primary Network Infrastructure Software" or 80 "Incidentally Available Software")
7133 if (sps && OfferSleepProxyService && OfferSleepProxyService < 100) sps = OfferSleepProxyService;
7134
7135 #ifdef NO_APPLETV_SLEEP_PROXY_ON_WIFI
7136 // AppleTVs are not reliable sleep proxy servers on WiFi. Do not offer to be a BSP if the WiFi interface is active.
7137 if (IsAppleTV())
7138 {
7139 NetworkInterfaceInfo *intf = mDNSNULL;
7140 mDNSEthAddr bssid = zeroEthAddr;
7141 for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next))
7142 {
7143 bssid = GetBSSID(intf->ifname);
7144 if (!mDNSSameEthAddress(&bssid, &zeroEthAddr))
7145 {
7146 LogMsg("SetSPS: AppleTV on WiFi - not advertising BSP services");
7147 sps = 0;
7148 break;
7149 }
7150 }
7151 }
7152 #endif // NO_APPLETV_SLEEP_PROXY_ON_WIFI
7153
7154 mDNSCoreBeSleepProxyServer(m, sps, SPMetricPortability, SPMetricMarginalPower, SPMetricTotalPower, SPMetricFeatures);
7155 }
7156
7157 // The definitions below should eventually come from some externally-supplied header file.
7158 // However, since these definitions can't really be changed without breaking binary compatibility,
7159 // they should never change, so in practice it should not be a big problem to have them defined here.
7160
7161 enum
7162 { // commands from the daemon to the driver
7163 cmd_mDNSOffloadRR = 21, // give the mdns update buffer to the driver
7164 };
7165
7166 typedef union { void *ptr; mDNSOpaque64 sixtyfourbits; } FatPtr;
7167
7168 typedef struct
7169 { // cmd_mDNSOffloadRR structure
7170 uint32_t command; // set to OffloadRR
7171 uint32_t rrBufferSize; // number of bytes of RR records
7172 uint32_t numUDPPorts; // number of SRV UDP ports
7173 uint32_t numTCPPorts; // number of SRV TCP ports
7174 uint32_t numRRRecords; // number of RR records
7175 uint32_t compression; // rrRecords - compression is base for compressed strings
7176 FatPtr rrRecords; // address of array of pointers to the rr records
7177 FatPtr udpPorts; // address of udp port list (SRV)
7178 FatPtr tcpPorts; // address of tcp port list (SRV)
7179 } mDNSOffloadCmd;
7180
7181 #include <IOKit/IOKitLib.h>
7182 #include <dns_util.h>
7183
7184 mDNSlocal mDNSu16 GetPortArray(mDNS *const m, int trans, mDNSIPPort *portarray)
7185 {
7186 const domainlabel *const tp = (trans == mDNSTransport_UDP) ? (const domainlabel *)"\x4_udp" : (const domainlabel *)"\x4_tcp";
7187 int count = 0;
7188 AuthRecord *rr;
7189 for (rr = m->ResourceRecords; rr; rr=rr->next)
7190 if (rr->resrec.rrtype == kDNSType_SRV && SameDomainLabel(ThirdLabel(rr->resrec.name)->c, tp->c))
7191 {
7192 if (portarray) portarray[count] = rr->resrec.rdata->u.srv.port;
7193 count++;
7194 }
7195
7196 // If Back to My Mac is on, also wake for packets to the IPSEC UDP port (4500)
7197 if (trans == mDNSTransport_UDP && m->AutoTunnelNAT.clientContext)
7198 {
7199 LogSPS("GetPortArray Back to My Mac at %d", count);
7200 if (portarray) portarray[count] = IPSECPort;
7201 count++;
7202 }
7203 return(count);
7204 }
7205
7206 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7207 mDNSlocal mDNSBool SupportsTCPKeepAlive()
7208 {
7209 IOReturn ret = kIOReturnSuccess;
7210 CFTypeRef obj = NULL;
7211 mDNSBool supports = mDNSfalse;
7212
7213 ret = IOPlatformCopyFeatureActive(CFSTR("TCPKeepAliveDuringSleep"), &obj);
7214 if ((kIOReturnSuccess == ret) && (obj != NULL))
7215 {
7216 supports = (obj == kCFBooleanTrue)? mDNStrue : mDNSfalse;
7217 CFRelease(obj);
7218 }
7219 LogSPS("%s: The hardware %s TCP Keep Alive", __func__, (supports ? "supports" : "does not support"));
7220 return supports;
7221 }
7222
7223 mDNSlocal mDNSBool OnBattery(void)
7224 {
7225 CFTypeRef powerInfo = IOPSCopyPowerSourcesInfo();
7226 CFTypeRef powerSrc = IOPSGetProvidingPowerSourceType(powerInfo);
7227 mDNSBool result = mDNSfalse;
7228
7229 if (powerInfo != NULL)
7230 {
7231 result = CFEqual(CFSTR(kIOPSBatteryPowerValue), powerSrc);
7232 CFRelease(powerInfo);
7233 }
7234 LogSPS("%s: The system is on %s", __func__, (result)? "Battery" : "AC Power");
7235 return result;
7236 }
7237
7238 #endif // !TARGET_OS_EMBEDDED
7239
7240 #define TfrRecordToNIC(RR) \
7241 ((!(RR)->resrec.InterfaceID && ((RR)->ForceMCast || IsLocalDomain((RR)->resrec.name))))
7242
7243 mDNSlocal mDNSu32 CountProxyRecords(mDNS *const m, uint32_t *const numbytes, NetworkInterfaceInfo *const intf, mDNSBool TCPKAOnly, mDNSBool supportsTCPKA)
7244 {
7245 *numbytes = 0;
7246 int count = 0;
7247
7248 AuthRecord *rr;
7249
7250 for (rr = m->ResourceRecords; rr; rr=rr->next)
7251 {
7252 if (!(rr->AuthFlags & AuthFlagsWakeOnly) && rr->resrec.RecordType > kDNSRecordTypeDeregistering)
7253 {
7254 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7255 mDNSBool isKeepAliveRecord = mDNS_KeepaliveRecord(&rr->resrec);
7256 // Skip over all other records if we are registering TCP KeepAlive records only
7257 // Skip over TCP KeepAlive records if the policy prohibits it or if the interface does not support TCP Keepalive.
7258 if ((TCPKAOnly && !isKeepAliveRecord) || (isKeepAliveRecord && !supportsTCPKA))
7259 continue;
7260
7261 // Update the record before calculating the number of bytes required
7262 // We offload the TCP Keepalive record even if the update fails. When the driver gets the record, it will
7263 // attempt to update the record again.
7264 if (isKeepAliveRecord && (UpdateKeepaliveRData(m, rr, intf, mDNSfalse, mDNSNULL) != mStatus_NoError))
7265 LogSPS("CountProxyRecords: Failed to update keepalive record - %s", ARDisplayString(m, rr));
7266 #else
7267 (void) TCPKAOnly; // unused
7268 (void) supportsTCPKA; // unused
7269 (void) intf; // unused
7270 #endif // APPLE_OSX_mDNSResponder
7271 if (TfrRecordToNIC(rr))
7272 {
7273 *numbytes += DomainNameLength(rr->resrec.name) + 10 + rr->resrec.rdestimate;
7274 LogSPS("CountProxyRecords: %3d size %5d total %5d %s",
7275 count, DomainNameLength(rr->resrec.name) + 10 + rr->resrec.rdestimate, *numbytes, ARDisplayString(m,rr));
7276 count++;
7277 }
7278 }
7279 }
7280 return(count);
7281 }
7282
7283 mDNSlocal void GetProxyRecords(mDNS *const m, DNSMessage *const msg, uint32_t *const numbytes, FatPtr *const records, mDNSBool TCPKAOnly, mDNSBool supportsTCPKA)
7284 {
7285 mDNSu8 *p = msg->data;
7286 const mDNSu8 *const limit = p + *numbytes;
7287 InitializeDNSMessage(&msg->h, zeroID, zeroID);
7288
7289 int count = 0;
7290 AuthRecord *rr;
7291
7292 for (rr = m->ResourceRecords; rr; rr=rr->next)
7293 {
7294 if (!(rr->AuthFlags & AuthFlagsWakeOnly) && rr->resrec.RecordType > kDNSRecordTypeDeregistering)
7295 {
7296 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7297 mDNSBool isKeepAliveRecord = mDNS_KeepaliveRecord(&rr->resrec);
7298
7299 // Skip over all other records if we are registering TCP KeepAlive records only
7300 // Skip over TCP KeepAlive records if the policy prohibits it or if the interface does not support TCP Keepalive
7301 if ((TCPKAOnly && !isKeepAliveRecord) || (isKeepAliveRecord && !supportsTCPKA))
7302 continue;
7303 #else
7304 (void) TCPKAOnly; // unused
7305 (void) supportsTCPKA; // unused
7306 #endif // APPLE_OSX_mDNSResponder
7307
7308 if (TfrRecordToNIC(rr))
7309 {
7310 records[count].sixtyfourbits = zeroOpaque64;
7311 records[count].ptr = p;
7312 if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
7313 rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the 'unique' bit so PutResourceRecord will set it
7314 p = PutResourceRecordTTLWithLimit(msg, p, &msg->h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit);
7315 rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear 'unique' bit back to normal state
7316 LogSPS("GetProxyRecords: %3d start %p end %p size %5d total %5d %s",
7317 count, records[count].ptr, p, p - (mDNSu8 *)records[count].ptr, p - msg->data, ARDisplayString(m,rr));
7318 count++;
7319 }
7320 }
7321 }
7322 *numbytes = p - msg->data;
7323 }
7324
7325 // If compiling with old headers and libraries (pre 10.5) that don't include IOConnectCallStructMethod
7326 // then we declare a dummy version here so that the code at least compiles
7327 #ifndef AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
7328 static kern_return_t
7329 IOConnectCallStructMethod(
7330 mach_port_t connection, // In
7331 uint32_t selector, // In
7332 const void *inputStruct, // In
7333 size_t inputStructCnt, // In
7334 void *outputStruct, // Out
7335 size_t *outputStructCnt) // In/Out
7336 {
7337 (void)connection;
7338 (void)selector;
7339 (void)inputStruct;
7340 (void)inputStructCnt;
7341 (void)outputStruct;
7342 (void)outputStructCnt;
7343 LogMsg("Compiled without IOConnectCallStructMethod");
7344 return(KERN_FAILURE);
7345 }
7346 #endif
7347
7348 mDNSexport mDNSBool SupportsInNICProxy(NetworkInterfaceInfo *const intf)
7349 {
7350 if(!UseInternalSleepProxy)
7351 {
7352 LogSPS("SupportsInNICProxy: Internal Sleep Proxy is disabled");
7353 return mDNSfalse;
7354 }
7355 return CheckInterfaceSupport(intf, mDNS_IOREG_KEY);
7356 }
7357
7358 mDNSexport mStatus ActivateLocalProxy(mDNS *const m, NetworkInterfaceInfo *const intf) // Called with the lock held
7359 {
7360 mStatus result = mStatus_UnknownErr;
7361 mDNSBool TCPKAOnly = mDNSfalse;
7362 mDNSBool supportsTCPKA = mDNSfalse;
7363 mDNSBool onbattery = mDNSfalse;
7364 io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, IOBSDNameMatching(kIOMasterPortDefault, 0, intf->ifname));
7365
7366 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7367 onbattery = OnBattery();
7368 // Check if the interface supports TCP Keepalives and the system policy says it is ok to offload TCP Keepalive records
7369 supportsTCPKA = (InterfaceSupportsKeepAlive(intf) && SupportsTCPKeepAlive());
7370
7371 // Only TCP Keepalive records are to be offloaded if
7372 // - The system is on battery
7373 // - OR wake for network access is not set but powernap is enabled
7374 TCPKAOnly = supportsTCPKA && ((m->SystemWakeOnLANEnabled == mDNS_WakeOnBattery) || onbattery);
7375 #else
7376 (void) onbattery; // unused;
7377 #endif
7378 if (!service) { LogMsg("ActivateLocalProxy: No service for interface %s", intf->ifname); return(mStatus_UnknownErr); }
7379
7380 io_name_t n1, n2;
7381 IOObjectGetClass(service, n1);
7382 io_object_t parent;
7383 kern_return_t kr = IORegistryEntryGetParentEntry(service, kIOServicePlane, &parent);
7384 if (kr != KERN_SUCCESS) LogMsg("ActivateLocalProxy: IORegistryEntryGetParentEntry for %s/%s failed %d", intf->ifname, n1, kr);
7385 else
7386 {
7387 IOObjectGetClass(parent, n2);
7388 LogSPS("ActivateLocalProxy: Interface %s service %s parent %s", intf->ifname, n1, n2);
7389 const CFTypeRef ref = IORegistryEntryCreateCFProperty(parent, CFSTR(mDNS_IOREG_KEY), kCFAllocatorDefault, mDNSNULL);
7390 if (!ref) LogSPS("ActivateLocalProxy: No mDNS_IOREG_KEY for interface %s/%s/%s", intf->ifname, n1, n2);
7391 else
7392 {
7393 if (CFGetTypeID(ref) != CFStringGetTypeID() || !CFEqual(ref, CFSTR(mDNS_IOREG_VALUE)))
7394 LogMsg("ActivateLocalProxy: mDNS_IOREG_KEY for interface %s/%s/%s value %s != %s",
7395 intf->ifname, n1, n2, CFStringGetCStringPtr(ref, mDNSNULL), mDNS_IOREG_VALUE);
7396 else if (!UseInternalSleepProxy)
7397 LogSPS("ActivateLocalProxy: Not using internal (NIC) sleep proxy for interface %s", intf->ifname);
7398 else
7399 {
7400 io_connect_t conObj;
7401 kr = IOServiceOpen(parent, mach_task_self(), mDNS_USER_CLIENT_CREATE_TYPE, &conObj);
7402 if (kr != KERN_SUCCESS) LogMsg("ActivateLocalProxy: IOServiceOpen for %s/%s/%s failed %d", intf->ifname, n1, n2, kr);
7403 else
7404 {
7405 mDNSOffloadCmd cmd;
7406 mDNSPlatformMemZero(&cmd, sizeof(cmd)); // When compiling 32-bit, make sure top 32 bits of 64-bit pointers get initialized to zero
7407 cmd.command = cmd_mDNSOffloadRR;
7408 cmd.numUDPPorts = GetPortArray(m, mDNSTransport_UDP, mDNSNULL);
7409 cmd.numTCPPorts = GetPortArray(m, mDNSTransport_TCP, mDNSNULL);
7410 cmd.numRRRecords = CountProxyRecords(m, &cmd.rrBufferSize, intf, TCPKAOnly, supportsTCPKA);
7411 cmd.compression = sizeof(DNSMessageHeader);
7412
7413 DNSMessage *msg = (DNSMessage *)mallocL("mDNSOffloadCmd msg", sizeof(DNSMessageHeader) + cmd.rrBufferSize);
7414 cmd.rrRecords.ptr = mallocL("mDNSOffloadCmd rrRecords", cmd.numRRRecords * sizeof(FatPtr));
7415 cmd.udpPorts.ptr = mallocL("mDNSOffloadCmd udpPorts", cmd.numUDPPorts * sizeof(mDNSIPPort));
7416 cmd.tcpPorts.ptr = mallocL("mDNSOffloadCmd tcpPorts", cmd.numTCPPorts * sizeof(mDNSIPPort));
7417
7418 LogSPS("ActivateLocalProxy: msg %p %d RR %p %d, UDP %p %d, TCP %p %d",
7419 msg, cmd.rrBufferSize,
7420 cmd.rrRecords.ptr, cmd.numRRRecords,
7421 cmd.udpPorts.ptr, cmd.numUDPPorts,
7422 cmd.tcpPorts.ptr, cmd.numTCPPorts);
7423
7424 if (!msg || !cmd.rrRecords.ptr || !cmd.udpPorts.ptr || !cmd.tcpPorts.ptr)
7425 LogMsg("ActivateLocalProxy: Failed to allocate memory: msg %p %d RR %p %d, UDP %p %d, TCP %p %d",
7426 msg, cmd.rrBufferSize,
7427 cmd.rrRecords.ptr, cmd.numRRRecords,
7428 cmd.udpPorts.ptr, cmd.numUDPPorts,
7429 cmd.tcpPorts.ptr, cmd.numTCPPorts);
7430 else
7431 {
7432 GetProxyRecords(m, msg, &cmd.rrBufferSize, cmd.rrRecords.ptr, TCPKAOnly, supportsTCPKA);
7433 GetPortArray(m, mDNSTransport_UDP, cmd.udpPorts.ptr);
7434 GetPortArray(m, mDNSTransport_TCP, cmd.tcpPorts.ptr);
7435 char outputData[2];
7436 size_t outputDataSize = sizeof(outputData);
7437 kr = IOConnectCallStructMethod(conObj, 0, &cmd, sizeof(cmd), outputData, &outputDataSize);
7438 LogSPS("ActivateLocalProxy: IOConnectCallStructMethod for %s/%s/%s %d", intf->ifname, n1, n2, kr);
7439 if (kr == KERN_SUCCESS) result = mStatus_NoError;
7440 }
7441
7442 if (cmd.tcpPorts.ptr) freeL("mDNSOffloadCmd udpPorts", cmd.tcpPorts.ptr);
7443 if (cmd.udpPorts.ptr) freeL("mDNSOffloadCmd tcpPorts", cmd.udpPorts.ptr);
7444 if (cmd.rrRecords.ptr) freeL("mDNSOffloadCmd rrRecords", cmd.rrRecords.ptr);
7445 if (msg) freeL("mDNSOffloadCmd msg", msg);
7446 IOServiceClose(conObj);
7447 }
7448 }
7449 CFRelease(ref);
7450 }
7451 IOObjectRelease(parent);
7452 }
7453 IOObjectRelease(service);
7454 return result;
7455 }
7456
7457 #endif // APPLE_OSX_mDNSResponder
7458
7459 mDNSlocal mDNSu8 SystemWakeForNetworkAccess(void)
7460 {
7461 mDNSs32 val = 0;
7462 mDNSu8 ret = (mDNSu8)mDNS_NoWake;
7463
7464 if (DisableSleepProxyClient)
7465 {
7466 LogSPS("SystemWakeForNetworkAccess: Sleep Proxy Client disabled by command-line option");
7467 return mDNSfalse;
7468 }
7469
7470 GetCurrentPMSetting(CFSTR("Wake On LAN"), &val);
7471
7472 ret = (mDNSu8)(val != 0) ? mDNS_WakeOnAC : mDNS_NoWake;
7473
7474 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7475 // If we have TCP Keepalive support, system is capable of registering for TCP Keepalives.
7476 // Further policy decisions on whether to offload the records is handled during sleep processing.
7477 if ((ret == mDNS_NoWake) && SupportsTCPKeepAlive())
7478 ret = (mDNSu8)mDNS_WakeOnBattery;
7479 #endif // APPLE_OSX_mDNSResponder
7480
7481 LogSPS("SystemWakeForNetworkAccess: Wake On LAN: %d", ret);
7482 return ret;
7483 }
7484
7485 mDNSlocal mDNSBool SystemSleepOnlyIfWakeOnLAN(void)
7486 {
7487 mDNSs32 val = 0;
7488 GetCurrentPMSetting(CFSTR("PrioritizeNetworkReachabilityOverSleep"), &val);
7489 return val != 0 ? mDNStrue : mDNSfalse;
7490 }
7491
7492 #if APPLE_OSX_mDNSResponder
7493 // When sleeping, we always ensure that the _autotunnel6 record (if connected to RR relay)
7494 // gets deregistered, so that older peers are forced to connect over direct UDP instead of
7495 // the RR relay.
7496 //
7497 // When sleeping w/o a successful AutoTunnel NAT Mapping, we ensure that all our BTMM
7498 // service records are deregistered, so they do not appear in peers' Finder sidebars.
7499 // We do this by checking for the (non-autotunnel) SRV records, as the PTR and TXT records
7500 // depend on their associated SRV record and therefore will be deregistered together in a
7501 // single update with the SRV record.
7502 //
7503 // Also, the per-zone _kerberos TXT record is always there, including while sleeping, so
7504 // its presence shouldn't delay sleep.
7505 //
7506 // Note that the order of record deregistration is: first _autotunnel6 (if connected to RR
7507 // relay) and host records get deregistered, then SRV (UpdateAllSrvRecords), PTR and TXT.
7508 //
7509 // Also note that returning false here will not delay sleep past the maximum of 10 seconds.
7510 mDNSexport mDNSBool RecordReadyForSleep(mDNS *const m, AuthRecord *rr)
7511 {
7512 if (!AuthRecord_uDNS(rr)) return mDNStrue;
7513
7514 if ((rr->resrec.rrtype == kDNSType_AAAA) && SameDomainLabel(rr->namestorage.c, (const mDNSu8 *)"\x0c_autotunnel6"))
7515 {
7516 LogInfo("RecordReadyForSleep: %s not ready for sleep", ARDisplayString(m, rr));
7517 return mDNSfalse;
7518 }
7519
7520 if ((mDNSIPPortIsZero(m->AutoTunnelNAT.ExternalPort) || m->AutoTunnelNAT.Result))
7521 {
7522 if (rr->resrec.rrtype == kDNSType_SRV && rr->state != regState_NoTarget && rr->zone
7523 && !SameDomainLabel(rr->namestorage.c, (const mDNSu8 *)"\x0b_autotunnel"))
7524 {
7525 DomainAuthInfo *info = GetAuthInfoForName_internal(m, rr->zone);
7526 if (info && info->AutoTunnel)
7527 {
7528 LogInfo("RecordReadyForSleep: %s not ready for sleep", ARDisplayString(m, rr));
7529 return mDNSfalse;
7530 }
7531 }
7532 }
7533
7534 return mDNStrue;
7535 }
7536
7537 // Caller must hold the lock
7538 mDNSexport void RemoveAutoTunnel6Record(mDNS *const m)
7539 {
7540 DomainAuthInfo *info;
7541 // Set the address to zero before calling UpdateAutoTunnel6Record, so that it will
7542 // deregister the record, and the MemFree callback won't re-register.
7543 m->AutoTunnelRelayAddr = zerov6Addr;
7544 for (info = m->AuthInfoList; info; info = info->next)
7545 if (info->AutoTunnel)
7546 UpdateAutoTunnel6Record(m, info);
7547 }
7548
7549 mDNSlocal mDNSBool IPv6AddressIsOnInterface(mDNSv6Addr ipv6Addr, char *ifname)
7550 {
7551 struct ifaddrs *ifa;
7552 struct ifaddrs *ifaddrs;
7553 mDNSAddr addr;
7554
7555 if (if_nametoindex(ifname) == 0) {LogInfo("IPv6AddressIsOnInterface: Invalid name %s", ifname); return mDNSfalse;}
7556
7557 if (getifaddrs(&ifaddrs) < 0) {LogInfo("IPv6AddressIsOnInterface: getifaddrs failed"); return mDNSfalse;}
7558
7559 for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next)
7560 {
7561 if (strncmp(ifa->ifa_name, ifname, IFNAMSIZ) != 0)
7562 continue;
7563 if ((ifa->ifa_flags & IFF_UP) == 0 || !ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET6)
7564 continue;
7565 if (SetupAddr(&addr, ifa->ifa_addr) != mStatus_NoError)
7566 {
7567 LogInfo("IPv6AddressIsOnInterface: SetupAddr error, continuing to the next address");
7568 continue;
7569 }
7570 if (mDNSSameIPv6Address(ipv6Addr, *(mDNSv6Addr*)&addr.ip.v6))
7571 {
7572 LogInfo("IPv6AddressIsOnInterface: found %.16a", &ipv6Addr);
7573 break;
7574 }
7575 }
7576 freeifaddrs(ifaddrs);
7577 return ifa != NULL;
7578 }
7579
7580 mDNSlocal mDNSv6Addr IPv6AddressFromString(char* buf)
7581 {
7582 mDNSv6Addr retVal;
7583 struct addrinfo hints;
7584 struct addrinfo *res0;
7585
7586 memset(&hints, 0, sizeof(hints));
7587 hints.ai_family = AF_INET6;
7588 hints.ai_flags = AI_NUMERICHOST;
7589
7590 int err = getaddrinfo(buf, NULL, &hints, &res0);
7591 if (err)
7592 return zerov6Addr;
7593
7594 retVal = *(mDNSv6Addr*)&((struct sockaddr_in6*)res0->ai_addr)->sin6_addr;
7595
7596 freeaddrinfo(res0);
7597
7598 return retVal;
7599 }
7600
7601 mDNSlocal CFDictionaryRef CopyConnectivityBackToMyMacDict()
7602 {
7603 SCDynamicStoreRef store = NULL;
7604 CFDictionaryRef connd = NULL;
7605 CFDictionaryRef BTMMDict = NULL;
7606
7607 store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:CopyConnectivityBackToMyMacDict"), NULL, NULL);
7608 if (!store)
7609 {
7610 LogMsg("CopyConnectivityBackToMyMacDict: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
7611 goto end;
7612 }
7613
7614 connd = SCDynamicStoreCopyValue(store, NetworkChangedKey_BTMMConnectivity);
7615 if (!connd)
7616 {
7617 LogInfo("CopyConnectivityBackToMyMacDict: SCDynamicStoreCopyValue failed: %s", SCErrorString(SCError()));
7618 goto end;
7619 }
7620
7621 BTMMDict = CFDictionaryGetValue(connd, CFSTR("BackToMyMac"));
7622 if (!BTMMDict)
7623 {
7624 LogInfo("CopyConnectivityBackToMyMacDict: CFDictionaryGetValue: No value for BackToMyMac");
7625 goto end;
7626 }
7627
7628 // Non-dictionary is treated as non-existent dictionary
7629 if (CFGetTypeID(BTMMDict) != CFDictionaryGetTypeID())
7630 {
7631 BTMMDict = NULL;
7632 LogMsg("CopyConnectivityBackToMyMacDict: BackToMyMac not a dictionary");
7633 goto end;
7634 }
7635
7636 CFRetain(BTMMDict);
7637
7638 end:
7639 if (connd) CFRelease(connd);
7640 if (store) CFRelease(store);
7641
7642 return BTMMDict;
7643 }
7644
7645 #define MAX_IPV6_TEXTUAL 40
7646
7647 mDNSlocal mDNSv6Addr ParseBackToMyMacAddr(CFDictionaryRef BTMMDict, CFStringRef ifKey, CFStringRef addrKey)
7648 {
7649 mDNSv6Addr retVal = zerov6Addr;
7650 CFTypeRef string = NULL;
7651 char ifname[IFNAMSIZ];
7652 char address[MAX_IPV6_TEXTUAL];
7653
7654 if (!BTMMDict)
7655 return zerov6Addr;
7656
7657 if (!CFDictionaryGetValueIfPresent(BTMMDict, ifKey, &string))
7658 {
7659 LogInfo("ParseBackToMyMacAddr: interface key does not exist");
7660 return zerov6Addr;
7661 }
7662
7663 if (!CFStringGetCString(string, ifname, IFNAMSIZ, kCFStringEncodingUTF8))
7664 {
7665 LogMsg("ParseBackToMyMacAddr: Could not convert interface to CString");
7666 return zerov6Addr;
7667 }
7668
7669 if (!CFDictionaryGetValueIfPresent(BTMMDict, addrKey, &string))
7670 {
7671 LogMsg("ParseBackToMyMacAddr: address key does not exist, but interface key does");
7672 return zerov6Addr;
7673 }
7674
7675 if (!CFStringGetCString(string, address, sizeof(address), kCFStringEncodingUTF8))
7676 {
7677 LogMsg("ParseBackToMyMacAddr: Could not convert address to CString");
7678 return zerov6Addr;
7679 }
7680
7681 retVal = IPv6AddressFromString(address);
7682 LogInfo("ParseBackToMyMacAddr: %s (%s) %.16a", ifname, address, &retVal);
7683
7684 if (mDNSIPv6AddressIsZero(retVal))
7685 return zerov6Addr;
7686
7687 if (!IPv6AddressIsOnInterface(retVal, ifname))
7688 {
7689 LogMsg("ParseBackToMyMacAddr: %.16a is not on %s", &retVal, ifname);
7690 return zerov6Addr;
7691 }
7692
7693 return retVal;
7694 }
7695
7696 mDNSlocal CFDictionaryRef GetBackToMyMacZones(CFDictionaryRef BTMMDict)
7697 {
7698 CFTypeRef zones = NULL;
7699
7700 if (!BTMMDict)
7701 return NULL;
7702
7703 if (!CFDictionaryGetValueIfPresent(BTMMDict, CFSTR("Zones"), &zones))
7704 {
7705 LogInfo("CopyBTMMZones: Zones key does not exist");
7706 return NULL;
7707 }
7708
7709 return zones;
7710 }
7711
7712 mDNSlocal mDNSv6Addr ParseBackToMyMacZone(CFDictionaryRef zones, DomainAuthInfo* info)
7713 {
7714 mDNSv6Addr addr = zerov6Addr;
7715 char buffer[MAX_ESCAPED_DOMAIN_NAME];
7716 CFStringRef domain = NULL;
7717 CFTypeRef theZone = NULL;
7718
7719 if (!zones)
7720 return addr;
7721
7722 ConvertDomainNameToCString(&info->domain, buffer);
7723 domain = CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
7724 if (!domain)
7725 return addr;
7726
7727 if (CFDictionaryGetValueIfPresent(zones, domain, &theZone))
7728 addr = ParseBackToMyMacAddr(theZone, CFSTR("Interface"), CFSTR("Address"));
7729
7730 CFRelease(domain);
7731
7732 return addr;
7733 }
7734
7735 mDNSlocal void SetupBackToMyMacInnerAddresses(mDNS *const m, CFDictionaryRef BTMMDict)
7736 {
7737 DomainAuthInfo* info;
7738 CFDictionaryRef zones = GetBackToMyMacZones(BTMMDict);
7739 mDNSv6Addr newAddr;
7740
7741 for (info = m->AuthInfoList; info; info = info->next)
7742 {
7743 if (!info->AutoTunnel)
7744 continue;
7745
7746 newAddr = ParseBackToMyMacZone(zones, info);
7747
7748 if (mDNSSameIPv6Address(newAddr, info->AutoTunnelInnerAddress))
7749 continue;
7750
7751 info->AutoTunnelInnerAddress = newAddr;
7752 DeregisterAutoTunnelHostRecord(m, info);
7753 UpdateAutoTunnelHostRecord(m, info);
7754 UpdateAutoTunnelDomainStatus(m, info);
7755 }
7756 }
7757
7758 // MUST be called holding the lock
7759 mDNSlocal void ProcessConndConfigChanges(mDNS *const m)
7760 {
7761 CFDictionaryRef dict = CopyConnectivityBackToMyMacDict();
7762 if (!dict)
7763 LogInfo("ProcessConndConfigChanges: No BTMM dictionary");
7764 mDNSv6Addr relayAddr = ParseBackToMyMacAddr(dict, CFSTR("RelayInterface"), CFSTR("RelayAddress"));
7765
7766 LogInfo("ProcessConndConfigChanges: relay %.16a", &relayAddr);
7767
7768 SetupBackToMyMacInnerAddresses(m, dict);
7769
7770 if (dict) CFRelease(dict);
7771
7772 if (!mDNSSameIPv6Address(relayAddr, m->AutoTunnelRelayAddr))
7773 {
7774 m->AutoTunnelRelayAddr = relayAddr;
7775
7776 DomainAuthInfo* info;
7777 for (info = m->AuthInfoList; info; info = info->next)
7778 if (info->AutoTunnel)
7779 {
7780 DeregisterAutoTunnel6Record(m, info);
7781 UpdateAutoTunnel6Record(m, info);
7782 UpdateAutoTunnelDomainStatus(m, info);
7783 }
7784
7785 // Determine whether we need racoon to accept incoming connections
7786 UpdateAnonymousRacoonConfig(m);
7787 }
7788
7789 // If awacsd crashes or exits for some reason, restart it
7790 UpdateBTMMRelayConnection(m);
7791 }
7792 #endif /* APPLE_OSX_mDNSResponder */
7793
7794 mDNSlocal mDNSBool IsAppleNetwork(mDNS *const m)
7795 {
7796 DNSServer *s;
7797 // Determine if we're on AppleNW based on DNSServer having 17.x.y.z IPv4 addr
7798 for (s = m->DNSServers; s; s = s->next)
7799 {
7800 if (s->addr.ip.v4.b[0] == 17)
7801 {
7802 LogInfo("IsAppleNetwork: Found 17.x.y.z DNSServer concluding that we are on AppleNW: %##s %#a", s->domain.c, &s->addr);
7803 return mDNStrue;
7804 }
7805 }
7806 return mDNSfalse;
7807 }
7808
7809 mDNSexport void mDNSMacOSXNetworkChanged(mDNS *const m)
7810 {
7811 LogInfo("*** Network Configuration Change *** (%d)%s",
7812 m->p->NetworkChanged ? mDNS_TimeNow(m) - m->p->NetworkChanged : 0,
7813 m->p->NetworkChanged ? "" : " (no scheduled configuration change)");
7814 m->p->NetworkChanged = 0; // If we received a network change event and deferred processing, we're now dealing with it
7815 mDNSs32 utc = mDNSPlatformUTC();
7816 m->SystemWakeOnLANEnabled = SystemWakeForNetworkAccess();
7817 m->SystemSleepOnlyIfWakeOnLAN = SystemSleepOnlyIfWakeOnLAN();
7818 MarkAllInterfacesInactive(m, utc);
7819 UpdateInterfaceList(m, utc);
7820 ClearInactiveInterfaces(m, utc);
7821 SetupActiveInterfaces(m, utc);
7822
7823 #if APPLE_OSX_mDNSResponder
7824
7825 mDNS_Lock(m);
7826 ProcessConndConfigChanges(m);
7827 mDNS_Unlock(m);
7828
7829 // Scan to find client tunnels whose questions have completed,
7830 // but whose local inner/outer addresses have changed since the tunnel was set up
7831 ClientTunnel *p;
7832 for (p = m->TunnelClients; p; p = p->next)
7833 if (p->q.ThisQInterval < 0)
7834 {
7835 DomainAuthInfo* info = GetAuthInfoForName(m, &p->dstname);
7836 if (!info)
7837 {
7838 LogMsg("mDNSMacOSXNetworkChanged: Could not get AuthInfo for %##s, removing tunnel keys", p->dstname.c);
7839 AutoTunnelSetKeys(p, mDNSfalse);
7840 }
7841 else
7842 {
7843 mDNSv6Addr inner = info->AutoTunnelInnerAddress;
7844
7845 if (!mDNSIPPortIsZero(p->rmt_outer_port))
7846 {
7847 mDNSAddr tmpSrc = zeroAddr;
7848 mDNSAddr tmpDst = { mDNSAddrType_IPv4, {{{0}}} };
7849 tmpDst.ip.v4 = p->rmt_outer;
7850 mDNSPlatformSourceAddrForDest(&tmpSrc, &tmpDst);
7851 if (!mDNSSameIPv6Address(p->loc_inner, inner) ||
7852 !mDNSSameIPv4Address(p->loc_outer, tmpSrc.ip.v4))
7853 {
7854 AutoTunnelSetKeys(p, mDNSfalse);
7855 p->loc_inner = inner;
7856 p->loc_outer = tmpSrc.ip.v4;
7857 AutoTunnelSetKeys(p, mDNStrue);
7858 }
7859 }
7860 else
7861 {
7862 if (!mDNSSameIPv6Address(p->loc_inner, inner) ||
7863 !mDNSSameIPv6Address(p->loc_outer6, m->AutoTunnelRelayAddr))
7864 {
7865 AutoTunnelSetKeys(p, mDNSfalse);
7866 p->loc_inner = inner;
7867 p->loc_outer6 = m->AutoTunnelRelayAddr;
7868 AutoTunnelSetKeys(p, mDNStrue);
7869 }
7870 }
7871 }
7872 }
7873
7874 SetSPS(m);
7875
7876 NetworkInterfaceInfoOSX *i;
7877 for (i = m->p->InterfaceList; i; i = i->next)
7878 {
7879 if (!m->SPSSocket) // Not being Sleep Proxy Server; close any open BPF fds
7880 {
7881 if (i->BPF_fd >= 0 && CountProxyTargets(m, i, mDNSNULL, mDNSNULL) == 0) CloseBPF(i);
7882 }
7883 else // else, we're Sleep Proxy Server; open BPF fds
7884 {
7885 if (i->Exists && i->Registered == i && i->ifinfo.McastTxRx && !(i->ifa_flags & IFF_LOOPBACK) && i->BPF_fd == -1)
7886 { LogSPS("%s requesting BPF", i->ifinfo.ifname); i->BPF_fd = -2; mDNSRequestBPF(); }
7887 }
7888 }
7889
7890 #endif // APPLE_OSX_mDNSResponder
7891
7892 uDNS_SetupDNSConfig(m);
7893 mDNS_ConfigChanged(m);
7894
7895 if (IsAppleNetwork(m) != mDNS_McastTracingEnabled)
7896 {
7897 mDNS_McastTracingEnabled = mDNS_McastTracingEnabled ? mDNSfalse : mDNStrue;
7898 LogMsg("mDNSMacOSXNetworkChanged: Multicast Tracing %s", mDNS_McastTracingEnabled ? "Enabled" : "Disabled");
7899 UpdateDebugState();
7900 }
7901
7902 }
7903
7904 // Called with KQueueLock & mDNS lock
7905 mDNSlocal void SetNetworkChanged(mDNS *const m, mDNSs32 delay)
7906 {
7907 if (!m->p->NetworkChanged || m->p->NetworkChanged - NonZeroTime(m->timenow + delay) < 0)
7908 {
7909 m->p->NetworkChanged = NonZeroTime(m->timenow + delay);
7910 LogInfo("SetNetworkChanged: scheduling in %d msec", delay);
7911 }
7912 }
7913
7914 // Called with KQueueLock & mDNS lock
7915 mDNSlocal void SetKeyChainTimer(mDNS *const m, mDNSs32 delay)
7916 {
7917 // If it's not set or it needs to happen sooner than when it's currently set
7918 if (!m->p->KeyChainTimer || m->p->KeyChainTimer - NonZeroTime(m->timenow + delay) > 0)
7919 {
7920 m->p->KeyChainTimer = NonZeroTime(m->timenow + delay);
7921 LogInfo("SetKeyChainTimer: %d", delay);
7922 }
7923 }
7924
7925 // Copy the fourth slash-delimited element from either:
7926 // State:/Network/Interface/<bsdname>/IPv4
7927 // or
7928 // Setup:/Network/Service/<servicename>/Interface
7929 mDNSlocal CFStringRef CopyNameFromKey(CFStringRef key)
7930 {
7931 CFArrayRef a;
7932 CFStringRef name = NULL;
7933
7934 a = CFStringCreateArrayBySeparatingStrings(NULL, key, CFSTR("/"));
7935 if (a && CFArrayGetCount(a) == 5) name = CFRetain(CFArrayGetValueAtIndex(a, 3));
7936 if (a != NULL) CFRelease(a);
7937
7938 return name;
7939 }
7940
7941 // Whether a key from a network change notification corresponds to
7942 // an IP service that is explicitly configured for IPv4 Link Local
7943 mDNSlocal mDNSBool ChangedKeysHaveIPv4LL(CFArrayRef inkeys)
7944 {
7945 SCDynamicStoreRef store = NULL;
7946 CFDictionaryRef dict = NULL;
7947 CFMutableArrayRef a;
7948 const void **keys = NULL, **vals = NULL;
7949 CFStringRef pattern = NULL;
7950 int i, ic, j, jc;
7951 mDNSBool found = mDNSfalse;
7952
7953 jc = CFArrayGetCount(inkeys);
7954 if (!jc) goto done;
7955
7956 store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:ChangedKeysHaveIPv4LL"), NULL, NULL);
7957 if (store == NULL) goto done;
7958
7959 a = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
7960 if (a == NULL) goto done;
7961
7962 // Setup:/Network/Service/[^/]+/Interface
7963 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, kSCDynamicStoreDomainSetup, kSCCompAnyRegex, kSCEntNetInterface);
7964 if (pattern == NULL) goto done;
7965 CFArrayAppendValue(a, pattern);
7966 CFRelease(pattern);
7967
7968 // Setup:/Network/Service/[^/]+/IPv4
7969 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, kSCDynamicStoreDomainSetup, kSCCompAnyRegex, kSCEntNetIPv4);
7970 if (pattern == NULL) goto done;
7971 CFArrayAppendValue(a, pattern);
7972 CFRelease(pattern);
7973
7974 dict = SCDynamicStoreCopyMultiple(store, NULL, a);
7975 CFRelease(a);
7976
7977 if (!dict)
7978 {
7979 LogMsg("ChangedKeysHaveIPv4LL: Empty dictionary");
7980 goto done;
7981 }
7982
7983 ic = CFDictionaryGetCount(dict);
7984 vals = mDNSPlatformMemAllocate(sizeof (void *) * ic);
7985 keys = mDNSPlatformMemAllocate(sizeof (void *) * ic);
7986 CFDictionaryGetKeysAndValues(dict, keys, vals);
7987
7988 for (j = 0; j < jc && !found; j++)
7989 {
7990 CFStringRef key = CFArrayGetValueAtIndex(inkeys, j);
7991 CFStringRef ifname = NULL;
7992
7993 char buf[256];
7994
7995 // It would be nice to use a regex here
7996 if (!CFStringHasPrefix(key, CFSTR("State:/Network/Interface/")) || !CFStringHasSuffix(key, kSCEntNetIPv4)) continue;
7997
7998 if ((ifname = CopyNameFromKey(key)) == NULL) continue;
7999 if (mDNS_LoggingEnabled)
8000 {
8001 if (!CFStringGetCString(ifname, buf, sizeof(buf), kCFStringEncodingUTF8)) buf[0] = 0;
8002 LogInfo("ChangedKeysHaveIPv4LL: potential ifname %s", buf);
8003 }
8004
8005 for (i = 0; i < ic; i++)
8006 {
8007 CFDictionaryRef ipv4dict;
8008 CFStringRef name;
8009 CFStringRef serviceid;
8010 CFStringRef configmethod;
8011
8012 if (!CFStringHasSuffix(keys[i], kSCEntNetInterface)) continue;
8013
8014 if (CFDictionaryGetTypeID() != CFGetTypeID(vals[i])) continue;
8015
8016 if ((name = CFDictionaryGetValue(vals[i], kSCPropNetInterfaceDeviceName)) == NULL) continue;
8017
8018 if (!CFEqual(ifname, name)) continue;
8019
8020 if ((serviceid = CopyNameFromKey(keys[i])) == NULL) continue;
8021 if (mDNS_LoggingEnabled)
8022 {
8023 if (!CFStringGetCString(serviceid, buf, sizeof(buf), kCFStringEncodingUTF8)) buf[0] = 0;
8024 LogInfo("ChangedKeysHaveIPv4LL: found serviceid %s", buf);
8025 }
8026
8027 pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, kSCDynamicStoreDomainSetup, serviceid, kSCEntNetIPv4);
8028 CFRelease(serviceid);
8029 if (pattern == NULL) continue;
8030
8031 ipv4dict = CFDictionaryGetValue(dict, pattern);
8032 CFRelease(pattern);
8033 if (!ipv4dict || CFDictionaryGetTypeID() != CFGetTypeID(ipv4dict)) continue;
8034
8035 configmethod = CFDictionaryGetValue(ipv4dict, kSCPropNetIPv4ConfigMethod);
8036 if (!configmethod) continue;
8037
8038 if (mDNS_LoggingEnabled)
8039 {
8040 if (!CFStringGetCString(configmethod, buf, sizeof(buf), kCFStringEncodingUTF8)) buf[0] = 0;
8041 LogInfo("ChangedKeysHaveIPv4LL: configmethod %s", buf);
8042 }
8043
8044 if (CFEqual(configmethod, kSCValNetIPv4ConfigMethodLinkLocal)) { found = mDNStrue; break; }
8045 }
8046
8047 CFRelease(ifname);
8048 }
8049
8050 done:
8051 if (vals != NULL) mDNSPlatformMemFree(vals);
8052 if (keys != NULL) mDNSPlatformMemFree(keys);
8053 if (dict != NULL) CFRelease(dict);
8054 if (store != NULL) CFRelease(store);
8055
8056 return found;
8057 }
8058
8059 mDNSlocal void NetworkChanged(SCDynamicStoreRef store, CFArrayRef changedKeys, void *context)
8060 {
8061 (void)store; // Parameter not used
8062 mDNSBool changeNow = mDNSfalse;
8063 mDNS *const m = (mDNS *const)context;
8064 KQueueLock(m);
8065 mDNS_Lock(m);
8066
8067 mDNSs32 delay = mDNSPlatformOneSecond * 2; // Start off assuming a two-second delay
8068
8069 int c = CFArrayGetCount(changedKeys); // Count changes
8070 CFRange range = { 0, c };
8071 int c1 = (CFArrayContainsValue(changedKeys, range, NetworkChangedKey_Hostnames ) != 0);
8072 int c2 = (CFArrayContainsValue(changedKeys, range, NetworkChangedKey_Computername) != 0);
8073 int c3 = (CFArrayContainsValue(changedKeys, range, NetworkChangedKey_DynamicDNS ) != 0);
8074 int c4 = (CFArrayContainsValue(changedKeys, range, NetworkChangedKey_DNS ) != 0);
8075 if (c && c - c1 - c2 - c3 - c4 == 0)
8076 delay = mDNSPlatformOneSecond/10; // If these were the only changes, shorten delay
8077
8078 // Do immediate network changed processing for "p2p*" interfaces and
8079 // for interfaces with the IFEF_DIRECTLINK flag set.
8080 {
8081 CFArrayRef labels;
8082 CFIndex n;
8083 for (int i = 0; i < c; i++)
8084 {
8085 CFStringRef key = CFArrayGetValueAtIndex(changedKeys, i);
8086
8087 // Only look at keys with prefix "State:/Network/Interface/"
8088 if (!CFStringHasPrefix(key, NetworkChangedKey_StateInterfacePrefix))
8089 continue;
8090
8091 // And suffix "IPv6" or "IPv4".
8092 if (!CFStringHasSuffix(key, kSCEntNetIPv6) && !CFStringHasSuffix(key, kSCEntNetIPv4))
8093 continue;
8094
8095 labels = CFStringCreateArrayBySeparatingStrings(NULL, key, CFSTR("/"));
8096 if (labels == NULL)
8097 break;
8098 n = CFArrayGetCount(labels);
8099
8100 // Interface changes will have keys of the form:
8101 // State:/Network/Interface/<interfaceName>/IPv6
8102 // Thus five '/' seperated fields, the 4th one being the <interfaceName> string.
8103 if (n == 5)
8104 {
8105 char buf[256];
8106
8107 // The 4th label (index = 3) should be the interface name.
8108 if (CFStringGetCString(CFArrayGetValueAtIndex(labels, 3), buf, sizeof(buf), kCFStringEncodingUTF8)
8109 && (strstr(buf, "p2p") || (getExtendedFlags(buf) & IFEF_DIRECTLINK)))
8110 {
8111 LogInfo("NetworkChanged: interface %s, not delaying network change", buf);
8112 changeNow = mDNStrue;
8113 CFRelease(labels);
8114 break;
8115 }
8116 }
8117 CFRelease(labels);
8118 }
8119 }
8120
8121 mDNSBool btmmChanged = CFArrayContainsValue(changedKeys, range, NetworkChangedKey_BackToMyMac);
8122 if (btmmChanged) delay = 0;
8123
8124 if (mDNS_LoggingEnabled)
8125 {
8126 int i;
8127 for (i=0; i<c; i++)
8128 {
8129 char buf[256];
8130 if (!CFStringGetCString(CFArrayGetValueAtIndex(changedKeys, i), buf, sizeof(buf), kCFStringEncodingUTF8)) buf[0] = 0;
8131 LogInfo("*** NetworkChanged SC key: %s", buf);
8132 }
8133 LogInfo("*** NetworkChanged *** %d change%s %s%s%s%sdelay %d",
8134 c, c>1 ? "s" : "",
8135 c1 ? "(Local Hostname) " : "",
8136 c2 ? "(Computer Name) " : "",
8137 c3 ? "(DynamicDNS) " : "",
8138 c4 ? "(DNS) " : "",
8139 changeNow ? 0 : delay);
8140 }
8141
8142 if (!changeNow)
8143 SetNetworkChanged(m, delay);
8144
8145 // Other software might pick up these changes to register or browse in WAB or BTMM domains,
8146 // so in order for secure updates to be made to the server, make sure to read the keychain and
8147 // setup the DomainAuthInfo before handing the network change.
8148 // If we don't, then we will first try to register services in the clear, then later setup the
8149 // DomainAuthInfo, which is incorrect.
8150 if (c3 || btmmChanged)
8151 SetKeyChainTimer(m, delay);
8152
8153 mDNS_Unlock(m);
8154
8155 // If DNS settings changed, immediately force a reconfig (esp. cache flush)
8156 // Similarly, if an interface changed that is explicitly IPv4 link local, immediately force a reconfig
8157 if (c4 || ChangedKeysHaveIPv4LL(changedKeys) || changeNow) mDNSMacOSXNetworkChanged(m);
8158
8159 KQueueUnlock(m, "NetworkChanged");
8160 }
8161
8162 #if APPLE_OSX_mDNSResponder
8163 mDNSlocal void RefreshSPSStatus(const void *key, const void *value, void *context)
8164 {
8165 (void)context;
8166 char buf[IFNAMSIZ];
8167
8168 CFStringRef ifnameStr = (CFStringRef)key;
8169 CFArrayRef array = (CFArrayRef)value;
8170 if (!CFStringGetCString(ifnameStr, buf, sizeof(buf), kCFStringEncodingUTF8))
8171 buf[0] = 0;
8172
8173 LogInfo("RefreshSPSStatus: Updating SPS state for key %s, array count %d", buf, CFArrayGetCount(array));
8174 mDNSDynamicStoreSetConfig(kmDNSSleepProxyServersState, buf, value);
8175 }
8176 #endif
8177
8178 mDNSlocal void DynamicStoreReconnected(SCDynamicStoreRef store, void *info)
8179 {
8180 mDNS *const m = (mDNS *const)info;
8181 (void)store;
8182
8183 LogInfo("DynamicStoreReconnected: Reconnected");
8184
8185 // State:/Network/MulticastDNS
8186 SetLocalDomains();
8187
8188 // State:/Network/DynamicDNS
8189 if (m->FQDN.c[0])
8190 mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1);
8191
8192 // Note: PrivateDNS and BackToMyMac are automatically populated when configd is restarted
8193 // as we receive network change notifications and thus not necessary. But we leave it here
8194 // so that if things are done differently in the future, this code still works.
8195
8196 // State:/Network/PrivateDNS
8197 if (privateDnsArray)
8198 mDNSDynamicStoreSetConfig(kmDNSPrivateConfig, mDNSNULL, privateDnsArray);
8199
8200 #if APPLE_OSX_mDNSResponder
8201 mDNS_Lock(m);
8202 // State:/Network/BackToMyMac
8203 UpdateAutoTunnelDomainStatuses(m);
8204 mDNS_Unlock(m);
8205
8206 // State:/Network/Interface/en0/SleepProxyServers
8207 if (spsStatusDict)
8208 CFDictionaryApplyFunction(spsStatusDict, RefreshSPSStatus, NULL);
8209 #endif
8210 }
8211
8212 mDNSlocal mStatus WatchForNetworkChanges(mDNS *const m)
8213 {
8214 mStatus err = -1;
8215 SCDynamicStoreContext context = { 0, m, NULL, NULL, NULL };
8216 SCDynamicStoreRef store = SCDynamicStoreCreate(NULL, CFSTR("mDNSResponder:WatchForNetworkChanges"), NetworkChanged, &context);
8217 CFMutableArrayRef keys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
8218 CFStringRef pattern1 = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL, kSCDynamicStoreDomainState, kSCCompAnyRegex, kSCEntNetIPv4);
8219 CFStringRef pattern2 = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL, kSCDynamicStoreDomainState, kSCCompAnyRegex, kSCEntNetIPv6);
8220 CFMutableArrayRef patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
8221
8222 if (!store) { LogMsg("SCDynamicStoreCreate failed: %s", SCErrorString(SCError())); goto error; }
8223 if (!keys || !pattern1 || !pattern2 || !patterns) goto error;
8224
8225 CFArrayAppendValue(keys, NetworkChangedKey_IPv4);
8226 CFArrayAppendValue(keys, NetworkChangedKey_IPv6);
8227 CFArrayAppendValue(keys, NetworkChangedKey_Hostnames);
8228 CFArrayAppendValue(keys, NetworkChangedKey_Computername);
8229 CFArrayAppendValue(keys, NetworkChangedKey_DNS);
8230 CFArrayAppendValue(keys, NetworkChangedKey_DynamicDNS);
8231 CFArrayAppendValue(keys, NetworkChangedKey_BackToMyMac);
8232 CFArrayAppendValue(keys, NetworkChangedKey_PowerSettings); // should remove as part of <rdar://problem/6751656>
8233 CFArrayAppendValue(keys, NetworkChangedKey_BTMMConnectivity);
8234 CFArrayAppendValue(patterns, pattern1);
8235 CFArrayAppendValue(patterns, pattern2);
8236 CFArrayAppendValue(patterns, CFSTR("State:/Network/Interface/[^/]+/AirPort"));
8237 if (!SCDynamicStoreSetNotificationKeys(store, keys, patterns))
8238 { LogMsg("SCDynamicStoreSetNotificationKeys failed: %s", SCErrorString(SCError())); goto error; }
8239
8240 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
8241 if (!SCDynamicStoreSetDispatchQueue(store, dispatch_get_main_queue()))
8242 { LogMsg("SCDynamicStoreCreateRunLoopSource failed: %s", SCErrorString(SCError())); goto error; }
8243 #else
8244 m->p->StoreRLS = SCDynamicStoreCreateRunLoopSource(NULL, store, 0);
8245 if (!m->p->StoreRLS) { LogMsg("SCDynamicStoreCreateRunLoopSource failed: %s", SCErrorString(SCError())); goto error; }
8246 CFRunLoopAddSource(CFRunLoopGetCurrent(), m->p->StoreRLS, kCFRunLoopDefaultMode);
8247 #endif
8248 SCDynamicStoreSetDisconnectCallBack(store, DynamicStoreReconnected);
8249 m->p->Store = store;
8250 err = 0;
8251 goto exit;
8252
8253 error:
8254 if (store) CFRelease(store);
8255
8256 exit:
8257 if (patterns) CFRelease(patterns);
8258 if (pattern2) CFRelease(pattern2);
8259 if (pattern1) CFRelease(pattern1);
8260 if (keys) CFRelease(keys);
8261
8262 return(err);
8263 }
8264
8265 #if 0 // <rdar://problem/6751656>
8266 mDNSlocal void PMChanged(void *context)
8267 {
8268 mDNS *const m = (mDNS *const)context;
8269
8270 KQueueLock(m);
8271 mDNS_Lock(m);
8272
8273 LogSPS("PMChanged");
8274
8275 SetNetworkChanged(m, mDNSPlatformOneSecond * 2);
8276
8277 mDNS_Unlock(m);
8278 KQueueUnlock(m, "PMChanged");
8279 }
8280
8281 mDNSlocal mStatus WatchForPMChanges(mDNS *const m)
8282 {
8283 m->p->PMRLS = IOPMPrefsNotificationCreateRunLoopSource(PMChanged, m);
8284 if (!m->p->PMRLS) { LogMsg("IOPMPrefsNotificationCreateRunLoopSource failed!"); return mStatus_UnknownErr; }
8285
8286 CFRunLoopAddSource(CFRunLoopGetCurrent(), m->p->PMRLS, kCFRunLoopDefaultMode);
8287
8288 return mStatus_NoError;
8289 }
8290 #endif
8291
8292 #if !TARGET_OS_EMBEDDED // don't setup packet filter rules on embedded
8293
8294 mDNSlocal void mDNSSetPacketFilterRules(mDNS *const m, char * ifname, const ResourceRecord *const excludeRecord)
8295 {
8296 AuthRecord *rr;
8297 pfArray_t portArray;
8298 pfArray_t protocolArray;
8299 uint32_t count = 0;
8300
8301 for (rr = m->ResourceRecords; rr; rr=rr->next)
8302 {
8303 if ((rr->resrec.rrtype == kDNSServiceType_SRV)
8304 && ((rr->ARType == AuthRecordAnyIncludeP2P) || (rr->ARType == AuthRecordAnyIncludeAWDLandP2P)))
8305 {
8306 const mDNSu8 *p;
8307
8308 if (count >= PFPortArraySize)
8309 {
8310 LogMsg("mDNSSetPacketFilterRules: %d service limit, skipping %s", PFPortArraySize, ARDisplayString(m, rr));
8311 continue;
8312 }
8313
8314 if (excludeRecord && IdenticalResourceRecord(&rr->resrec, excludeRecord))
8315 {
8316 LogInfo("mDNSSetPacketFilterRules: record being removed, skipping %s", ARDisplayString(m, rr));
8317 continue;
8318 }
8319
8320 LogInfo("mDNSSetPacketFilterRules: found %s", ARDisplayString(m, rr));
8321
8322 portArray[count] = rr->resrec.rdata->u.srv.port.NotAnInteger;
8323
8324 // Assume <Service Instance>.<App Protocol>.<Transport Protocol>.<Name>
8325 p = rr->resrec.name->c;
8326
8327 // Skip to App Protocol
8328 if (p[0]) p += 1 + p[0];
8329
8330 // Skip to Transport Protocol
8331 if (p[0]) p += 1 + p[0];
8332
8333 if (SameDomainLabel(p, (mDNSu8 *)"\x4" "_tcp")) protocolArray[count] = IPPROTO_TCP;
8334 else if (SameDomainLabel(p, (mDNSu8 *)"\x4" "_udp")) protocolArray[count] = IPPROTO_UDP;
8335 else
8336 {
8337 LogMsg("mDNSSetPacketFilterRules: could not determine transport protocol of service");
8338 LogMsg("mDNSSetPacketFilterRules: %s", ARDisplayString(m, rr));
8339 return;
8340 }
8341 count++;
8342 }
8343 }
8344 mDNSPacketFilterControl(PF_SET_RULES, ifname, count, portArray, protocolArray);
8345 }
8346
8347 // If the p2p interface already exists, update the Bonjour packet filter rules for it.
8348 mDNSexport void mDNSUpdatePacketFilter(const ResourceRecord *const excludeRecord)
8349 {
8350 mDNS *const m = &mDNSStorage;
8351
8352 NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
8353 while (intf)
8354 {
8355 if (strncmp(intf->ifname, "p2p", 3) == 0)
8356 {
8357 LogInfo("mDNSInitPacketFilter: Setting rules for ifname %s", intf->ifname);
8358 mDNSSetPacketFilterRules(m, intf->ifname, excludeRecord);
8359 break;
8360 }
8361 intf = GetFirstActiveInterface(intf->next);
8362 }
8363 }
8364
8365 #else // !TARGET_OS_EMBEDDED
8366
8367 // Currently no packet filter setup required on embedded platforms.
8368 mDNSexport void mDNSUpdatePacketFilter(const ResourceRecord *const excludeRecord)
8369 {
8370 (void) excludeRecord; // unused
8371 }
8372
8373 #endif // !TARGET_OS_EMBEDDED
8374
8375 // Handle AWDL KEV_DL_MASTER_ELECTED event by restarting queries and advertisements
8376 // marked to include the AWDL interface.
8377 mDNSlocal void newMasterElected(mDNS *const m, struct net_event_data * ptr)
8378 {
8379 char ifname[IFNAMSIZ];
8380 mDNSu32 interfaceIndex;
8381 DNSQuestion *q;
8382 AuthRecord *rr;
8383 NetworkInterfaceInfoOSX *infoOSX;
8384 mDNSInterfaceID InterfaceID;
8385
8386 snprintf(ifname, IFNAMSIZ, "%s%d", ptr->if_name, ptr->if_unit);
8387 interfaceIndex = if_nametoindex(ifname);
8388
8389 if (!interfaceIndex)
8390 {
8391 LogMsg("newMasterElected: if_nametoindex(%s) failed", ifname);
8392 return;
8393 }
8394
8395 LogInfo("newMasterElected: ifname = %s, interfaceIndex = %d", ifname, interfaceIndex);
8396 infoOSX = IfindexToInterfaceInfoOSX(m, (mDNSInterfaceID)(uintptr_t)interfaceIndex);
8397
8398 // Can get an KEV_DL_MASTER_ELECTED event prior to the interface existing
8399 // when it is first brought up.
8400 if (!infoOSX)
8401 {
8402 LogInfo("newMasterElected: interface not yet active");
8403 return;
8404 }
8405 InterfaceID = infoOSX->ifinfo.InterfaceID;
8406
8407 for (q = m->Questions; q; q=q->next)
8408 {
8409 if ((!q->InterfaceID && (q->flags & kDNSServiceFlagsIncludeAWDL))
8410 || q->InterfaceID == InterfaceID)
8411 {
8412 LogInfo("newMasterElected: restarting %s query for %##s", DNSTypeName(q->qtype), q->qname.c);
8413 mDNSCoreRestartQuestion(m, q);
8414 }
8415 }
8416
8417 for (rr = m->ResourceRecords; rr; rr=rr->next)
8418 {
8419 if ((!rr->resrec.InterfaceID
8420 && ((rr->ARType == AuthRecordAnyIncludeAWDL) || ((rr->ARType == AuthRecordAnyIncludeAWDLandP2P))))
8421 || rr->resrec.InterfaceID == InterfaceID)
8422 {
8423 LogInfo("newMasterElected: restarting %s announcements for %##s", DNSTypeName(rr->resrec.rrtype), rr->namestorage.c);
8424 mDNSCoreRestartRegistration(m, rr, -1);
8425 }
8426 }
8427 }
8428
8429 // An ssth array of all zeroes indicates the peer has no services registered.
8430 mDNSlocal mDNSBool allZeroSSTH(struct opaque_presence_indication *op)
8431 {
8432 int i;
8433 int *intp = (int *) op->ssth;
8434
8435 // MAX_SSTH_SIZE should always be a multiple of sizeof(int), if
8436 // it's not, print an error message and return false so that
8437 // corresponding peer records are not flushed when KEV_DL_NODE_PRESENCE event
8438 // is received.
8439 if (MAX_SSTH_SIZE % sizeof(int))
8440 {
8441 LogInfo("allZeroSSTH: MAX_SSTH_SIZE = %d not a multiple of sizeof(int)", MAX_SSTH_SIZE);
8442 return mDNSfalse;
8443 }
8444
8445 for (i = 0; i < (int)(MAX_SSTH_SIZE / sizeof(int)); i++, intp++)
8446 {
8447 if (*intp)
8448 return mDNSfalse;
8449 }
8450 return mDNStrue;
8451 }
8452
8453 // mDNS_Reconfirm_internal() adds 33% to this interval, so the records should
8454 // be removed in 4 seconds.
8455 #define kAWDLReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 3)
8456
8457 // Mark records from this peer for deletion from the cache.
8458 mDNSlocal void removeCachedPeerRecords(mDNS *const m, mDNSu32 ifindex, mDNSAddr *ap)
8459 {
8460 mDNSu32 slot;
8461 CacheGroup *cg;
8462 CacheRecord *cr;
8463 mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(m, ifindex);
8464
8465 if (!InterfaceID)
8466 {
8467 LogInfo("removeCachedPeerRecords: Invalid ifindex: %d", ifindex);
8468 return;
8469 }
8470
8471 FORALL_CACHERECORDS(slot, cg, cr)
8472 {
8473 if ((InterfaceID == cr->resrec.InterfaceID) && mDNSSameAddress(ap, & cr->sourceAddress))
8474 {
8475 LogInfo("removeCachedPeerRecords: %s %##s marking for deletion",
8476 DNSTypeName(cr->resrec.rrtype), cr->resrec.name->c);
8477 mDNS_Reconfirm_internal(m, cr, kAWDLReconfirmTime);
8478 }
8479 }
8480 }
8481
8482 // Handle KEV_DL_NODE_PRESENCE event.
8483 mDNSlocal void nodePresence(mDNS *const m, struct kev_dl_node_presence * p)
8484 {
8485 char buf[INET6_ADDRSTRLEN];
8486 struct opaque_presence_indication *op = (struct opaque_presence_indication *) p->node_service_info;
8487
8488 if (inet_ntop(AF_INET6, & p->sin6_node_address.sin6_addr, buf, sizeof(buf)))
8489 LogInfo("nodePresence: IPv6 address: %s, SUI %d", buf, op->SUI);
8490 else
8491 LogInfo("nodePresence: inet_ntop() error");
8492
8493 // AWDL will generate a KEV_DL_NODE_PRESENCE event with SSTH field of
8494 // all zeroes when a node is present and has no services registered.
8495 if (allZeroSSTH(op))
8496 {
8497 mDNSAddr peerAddr;
8498
8499 peerAddr.type = mDNSAddrType_IPv6;
8500 peerAddr.ip.v6 = *(mDNSv6Addr*)&p->sin6_node_address.sin6_addr;
8501
8502 LogInfo("nodePresence: ssth is all zeroes, delete cached records from this peer");
8503 removeCachedPeerRecords(m, p->sdl_node_address.sdl_index, & peerAddr);
8504 }
8505 }
8506
8507 // Handle KEV_DL_NODE_ABSENCE event.
8508 mDNSlocal void nodeAbsence(mDNS *const m, struct kev_dl_node_absence * p)
8509 {
8510 mDNSAddr peerAddr;
8511 char buf[INET6_ADDRSTRLEN];
8512
8513 if (inet_ntop(AF_INET6, & p->sin6_node_address.sin6_addr, buf, sizeof(buf)))
8514 LogInfo("nodeAbsence: IPv6 address: %s", buf);
8515 else
8516 LogInfo("nodeAbsence: inet_ntop() error");
8517
8518 peerAddr.type = mDNSAddrType_IPv6;
8519 peerAddr.ip.v6 = *(mDNSv6Addr*)&p->sin6_node_address.sin6_addr;
8520
8521 LogInfo("nodeAbsence: delete cached records from this peer");
8522 removeCachedPeerRecords(m, p->sdl_node_address.sdl_index, & peerAddr);
8523 }
8524
8525 mDNSlocal void SysEventCallBack(int s1, short __unused filter, void *context)
8526 {
8527 mDNS *const m = (mDNS *const)context;
8528
8529 mDNS_Lock(m);
8530
8531 struct { struct kern_event_msg k; char extra[256]; } msg;
8532 int bytes = recv(s1, &msg, sizeof(msg), 0);
8533 if (bytes < 0)
8534 LogMsg("SysEventCallBack: recv error %d errno %d (%s)", bytes, errno, strerror(errno));
8535 else
8536 {
8537 LogInfo("SysEventCallBack got %d bytes size %d %X %s %X %s %X %s id %d code %d %s",
8538 bytes, msg.k.total_size,
8539 msg.k.vendor_code, msg.k.vendor_code == KEV_VENDOR_APPLE ? "KEV_VENDOR_APPLE" : "?",
8540 msg.k.kev_class, msg.k.kev_class == KEV_NETWORK_CLASS ? "KEV_NETWORK_CLASS" : "?",
8541 msg.k.kev_subclass, msg.k.kev_subclass == KEV_DL_SUBCLASS ? "KEV_DL_SUBCLASS" : "?",
8542 msg.k.id, msg.k.event_code,
8543 msg.k.event_code == KEV_DL_SIFFLAGS ? "KEV_DL_SIFFLAGS" :
8544 msg.k.event_code == KEV_DL_SIFMETRICS ? "KEV_DL_SIFMETRICS" :
8545 msg.k.event_code == KEV_DL_SIFMTU ? "KEV_DL_SIFMTU" :
8546 msg.k.event_code == KEV_DL_SIFPHYS ? "KEV_DL_SIFPHYS" :
8547 msg.k.event_code == KEV_DL_SIFMEDIA ? "KEV_DL_SIFMEDIA" :
8548 msg.k.event_code == KEV_DL_SIFGENERIC ? "KEV_DL_SIFGENERIC" :
8549 msg.k.event_code == KEV_DL_ADDMULTI ? "KEV_DL_ADDMULTI" :
8550 msg.k.event_code == KEV_DL_DELMULTI ? "KEV_DL_DELMULTI" :
8551 msg.k.event_code == KEV_DL_IF_ATTACHED ? "KEV_DL_IF_ATTACHED" :
8552 msg.k.event_code == KEV_DL_IF_DETACHING ? "KEV_DL_IF_DETACHING" :
8553 msg.k.event_code == KEV_DL_IF_DETACHED ? "KEV_DL_IF_DETACHED" :
8554 msg.k.event_code == KEV_DL_LINK_OFF ? "KEV_DL_LINK_OFF" :
8555 msg.k.event_code == KEV_DL_LINK_ON ? "KEV_DL_LINK_ON" :
8556 msg.k.event_code == KEV_DL_PROTO_ATTACHED ? "KEV_DL_PROTO_ATTACHED" :
8557 msg.k.event_code == KEV_DL_PROTO_DETACHED ? "KEV_DL_PROTO_DETACHED" :
8558 msg.k.event_code == KEV_DL_LINK_ADDRESS_CHANGED ? "KEV_DL_LINK_ADDRESS_CHANGED" :
8559 msg.k.event_code == KEV_DL_WAKEFLAGS_CHANGED ? "KEV_DL_WAKEFLAGS_CHANGED" :
8560 msg.k.event_code == KEV_DL_IF_IDLE_ROUTE_REFCNT ? "KEV_DL_IF_IDLE_ROUTE_REFCNT" :
8561 msg.k.event_code == KEV_DL_IFCAP_CHANGED ? "KEV_DL_IFCAP_CHANGED" :
8562 msg.k.event_code == KEV_DL_LINK_QUALITY_METRIC_CHANGED ? "KEV_DL_LINK_QUALITY_METRIC_CHANGED" :
8563 msg.k.event_code == KEV_DL_NODE_PRESENCE ? "KEV_DL_NODE_PRESENCE" :
8564 msg.k.event_code == KEV_DL_NODE_ABSENCE ? "KEV_DL_NODE_ABSENCE" :
8565 msg.k.event_code == KEV_DL_MASTER_ELECTED ? "KEV_DL_MASTER_ELECTED" :
8566 "?");
8567
8568 if (msg.k.event_code == KEV_DL_NODE_PRESENCE)
8569 nodePresence(m, (struct kev_dl_node_presence *) &msg.k.event_data);
8570
8571 if (msg.k.event_code == KEV_DL_NODE_ABSENCE)
8572 nodeAbsence(m, (struct kev_dl_node_absence *) &msg.k.event_data);
8573
8574 if (msg.k.event_code == KEV_DL_MASTER_ELECTED)
8575 newMasterElected(m, (struct net_event_data *) &msg.k.event_data);
8576
8577 // We receive network change notifications both through configd and through SYSPROTO_EVENT socket.
8578 // Configd may not generate network change events for manually configured interfaces (i.e., non-DHCP)
8579 // always during sleep/wakeup due to some race conditions (See radar:8666757). At the same time, if
8580 // "Wake on Network Access" is not turned on, the notification will not have KEV_DL_WAKEFLAGS_CHANGED.
8581 // Hence, during wake up, if we see a KEV_DL_LINK_ON (i.e., link is UP), we trigger a network change.
8582
8583 if (msg.k.event_code == KEV_DL_WAKEFLAGS_CHANGED || msg.k.event_code == KEV_DL_LINK_ON)
8584 SetNetworkChanged(m, mDNSPlatformOneSecond * 2);
8585
8586 #if !TARGET_OS_EMBEDDED // don't setup packet filter rules on embedded
8587
8588 // For p2p interfaces, need to open the advertised service port in the firewall.
8589 if (msg.k.event_code == KEV_DL_IF_ATTACHED)
8590 {
8591 struct net_event_data * p;
8592 p = (struct net_event_data *) &msg.k.event_data;
8593
8594 if (strncmp(p->if_name, "p2p", 3) == 0)
8595 {
8596 char ifname[IFNAMSIZ];
8597 snprintf(ifname, IFNAMSIZ, "%s%d", p->if_name, p->if_unit);
8598
8599 LogInfo("SysEventCallBack: KEV_DL_IF_ATTACHED if_family = %d, if_unit = %d, if_name = %s", p->if_family, p->if_unit, p->if_name);
8600
8601 mDNSSetPacketFilterRules(m, ifname, NULL);
8602 }
8603 }
8604
8605 // For p2p interfaces, need to clear the firewall rules on interface detach
8606 if (msg.k.event_code == KEV_DL_IF_DETACHED)
8607 {
8608 struct net_event_data * p;
8609 p = (struct net_event_data *) &msg.k.event_data;
8610
8611 if (strncmp(p->if_name, "p2p", 3) == 0)
8612 {
8613 pfArray_t portArray, protocolArray; // not initialized since count is 0 for PF_CLEAR_RULES
8614 char ifname[IFNAMSIZ];
8615 snprintf(ifname, IFNAMSIZ, "%s%d", p->if_name, p->if_unit);
8616
8617 LogInfo("SysEventCallBack: KEV_DL_IF_DETACHED if_family = %d, if_unit = %d, if_name = %s", p->if_family, p->if_unit, p->if_name);
8618
8619 mDNSPacketFilterControl(PF_CLEAR_RULES, ifname, 0, portArray, protocolArray);
8620 }
8621 }
8622 #endif // !TARGET_OS_EMBEDDED
8623
8624 }
8625
8626 mDNS_Unlock(m);
8627 }
8628
8629 mDNSlocal mStatus WatchForSysEvents(mDNS *const m)
8630 {
8631 m->p->SysEventNotifier = socket(PF_SYSTEM, SOCK_RAW, SYSPROTO_EVENT);
8632 if (m->p->SysEventNotifier < 0)
8633 { LogMsg("WatchForSysEvents: socket failed error %d errno %d (%s)", m->p->SysEventNotifier, errno, strerror(errno)); return(mStatus_NoMemoryErr); }
8634
8635 struct kev_request kev_req = { KEV_VENDOR_APPLE, KEV_NETWORK_CLASS, KEV_DL_SUBCLASS };
8636 int err = ioctl(m->p->SysEventNotifier, SIOCSKEVFILT, &kev_req);
8637 if (err < 0)
8638 {
8639 LogMsg("WatchForSysEvents: SIOCSKEVFILT failed error %d errno %d (%s)", err, errno, strerror(errno));
8640 close(m->p->SysEventNotifier);
8641 m->p->SysEventNotifier = -1;
8642 return(mStatus_UnknownErr);
8643 }
8644
8645 m->p->SysEventKQueue.KQcallback = SysEventCallBack;
8646 m->p->SysEventKQueue.KQcontext = m;
8647 m->p->SysEventKQueue.KQtask = "System Event Notifier";
8648 KQueueSet(m->p->SysEventNotifier, EV_ADD, EVFILT_READ, &m->p->SysEventKQueue);
8649
8650 return(mStatus_NoError);
8651 }
8652
8653 #ifndef NO_SECURITYFRAMEWORK
8654 mDNSlocal OSStatus KeychainChanged(SecKeychainEvent keychainEvent, SecKeychainCallbackInfo *info, void *context)
8655 {
8656 LogInfo("*** Keychain Changed ***");
8657 mDNS *const m = (mDNS *const)context;
8658 SecKeychainRef skc;
8659 OSStatus err = SecKeychainCopyDefault(&skc);
8660 if (!err)
8661 {
8662 if (info->keychain == skc)
8663 {
8664 // For delete events, attempt to verify what item was deleted fail because the item is already gone, so we just assume they may be relevant
8665 mDNSBool relevant = (keychainEvent == kSecDeleteEvent);
8666 if (!relevant)
8667 {
8668 UInt32 tags[3] = { kSecTypeItemAttr, kSecServiceItemAttr, kSecAccountItemAttr };
8669 SecKeychainAttributeInfo attrInfo = { 3, tags, NULL }; // Count, array of tags, array of formats
8670 SecKeychainAttributeList *a = NULL;
8671 err = SecKeychainItemCopyAttributesAndData(info->item, &attrInfo, NULL, &a, NULL, NULL);
8672 if (!err)
8673 {
8674 relevant = ((a->attr[0].length == 4 && (!strncasecmp(a->attr[0].data, "ddns", 4) || !strncasecmp(a->attr[0].data, "sndd", 4))) ||
8675 (a->attr[1].length >= mDNSPlatformStrLen(dnsprefix) && (!strncasecmp(a->attr[1].data, dnsprefix, mDNSPlatformStrLen(dnsprefix)))) ||
8676 (a->attr[1].length >= mDNSPlatformStrLen(btmmprefix) && (!strncasecmp(a->attr[1].data, btmmprefix, mDNSPlatformStrLen(btmmprefix)))));
8677 SecKeychainItemFreeAttributesAndData(a, NULL);
8678 }
8679 }
8680 if (relevant)
8681 {
8682 LogInfo("*** Keychain Changed *** KeychainEvent=%d %s",
8683 keychainEvent,
8684 keychainEvent == kSecAddEvent ? "kSecAddEvent" :
8685 keychainEvent == kSecDeleteEvent ? "kSecDeleteEvent" :
8686 keychainEvent == kSecUpdateEvent ? "kSecUpdateEvent" : "<Unknown>");
8687 // We're running on the CFRunLoop (Mach port) thread, not the kqueue thread, so we need to grab the KQueueLock before proceeding
8688 KQueueLock(m);
8689 mDNS_Lock(m);
8690
8691 // To not read the keychain twice: when BTMM is enabled, changes happen to the keychain
8692 // then the BTMM DynStore dictionary, so delay reading the keychain for a second.
8693 // NetworkChanged() will reset the keychain timer to fire immediately when the DynStore changes.
8694 //
8695 // In the "fixup" case where the BTMM DNS servers aren't accepting the key mDNSResponder has,
8696 // the DynStore dictionary won't change (because the BTMM zone won't change). In that case,
8697 // a one second delay is ok, as we'll still converge to correctness, and there's no race
8698 // condition between the RegistrationDomain and the DomainAuthInfo.
8699 //
8700 // Lastly, non-BTMM WAB cases can use the keychain but not the DynStore, so we need to set
8701 // the timer here, as it will not get set by NetworkChanged().
8702 SetKeyChainTimer(m, mDNSPlatformOneSecond);
8703
8704 mDNS_Unlock(m);
8705 KQueueUnlock(m, "KeychainChanged");
8706 }
8707 }
8708 CFRelease(skc);
8709 }
8710
8711 return 0;
8712 }
8713 #endif
8714
8715 mDNSlocal void PowerOn(mDNS *const m)
8716 {
8717 mDNSCoreMachineSleep(m, false); // Will set m->SleepState = SleepState_Awake;
8718 if (m->p->WakeAtUTC)
8719 {
8720 long utc = mDNSPlatformUTC();
8721 mDNSPowerRequest(-1,-1); // Need to explicitly clear any previous power requests -- they're not cleared automatically on wake
8722 if (m->p->WakeAtUTC - utc > 30)
8723 {
8724 LogSPS("PowerChanged PowerOn %d seconds early, assuming not maintenance wake", m->p->WakeAtUTC - utc);
8725 }
8726 else if (utc - m->p->WakeAtUTC > 30)
8727 {
8728 LogSPS("PowerChanged PowerOn %d seconds late, assuming not maintenance wake", utc - m->p->WakeAtUTC);
8729 }
8730 else if (IsAppleTV())
8731 {
8732 LogSPS("PowerChanged PowerOn %d seconds late, device is an AppleTV running iOS so not re-sleeping", utc - m->p->WakeAtUTC);
8733 }
8734 else
8735 {
8736 LogSPS("PowerChanged: Waking for network maintenance operations %d seconds early; re-sleeping in 20 seconds", m->p->WakeAtUTC - utc);
8737 m->p->RequestReSleep = mDNS_TimeNow(m) + 20 * mDNSPlatformOneSecond;
8738 }
8739 }
8740 }
8741
8742 mDNSlocal void PowerChanged(void *refcon, io_service_t service, natural_t messageType, void *messageArgument)
8743 {
8744 mDNS *const m = (mDNS *const)refcon;
8745 KQueueLock(m);
8746 (void)service; // Parameter not used
8747 debugf("PowerChanged %X %lX", messageType, messageArgument);
8748
8749 // Make sure our m->SystemWakeOnLANEnabled value correctly reflects the current system setting
8750 m->SystemWakeOnLANEnabled = SystemWakeForNetworkAccess();
8751
8752 switch(messageType)
8753 {
8754 case kIOMessageCanSystemPowerOff: LogSPS("PowerChanged kIOMessageCanSystemPowerOff (no action)"); break; // E0000240
8755 case kIOMessageSystemWillPowerOff: LogSPS("PowerChanged kIOMessageSystemWillPowerOff"); // E0000250
8756 mDNSCoreMachineSleep(m, true);
8757 if (m->SleepState == SleepState_Sleeping) mDNSMacOSXNetworkChanged(m);
8758 break;
8759 case kIOMessageSystemWillNotPowerOff: LogSPS("PowerChanged kIOMessageSystemWillNotPowerOff (no action)"); break; // E0000260
8760 case kIOMessageCanSystemSleep: LogSPS("PowerChanged kIOMessageCanSystemSleep (no action)"); break; // E0000270
8761 case kIOMessageSystemWillSleep: LogSPS("PowerChanged kIOMessageSystemWillSleep"); // E0000280
8762 mDNSCoreMachineSleep(m, true);
8763 break;
8764 case kIOMessageSystemWillNotSleep: LogSPS("PowerChanged kIOMessageSystemWillNotSleep (no action)"); break; // E0000290
8765 case kIOMessageSystemHasPoweredOn: LogSPS("PowerChanged kIOMessageSystemHasPoweredOn"); // E0000300
8766 // If still sleeping (didn't get 'WillPowerOn' message for some reason?) wake now
8767 if (m->SleepState)
8768 {
8769 LogMsg("PowerChanged kIOMessageSystemHasPoweredOn: ERROR m->SleepState %d", m->SleepState);
8770 PowerOn(m);
8771 }
8772 // Just to be safe, schedule a mDNSMacOSXNetworkChanged(), in case we never received
8773 // the System Configuration Framework "network changed" event that we expect
8774 // to receive some time shortly after the kIOMessageSystemWillPowerOn message
8775 mDNS_Lock(m);
8776 if (!m->p->NetworkChanged ||
8777 m->p->NetworkChanged - NonZeroTime(m->timenow + mDNSPlatformOneSecond * 2) < 0)
8778 m->p->NetworkChanged = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 2);
8779 mDNS_Unlock(m);
8780
8781 break;
8782 case kIOMessageSystemWillRestart: LogSPS("PowerChanged kIOMessageSystemWillRestart (no action)"); break; // E0000310
8783 case kIOMessageSystemWillPowerOn: LogSPS("PowerChanged kIOMessageSystemWillPowerOn"); // E0000320
8784
8785 // Make sure our interface list is cleared to the empty state, then tell mDNSCore to wake
8786 if (m->SleepState != SleepState_Sleeping)
8787 {
8788 LogMsg("kIOMessageSystemWillPowerOn: ERROR m->SleepState %d", m->SleepState);
8789 m->SleepState = SleepState_Sleeping;
8790 mDNSMacOSXNetworkChanged(m);
8791 }
8792 PowerOn(m);
8793 break;
8794 default: LogSPS("PowerChanged unknown message %X", messageType); break;
8795 }
8796
8797 if (messageType == kIOMessageSystemWillSleep) m->p->SleepCookie = (long)messageArgument;
8798 else IOAllowPowerChange(m->p->PowerConnection, (long)messageArgument);
8799
8800 KQueueUnlock(m, "PowerChanged Sleep/Wake");
8801 }
8802
8803 // iPhone OS doesn't currently have SnowLeopard's IO Power Management
8804 // but it does define kIOPMAcknowledgmentOptionSystemCapabilityRequirements
8805 #if defined(kIOPMAcknowledgmentOptionSystemCapabilityRequirements) && !TARGET_OS_EMBEDDED
8806 mDNSlocal void SnowLeopardPowerChanged(void *refcon, IOPMConnection connection, IOPMConnectionMessageToken token, IOPMSystemPowerStateCapabilities eventDescriptor)
8807 {
8808 mDNS *const m = (mDNS *const)refcon;
8809 KQueueLock(m);
8810 LogSPS("SnowLeopardPowerChanged %X %X %X%s%s%s%s%s",
8811 connection, token, eventDescriptor,
8812 eventDescriptor & kIOPMSystemPowerStateCapabilityCPU ? " CPU" : "",
8813 eventDescriptor & kIOPMSystemPowerStateCapabilityVideo ? " Video" : "",
8814 eventDescriptor & kIOPMSystemPowerStateCapabilityAudio ? " Audio" : "",
8815 eventDescriptor & kIOPMSystemPowerStateCapabilityNetwork ? " Network" : "",
8816 eventDescriptor & kIOPMSystemPowerStateCapabilityDisk ? " Disk" : "");
8817
8818 // Make sure our m->SystemWakeOnLANEnabled value correctly reflects the current system setting
8819 m->SystemWakeOnLANEnabled = SystemWakeForNetworkAccess();
8820
8821 if (eventDescriptor & kIOPMSystemPowerStateCapabilityCPU)
8822 {
8823 // We might be in Sleeping or Transferring state. When we go from "wakeup" to "sleep" state, we don't
8824 // go directly to sleep state, but transfer in to the sleep state during which SleepState is set to
8825 // SleepState_Transferring. During that time, we might get another wakeup before we transition to Sleeping
8826 // state. In that case, we need to acknowledge the previous "sleep" before we acknowledge the wakeup.
8827 if (m->SleepLimit)
8828 {
8829 LogSPS("SnowLeopardPowerChanged: Waking up, Acking old Sleep, SleepLimit %d SleepState %d", m->SleepLimit, m->SleepState);
8830 IOPMConnectionAcknowledgeEvent(connection, m->p->SleepCookie);
8831 m->SleepLimit = 0;
8832 }
8833 LogSPS("SnowLeopardPowerChanged: Waking up, Acking Wakeup, SleepLimit %d SleepState %d", m->SleepLimit, m->SleepState);
8834 // If the network notifications have already come before we got the wakeup, we ignored them and
8835 // in case we get no more, we need to trigger one.
8836 mDNS_Lock(m);
8837 SetNetworkChanged(m, 2 * mDNSPlatformOneSecond);
8838 mDNS_Unlock(m);
8839 // CPU Waking. Note: Can get this message repeatedly, as other subsystems power up or down.
8840 if (m->SleepState != SleepState_Awake) PowerOn(m);
8841 IOPMConnectionAcknowledgeEvent(connection, token);
8842 }
8843 else
8844 {
8845 // CPU sleeping. Should not get this repeatedly -- once we're told that the CPU is halting
8846 // we should hear nothing more until we're told that the CPU has started executing again.
8847 if (m->SleepState) LogMsg("SnowLeopardPowerChanged: Sleep Error %X m->SleepState %d", eventDescriptor, m->SleepState);
8848 //sleep(5);
8849 //mDNSMacOSXNetworkChanged(m);
8850 mDNSCoreMachineSleep(m, true);
8851 //if (m->SleepState == SleepState_Sleeping) mDNSMacOSXNetworkChanged(m);
8852 m->p->SleepCookie = token;
8853 }
8854
8855 KQueueUnlock(m, "SnowLeopardPowerChanged Sleep/Wake");
8856 }
8857 #endif
8858
8859 #if COMPILER_LIKES_PRAGMA_MARK
8860 #pragma mark -
8861 #pragma mark - /etc/hosts support
8862 #endif
8863
8864 // Implementation Notes
8865 //
8866 // As /etc/hosts file can be huge (1000s of entries - when this comment was written, the test file had about
8867 // 23000 entries with about 4000 duplicates), we can't use a linked list to store these entries. So, we parse
8868 // them into a hash table. The implementation need to be able to do the following things efficiently
8869 //
8870 // 1. Detect duplicates e.g., two entries with "1.2.3.4 foo"
8871 // 2. Detect whether /etc/hosts has changed and what has changed since the last read from the disk
8872 // 3. Ability to support multiple addresses per name e.g., "1.2.3.4 foo, 2.3.4.5 foo". To support this, we
8873 // need to be able set the RRSet of a resource record to the first one in the list and also update when
8874 // one of them go away. This is needed so that the core thinks that they are all part of the same RRSet and
8875 // not a duplicate
8876 // 4. Don't maintain any local state about any records registered with the core to detect changes to /etc/hosts
8877 //
8878 // CFDictionary is not a suitable candidate because it does not support duplicates and even if we use a custom
8879 // "hash" function to solve this, the others are hard to solve. Hence, we share the hash (AuthHash) implementation
8880 // of the core layer which does all of the above very efficiently
8881
8882 #define ETCHOSTS_BUFSIZE 1024 // Buffer size to parse a single line in /etc/hosts
8883
8884 mDNSexport void FreeEtcHosts(mDNS *const m, AuthRecord *const rr, mStatus result)
8885 {
8886 (void)m; // unused
8887 (void)rr;
8888 (void)result;
8889 if (result == mStatus_MemFree)
8890 {
8891 LogInfo("FreeEtcHosts: %s", ARDisplayString(m, rr));
8892 freeL("etchosts", rr);
8893 }
8894 }
8895
8896 // Returns true on success and false on failure
8897 mDNSlocal mDNSBool mDNSMacOSXCreateEtcHostsEntry(mDNS *const m, const domainname *domain, const struct sockaddr *sa, const domainname *cname, char *ifname, AuthHash *auth)
8898 {
8899 AuthRecord *rr;
8900 mDNSu32 slot;
8901 mDNSu32 namehash;
8902 AuthGroup *ag;
8903 mDNSInterfaceID InterfaceID = mDNSInterface_LocalOnly;
8904 mDNSu16 rrtype;
8905
8906 if (!domain)
8907 {
8908 LogMsg("mDNSMacOSXCreateEtcHostsEntry: ERROR!! name NULL");
8909 return mDNSfalse;
8910 }
8911 if (!sa && !cname)
8912 {
8913 LogMsg("mDNSMacOSXCreateEtcHostsEntry: ERROR!! sa and cname both NULL");
8914 return mDNSfalse;
8915 }
8916
8917 if (sa && sa->sa_family != AF_INET && sa->sa_family != AF_INET6)
8918 {
8919 LogMsg("mDNSMacOSXCreateEtcHostsEntry: ERROR!! sa with bad family %d", sa->sa_family);
8920 return mDNSfalse;
8921 }
8922
8923
8924 if (ifname)
8925 {
8926 mDNSu32 ifindex = if_nametoindex(ifname);
8927 if (!ifindex)
8928 {
8929 LogMsg("mDNSMacOSXCreateEtcHostsEntry: hosts entry %##s with invalid ifname %s", domain->c, ifname);
8930 return mDNSfalse;
8931 }
8932 InterfaceID = (mDNSInterfaceID)(uintptr_t)ifindex;
8933 }
8934
8935 if (sa)
8936 rrtype = (sa->sa_family == AF_INET ? kDNSType_A : kDNSType_AAAA);
8937 else
8938 rrtype = kDNSType_CNAME;
8939
8940 // Check for duplicates. See whether we parsed an entry before like this ?
8941 slot = AuthHashSlot(domain);
8942 namehash = DomainNameHashValue(domain);
8943 ag = AuthGroupForName(auth, slot, namehash, domain);
8944 if (ag)
8945 {
8946 rr = ag->members;
8947 while (rr)
8948 {
8949 if (rr->resrec.rrtype == rrtype)
8950 {
8951 if (rrtype == kDNSType_A)
8952 {
8953 mDNSv4Addr ip;
8954 ip.NotAnInteger = ((struct sockaddr_in*)sa)->sin_addr.s_addr;
8955 if (mDNSSameIPv4Address(rr->resrec.rdata->u.ipv4, ip))
8956 {
8957 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Same IPv4 address for name %##s", domain->c);
8958 return mDNSfalse;
8959 }
8960 }
8961 else if (rrtype == kDNSType_AAAA)
8962 {
8963 mDNSv6Addr ip6;
8964 ip6.l[0] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[0];
8965 ip6.l[1] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[1];
8966 ip6.l[2] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[2];
8967 ip6.l[3] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[3];
8968 if (mDNSSameIPv6Address(rr->resrec.rdata->u.ipv6, ip6))
8969 {
8970 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Same IPv6 address for name %##s", domain->c);
8971 return mDNSfalse;
8972 }
8973 }
8974 else if (rrtype == kDNSType_CNAME)
8975 {
8976 if (SameDomainName(&rr->resrec.rdata->u.name, cname))
8977 {
8978 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Same cname %##s for name %##s", cname->c, domain->c);
8979 return mDNSfalse;
8980 }
8981 }
8982 }
8983 rr = rr->next;
8984 }
8985 }
8986 rr= mallocL("etchosts", sizeof(*rr));
8987 if (rr == NULL) return mDNSfalse;
8988 mDNSPlatformMemZero(rr, sizeof(*rr));
8989 mDNS_SetupResourceRecord(rr, NULL, InterfaceID, rrtype, 1, kDNSRecordTypeKnownUnique, AuthRecordLocalOnly, FreeEtcHosts, NULL);
8990 AssignDomainName(&rr->namestorage, domain);
8991
8992 if (sa)
8993 {
8994 rr->resrec.rdlength = sa->sa_family == AF_INET ? sizeof(mDNSv4Addr) : sizeof(mDNSv6Addr);
8995 if (sa->sa_family == AF_INET)
8996 rr->resrec.rdata->u.ipv4.NotAnInteger = ((struct sockaddr_in*)sa)->sin_addr.s_addr;
8997 else
8998 {
8999 rr->resrec.rdata->u.ipv6.l[0] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[0];
9000 rr->resrec.rdata->u.ipv6.l[1] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[1];
9001 rr->resrec.rdata->u.ipv6.l[2] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[2];
9002 rr->resrec.rdata->u.ipv6.l[3] = ((struct sockaddr_in6*)sa)->sin6_addr.__u6_addr.__u6_addr32[3];
9003 }
9004 }
9005 else
9006 {
9007 rr->resrec.rdlength = DomainNameLength(cname);
9008 rr->resrec.rdata->u.name.c[0] = 0;
9009 AssignDomainName(&rr->resrec.rdata->u.name, cname);
9010 }
9011 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
9012 SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
9013 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Adding resource record %s", ARDisplayString(m, rr));
9014 InsertAuthRecord(m, auth, rr);
9015 return mDNStrue;
9016 }
9017
9018 mDNSlocal int EtcHostsParseOneName(int start, int length, char *buffer, char **name)
9019 {
9020 int i;
9021
9022 *name = NULL;
9023 for (i = start; i < length; i++)
9024 {
9025 if (buffer[i] == '#')
9026 return -1;
9027 if (buffer[i] != ' ' && buffer[i] != ',' && buffer[i] != '\t')
9028 {
9029 *name = &buffer[i];
9030
9031 // Found the start of a name, find the end and null terminate
9032 for (i++; i < length; i++)
9033 {
9034 if (buffer[i] == ' ' || buffer[i] == ',' || buffer[i] == '\t')
9035 {
9036 buffer[i] = 0;
9037 break;
9038 }
9039 }
9040 return i;
9041 }
9042 }
9043 return -1;
9044 }
9045
9046 mDNSlocal void mDNSMacOSXParseEtcHostsLine(mDNS *const m, char *buffer, ssize_t length, AuthHash *auth)
9047 {
9048 int i;
9049 int ifStart = 0;
9050 char *ifname = NULL;
9051 domainname name1d;
9052 domainname name2d;
9053 char *name1;
9054 char *name2;
9055 int aliasIndex;
9056
9057 //Ignore leading whitespaces and tabs
9058 while (*buffer == ' ' || *buffer == '\t')
9059 {
9060 buffer++;
9061 length--;
9062 }
9063
9064 // Find the end of the address string
9065 for (i = 0; i < length; i++)
9066 {
9067 if (buffer[i] == ' ' || buffer[i] == ',' || buffer[i] == '\t' || buffer[i] == '%')
9068 {
9069 if (buffer[i] == '%')
9070 ifStart = i + 1;
9071 buffer[i] = 0;
9072 break;
9073 }
9074 }
9075
9076 // Convert the address string to an address
9077 struct addrinfo hints;
9078 bzero(&hints, sizeof(hints));
9079 hints.ai_flags = AI_NUMERICHOST;
9080 struct addrinfo *gairesults = NULL;
9081 if (getaddrinfo(buffer, NULL, &hints, &gairesults) != 0)
9082 {
9083 LogInfo("mDNSMacOSXParseEtcHostsLine: getaddrinfo returning null");
9084 return;
9085 }
9086
9087 if (ifStart)
9088 {
9089 // Parse the interface
9090 ifname = &buffer[ifStart];
9091 for (i = ifStart + 1; i < length; i++)
9092 {
9093 if (buffer[i] == ' ' || buffer[i] == ',' || buffer[i] == '\t')
9094 {
9095 buffer[i] = 0;
9096 break;
9097 }
9098 }
9099 }
9100
9101 i = EtcHostsParseOneName(i + 1, length, buffer, &name1);
9102 if (i == length)
9103 {
9104 // Common case (no aliases) : The entry is of the form "1.2.3.4 somehost" with no trailing white spaces/tabs etc.
9105 if (!MakeDomainNameFromDNSNameString(&name1d, name1))
9106 {
9107 LogMsg("mDNSMacOSXParseEtcHostsLine: ERROR!! cannot convert to domain name %s", name1);
9108 freeaddrinfo(gairesults);
9109 return;
9110 }
9111 mDNSMacOSXCreateEtcHostsEntry(m, &name1d, gairesults->ai_addr, mDNSNULL, ifname, auth);
9112 }
9113 else if (i != -1)
9114 {
9115 domainname first;
9116 // We might have some extra white spaces at the end for the common case of "1.2.3.4 somehost".
9117 // When we parse again below, EtchHostsParseOneName would return -1 and we will end up
9118 // doing the right thing.
9119 if (!MakeDomainNameFromDNSNameString(&first, name1))
9120 {
9121 LogMsg("mDNSMacOSXParseEtcHostsLine: ERROR!! cannot convert to domain name %s", name1);
9122 freeaddrinfo(gairesults);
9123 return;
9124 }
9125 // If the /etc/hosts has an entry like this
9126 //
9127 // 1.2.3.4 sun star bright
9128 //
9129 // star and bright are aliases (gethostbyname h_alias should point to these) and sun is the canonical
9130 // name (getaddrinfo ai_cannonname and gethostbyname h_name points to "sun")
9131 //
9132 // To achieve this, we need to add the entry like this:
9133 //
9134 // star CNAME bright
9135 // bright CNAME sun
9136 // sun A 1.2.3.4
9137 //
9138 // We store the first name we parsed in "first". Then we parse additional names adding CNAME records
9139 // till we reach the end. When we reach the end, we wrap around and add one final CNAME with the last
9140 // entry and the first entry. Finally, we add the Address (A/AAAA) record.
9141 aliasIndex = 0;
9142 while (i <= length)
9143 {
9144 // Parse a name. If there are no names, we need to know whether we
9145 // parsed CNAMEs before or not. If we parsed CNAMEs before, then we
9146 // add a CNAME with the last name and the first name. Otherwise, this
9147 // is same as the common case above where the line has just one name
9148 // but with trailing white spaces.
9149 i = EtcHostsParseOneName(i + 1, length, buffer, &name2);
9150 if (name2)
9151 {
9152 if (!MakeDomainNameFromDNSNameString(&name2d, name2))
9153 {
9154 LogMsg("mDNSMacOSXParseEtcHostsLine: ERROR!! cannot convert to domain name %s", name2);
9155 freeaddrinfo(gairesults);
9156 return;
9157 }
9158 aliasIndex++;
9159 }
9160 else if (!aliasIndex)
9161 {
9162 // We have never parsed any aliases. This case happens if there
9163 // is just one name and some extra white spaces at the end.
9164 LogInfo("mDNSMacOSXParseEtcHostsLine: White space at the end of %##s", first.c);
9165 break;
9166 }
9167 else
9168 {
9169 // We have parsed at least one alias before and we reached the end of the line.
9170 // Setup a CNAME for the last name with "first" name as its RDATA
9171 name2d.c[0] = 0;
9172 AssignDomainName(&name2d, &first);
9173 }
9174
9175 // Don't add a CNAME for the first alias we parse (see the example above).
9176 // As we parse more, we might discover that there are no more aliases, in
9177 // which case we would have set "name2d" to "first" above. We need to add
9178 // the CNAME in that case.
9179
9180 if (aliasIndex > 1 || SameDomainName(&name2d, &first))
9181 {
9182 // Ignore if it points to itself
9183 if (!SameDomainName(&name1d, &name2d))
9184 {
9185 if (!mDNSMacOSXCreateEtcHostsEntry(m, &name1d, mDNSNULL, &name2d, ifname, auth))
9186 {
9187 freeaddrinfo(gairesults);
9188 return;
9189 }
9190 }
9191 else
9192 LogMsg("mDNSMacOSXParseEtcHostsLine: Ignoring entry with same names name1 %##s, name2 %##s", name1d.c, name2d.c);
9193 }
9194
9195 // If we have already wrapped around, we just need to add the A/AAAA record alone
9196 // which is done below
9197 if (SameDomainName(&name2d, &first)) break;
9198
9199 // Remember the current name so that we can set the CNAME record if we parse one
9200 // more name
9201 name1d.c[0] = 0;
9202 AssignDomainName(&name1d, &name2d);
9203 }
9204 // Added all the CNAMEs if any, add the "A/AAAA" record
9205 mDNSMacOSXCreateEtcHostsEntry(m, &first, gairesults->ai_addr, mDNSNULL, ifname, auth);
9206 }
9207 freeaddrinfo(gairesults);
9208 }
9209
9210 mDNSlocal void mDNSMacOSXParseEtcHosts(mDNS *const m, int fd, AuthHash *auth)
9211 {
9212 mDNSBool good;
9213 char buf[ETCHOSTS_BUFSIZE];
9214 ssize_t len;
9215 FILE *fp;
9216
9217 if (fd == -1) { LogInfo("mDNSMacOSXParseEtcHosts: fd is -1"); return; }
9218
9219 fp = fopen("/etc/hosts", "r");
9220 if (!fp) { LogInfo("mDNSMacOSXParseEtcHosts: fp is NULL"); return; }
9221
9222 while (1)
9223 {
9224 good = (fgets(buf, ETCHOSTS_BUFSIZE, fp) != NULL);
9225 if (!good) break;
9226
9227 // skip comment and empty lines
9228 if (buf[0] == '#' || buf[0] == '\r' || buf[0] == '\n')
9229 continue;
9230
9231 len = strlen(buf);
9232 if (!len) break; // sanity check
9233 //Check for end of line code(mostly only \n but pre-OS X Macs could have only \r)
9234 if (buf[len - 1] == '\r' || buf[len - 1] == '\n')
9235 {
9236 buf[len - 1] = '\0';
9237 len = len - 1;
9238 }
9239 // fgets always null terminates and hence even if we have no
9240 // newline at the end, it is null terminated. The callee
9241 // (mDNSMacOSXParseEtcHostsLine) expects the length to be such that
9242 // buf[length] is zero and hence we decrement len to reflect that.
9243 if (len)
9244 {
9245 //Additional check when end of line code is 2 chars ie\r\n(DOS, other old OSes)
9246 //here we need to check for just \r but taking extra caution.
9247 if (buf[len - 1] == '\r' || buf[len - 1] == '\n')
9248 {
9249 buf[len - 1] = '\0';
9250 len = len - 1;
9251 }
9252 }
9253 if (!len) //Sanity Check: len should never be zero
9254 {
9255 LogMsg("mDNSMacOSXParseEtcHosts: Length is zero!");
9256 continue;
9257 }
9258 mDNSMacOSXParseEtcHostsLine(m, buf, len, auth);
9259 }
9260 fclose(fp);
9261 }
9262
9263 mDNSlocal void mDNSMacOSXUpdateEtcHosts(mDNS *const m);
9264
9265 mDNSlocal int mDNSMacOSXGetEtcHostsFD(mDNS *const m)
9266 {
9267 #ifdef __DISPATCH_GROUP__
9268 // Can't do this stuff to be notified of changes in /etc/hosts if we don't have libdispatch
9269 static dispatch_queue_t etcq = 0;
9270 static dispatch_source_t etcsrc = 0;
9271 static dispatch_source_t hostssrc = 0;
9272
9273 // First time through? just schedule ourselves on the main queue and we'll do the work later
9274 if (!etcq)
9275 {
9276 etcq = dispatch_get_main_queue();
9277 if (etcq)
9278 {
9279 // Do this work on the queue, not here - solves potential synchronization issues
9280 dispatch_async(etcq, ^{mDNSMacOSXUpdateEtcHosts(m);});
9281 }
9282 return -1;
9283 }
9284
9285 if (hostssrc) return dispatch_source_get_handle(hostssrc);
9286 #endif
9287
9288 int fd = open("/etc/hosts", O_RDONLY);
9289
9290 #ifdef __DISPATCH_GROUP__
9291 // Can't do this stuff to be notified of changes in /etc/hosts if we don't have libdispatch
9292 if (fd == -1)
9293 {
9294 // If the open failed and we're already watching /etc, we're done
9295 if (etcsrc) { LogInfo("mDNSMacOSXGetEtcHostsFD: Returning etcfd because no etchosts"); return fd; }
9296
9297 // we aren't watching /etc, we should be
9298 fd = open("/etc", O_RDONLY);
9299 if (fd == -1) { LogInfo("mDNSMacOSXGetEtcHostsFD: etc does not exist"); return -1; }
9300 etcsrc = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE, fd, DISPATCH_VNODE_DELETE | DISPATCH_VNODE_WRITE | DISPATCH_VNODE_RENAME, etcq);
9301 if (etcsrc == NULL)
9302 {
9303 close(fd);
9304 return -1;
9305 }
9306 dispatch_source_set_event_handler(etcsrc,
9307 ^{
9308 u_int32_t flags = dispatch_source_get_data(etcsrc);
9309 LogMsg("mDNSMacOSXGetEtcHostsFD: /etc changed 0x%x", flags);
9310 if ((flags & (DISPATCH_VNODE_DELETE | DISPATCH_VNODE_RENAME)) != 0)
9311 {
9312 dispatch_source_cancel(etcsrc);
9313 dispatch_release(etcsrc);
9314 etcsrc = NULL;
9315 dispatch_async(etcq, ^{mDNSMacOSXUpdateEtcHosts(m);});
9316 return;
9317 }
9318 if ((flags & DISPATCH_VNODE_WRITE) != 0 && hostssrc == NULL)
9319 {
9320 mDNSMacOSXUpdateEtcHosts(m);
9321 }
9322 });
9323 dispatch_source_set_cancel_handler(etcsrc, ^{close(fd);});
9324 dispatch_resume(etcsrc);
9325
9326 // Try and open /etc/hosts once more now that we're watching /etc, in case we missed the creation
9327 fd = open("/etc/hosts", O_RDONLY | O_EVTONLY);
9328 if (fd == -1) { LogMsg("mDNSMacOSXGetEtcHostsFD etc hosts does not exist, watching etc"); return -1; }
9329 }
9330
9331 // create a dispatch source to watch for changes to hosts file
9332 hostssrc = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE, fd,
9333 (DISPATCH_VNODE_DELETE | DISPATCH_VNODE_WRITE | DISPATCH_VNODE_RENAME |
9334 DISPATCH_VNODE_ATTRIB | DISPATCH_VNODE_EXTEND | DISPATCH_VNODE_LINK | DISPATCH_VNODE_REVOKE), etcq);
9335 if (hostssrc == NULL)
9336 {
9337 close(fd);
9338 return -1;
9339 }
9340 dispatch_source_set_event_handler(hostssrc,
9341 ^{
9342 u_int32_t flags = dispatch_source_get_data(hostssrc);
9343 LogInfo("mDNSMacOSXGetEtcHostsFD: /etc/hosts changed 0x%x", flags);
9344 if ((flags & (DISPATCH_VNODE_DELETE | DISPATCH_VNODE_RENAME)) != 0)
9345 {
9346 dispatch_source_cancel(hostssrc);
9347 dispatch_release(hostssrc);
9348 hostssrc = NULL;
9349 // Bug in LibDispatch: wait a second before scheduling the block. If we schedule
9350 // the block immediately, we try to open the file and the file may not exist and may
9351 // fail to get a notification in the future. When the file does not exist and
9352 // we start to monitor the directory, on "dispatch_resume" of that source, there
9353 // is no guarantee that the file creation will be notified always because when
9354 // the dispatch_resume returns, the kevent manager may not have registered the
9355 // kevent yet but the file may have been created
9356 usleep(1000000);
9357 dispatch_async(etcq, ^{mDNSMacOSXUpdateEtcHosts(m);});
9358 return;
9359 }
9360 if ((flags & DISPATCH_VNODE_WRITE) != 0)
9361 {
9362 mDNSMacOSXUpdateEtcHosts(m);
9363 }
9364 });
9365 dispatch_source_set_cancel_handler(hostssrc, ^{LogInfo("mDNSMacOSXGetEtcHostsFD: Closing etchosts fd %d", fd); close(fd);});
9366 dispatch_resume(hostssrc);
9367
9368 // Cleanup /etc source, no need to watch it if we already have /etc/hosts
9369 if (etcsrc)
9370 {
9371 dispatch_source_cancel(etcsrc);
9372 dispatch_release(etcsrc);
9373 etcsrc = NULL;
9374 }
9375
9376 LogInfo("mDNSMacOSXGetEtcHostsFD: /etc/hosts being monitored, and not etc");
9377 return hostssrc ? (int)dispatch_source_get_handle(hostssrc) : -1;
9378 #else
9379 (void)m;
9380 return fd;
9381 #endif
9382 }
9383
9384 // When /etc/hosts is modified, flush all the cache records as there may be local
9385 // authoritative answers now
9386 mDNSlocal void FlushAllCacheRecords(mDNS *const m)
9387 {
9388 CacheRecord *cr;
9389 mDNSu32 slot;
9390 CacheGroup *cg;
9391
9392 FORALL_CACHERECORDS(slot, cg, cr)
9393 {
9394 // Skip multicast.
9395 if (cr->resrec.InterfaceID) continue;
9396
9397 // If a resource record can answer A or AAAA, they need to be flushed so that we will
9398 // never used to deliver an ADD or RMV
9399 if (RRTypeAnswersQuestionType(&cr->resrec, kDNSType_A) ||
9400 RRTypeAnswersQuestionType(&cr->resrec, kDNSType_AAAA))
9401 {
9402 LogInfo("FlushAllCacheRecords: Purging Resourcerecord %s", CRDisplayString(m, cr));
9403 mDNS_PurgeCacheResourceRecord(m, cr);
9404 }
9405 }
9406 }
9407
9408 // Add new entries to the core. If justCheck is set, this function does not add, just returns true
9409 mDNSlocal mDNSBool EtcHostsAddNewEntries(mDNS *const m, AuthHash *newhosts, mDNSBool justCheck)
9410 {
9411 AuthGroup *ag;
9412 mDNSu32 slot;
9413 AuthRecord *rr, *primary, *rrnext;
9414 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
9415 for (ag = newhosts->rrauth_hash[slot]; ag; ag = ag->next)
9416 {
9417 primary = NULL;
9418 for (rr = ag->members; rr; rr = rrnext)
9419 {
9420 rrnext = rr->next;
9421 AuthGroup *ag1;
9422 AuthRecord *rr1;
9423 mDNSBool found = mDNSfalse;
9424 ag1 = AuthGroupForRecord(&m->rrauth, slot, &rr->resrec);
9425 if (ag1 && ag1->members)
9426 {
9427 if (!primary) primary = ag1->members;
9428 rr1 = ag1->members;
9429 while (rr1)
9430 {
9431 // We are not using InterfaceID in checking for duplicates. This means,
9432 // if there are two addresses for a given name e.g., fe80::1%en0 and
9433 // fe80::1%en1, we only add the first one. It is not clear whether
9434 // this is a common case. To fix this, we also need to modify
9435 // mDNS_Register_internal in how it handles duplicates. If it becomes a
9436 // common case, we will fix it then.
9437 if (IdenticalResourceRecord(&rr1->resrec, &rr->resrec))
9438 {
9439 LogInfo("EtcHostsAddNewEntries: Skipping, not adding %s", ARDisplayString(m, rr1));
9440 found = mDNStrue;
9441 break;
9442 }
9443 rr1 = rr1->next;
9444 }
9445 }
9446 if (!found)
9447 {
9448 if (justCheck)
9449 {
9450 LogInfo("EtcHostsAddNewEntries: Entry %s not registered with core yet", ARDisplayString(m, rr));
9451 return mDNStrue;
9452 }
9453 RemoveAuthRecord(m, newhosts, rr);
9454 // if there is no primary, point to self
9455 rr->RRSet = (primary ? primary : rr);
9456 rr->next = NULL;
9457 LogInfo("EtcHostsAddNewEntries: Adding %s", ARDisplayString(m, rr));
9458 if (mDNS_Register_internal(m, rr) != mStatus_NoError)
9459 LogMsg("EtcHostsAddNewEntries: mDNS_Register failed for %s", ARDisplayString(m, rr));
9460 }
9461 }
9462 }
9463 return mDNSfalse;
9464 }
9465
9466 // Delete entries from the core that are no longer needed. If justCheck is set, this function
9467 // does not delete, just returns true
9468 mDNSlocal mDNSBool EtcHostsDeleteOldEntries(mDNS *const m, AuthHash *newhosts, mDNSBool justCheck)
9469 {
9470 AuthGroup *ag;
9471 mDNSu32 slot;
9472 AuthRecord *rr, *primary, *rrnext;
9473 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
9474 for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
9475 for (rr = ag->members; rr; rr = rrnext)
9476 {
9477 mDNSBool found = mDNSfalse;
9478 AuthGroup *ag1;
9479 AuthRecord *rr1;
9480 rrnext = rr->next;
9481 if (rr->RecordCallback != FreeEtcHosts) continue;
9482 ag1 = AuthGroupForRecord(newhosts, slot, &rr->resrec);
9483 if (ag1)
9484 {
9485 primary = rr1 = ag1->members;
9486 while (rr1)
9487 {
9488 if (IdenticalResourceRecord(&rr1->resrec, &rr->resrec))
9489 {
9490 LogInfo("EtcHostsDeleteOldEntries: Old record %s found in new, skipping", ARDisplayString(m, rr));
9491 found = mDNStrue;
9492 break;
9493 }
9494 rr1 = rr1->next;
9495 }
9496 }
9497 // there is no corresponding record in newhosts for the same name. This means
9498 // we should delete this from the core.
9499 if (!found)
9500 {
9501 if (justCheck)
9502 {
9503 LogInfo("EtcHostsDeleteOldEntries: Record %s not found in new, deleting", ARDisplayString(m, rr));
9504 return mDNStrue;
9505 }
9506 // if primary is going away, make sure that the rest of the records
9507 // point to the new primary
9508 if (rr == ag->members)
9509 {
9510 AuthRecord *new_primary = rr->next;
9511 AuthRecord *r = new_primary;
9512 while (r)
9513 {
9514 if (r->RRSet == rr)
9515 {
9516 LogInfo("EtcHostsDeleteOldEntries: Updating Resource Record %s to primary", ARDisplayString(m, r));
9517 r->RRSet = new_primary;
9518 }
9519 else LogMsg("EtcHostsDeleteOldEntries: ERROR!! Resource Record %s not pointing to primary %##s", ARDisplayString(m, r), r->resrec.name);
9520 r = r->next;
9521 }
9522 }
9523 LogInfo("EtcHostsDeleteOldEntries: Deleting %s", ARDisplayString(m, rr));
9524 mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
9525 }
9526 }
9527 return mDNSfalse;
9528 }
9529
9530 mDNSlocal void UpdateEtcHosts(mDNS *const m, void *context)
9531 {
9532 AuthHash *newhosts = (AuthHash *)context;
9533
9534 mDNS_CheckLock(m);
9535
9536 //Delete old entries from the core if they are not present in the newhosts
9537 EtcHostsDeleteOldEntries(m, newhosts, mDNSfalse);
9538 // Add the new entries to the core if not already present in the core
9539 EtcHostsAddNewEntries(m, newhosts, mDNSfalse);
9540 }
9541
9542 mDNSlocal void FreeNewHosts(AuthHash *newhosts)
9543 {
9544 mDNSu32 slot;
9545 AuthGroup *ag, *agnext;
9546 AuthRecord *rr, *rrnext;
9547
9548 for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
9549 for (ag = newhosts->rrauth_hash[slot]; ag; ag = agnext)
9550 {
9551 agnext = ag->next;
9552 for (rr = ag->members; rr; rr = rrnext)
9553 {
9554 rrnext = rr->next;
9555 freeL("etchosts", rr);
9556 }
9557 freeL("AuthGroups", ag);
9558 }
9559 }
9560
9561 mDNSlocal void mDNSMacOSXUpdateEtcHosts(mDNS *const m)
9562 {
9563 AuthHash newhosts;
9564
9565 // As we will be modifying the core, we can only have one thread running at
9566 // any point in time.
9567 KQueueLock(m);
9568
9569 mDNSPlatformMemZero(&newhosts, sizeof(AuthHash));
9570
9571 // Get the file desecriptor (will trigger us to start watching for changes)
9572 int fd = mDNSMacOSXGetEtcHostsFD(m);
9573 if (fd != -1)
9574 {
9575 LogInfo("mDNSMacOSXUpdateEtcHosts: Parsing /etc/hosts fd %d", fd);
9576 mDNSMacOSXParseEtcHosts(m, fd, &newhosts);
9577 }
9578 else LogInfo("mDNSMacOSXUpdateEtcHosts: /etc/hosts is not present");
9579
9580 // Optimization: Detect whether /etc/hosts changed or not.
9581 //
9582 // 1. Check to see if there are any new entries. We do this by seeing whether any entries in
9583 // newhosts is already registered with core. If we find at least one entry that is not
9584 // registered with core, then it means we have work to do.
9585 //
9586 // 2. Next, we check to see if any of the entries that are registered with core is not present
9587 // in newhosts. If we find at least one entry that is not present, it means we have work to
9588 // do.
9589 //
9590 // Note: We may not have to hold the lock right here as KQueueLock is held which prevents any
9591 // other thread from running. But mDNS_Lock is needed here as we will be traversing the core
9592 // data structure in EtcHostsDeleteOldEntries/NewEntries which might expect the lock to be held
9593 // in the future and this code does not have to change.
9594 mDNS_Lock(m);
9595 // Add the new entries to the core if not already present in the core
9596 if (!EtcHostsAddNewEntries(m, &newhosts, mDNStrue))
9597 {
9598 // No new entries to add, check to see if we need to delete any old entries from the
9599 // core if they are not present in the newhosts
9600 if (!EtcHostsDeleteOldEntries(m, &newhosts, mDNStrue))
9601 {
9602 LogInfo("mDNSMacOSXUpdateEtcHosts: No work");
9603 mDNS_Unlock(m);
9604 KQueueUnlock(m, "/etc/hosts changed");
9605 FreeNewHosts(&newhosts);
9606 return;
9607 }
9608 }
9609
9610 // This will flush the cache, stop and start the query so that the queries
9611 // can look at the /etc/hosts again
9612 //
9613 // Notes:
9614 //
9615 // We can't delete and free the records here. We wait for the mDNSCoreRestartAddressQueries to
9616 // deliver RMV events. It has to be done in a deferred way because we can't deliver RMV
9617 // events for local records *before* the RMV events for cache records. mDNSCoreRestartAddressQueries
9618 // delivers these events in the right order and then calls us back to delete them.
9619 //
9620 // Similarly, we do a deferred Registration of the record because mDNSCoreRestartAddressQueries
9621 // is a common function that looks at all local auth records and delivers a RMV including
9622 // the records that we might add here. If we deliver a ADD here, it will get a RMV and then when
9623 // the query is restarted, it will get another ADD. To avoid this (ADD-RMV-ADD), we defer registering
9624 // the record until the RMVs are delivered in mDNSCoreRestartAddressQueries after which UpdateEtcHosts
9625 // is called back where we do the Registration of the record. This results in RMV followed by ADD which
9626 // looks normal.
9627 mDNSCoreRestartAddressQueries(m, mDNSfalse, FlushAllCacheRecords, UpdateEtcHosts, &newhosts);
9628 mDNS_Unlock(m);
9629
9630 KQueueUnlock(m, "/etc/hosts changed");
9631 FreeNewHosts(&newhosts);
9632 }
9633
9634 #if COMPILER_LIKES_PRAGMA_MARK
9635 #pragma mark -
9636 #pragma mark - Initialization & Teardown
9637 #endif
9638
9639 CF_EXPORT CFDictionaryRef _CFCopySystemVersionDictionary(void);
9640 CF_EXPORT const CFStringRef _kCFSystemVersionProductNameKey;
9641 CF_EXPORT const CFStringRef _kCFSystemVersionProductVersionKey;
9642 CF_EXPORT const CFStringRef _kCFSystemVersionBuildVersionKey;
9643
9644 // Major version 13 is 10.9.x
9645 mDNSexport void mDNSMacOSXSystemBuildNumber(char *HINFO_SWstring)
9646 {
9647 int major = 0, minor = 0;
9648 char letter = 0, prodname[256]="<Unknown>", prodvers[256]="<Unknown>", buildver[256]="<Unknown>";
9649 CFDictionaryRef vers = _CFCopySystemVersionDictionary();
9650 if (vers)
9651 {
9652 CFStringRef cfprodname = CFDictionaryGetValue(vers, _kCFSystemVersionProductNameKey);
9653 CFStringRef cfprodvers = CFDictionaryGetValue(vers, _kCFSystemVersionProductVersionKey);
9654 CFStringRef cfbuildver = CFDictionaryGetValue(vers, _kCFSystemVersionBuildVersionKey);
9655 if (cfprodname)
9656 CFStringGetCString(cfprodname, prodname, sizeof(prodname), kCFStringEncodingUTF8);
9657 if (cfprodvers)
9658 CFStringGetCString(cfprodvers, prodvers, sizeof(prodvers), kCFStringEncodingUTF8);
9659 if (cfbuildver && CFStringGetCString(cfbuildver, buildver, sizeof(buildver), kCFStringEncodingUTF8))
9660 sscanf(buildver, "%d%c%d", &major, &letter, &minor);
9661 CFRelease(vers);
9662 }
9663 if (!major)
9664 {
9665 major = 13;
9666 LogMsg("Note: No Major Build Version number found; assuming 13");
9667 }
9668 if (HINFO_SWstring)
9669 mDNS_snprintf(HINFO_SWstring, 256, "%s %s (%s), %s", prodname, prodvers, buildver, STRINGIFY(mDNSResponderVersion));
9670 //LogMsg("%s %s (%s), %d %c %d", prodname, prodvers, buildver, major, letter, minor);
9671
9672 // If product name is "Mac OS X" (or similar) we set OSXVers, else we set iOSVers;
9673 if ((prodname[0] & 0xDF) == 'M')
9674 OSXVers = major;
9675 else
9676 iOSVers = major;
9677 }
9678
9679 // Test to see if we're the first client running on UDP port 5353, by trying to bind to 5353 without using SO_REUSEPORT.
9680 // If we fail, someone else got here first. That's not a big problem; we can share the port for multicast responses --
9681 // we just need to be aware that we shouldn't expect to successfully receive unicast UDP responses.
9682 mDNSlocal mDNSBool mDNSPlatformInit_CanReceiveUnicast(void)
9683 {
9684 int err = -1;
9685 int s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
9686 if (s < 3)
9687 LogMsg("mDNSPlatformInit_CanReceiveUnicast: socket error %d errno %d (%s)", s, errno, strerror(errno));
9688 else
9689 {
9690 struct sockaddr_in s5353;
9691 s5353.sin_family = AF_INET;
9692 s5353.sin_port = MulticastDNSPort.NotAnInteger;
9693 s5353.sin_addr.s_addr = 0;
9694 err = bind(s, (struct sockaddr *)&s5353, sizeof(s5353));
9695 close(s);
9696 }
9697
9698 if (err) LogMsg("No unicast UDP responses");
9699 else debugf("Unicast UDP responses okay");
9700 return(err == 0);
9701 }
9702
9703 mDNSlocal void CreatePTRRecord(mDNS *const m, const domainname *domain)
9704 {
9705 AuthRecord *rr;
9706 const domainname *pname = (domainname *)"\x9" "localhost";
9707
9708 rr= mallocL("localhosts", sizeof(*rr));
9709 if (rr == NULL) return;
9710 mDNSPlatformMemZero(rr, sizeof(*rr));
9711
9712 mDNS_SetupResourceRecord(rr, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, AuthRecordLocalOnly, mDNSNULL, mDNSNULL);
9713 AssignDomainName(&rr->namestorage, domain);
9714
9715 rr->resrec.rdlength = DomainNameLength(pname);
9716 rr->resrec.rdata->u.name.c[0] = 0;
9717 AssignDomainName(&rr->resrec.rdata->u.name, pname);
9718
9719 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
9720 SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
9721 mDNS_Register(m, rr);
9722 }
9723
9724 // Setup PTR records for 127.0.0.1 and ::1. This helps answering them locally rather than relying
9725 // on the external DNS server to answer this. Sometimes, the DNS servers don't respond in a timely
9726 // fashion and applications depending on this e.g., telnetd, times out after 30 seconds creating
9727 // a bad user experience. For now, we specifically create only localhosts to handle radar://9354225
9728 //
9729 // Note: We could have set this up while parsing the entries in /etc/hosts. But this is kept separate
9730 // intentionally to avoid adding to the complexity of code handling /etc/hosts.
9731 mDNSlocal void SetupLocalHostRecords(mDNS *const m)
9732 {
9733 char buffer[MAX_REVERSE_MAPPING_NAME];
9734 domainname name;
9735 int i;
9736 struct in6_addr addr;
9737 mDNSu8 *ptr = addr.__u6_addr.__u6_addr8;
9738
9739 if (inet_pton(AF_INET, "127.0.0.1", &addr) == 1)
9740 {
9741 mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.",
9742 ptr[3], ptr[2], ptr[1], ptr[0]);
9743 MakeDomainNameFromDNSNameString(&name, buffer);
9744 CreatePTRRecord(m, &name);
9745 }
9746 else LogMsg("SetupLocalHostRecords: ERROR!! inet_pton AF_INET failed");
9747
9748 if (inet_pton(AF_INET6, "::1", &addr) == 1)
9749 {
9750 for (i = 0; i < 16; i++)
9751 {
9752 static const char hexValues[] = "0123456789ABCDEF";
9753 buffer[i * 4 ] = hexValues[ptr[15 - i] & 0x0F];
9754 buffer[i * 4 + 1] = '.';
9755 buffer[i * 4 + 2] = hexValues[ptr[15 - i] >> 4];
9756 buffer[i * 4 + 3] = '.';
9757 }
9758 mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa.");
9759 MakeDomainNameFromDNSNameString(&name, buffer);
9760 CreatePTRRecord(m, &name);
9761 }
9762 else LogMsg("SetupLocalHostRecords: ERROR!! inet_pton AF_INET6 failed");
9763 }
9764
9765 // Construction of Default Browse domain list (i.e. when clients pass NULL) is as follows:
9766 // 1) query for b._dns-sd._udp.local on LocalOnly interface
9767 // (.local manually generated via explicit callback)
9768 // 2) for each search domain (from prefs pane), query for b._dns-sd._udp.<searchdomain>.
9769 // 3) for each result from (2), register LocalOnly PTR record b._dns-sd._udp.local. -> <result>
9770 // 4) result above should generate a callback from question in (1). result added to global list
9771 // 5) global list delivered to client via GetSearchDomainList()
9772 // 6) client calls to enumerate domains now go over LocalOnly interface
9773 // (!!!KRS may add outgoing interface in addition)
9774
9775 mDNSlocal mStatus mDNSPlatformInit_setup(mDNS *const m)
9776 {
9777 mStatus err;
9778 m->p->CFRunLoop = CFRunLoopGetCurrent();
9779
9780 char HINFO_SWstring[256] = "";
9781 mDNSMacOSXSystemBuildNumber(HINFO_SWstring);
9782
9783 err = mDNSHelperInit();
9784 if (err)
9785 return err;
9786
9787 DynamicStoreQueue = dispatch_queue_create("com.apple.mDNSResponder.DynamicStoreQueue", NULL);
9788 if (DynamicStoreQueue == NULL)
9789 {
9790 LogMsg("dispatch_queue_create: DynamicStoreQueue NULL!");
9791 return mStatus_NoMemoryErr;
9792 }
9793
9794 // Store mDNSResponder Platform
9795 if (OSXVers)
9796 {
9797 m->mDNS_plat = platform_OSX;
9798 }
9799 else if (iOSVers)
9800 {
9801 if (IsAppleTV())
9802 m->mDNS_plat = platform_Atv;
9803 else
9804 m->mDNS_plat = platform_iOS;
9805 }
9806 else
9807 {
9808 m->mDNS_plat = platform_NonApple;
9809 }
9810
9811 // In 10.4, mDNSResponder is launched very early in the boot process, while other subsystems are still in the process of starting up.
9812 // If we can't read the user's preferences, then we sleep a bit and try again, for up to five seconds before we give up.
9813 int i;
9814 for (i=0; i<100; i++)
9815 {
9816 domainlabel testlabel;
9817 testlabel.c[0] = 0;
9818 GetUserSpecifiedLocalHostName(&testlabel);
9819 if (testlabel.c[0]) break;
9820 usleep(50000);
9821 }
9822
9823 m->hostlabel.c[0] = 0;
9824
9825 int get_model[2] = { CTL_HW, HW_MODEL };
9826 size_t len_model = sizeof(HINFO_HWstring_buffer);
9827
9828 // Normal Apple model names are of the form "iPhone2,1", and
9829 // internal code names are strings containing no commas, e.g. "N88AP".
9830 // We used to ignore internal code names, but Apple now uses these internal code names
9831 // even in released shipping products, so we no longer ignore strings containing no commas.
9832 // if (sysctl(get_model, 2, HINFO_HWstring_buffer, &len_model, NULL, 0) == 0 && strchr(HINFO_HWstring_buffer, ','))
9833 if (sysctl(get_model, 2, HINFO_HWstring_buffer, &len_model, NULL, 0) == 0)
9834 HINFO_HWstring = HINFO_HWstring_buffer;
9835
9836 // For names of the form "iPhone2,1" we use "iPhone" as the prefix for automatic name generation.
9837 // For names of the form "N88AP" containg no comma, we use the entire string.
9838 HINFO_HWstring_prefixlen = strchr(HINFO_HWstring_buffer, ',') ? strcspn(HINFO_HWstring, "0123456789") : strlen(HINFO_HWstring);
9839
9840 if (mDNSPlatformInit_CanReceiveUnicast())
9841 m->CanReceiveUnicastOn5353 = mDNStrue;
9842
9843 mDNSu32 hlen = mDNSPlatformStrLen(HINFO_HWstring);
9844 mDNSu32 slen = mDNSPlatformStrLen(HINFO_SWstring);
9845 if (hlen + slen < 254)
9846 {
9847 m->HIHardware.c[0] = hlen;
9848 m->HISoftware.c[0] = slen;
9849 mDNSPlatformMemCopy(&m->HIHardware.c[1], HINFO_HWstring, hlen);
9850 mDNSPlatformMemCopy(&m->HISoftware.c[1], HINFO_SWstring, slen);
9851 }
9852
9853 m->p->permanentsockets.port = MulticastDNSPort;
9854 m->p->permanentsockets.m = m;
9855 m->p->permanentsockets.sktv4 = -1;
9856 m->p->permanentsockets.kqsv4.KQcallback = myKQSocketCallBack;
9857 m->p->permanentsockets.kqsv4.KQcontext = &m->p->permanentsockets;
9858 m->p->permanentsockets.kqsv4.KQtask = "UDP packet reception";
9859 m->p->permanentsockets.sktv6 = -1;
9860 m->p->permanentsockets.kqsv6.KQcallback = myKQSocketCallBack;
9861 m->p->permanentsockets.kqsv6.KQcontext = &m->p->permanentsockets;
9862 m->p->permanentsockets.kqsv6.KQtask = "UDP packet reception";
9863
9864 err = SetupSocket(&m->p->permanentsockets, MulticastDNSPort, AF_INET, mDNSNULL);
9865 err = SetupSocket(&m->p->permanentsockets, MulticastDNSPort, AF_INET6, mDNSNULL);
9866
9867 struct sockaddr_in s4;
9868 socklen_t n4 = sizeof(s4);
9869 if (getsockname(m->p->permanentsockets.sktv4, (struct sockaddr *)&s4, &n4) < 0)
9870 LogMsg("getsockname v4 error %d (%s)", errno, strerror(errno));
9871 else
9872 m->UnicastPort4.NotAnInteger = s4.sin_port;
9873
9874 if (m->p->permanentsockets.sktv6 >= 0)
9875 {
9876 struct sockaddr_in6 s6;
9877 socklen_t n6 = sizeof(s6);
9878 if (getsockname(m->p->permanentsockets.sktv6, (struct sockaddr *)&s6, &n6) < 0) LogMsg("getsockname v6 error %d (%s)", errno, strerror(errno));
9879 else m->UnicastPort6.NotAnInteger = s6.sin6_port;
9880 }
9881
9882 m->p->InterfaceList = mDNSNULL;
9883 m->p->userhostlabel.c[0] = 0;
9884 m->p->usernicelabel.c[0] = 0;
9885 m->p->prevoldnicelabel.c[0] = 0;
9886 m->p->prevnewnicelabel.c[0] = 0;
9887 m->p->prevoldhostlabel.c[0] = 0;
9888 m->p->prevnewhostlabel.c[0] = 0;
9889 m->p->NotifyUser = 0;
9890 m->p->KeyChainTimer = 0;
9891 m->p->WakeAtUTC = 0;
9892 m->p->RequestReSleep = 0;
9893 // Assume that everything is good to begin with. If something is not working,
9894 // we will detect that when we start sending questions.
9895 m->p->v4answers = 1;
9896 m->p->v6answers = 1;
9897 m->p->DNSTrigger = 0;
9898 m->p->LastConfigGeneration = 0;
9899
9900 #if APPLE_OSX_mDNSResponder
9901 uuid_generate(m->asl_uuid);
9902 #endif
9903
9904 m->AutoTunnelRelayAddr = zerov6Addr;
9905
9906 NetworkChangedKey_IPv4 = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, kSCDynamicStoreDomainState, kSCEntNetIPv4);
9907 NetworkChangedKey_IPv6 = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, kSCDynamicStoreDomainState, kSCEntNetIPv6);
9908 NetworkChangedKey_Hostnames = SCDynamicStoreKeyCreateHostNames(NULL);
9909 NetworkChangedKey_Computername = SCDynamicStoreKeyCreateComputerName(NULL);
9910 NetworkChangedKey_DNS = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, kSCDynamicStoreDomainState, kSCEntNetDNS);
9911 NetworkChangedKey_StateInterfacePrefix = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL, kSCDynamicStoreDomainState, CFSTR(""), NULL);
9912 if (!NetworkChangedKey_IPv4 || !NetworkChangedKey_IPv6 || !NetworkChangedKey_Hostnames || !NetworkChangedKey_Computername || !NetworkChangedKey_DNS || !NetworkChangedKey_StateInterfacePrefix)
9913 { LogMsg("SCDynamicStore string setup failed"); return(mStatus_NoMemoryErr); }
9914
9915 err = WatchForNetworkChanges(m);
9916 if (err) { LogMsg("mDNSPlatformInit_setup: WatchForNetworkChanges failed %d", err); return(err); }
9917
9918 #if 0 // <rdar://problem/6751656>
9919 err = WatchForPMChanges(m);
9920 if (err) { LogMsg("mDNSPlatformInit_setup: WatchForPMChanges failed %d", err); return(err); }
9921 #endif
9922
9923 err = WatchForSysEvents(m);
9924 if (err) { LogMsg("mDNSPlatformInit_setup: WatchForSysEvents failed %d", err); return(err); }
9925
9926 mDNSs32 utc = mDNSPlatformUTC();
9927 m->SystemWakeOnLANEnabled = SystemWakeForNetworkAccess();
9928 UpdateInterfaceList(m, utc);
9929 SetupActiveInterfaces(m, utc);
9930
9931 // Explicitly ensure that our Keychain operations utilize the system domain.
9932 #ifndef NO_SECURITYFRAMEWORK
9933 SecKeychainSetPreferenceDomain(kSecPreferencesDomainSystem);
9934 #endif
9935
9936 mDNS_Lock(m);
9937 SetDomainSecrets(m);
9938 SetLocalDomains();
9939 mDNS_Unlock(m);
9940
9941 #ifndef NO_SECURITYFRAMEWORK
9942 err = SecKeychainAddCallback(KeychainChanged, kSecAddEventMask|kSecDeleteEventMask|kSecUpdateEventMask, m);
9943 if (err) { LogMsg("mDNSPlatformInit_setup: SecKeychainAddCallback failed %d", err); return(err); }
9944 #endif
9945
9946 #if !defined(kIOPMAcknowledgmentOptionSystemCapabilityRequirements) || TARGET_OS_EMBEDDED
9947 LogMsg("Note: Compiled without SnowLeopard Fine-Grained Power Management support");
9948 #else
9949 IOPMConnection c;
9950 IOReturn iopmerr = IOPMConnectionCreate(CFSTR("mDNSResponder"), kIOPMSystemPowerStateCapabilityCPU, &c);
9951 if (iopmerr) LogMsg("IOPMConnectionCreate failed %d", iopmerr);
9952 else
9953 {
9954 iopmerr = IOPMConnectionSetNotification(c, m, SnowLeopardPowerChanged);
9955 if (iopmerr) LogMsg("IOPMConnectionSetNotification failed %d", iopmerr);
9956 else
9957 {
9958 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
9959 IOPMConnectionSetDispatchQueue(c, dispatch_get_main_queue());
9960 LogInfo("IOPMConnectionSetDispatchQueue is now running");
9961 #else
9962 iopmerr = IOPMConnectionScheduleWithRunLoop(c, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
9963 if (iopmerr) LogMsg("IOPMConnectionScheduleWithRunLoop failed %d", iopmerr);
9964 LogInfo("IOPMConnectionScheduleWithRunLoop is now running");
9965 #endif /* MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM */
9966 }
9967 }
9968 m->p->IOPMConnection = iopmerr ? mDNSNULL : c;
9969 if (iopmerr) // If IOPMConnectionCreate unavailable or failed, proceed with old-style power notification code below
9970 #endif // kIOPMAcknowledgmentOptionSystemCapabilityRequirements
9971 {
9972 m->p->PowerConnection = IORegisterForSystemPower(m, &m->p->PowerPortRef, PowerChanged, &m->p->PowerNotifier);
9973 if (!m->p->PowerConnection) { LogMsg("mDNSPlatformInit_setup: IORegisterForSystemPower failed"); return(-1); }
9974 else
9975 {
9976 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
9977 IONotificationPortSetDispatchQueue(m->p->PowerPortRef, dispatch_get_main_queue());
9978 #else
9979 CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(m->p->PowerPortRef), kCFRunLoopDefaultMode);
9980 #endif /* MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM */
9981 }
9982 }
9983
9984 #if APPLE_OSX_mDNSResponder
9985 // Note: We use SPMetricPortability > 35 to indicate a laptop of some kind
9986 // SPMetricPortability <= 35 means nominally a non-portable machine (i.e. Mac mini or better)
9987 // Apple TVs, AirPort base stations, and Time Capsules do not actually weigh 3kg, but we assign them
9988 // higher 'nominal' masses to indicate they should be treated as being relatively less portable than a laptop
9989 if (!strncasecmp(HINFO_HWstring, "Xserve", 6)) { SPMetricPortability = 25 /* 30kg */; SPMetricMarginalPower = 84 /* 250W */; SPMetricTotalPower = 85 /* 300W */; }
9990 else if (!strncasecmp(HINFO_HWstring, "RackMac", 7)) { SPMetricPortability = 25 /* 30kg */; SPMetricMarginalPower = 84 /* 250W */; SPMetricTotalPower = 85 /* 300W */; }
9991 else if (!strncasecmp(HINFO_HWstring, "MacPro", 6)) { SPMetricPortability = 27 /* 20kg */; SPMetricMarginalPower = 84 /* 250W */; SPMetricTotalPower = 85 /* 300W */; }
9992 else if (!strncasecmp(HINFO_HWstring, "PowerMac", 8)) { SPMetricPortability = 27 /* 20kg */; SPMetricMarginalPower = 82 /* 160W */; SPMetricTotalPower = 83 /* 200W */; }
9993 else if (!strncasecmp(HINFO_HWstring, "iMac", 4)) { SPMetricPortability = 30 /* 10kg */; SPMetricMarginalPower = 77 /* 50W */; SPMetricTotalPower = 78 /* 60W */; }
9994 else if (!strncasecmp(HINFO_HWstring, "Macmini", 7)) { SPMetricPortability = 33 /* 5kg */; SPMetricMarginalPower = 73 /* 20W */; SPMetricTotalPower = 74 /* 25W */; }
9995 else if (!strncasecmp(HINFO_HWstring, "TimeCapsule", 11)) { SPMetricPortability = 34 /* 4kg */; SPMetricMarginalPower = 10 /* ~0W */; SPMetricTotalPower = 70 /* 13W */; }
9996 else if (!strncasecmp(HINFO_HWstring, "AirPort", 7)) { SPMetricPortability = 35 /* 3kg */; SPMetricMarginalPower = 10 /* ~0W */; SPMetricTotalPower = 70 /* 12W */; }
9997 else if ( IsAppleTV() ) { SPMetricPortability = 35 /* 3kg */; SPMetricMarginalPower = 60 /* 1W */; SPMetricTotalPower = 63 /* 2W */; }
9998 else if (!strncasecmp(HINFO_HWstring, "MacBook", 7)) { SPMetricPortability = 37 /* 2kg */; SPMetricMarginalPower = 71 /* 13W */; SPMetricTotalPower = 72 /* 15W */; }
9999 else if (!strncasecmp(HINFO_HWstring, "PowerBook", 9)) { SPMetricPortability = 37 /* 2kg */; SPMetricMarginalPower = 71 /* 13W */; SPMetricTotalPower = 72 /* 15W */; }
10000 LogSPS("HW_MODEL: %.*s (%s) Portability %d Marginal Power %d Total Power %d Features %d",
10001 HINFO_HWstring_prefixlen, HINFO_HWstring, HINFO_HWstring, SPMetricPortability, SPMetricMarginalPower, SPMetricTotalPower, SPMetricFeatures);
10002 #endif // APPLE_OSX_mDNSResponder
10003
10004 // Currently this is not defined. SSL code will eventually fix this. If it becomes
10005 // critical, we will define this to workaround the bug in SSL.
10006 #ifdef __SSL_NEEDS_SERIALIZATION__
10007 SSLqueue = dispatch_queue_create("com.apple.mDNSResponder.SSLQueue", NULL);
10008 #else
10009 SSLqueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
10010 #endif
10011 if (SSLqueue == mDNSNULL) LogMsg("dispatch_queue_create: SSL queue NULL");
10012
10013 mDNSMacOSXUpdateEtcHosts(m);
10014 SetupLocalHostRecords(m);
10015 CUPInit(m);
10016
10017 return(mStatus_NoError);
10018 }
10019
10020 mDNSexport mStatus mDNSPlatformInit(mDNS *const m)
10021 {
10022 #if MDNS_NO_DNSINFO
10023 LogMsg("Note: Compiled without Apple-specific Split-DNS support");
10024 #endif
10025
10026 // Adding interfaces will use this flag, so set it now.
10027 m->DivertMulticastAdvertisements = !m->AdvertiseLocalAddresses;
10028
10029 #if APPLE_OSX_mDNSResponder
10030 m->SPSBrowseCallback = UpdateSPSStatus;
10031 #endif // APPLE_OSX_mDNSResponder
10032
10033 mStatus result = mDNSPlatformInit_setup(m);
10034
10035 // We don't do asynchronous initialization on OS X, so by the time we get here the setup will already
10036 // have succeeded or failed -- so if it succeeded, we should just call mDNSCoreInitComplete() immediately
10037 if (result == mStatus_NoError)
10038 {
10039 mDNSCoreInitComplete(m, mStatus_NoError);
10040
10041 #if !NO_D2D
10042 // We only initialize if mDNSCore successfully initialized.
10043 if (D2DInitialize)
10044 {
10045 D2DStatus ds = D2DInitialize(m->p->CFRunLoop, xD2DServiceCallback, m) ;
10046 if (ds != kD2DSuccess)
10047 LogMsg("D2DInitialiize failed: %d", ds);
10048 else
10049 LogMsg("D2DInitialize succeeded");
10050 }
10051 #endif // ! NO_D2D
10052
10053 }
10054 result = DNSSECCryptoInit(m);
10055 return(result);
10056 }
10057
10058 mDNSexport void mDNSPlatformClose(mDNS *const m)
10059 {
10060 if (m->p->PowerConnection)
10061 {
10062 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
10063 IONotificationPortSetDispatchQueue(m->p->PowerPortRef, NULL);
10064 #else
10065 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(m->p->PowerPortRef), kCFRunLoopDefaultMode);
10066 #endif
10067 // According to <http://developer.apple.com/qa/qa2004/qa1340.html>, a single call
10068 // to IORegisterForSystemPower creates *three* objects that need to be disposed individually:
10069 IODeregisterForSystemPower(&m->p->PowerNotifier);
10070 IOServiceClose ( m->p->PowerConnection);
10071 IONotificationPortDestroy ( m->p->PowerPortRef);
10072 m->p->PowerConnection = 0;
10073 }
10074
10075 if (m->p->Store)
10076 {
10077 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
10078 if (!SCDynamicStoreSetDispatchQueue(m->p->Store, NULL))
10079 LogMsg("mDNSPlatformClose: SCDynamicStoreSetDispatchQueue failed");
10080 #else
10081 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m->p->StoreRLS, kCFRunLoopDefaultMode);
10082 CFRunLoopSourceInvalidate(m->p->StoreRLS);
10083 CFRelease(m->p->StoreRLS);
10084 m->p->StoreRLS = NULL;
10085 #endif
10086 CFRelease(m->p->Store);
10087 m->p->Store = NULL;
10088 }
10089
10090 if (m->p->PMRLS)
10091 {
10092 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m->p->PMRLS, kCFRunLoopDefaultMode);
10093 CFRunLoopSourceInvalidate(m->p->PMRLS);
10094 CFRelease(m->p->PMRLS);
10095 m->p->PMRLS = NULL;
10096 }
10097
10098 if (m->p->SysEventNotifier >= 0) { close(m->p->SysEventNotifier); m->p->SysEventNotifier = -1; }
10099
10100 #if !NO_D2D
10101 if (D2DTerminate)
10102 {
10103 D2DStatus ds = D2DTerminate();
10104 if (ds != kD2DSuccess)
10105 LogMsg("D2DTerminate failed: %d", ds);
10106 else
10107 LogMsg("D2DTerminate succeeded");
10108 }
10109 #endif // ! NO_D2D
10110
10111 mDNSs32 utc = mDNSPlatformUTC();
10112 MarkAllInterfacesInactive(m, utc);
10113 ClearInactiveInterfaces(m, utc);
10114 CloseSocketSet(&m->p->permanentsockets);
10115
10116 #if APPLE_OSX_mDNSResponder
10117 // clean up tunnels
10118 while (m->TunnelClients)
10119 {
10120 ClientTunnel *cur = m->TunnelClients;
10121 LogInfo("mDNSPlatformClose: removing client tunnel %p %##s from list", cur, cur->dstname.c);
10122 if (cur->q.ThisQInterval >= 0) mDNS_StopQuery(m, &cur->q);
10123 AutoTunnelSetKeys(cur, mDNSfalse);
10124 m->TunnelClients = cur->next;
10125 freeL("ClientTunnel", cur);
10126 }
10127
10128 if (AnonymousRacoonConfig)
10129 {
10130 AnonymousRacoonConfig = mDNSNULL;
10131 LogInfo("mDNSPlatformClose: Deconfiguring autotunnel");
10132 (void)mDNSConfigureServer(kmDNSDown, mDNSNULL, mDNSNULL);
10133 }
10134 #endif // APPLE_OSX_mDNSResponder
10135 }
10136
10137 #if COMPILER_LIKES_PRAGMA_MARK
10138 #pragma mark -
10139 #pragma mark - General Platform Support Layer functions
10140 #endif
10141
10142 mDNSexport mDNSu32 mDNSPlatformRandomNumber(void)
10143 {
10144 return(arc4random());
10145 }
10146
10147 mDNSexport mDNSs32 mDNSPlatformOneSecond = 1000;
10148 mDNSexport mDNSu32 mDNSPlatformClockDivisor = 0;
10149
10150 mDNSexport mStatus mDNSPlatformTimeInit(void)
10151 {
10152 // Notes: Typical values for mach_timebase_info:
10153 // tbi.numer = 1000 million
10154 // tbi.denom = 33 million
10155 // These are set such that (mach_absolute_time() * numer/denom) gives us nanoseconds;
10156 // numer / denom = nanoseconds per hardware clock tick (e.g. 30);
10157 // denom / numer = hardware clock ticks per nanosecond (e.g. 0.033)
10158 // (denom*1000000) / numer = hardware clock ticks per millisecond (e.g. 33333)
10159 // So: mach_absolute_time() / ((denom*1000000)/numer) = milliseconds
10160 //
10161 // Arithmetic notes:
10162 // tbi.denom is at least 1, and not more than 2^32-1.
10163 // Therefore (tbi.denom * 1000000) is at least one million, but cannot overflow a uint64_t.
10164 // tbi.denom is at least 1, and not more than 2^32-1.
10165 // Therefore clockdivisor should end up being a number roughly in the range 10^3 - 10^9.
10166 // If clockdivisor is less than 10^3 then that means that the native clock frequency is less than 1MHz,
10167 // which is unlikely on any current or future Macintosh.
10168 // If clockdivisor is greater than 10^9 then that means the native clock frequency is greater than 1000GHz.
10169 // When we ship Macs with clock frequencies above 1000GHz, we may have to update this code.
10170 struct mach_timebase_info tbi;
10171 kern_return_t result = mach_timebase_info(&tbi);
10172 if (result == KERN_SUCCESS) mDNSPlatformClockDivisor = ((uint64_t)tbi.denom * 1000000) / tbi.numer;
10173 return(result);
10174 }
10175
10176 mDNSexport mDNSs32 mDNSPlatformRawTime(void)
10177 {
10178 if (mDNSPlatformClockDivisor == 0) { LogMsg("mDNSPlatformRawTime called before mDNSPlatformTimeInit"); return(0); }
10179
10180 static uint64_t last_mach_absolute_time = 0;
10181 //static uint64_t last_mach_absolute_time = 0x8000000000000000LL; // Use this value for testing the alert display
10182 uint64_t this_mach_absolute_time = mach_absolute_time();
10183 if ((int64_t)this_mach_absolute_time - (int64_t)last_mach_absolute_time < 0)
10184 {
10185 LogMsg("mDNSPlatformRawTime: last_mach_absolute_time %08X%08X", last_mach_absolute_time);
10186 LogMsg("mDNSPlatformRawTime: this_mach_absolute_time %08X%08X", this_mach_absolute_time);
10187 // Update last_mach_absolute_time *before* calling NotifyOfElusiveBug()
10188 last_mach_absolute_time = this_mach_absolute_time;
10189 // Note: This bug happens all the time on 10.3
10190 NotifyOfElusiveBug("mach_absolute_time went backwards!",
10191 "This error occurs from time to time, often on newly released hardware, "
10192 "and usually the exact cause is different in each instance.\r\r"
10193 "Please file a new Radar bug report with the title “mach_absolute_time went backwards” "
10194 "and assign it to Radar Component “Kernel” Version “X”.");
10195 }
10196 last_mach_absolute_time = this_mach_absolute_time;
10197
10198 return((mDNSs32)(this_mach_absolute_time / mDNSPlatformClockDivisor));
10199 }
10200
10201 mDNSexport mDNSs32 mDNSPlatformUTC(void)
10202 {
10203 return time(NULL);
10204 }
10205
10206 // Locking is a no-op here, because we're single-threaded with a CFRunLoop, so we can never interrupt ourselves
10207 mDNSexport void mDNSPlatformLock (const mDNS *const m) { (void)m; }
10208 mDNSexport void mDNSPlatformUnlock (const mDNS *const m) { (void)m; }
10209 mDNSexport void mDNSPlatformStrCopy( void *dst, const void *src) { strcpy((char *)dst, (char *)src); }
10210 mDNSexport mDNSu32 mDNSPlatformStrLen ( const void *src) { return(strlen((char*)src)); }
10211 mDNSexport void mDNSPlatformMemCopy( void *dst, const void *src, mDNSu32 len) { memcpy(dst, src, len); }
10212 mDNSexport mDNSBool mDNSPlatformMemSame(const void *dst, const void *src, mDNSu32 len) { return(memcmp(dst, src, len) == 0); }
10213 mDNSexport int mDNSPlatformMemCmp(const void *dst, const void *src, mDNSu32 len) { return(memcmp(dst, src, len)); }
10214 mDNSexport void mDNSPlatformMemZero( void *dst, mDNSu32 len) { memset(dst, 0, len); }
10215 mDNSexport void mDNSPlatformQsort ( void *base, int nel, int width, int (*compar)(const void *, const void *))
10216 {
10217 return (qsort(base, nel, width, compar));
10218 }
10219 #if !(APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING)
10220 mDNSexport void * mDNSPlatformMemAllocate(mDNSu32 len) { return(mallocL("mDNSPlatformMemAllocate", len)); }
10221 #endif
10222 mDNSexport void mDNSPlatformMemFree (void *mem) { freeL("mDNSPlatformMemFree", mem); }
10223
10224 mDNSexport void mDNSPlatformSetAllowSleep(mDNS *const m, mDNSBool allowSleep, const char *reason)
10225 {
10226 if (allowSleep && m->p->IOPMAssertion)
10227 {
10228 LogInfo("%s Destroying NoIdleSleep power assertion", __FUNCTION__);
10229 IOPMAssertionRelease(m->p->IOPMAssertion);
10230 m->p->IOPMAssertion = 0;
10231 }
10232 else if (!allowSleep)
10233 {
10234 #ifdef kIOPMAssertionTypeNoIdleSleep
10235 if (m->p->IOPMAssertion)
10236 {
10237 IOPMAssertionRelease(m->p->IOPMAssertion);
10238 m->p->IOPMAssertion = 0;
10239 }
10240
10241 CFStringRef assertionName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%s.%d %s"), getprogname(), getpid(), reason ? reason : "");
10242 IOPMAssertionCreateWithName(kIOPMAssertionTypeNoIdleSleep, kIOPMAssertionLevelOn, assertionName ? assertionName : CFSTR("mDNSResponder"), &m->p->IOPMAssertion);
10243 if (assertionName) CFRelease(assertionName);
10244 LogInfo("%s Creating NoIdleSleep power assertion", __FUNCTION__);
10245 #endif
10246 }
10247 }
10248
10249 mDNSexport void mDNSPlatformSendWakeupPacket(mDNS *const m, mDNSInterfaceID InterfaceID, char *EthAddr, char *IPAddr, int iteration)
10250 {
10251 mDNSu32 ifindex;
10252
10253 // Sanity check
10254 ifindex = mDNSPlatformInterfaceIndexfromInterfaceID(m, InterfaceID, mDNStrue);
10255 if (ifindex <= 0)
10256 {
10257 LogMsg("mDNSPlatformSendWakeupPacket: ERROR!! Invalid InterfaceID %u", ifindex);
10258 return;
10259 }
10260 mDNSSendWakeupPacket(ifindex, EthAddr, IPAddr, iteration);
10261 }
10262
10263 mDNSexport mDNSBool mDNSPlatformInterfaceIsD2D(mDNSInterfaceID InterfaceID)
10264 {
10265 NetworkInterfaceInfoOSX *info;
10266
10267 if (InterfaceID == mDNSInterface_P2P)
10268 return mDNStrue;
10269
10270 if ( (InterfaceID == mDNSInterface_Any)
10271 || (InterfaceID == mDNSInterfaceMark)
10272 || (InterfaceID == mDNSInterface_LocalOnly)
10273 || (InterfaceID == mDNSInterface_Unicast))
10274 return mDNSfalse;
10275
10276 info = IfindexToInterfaceInfoOSX(&mDNSStorage, InterfaceID);
10277 if (info == NULL)
10278 {
10279 // this log message can print when operations are stopped on an interface that has gone away
10280 LogInfo("mDNSPlatformInterfaceIsD2D: Invalid interface index %d", InterfaceID);
10281 return mDNSfalse;
10282 }
10283
10284 return (mDNSBool) info->D2DInterface;
10285 }
10286
10287 // Filter records send over P2P (D2D) type interfaces
10288 // Note that the terms P2P and D2D are used synonymously in the current code and comments.
10289 mDNSexport mDNSBool mDNSPlatformValidRecordForInterface(AuthRecord *rr, const NetworkInterfaceInfo *intf)
10290 {
10291 // For an explicit match to a valid interface ID, return true.
10292 if (rr->resrec.InterfaceID == intf->InterfaceID)
10293 return mDNStrue;
10294
10295 // Only filtering records for D2D type interfaces, return true for all other interface types.
10296 if (!mDNSPlatformInterfaceIsD2D(intf->InterfaceID))
10297 return mDNStrue;
10298
10299 // If it's an AWDL interface the record must be explicitly marked to include AWDL.
10300 if (intf->InterfaceID == AWDLInterfaceID)
10301 {
10302 if (rr->ARType == AuthRecordAnyIncludeAWDL || rr->ARType == AuthRecordAnyIncludeAWDLandP2P)
10303 return mDNStrue;
10304 else
10305 return mDNSfalse;
10306 }
10307
10308 // Send record if it is explicitly marked to include all other P2P type interfaces.
10309 if (rr->ARType == AuthRecordAnyIncludeP2P || rr->ARType == AuthRecordAnyIncludeAWDLandP2P)
10310 return mDNStrue;
10311
10312 // Don't send the record over this interface.
10313 return mDNSfalse;
10314 }
10315
10316 // Filter questions send over P2P (D2D) type interfaces.
10317 mDNSexport mDNSBool mDNSPlatformValidQuestionForInterface(DNSQuestion *q, const NetworkInterfaceInfo *intf)
10318 {
10319 // For an explicit match to a valid interface ID, return true.
10320 if (q->InterfaceID == intf->InterfaceID)
10321 return mDNStrue;
10322
10323 // Only filtering questions for D2D type interfaces
10324 if (!mDNSPlatformInterfaceIsD2D(intf->InterfaceID))
10325 return mDNStrue;
10326
10327 // If it's an AWDL interface the question must be explicitly marked to include AWDL.
10328 if (intf->InterfaceID == AWDLInterfaceID)
10329 {
10330 if (q->flags & kDNSServiceFlagsIncludeAWDL)
10331 return mDNStrue;
10332 else
10333 return mDNSfalse;
10334 }
10335
10336 // Sent question if it is explicitly marked to include all other P2P type interfaces.
10337 if (q->flags & kDNSServiceFlagsIncludeP2P)
10338 return mDNStrue;
10339
10340 // Don't send the question over this interface.
10341 return mDNSfalse;
10342 }
10343
10344 // Returns true unless record was received over the AWDL interface and
10345 // the question was not specific to the AWDL interface or did not specify kDNSServiceInterfaceIndexAny
10346 // with the kDNSServiceFlagsIncludeAWDL flag set.
10347 mDNSexport mDNSBool mDNSPlatformValidRecordForQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
10348 {
10349 if (!rr->InterfaceID || (rr->InterfaceID == q->InterfaceID))
10350 return mDNStrue;
10351
10352 if ((rr->InterfaceID == AWDLInterfaceID) && !(q->flags & kDNSServiceFlagsIncludeAWDL))
10353 {
10354 LogInfo("mDNSPlatformValidRecordForQuestion: Record recieved over AWDL not returned for %s %##s query",
10355 DNSTypeName(q->qtype), q->qname.c);
10356 return mDNSfalse;
10357 }
10358
10359 return mDNStrue;
10360 }
10361
10362 // formating time to RFC 4034 format
10363 mDNSexport void mDNSPlatformFormatTime(unsigned long te, mDNSu8 *buf, int bufsize)
10364 {
10365 struct tm tmTime;
10366 time_t t = (time_t)te;
10367 // Time since epoch : strftime takes "tm". Convert seconds to "tm" using
10368 // gmtime_r first and then use strftime
10369 gmtime_r(&t, &tmTime);
10370 strftime((char *)buf, bufsize, "%Y%m%d%H%M%S", &tmTime);
10371 }
10372
10373 mDNSexport mDNSs32 mDNSPlatformGetPID()
10374 {
10375 return getpid();
10376 }
10377
10378 // Schedule a function asynchronously on the main queue
10379 mDNSexport void mDNSPlatformDispatchAsync(mDNS *const m, void *context, AsyncDispatchFunc func)
10380 {
10381 // KQueueLock/Unlock is used for two purposes
10382 //
10383 // 1. We can't be running along with the KQueue thread and hence acquiring the lock
10384 // serializes the access to the "core"
10385 //
10386 // 2. KQueueUnlock also sends a message wake up the KQueue thread which in turn wakes
10387 // up and calls udsserver_idle which schedules the messages across the uds socket.
10388 // If "func" delivers something to the uds socket from the dispatch thread, it will
10389 // not be delivered immediately if not for the Unlock.
10390 dispatch_async(dispatch_get_main_queue(), ^{
10391 KQueueLock(m);
10392 func(m, context);
10393 KQueueUnlock(m, "mDNSPlatformDispatchAsync");
10394 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
10395 // KQueueUnlock is a noop. Hence, we need to run kick off the idle loop
10396 // to handle any message that "func" might deliver.
10397 TriggerEventCompletion();
10398 #endif
10399 });
10400 }
10401
10402 // definitions for device-info record construction
10403 #define DEVINFO_MODEL "model="
10404 #define DEVINFO_MODEL_LEN strlen(DEVINFO_MODEL)
10405
10406 #define OSX_VER "osxvers="
10407 #define OSX_VER_LEN strlen(OSX_VER)
10408 #define VER_NUM_LEN 2 // 2 digits of version number added to base string
10409
10410 // Bytes available in TXT record for model name after subtracting space for other
10411 // fixed size strings and their length bytes.
10412 #define MAX_MODEL_NAME_LEN (256 - (DEVINFO_MODEL_LEN + 1) - (OSX_VER_LEN + VER_NUM_LEN + 1))
10413
10414 // Initialize device-info TXT record contents and return total length of record data.
10415 mDNSexport mDNSu32 initializeDeviceInfoTXT(mDNS *m, mDNSu8 *ptr)
10416 {
10417 mDNSu8 *bufferStart = ptr;
10418 mDNSu8 len = m->HIHardware.c[0] < MAX_MODEL_NAME_LEN ? m->HIHardware.c[0] : MAX_MODEL_NAME_LEN;
10419
10420 *ptr = DEVINFO_MODEL_LEN + len; // total length of DEVINFO_MODEL string plus the hardware name string
10421 ptr++;
10422 mDNSPlatformMemCopy(ptr, DEVINFO_MODEL, DEVINFO_MODEL_LEN);
10423 ptr += DEVINFO_MODEL_LEN;
10424 mDNSPlatformMemCopy(ptr, m->HIHardware.c + 1, len);
10425 ptr += len;
10426
10427 // only include this string for OSX
10428 if (OSXVers)
10429 {
10430 char ver_num[VER_NUM_LEN + 1]; // version digits + null written by snprintf
10431 *ptr = OSX_VER_LEN + VER_NUM_LEN; // length byte
10432 ptr++;
10433 mDNSPlatformMemCopy(ptr, OSX_VER, OSX_VER_LEN);
10434 ptr += OSX_VER_LEN;
10435 // convert version number to ASCII, add 1 for terminating null byte written by snprintf()
10436 snprintf(ver_num, VER_NUM_LEN + 1, "%d", OSXVers);
10437 mDNSPlatformMemCopy(ptr, ver_num, VER_NUM_LEN);
10438 ptr += VER_NUM_LEN;
10439 }
10440
10441 return (ptr - bufferStart);
10442 }