1 /* -*- Mode: C; tab-width: 4 -*-
3 * Copyright (c) 2002-2013 Apple Computer, Inc. All rights reserved.
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 // ***************************************************************************
20 // Supporting routines to run mDNS on a CFRunLoop platform
21 // ***************************************************************************
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
27 #include "mDNSEmbeddedAPI.h" // Defines the interface provided to the client layer above
28 #include "DNSCommon.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"
37 #include <stdarg.h> // For va_list support
38 #include <stdlib.h> // For arc4random
40 #include <net/if_types.h> // For IFT_ETHER
41 #include <net/if_dl.h>
42 #include <net/bpf.h> // For BIOCSETIF etc.
44 #include <sys/param.h>
45 #include <sys/socket.h>
46 #include <sys/sysctl.h>
47 #include <sys/event.h>
49 #include <sys/ioctl.h>
50 #include <time.h> // platform support for UTC time
51 #include <arpa/inet.h> // for inet_aton
53 #include <netdb.h> // for getaddrinfo
54 #include <sys/sockio.h> // for SIOCGIFEFLAGS
56 #include <netinet/in.h> // For IP_RECVTTL
58 #define IP_RECVTTL 24 // bool; receive reception TTL w/dgram
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.
66 #include <netinet/tcp.h>
68 #include <DebugServices.h>
73 #include <IOKit/IOKitLib.h>
74 #include <IOKit/IOMessage.h>
76 #include <IOKit/ps/IOPowerSources.h>
77 #include <IOKit/ps/IOPowerSourcesPrivate.h>
78 #include <IOKit/ps/IOPSKeys.h>
80 #include <mach/mach_error.h>
81 #include <mach/mach_port.h>
82 #include <mach/mach_time.h>
84 #include "P2PPacketFilter.h"
87 #include <SystemConfiguration/SCPrivate.h>
89 // Include definition of opaque_presence_indication for KEV_DL_NODE_PRESENCE handling logic.
90 #include <Kernel/IOKit/apple80211/apple80211_var.h>
92 #if APPLE_OSX_mDNSResponder
93 #include <DeviceToDeviceManager/DeviceToDeviceManager.h>
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
));
112 #endif // APPLE_OSX_mDNSResponder
114 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
115 #include <IOKit/platform/IOPlatformSupportPrivate.h>
116 #endif // APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
119 #define kInterfaceSpecificOption "interface="
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'
126 // cache the InterfaceID of the AWDL interface
127 static mDNSInterfaceID AWDLInterfaceID
;
129 // ***************************************************************************
132 #if COMPILER_LIKES_PRAGMA_MARK
133 #pragma mark - Globals
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
144 mDNSexport
int OSXVers
, iOSVers
;
145 mDNSexport
int KQueueFD
;
147 #ifndef NO_SECURITYFRAMEWORK
148 static CFArrayRef ServerCerts
;
149 OSStatus
SSLSetAllowAnonymousCiphers(SSLContextRef context
, Boolean enable
);
150 #endif /* NO_SECURITYFRAMEWORK */
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");
163 static char HINFO_HWstring_buffer
[32];
164 static char *HINFO_HWstring
= "Device";
165 static int HINFO_HWstring_prefixlen
= 6;
167 mDNSexport
int WatchDogReportingThreshold
= 250;
169 dispatch_queue_t SSLqueue
;
171 //To prevent blocking the main queue, all writes to DynamicStore happen on the DynamicStoreQueue
172 static dispatch_queue_t DynamicStoreQueue
;
174 #if TARGET_OS_EMBEDDED
175 #define kmDNSResponderManagedPrefsID CFSTR("/Library/Managed Preferences/mobile/com.apple.mDNSResponder.plist")
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
188 // Don't send triggers too often. We arbitrarily limit it to three minutes.
189 #define DNS_TRIGGER_INTERVAL (180 * mDNSPlatformOneSecond)
191 // Used by AutoTunnel
192 const char btmmprefix
[] = "btmmdns:";
193 const char dnsprefix
[] = "dns:";
195 // String Array used to write list of private domains to Dynamic Store
196 static CFArrayRef privateDnsArray
= NULL
;
198 // ***************************************************************************
199 #if COMPILER_LIKES_PRAGMA_MARK
201 #pragma mark - D2D Support
206 mDNSexport
void D2D_start_advertising_interface(NetworkInterfaceInfo
*interface
)
208 // AWDL wants the address and reverse address PTR record communicated
209 // via the D2D interface layer.
210 if (interface
->InterfaceID
== AWDLInterfaceID
)
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
);
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
);
223 mDNSexport
void D2D_stop_advertising_interface(NetworkInterfaceInfo
*interface
)
225 if (interface
->InterfaceID
== AWDLInterfaceID
)
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
);
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
);
238 // Name compression items for fake packet version number 1
239 static const mDNSu8 compression_packet_v1
= 0x01;
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;
245 mDNSlocal
void FreeD2DARElemCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
);
246 mDNSlocal
void PrintHex(mDNSu8
*data
, mDNSu16 len
);
248 typedef struct D2DRecordListElem
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.
257 static D2DRecordListElem
*D2DRecords
= NULL
; // List of records returned with D2DServiceFound events
259 typedef struct D2DBrowseListElem
261 struct D2DBrowseListElem
*next
;
264 unsigned int refCount
;
267 D2DBrowseListElem
* D2DBrowseList
= NULL
;
269 mDNSlocal mDNSu8
*putVal16(mDNSu8
*ptr
, mDNSu16 val
)
271 ptr
[0] = (mDNSu8
)((val
>> 8 ) & 0xFF);
272 ptr
[1] = (mDNSu8
)((val
) & 0xFF);
273 return ptr
+ sizeof(mDNSu16
);
276 mDNSlocal mDNSu8
*putVal32(mDNSu8
*ptr
, mDNSu32 val
)
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
);
285 mDNSlocal
void DomainnameToLower(const domainname
* const in
, domainname
* const out
)
287 const mDNSu8
* const start
= (const mDNSu8
* const)in
;
288 mDNSu8
*ptr
= (mDNSu8
*)start
;
292 out
->c
[ptr
-start
] = *ptr
;
294 for (; c
; c
--,ptr
++) out
->c
[ptr
-start
] = mDNSIsUpperCase(*ptr
) ? (*ptr
- 'A' + 'a') : *ptr
;
296 out
->c
[ptr
-start
] = *ptr
;
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
)
301 if (mDNS_LoggingEnabled
)
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
);
308 mDNSu8
*ptr
= compression_lhs
; // pointer to the end of our fake packet
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
;
314 // Copy the LHS onto our fake wire packet
315 mDNSPlatformMemCopy(ptr
, lhs
, lhs_len
);
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
;
321 // two bytes of CLASS
322 ptr
= putVal16(ptr
, kDNSClass_IN
| kDNSClass_UniqueRRSet
);
325 ptr
= putVal32(ptr
, 120);
327 // Copy the RHS length into the RDLENGTH of our fake wire packet
328 ptr
= putVal16(ptr
, rhs_len
);
330 // Copy the RHS onto our fake wire packet
331 mDNSPlatformMemCopy(ptr
, rhs
, rhs_len
);
334 if (mDNS_LoggingEnabled
)
336 LogInfo(" Our Bytes (%d bytes): ", ptr
- compression_lhs
);
337 PrintHex(compression_lhs
, ptr
- compression_lhs
);
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
));
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
353 m
->rec
.r
.resrec
.RecordType
= 0; // Mark m->rec as no longer in use
355 return mStatus_NoError
;
358 mDNSlocal mDNSu8
* DNSNameCompressionBuildLHS(const domainname
* typeDomain
, DNS_TypeValues qtype
)
360 mDNSu8
*ptr
= putDomainNameAsLabels(&compression_base_msg
, compression_lhs
, compression_limit
, typeDomain
);
361 if (!ptr
) return ptr
;
362 *ptr
= (qtype
>> 8) & 0xff;
366 *ptr
= compression_packet_v1
;
370 mDNSlocal mDNSu8
* DNSNameCompressionBuildRHS(mDNSu8
*start
, const ResourceRecord
*const resourceRecord
)
372 return putRData(&compression_base_msg
, start
, compression_limit
, resourceRecord
);
375 #define PRINT_DEBUG_BYTES_LIMIT 64 // set limit on number of record bytes printed for debugging
377 mDNSlocal
void PrintHex(mDNSu8
*data
, mDNSu16 len
)
380 char buffer
[49] = {0};
381 char *bufend
= buffer
+ sizeof(buffer
);
383 if (len
> PRINT_DEBUG_BYTES_LIMIT
)
385 LogInfo(" (limiting debug output to %d bytes)", PRINT_DEBUG_BYTES_LIMIT
);
386 len
= PRINT_DEBUG_BYTES_LIMIT
;
393 for(; data
< end
&& ptr
< bufend
-1; ptr
+=3,data
++)
394 mDNS_snprintf(ptr
, bufend
- ptr
, "%02X ", *data
);
395 LogInfo(" %s", buffer
);
399 mDNSlocal
void PrintHelper(const char *const tag
, mDNSu8
*lhs
, mDNSu16 lhs_len
, mDNSu8
*rhs
, mDNSu16 rhs_len
)
401 if (!mDNS_LoggingEnabled
) return;
404 LogInfo(" LHS: (%d bytes)", lhs_len
);
405 PrintHex(lhs
, lhs_len
);
409 LogInfo(" RHS: (%d bytes)", rhs_len
);
410 PrintHex(rhs
, rhs_len
);
413 mDNSlocal
void FreeD2DARElemCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
416 if (result
== mStatus_MemFree
)
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
));
425 // Just because we stoppped browsing, doesn't mean we should tear down the PAN connection.
426 mDNSPlatformMemFree(tmp
);
430 mDNSexport
void external_connection_release(const domainname
*instance
)
433 D2DRecordListElem
*ptr
= D2DRecords
;
435 for ( ; ptr
; ptr
= ptr
->next
)
437 if ((ptr
->ar
.resrec
.rrtype
== kDNSServiceType_PTR
) &&
438 SameDomainName(&ptr
->ar
.rdatastorage
.u
.name
, instance
))
440 LogInfo("external_connection_release: Calling D2DRelease(instanceHandle = %p, transportType = %d",
441 ptr
->instanceHandle
, ptr
->transportType
);
442 if (D2DRelease
) D2DRelease(ptr
->instanceHandle
, ptr
->transportType
);
447 mDNSlocal
void xD2DClearCache(const domainname
*regType
, DNS_TypeValues qtype
)
449 D2DRecordListElem
*ptr
= D2DRecords
;
450 for ( ; ptr
; ptr
= ptr
->next
)
452 if ((ptr
->ar
.resrec
.rrtype
== qtype
) && SameDomainName(&ptr
->ar
.namestorage
, regType
))
454 mDNS_Deregister(&mDNSStorage
, &ptr
->ar
);
455 LogInfo("xD2DClearCache: Clearing cache record and deregistering %s", ARDisplayString(&mDNSStorage
, &ptr
->ar
));
460 mDNSlocal D2DBrowseListElem
** D2DFindInBrowseList(const domainname
*const name
, mDNSu16 type
)
462 D2DBrowseListElem
**ptr
= &D2DBrowseList
;
464 for ( ; *ptr
; ptr
= &(*ptr
)->next
)
465 if ((*ptr
)->type
== type
&& SameDomainName(&(*ptr
)->name
, name
))
471 mDNSlocal
unsigned int D2DBrowseListRefCount(const domainname
*const name
, mDNSu16 type
)
473 D2DBrowseListElem
**ptr
= D2DFindInBrowseList(name
, type
);
474 return *ptr
? (*ptr
)->refCount
: 0;
477 mDNSlocal
void D2DBrowseListRetain(const domainname
*const name
, mDNSu16 type
)
479 D2DBrowseListElem
**ptr
= D2DFindInBrowseList(name
, type
);
483 *ptr
= mDNSPlatformMemAllocate(sizeof(**ptr
));
484 mDNSPlatformMemZero(*ptr
, sizeof(**ptr
));
486 AssignDomainName(&(*ptr
)->name
, name
);
488 (*ptr
)->refCount
+= 1;
490 LogInfo("D2DBrowseListRetain: %##s %s refcount now %u", (*ptr
)->name
.c
, DNSTypeName((*ptr
)->type
), (*ptr
)->refCount
);
493 mDNSlocal
void D2DBrowseListRelease(const domainname
*const name
, mDNSu16 type
)
495 D2DBrowseListElem
**ptr
= D2DFindInBrowseList(name
, type
);
497 if (!*ptr
) { LogMsg("D2DBrowseListRelease: Didn't find %##s %s in list", name
->c
, DNSTypeName(type
)); return; }
499 (*ptr
)->refCount
-= 1;
501 LogInfo("D2DBrowseListRelease: %##s %s refcount now %u", (*ptr
)->name
.c
, DNSTypeName((*ptr
)->type
), (*ptr
)->refCount
);
503 if (!(*ptr
)->refCount
)
505 D2DBrowseListElem
*tmp
= *ptr
;
507 mDNSPlatformMemFree(tmp
);
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
)
513 if (*(lhs
+ (lhs_len
- 1)) == compression_packet_v1
)
514 return DNSNameCompressionParseBytes(m
, lhs
, lhs_len
, rhs
, rhs_len
, rr
);
516 return mStatus_Incompatible
;
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
)
521 if (result
== kD2DSuccess
)
523 if ( key
== NULL
|| value
== NULL
|| keySize
== 0 || valueSize
== 0) { LogMsg("xD2DAddToCache: NULL Byte * passed in or length == 0"); return; }
526 D2DRecordListElem
*ptr
= mDNSPlatformMemAllocate(sizeof(D2DRecordListElem
) + (valueSize
< sizeof(RData
) ? 0 : valueSize
- sizeof(RData
)));
528 if (ptr
== NULL
) { LogMsg("xD2DAddToCache: memory allocation failure"); return; }
530 err
= xD2DParse(m
, (const mDNSu8
* const)key
, (const mDNSu16
)keySize
, (const mDNSu8
* const)value
, (const mDNSu16
)valueSize
, &ptr
->ar
);
533 LogMsg("xD2DAddToCache: xD2DParse returned error: %d", err
);
534 PrintHelper(__func__
, (mDNSu8
*)key
, (mDNSu16
)keySize
, (mDNSu8
*)value
, (mDNSu16
)valueSize
);
535 mDNSPlatformMemFree(ptr
);
538 err
= mDNS_Register(m
, &ptr
->ar
);
541 LogMsg("xD2DAddToCache: mDNS_Register returned error %d for %s", err
, ARDisplayString(m
, &ptr
->ar
));
542 mDNSPlatformMemFree(ptr
);
546 LogInfo("xD2DAddToCache: mDNS_Register succeeded for %s", ARDisplayString(m
, &ptr
->ar
));
547 ptr
->instanceHandle
= instanceHandle
;
548 ptr
->transportType
= transportType
;
549 ptr
->next
= D2DRecords
;
553 LogMsg("xD2DAddToCache: Unexpected result %d", result
);
556 mDNSlocal D2DRecordListElem
* xD2DFindInList(mDNS
*const m
, const Byte
*const key
, const size_t keySize
, const Byte
*const value
, const size_t valueSize
)
558 D2DRecordListElem
*ptr
= D2DRecords
;
559 D2DRecordListElem
*arptr
;
561 if ( key
== NULL
|| value
== NULL
|| keySize
== 0 || valueSize
== 0) { LogMsg("xD2DFindInList: NULL Byte * passed in or length == 0"); return NULL
; }
563 arptr
= mDNSPlatformMemAllocate(sizeof(D2DRecordListElem
) + (valueSize
< sizeof(RData
) ? 0 : valueSize
- sizeof(RData
)));
564 if (arptr
== NULL
) { LogMsg("xD2DFindInList: memory allocation failure"); return NULL
; }
566 if (xD2DParse(m
, (const mDNSu8
*const)key
, (const mDNSu16
)keySize
, (const mDNSu8
*const)value
, (const mDNSu16
)valueSize
, &arptr
->ar
) != mStatus_NoError
)
568 LogMsg("xD2DFindInList: xD2DParse failed for key: %p (%u) value: %p (%u)", key
, keySize
, value
, valueSize
);
569 mDNSPlatformMemFree(arptr
);
575 if (IdenticalResourceRecord(&arptr
->ar
.resrec
, &ptr
->ar
.resrec
)) break;
579 if (!ptr
) LogMsg("xD2DFindInList: Could not find in D2DRecords: %s", ARDisplayString(m
, &arptr
->ar
));
580 mDNSPlatformMemFree(arptr
);
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
)
586 (void)transportType
; // We don't care about this, yet.
587 (void)instanceHandle
; // We don't care about this, yet.
589 if (result
== kD2DSuccess
)
591 D2DRecordListElem
*ptr
= xD2DFindInList(m
, key
, keySize
, value
, valueSize
);
594 LogInfo("xD2DRemoveFromCache: Remove from cache: %s", ARDisplayString(m
, &ptr
->ar
));
595 mDNS_Deregister(m
, &ptr
->ar
);
599 LogMsg("xD2DRemoveFromCache: Unexpected result %d", result
);
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
)
610 if (result
== kD2DSuccess
)
612 LogInfo("xD2DServiceResolved: Starting up PAN connection for %p", instanceHandle
);
613 if (D2DRetain
) D2DRetain(instanceHandle
, transportType
);
615 else LogMsg("xD2DServiceResolved: Unexpected result %d", result
);
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
)
621 (void)instanceHandle
;
628 if (result
== kD2DSuccess
) LogInfo("xD2DRetainHappened: Opening up PAN connection for %p", instanceHandle
);
629 else LogMsg("xD2DRetainHappened: Unexpected result %d", result
);
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
)
635 (void)instanceHandle
;
642 if (result
== kD2DSuccess
) LogInfo("xD2DReleaseHappened: Closing PAN connection for %p", instanceHandle
);
643 else LogMsg("xD2DReleaseHappened: Unexpected result %d", result
);
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
)
648 mDNS
*m
= (mDNS
*) userData
;
649 const char *eventString
= "unknown";
653 if (keySize
> 0xFFFF) LogMsg("xD2DServiceCallback: keySize too large: %u", keySize
);
654 if (valueSize
> 0xFFFF) LogMsg("xD2DServiceCallback: valueSize too large: %u", valueSize
);
658 case D2DServiceFound
:
659 eventString
= "D2DServiceFound";
662 eventString
= "D2DServiceLost";
664 case D2DServiceResolved
:
665 eventString
= "D2DServiceResolved";
667 case D2DServiceRetained
:
668 eventString
= "D2DServiceRetained";
670 case D2DServiceReleased
:
671 eventString
= "D2DServiceReleased";
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
);
682 case D2DServiceFound
:
683 xD2DAddToCache(m
, result
, instanceHandle
, transportType
, key
, keySize
, value
, valueSize
);
686 xD2DRemoveFromCache(m
, result
, instanceHandle
, transportType
, key
, keySize
, value
, valueSize
);
688 case D2DServiceResolved
:
689 xD2DServiceResolved(m
, result
, instanceHandle
, transportType
, key
, keySize
, value
, valueSize
);
691 case D2DServiceRetained
:
692 xD2DRetainHappened(m
, result
, instanceHandle
, transportType
, key
, keySize
, value
, valueSize
);
694 case D2DServiceReleased
:
695 xD2DReleaseHappened(m
, result
, instanceHandle
, transportType
, key
, keySize
, value
, valueSize
);
701 // Need to tickle the main kqueue loop to potentially handle records we removed or added.
702 KQueueUnlock(m
, "xD2DServiceCallback");
705 // Map interface index and flags to a specific D2D transport type or D2DTransportMax if all plugins
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.
711 mDNSlocal D2DTransportType
xD2DInterfaceToTransportType(mDNSInterfaceID InterfaceID
, DNSServiceFlags flags
, D2DTransportType
* excludedTransportType
)
713 NetworkInterfaceInfoOSX
*info
;
715 // Default exludes the D2DAWDLTransport when D2DTransportMax is returned.
716 *excludedTransportType
= D2DAWDLTransport
;
718 // Call all D2D plugins when both kDNSServiceFlagsIncludeP2P and kDNSServiceFlagsIncludeAWDL are set.
719 if ((flags
& kDNSServiceFlagsIncludeP2P
) && (flags
& kDNSServiceFlagsIncludeAWDL
))
721 LogInfo("xD2DInterfaceToTransportType: returning D2DTransportMax (including AWDL) since both kDNSServiceFlagsIncludeP2P and kDNSServiceFlagsIncludeAWDL are set");
722 *excludedTransportType
= D2DTransportMax
;
723 return D2DTransportMax
;
725 // Call all D2D plugins (exlcluding AWDL) when only kDNSServiceFlagsIncludeP2P is set.
726 else if (flags
& kDNSServiceFlagsIncludeP2P
)
728 LogInfo("xD2DInterfaceToTransportType: returning D2DTransportMax (excluding AWDL) since only kDNSServiceFlagsIncludeP2P is set");
729 return D2DTransportMax
;
731 // Call AWDL D2D plugin when only kDNSServiceFlagsIncludeAWDL is set.
732 else if (flags
& kDNSServiceFlagsIncludeAWDL
)
734 LogInfo("xD2DInterfaceToTransportType: returning D2DAWDLTransport since only kDNSServiceFlagsIncludeAWDL is set");
735 return D2DAWDLTransport
;
738 if (InterfaceID
== mDNSInterface_P2P
)
740 LogInfo("xD2DInterfaceToTransportType: returning D2DTransportMax (excluding AWDL) for interface index mDNSInterface_P2P");
741 return D2DTransportMax
;
744 // Compare to cached AWDL interface ID.
745 if (AWDLInterfaceID
&& (InterfaceID
== AWDLInterfaceID
))
747 LogInfo("xD2DInterfaceToTransportType: returning D2DAWDLTransport for interface index %d", InterfaceID
);
748 return D2DAWDLTransport
;
751 info
= IfindexToInterfaceInfoOSX(&mDNSStorage
, InterfaceID
);
754 LogInfo("xD2DInterfaceToTransportType: Invalid interface index %d", InterfaceID
);
755 return D2DTransportMax
;
758 // Recognize AirDrop specific p2p* interface based on interface name.
759 if (strncmp(info
->ifinfo
.ifname
, "p2p", 3) == 0)
761 LogInfo("xD2DInterfaceToTransportType: returning D2DWifiPeerToPeerTransport for interface index %d", InterfaceID
);
762 return D2DWifiPeerToPeerTransport
;
765 // Currently there is no way to identify Bluetooth interface by name,
766 // since they use "en*" based name strings.
768 LogInfo("xD2DInterfaceToTransportType: returning default D2DTransportMax for interface index %d", InterfaceID
);
769 return D2DTransportMax
;
772 mDNSexport
void external_start_browsing_for_service(mDNSInterfaceID InterfaceID
, const domainname
*const typeDomain
, DNS_TypeValues qtype
, DNSServiceFlags flags
)
776 if (qtype
== kDNSServiceType_A
|| qtype
== kDNSServiceType_AAAA
)
778 LogInfo("external_start_browsing_for_service: ignoring address record");
782 DomainnameToLower(typeDomain
, &lower
);
784 if (!D2DBrowseListRefCount(&lower
, qtype
))
786 D2DTransportType transportType
, excludedTransport
;
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);
792 transportType
= xD2DInterfaceToTransportType(InterfaceID
, flags
, & excludedTransport
);
793 if (transportType
== D2DTransportMax
)
796 for (i
= 0; i
< D2DTransportMax
; i
++)
798 if (i
== excludedTransport
) continue;
799 if (D2DStartBrowsingForKeyOnTransport
) D2DStartBrowsingForKeyOnTransport(compression_lhs
, end
- compression_lhs
, i
);
804 if (D2DStartBrowsingForKeyOnTransport
) D2DStartBrowsingForKeyOnTransport(compression_lhs
, end
- compression_lhs
, transportType
);
807 D2DBrowseListRetain(&lower
, qtype
);
810 mDNSexport
void external_stop_browsing_for_service(mDNSInterfaceID InterfaceID
, const domainname
*const typeDomain
, DNS_TypeValues qtype
, DNSServiceFlags flags
)
814 if (qtype
== kDNSServiceType_A
|| qtype
== kDNSServiceType_AAAA
)
816 LogInfo("external_stop_browsing_for_service: ignoring address record");
820 DomainnameToLower(typeDomain
, &lower
);
822 D2DBrowseListRelease(&lower
, qtype
);
823 if (!D2DBrowseListRefCount(&lower
, qtype
))
825 D2DTransportType transportType
, excludedTransport
;
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);
831 transportType
= xD2DInterfaceToTransportType(InterfaceID
, flags
, & excludedTransport
);
832 if (transportType
== D2DTransportMax
)
835 for (i
= 0; i
< D2DTransportMax
; i
++)
837 if (i
== excludedTransport
) continue;
838 if (D2DStopBrowsingForKeyOnTransport
) D2DStopBrowsingForKeyOnTransport(compression_lhs
, end
- compression_lhs
, i
);
843 if (D2DStopBrowsingForKeyOnTransport
) D2DStopBrowsingForKeyOnTransport(compression_lhs
, end
- compression_lhs
, transportType
);
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
849 xD2DClearCache(&lower
, qtype
);
853 mDNSexport
void external_start_advertising_service(const ResourceRecord
*const resourceRecord
, DNSServiceFlags flags
)
858 D2DTransportType transportType
, excludedTransport
;
859 DomainnameToLower(resourceRecord
->name
, &lower
);
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
);
867 rhs
= DNSNameCompressionBuildLHS(&lower
, resourceRecord
->rrtype
);
868 end
= DNSNameCompressionBuildRHS(rhs
, resourceRecord
);
869 PrintHelper(__func__
, compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
);
871 transportType
= xD2DInterfaceToTransportType(resourceRecord
->InterfaceID
, flags
, & excludedTransport
);
872 if (transportType
== D2DTransportMax
)
875 for (i
= 0; i
< D2DTransportMax
; i
++)
877 if (i
== excludedTransport
) continue;
878 if (D2DStartAdvertisingPairOnTransport
) D2DStartAdvertisingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, i
);
883 if (D2DStartAdvertisingPairOnTransport
) D2DStartAdvertisingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, transportType
);
887 mDNSexport
void external_stop_advertising_service(const ResourceRecord
*const resourceRecord
, DNSServiceFlags flags
)
892 D2DTransportType transportType
, excludedTransport
;
893 DomainnameToLower(resourceRecord
->name
, &lower
);
895 LogInfo("external_stop_advertising_service: %s", RRDisplayString(&mDNSStorage
, resourceRecord
));
897 // For SRV records, update packet filter to to remove this port from list
898 if (resourceRecord
->rrtype
== kDNSType_SRV
)
899 mDNSUpdatePacketFilter(resourceRecord
);
901 rhs
= DNSNameCompressionBuildLHS(&lower
, resourceRecord
->rrtype
);
902 end
= DNSNameCompressionBuildRHS(rhs
, resourceRecord
);
903 PrintHelper(__func__
, compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
);
905 transportType
= xD2DInterfaceToTransportType(resourceRecord
->InterfaceID
, flags
, & excludedTransport
);
906 if (transportType
== D2DTransportMax
)
909 for (i
= 0; i
< D2DTransportMax
; i
++)
911 if (i
== excludedTransport
) continue;
912 if (D2DStopAdvertisingPairOnTransport
) D2DStopAdvertisingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, i
);
917 if (D2DStopAdvertisingPairOnTransport
) D2DStopAdvertisingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, transportType
);
921 mDNSexport
void external_start_resolving_service(mDNSInterfaceID InterfaceID
, const domainname
*const fqdn
, DNSServiceFlags flags
)
926 mDNSBool AWDL_used
= false; // whether AWDL was used for this resolve
927 D2DTransportType transportType
, excludedTransport
;
928 DomainnameToLower(SkipLeadingLabels(fqdn
, 1), &lower
);
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
);
935 transportType
= xD2DInterfaceToTransportType(InterfaceID
, flags
, & excludedTransport
);
936 if (transportType
== D2DTransportMax
)
938 // Resolving over all the transports, except for excludedTransport if set.
940 for (i
= 0; i
< D2DTransportMax
; i
++)
942 if (i
== excludedTransport
) continue;
943 if (D2DStartResolvingPairOnTransport
) D2DStartResolvingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, i
);
945 if (i
== D2DAWDLTransport
)
951 // Resolving over one specific transport.
952 if (D2DStartResolvingPairOnTransport
) D2DStartResolvingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, transportType
);
954 if (transportType
== D2DAWDLTransport
)
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
)
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
);
969 mDNSexport
void external_stop_resolving_service(mDNSInterfaceID InterfaceID
, const domainname
*const fqdn
, DNSServiceFlags flags
)
974 mDNSBool AWDL_used
= false; // whether AWDL was used for this resolve
975 D2DTransportType transportType
, excludedTransport
;
976 DomainnameToLower(SkipLeadingLabels(fqdn
, 1), &lower
);
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
);
983 transportType
= xD2DInterfaceToTransportType(InterfaceID
, flags
, & excludedTransport
);
984 if (transportType
== D2DTransportMax
)
987 for (i
= 0; i
< D2DTransportMax
; i
++)
989 if (i
== excludedTransport
) continue;
990 if (D2DStopResolvingPairOnTransport
) D2DStopResolvingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, i
);
992 if (i
== D2DAWDLTransport
)
998 if (D2DStopResolvingPairOnTransport
) D2DStopResolvingPairOnTransport(compression_lhs
, rhs
- compression_lhs
, rhs
, end
- rhs
, transportType
);
1000 if (transportType
== D2DAWDLTransport
)
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
)
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
);
1015 #elif APPLE_OSX_mDNSResponder
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
;}
1026 // ***************************************************************************
1029 #if COMPILER_LIKES_PRAGMA_MARK
1031 #pragma mark - Utility Functions
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))
1042 mDNSexport
void NotifyOfElusiveBug(const char *title
, const char *msg
) // Both strings are UTF-8 text
1044 static int notifyCount
= 0;
1045 if (notifyCount
) return;
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;
1051 // Unless ForceAlerts is defined, we only show these bug report alerts on machines that have a 17.x.x.x address
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)
1059 if (!i
) return; // If not at Apple, don't show the alert
1063 LogMsg("%s", title
);
1065 // Display a notification to the user
1068 #ifndef NO_CFUSERNOTIFICATION
1069 mDNSNotify(title
, msg
);
1070 #endif /* NO_CFUSERNOTIFICATION */
1073 // Returns true if it is an AppleTV based hardware running iOS, false otherwise
1074 mDNSlocal mDNSBool
IsAppleTV(void)
1076 #if TARGET_OS_EMBEDDED
1077 static mDNSBool sInitialized
= mDNSfalse
;
1078 static mDNSBool sIsAppleTV
= mDNSfalse
;
1079 CFStringRef deviceClass
= NULL
;
1083 deviceClass
= (CFStringRef
) MGCopyAnswer(kMGQDeviceClass
, NULL
);
1086 if(CFEqual(deviceClass
, kMGDeviceClassAppleTV
))
1087 sIsAppleTV
= mDNStrue
;
1088 CFRelease(deviceClass
);
1090 sInitialized
= mDNStrue
;
1095 #endif // TARGET_OS_EMBEDDED
1098 mDNSlocal
struct ifaddrs
*myGetIfAddrs(int refresh
)
1100 static struct ifaddrs
*ifa
= NULL
;
1113 mDNSlocal
void DynamicStoreWrite(int key
, const char* subkey
, uintptr_t value
, signed long valueCnt
)
1115 CFStringRef sckey
= NULL
;
1116 Boolean release_sckey
= FALSE
;
1117 CFDataRef bytes
= NULL
;
1118 CFPropertyListRef plist
= NULL
;
1119 SCDynamicStoreRef store
= NULL
;
1121 switch ((enum mDNSDynamicStoreSetConfigKey
)key
)
1123 case kmDNSMulticastConfig
:
1124 sckey
= CFSTR("State:/Network/" kDNSServiceCompMulticastDNS
);
1126 case kmDNSDynamicConfig
:
1127 sckey
= CFSTR("State:/Network/DynamicDNS");
1129 case kmDNSPrivateConfig
:
1130 sckey
= CFSTR("State:/Network/" kDNSServiceCompPrivateDNS
);
1132 case kmDNSBackToMyMacConfig
:
1133 sckey
= CFSTR("State:/Network/BackToMyMac");
1135 case kmDNSSleepProxyServersState
:
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
;
1146 case kmDNSDebugState
:
1147 sckey
= CFSTR("State:/Network/mDNSResponder/DebugState");
1150 LogMsg("unrecognized key %d", key
);
1153 if (NULL
== (bytes
= CFDataCreateWithBytesNoCopy(NULL
, (void *)value
,
1154 valueCnt
, kCFAllocatorNull
)))
1156 LogMsg("CFDataCreateWithBytesNoCopy of value failed");
1159 if (NULL
== (plist
= CFPropertyListCreateFromXMLData(NULL
, bytes
,
1160 kCFPropertyListImmutable
, NULL
)))
1162 LogMsg("CFPropertyListCreateFromXMLData of bytes failed");
1167 if (NULL
== (store
= SCDynamicStoreCreate(NULL
,
1168 CFSTR(kmDNSResponderServName
), NULL
, NULL
)))
1170 LogMsg("SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
1173 SCDynamicStoreSetValue(store
, sckey
, plist
);
1182 if (release_sckey
&& sckey
)
1186 mDNSexport
void mDNSDynamicStoreSetConfig(int key
, const char *subkey
, CFPropertyListRef value
)
1188 CFPropertyListRef valueCopy
;
1189 char *subkeyCopy
= NULL
;
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
);
1198 LogMsg("mDNSDynamicStoreSetConfig: ERROR valueCopy NULL");
1203 int len
= strlen(subkey
);
1204 subkeyCopy
= mDNSPlatformMemAllocate(len
+ 1);
1207 LogMsg("mDNSDynamicStoreSetConfig: ERROR subkeyCopy NULL");
1210 mDNSPlatformMemCopy(subkeyCopy
, subkey
, len
);
1211 subkeyCopy
[len
] = 0;
1214 dispatch_async(DynamicStoreQueue
, ^{
1215 CFWriteStreamRef stream
= NULL
;
1216 CFDataRef bytes
= NULL
;
1220 if (NULL
== (stream
= CFWriteStreamCreateWithAllocatedBuffers(NULL
, NULL
)))
1222 LogMsg("mDNSDynamicStoreSetConfig : CFWriteStreamCreateWithAllocatedBuffers failed (Object creation failed)");
1225 CFWriteStreamOpen(stream
);
1226 ret
= CFPropertyListWriteToStream(valueCopy
, stream
, kCFPropertyListBinaryFormat_v1_0
, &error
);
1229 LogMsg("mDNSDynamicStoreSetConfig : CFPropertyListWriteToStream failed (Could not write property list to stream)");
1232 if (NULL
== (bytes
= CFWriteStreamCopyProperty(stream
, kCFStreamPropertyDataWritten
)))
1234 LogMsg("mDNSDynamicStoreSetConfig : CFWriteStreamCopyProperty failed (Object creation failed) ");
1237 CFWriteStreamClose(stream
);
1240 LogInfo("mDNSDynamicStoreSetConfig: key %d subkey %s", key
, subkeyCopy
);
1241 DynamicStoreWrite(key
, subkeyCopy
? subkeyCopy
: "", (uintptr_t)CFDataGetBytePtr(bytes
), CFDataGetLength(bytes
));
1244 CFRelease(valueCopy
);
1247 CFWriteStreamClose(stream
);
1253 mDNSPlatformMemFree(subkeyCopy
);
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
)
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
);
1269 #if TARGET_OS_EMBEDDED
1270 mDNSlocal SCPreferencesRef
mDNSManagedPrefsGet(void)
1272 SCPreferencesRef smDNSManagedPrefs
= NULL
;
1273 smDNSManagedPrefs
= SCPreferencesCreate(kCFAllocatorDefault
, CFSTR("mDNSManagedPrefs"), kmDNSResponderManagedPrefsID
);
1275 return (smDNSManagedPrefs
);
1278 mDNSlocal mDNSBool
GetmDNSManagedPrefKeyVal(SCPreferencesRef prefs
, CFStringRef key
)
1280 mDNSBool val
= mDNSfalse
;
1281 CFBooleanRef val_cf
= NULL
;
1285 val_cf
= SCPreferencesGetValue(prefs
, key
);
1286 if (isA_CFBoolean(val_cf
) != NULL
)
1287 val
= CFBooleanGetValue(val_cf
); //When mDNSResponder-Debug-profile is Installed
1289 val
= mDNSfalse
; //When mDNSResponder-Debug-profile is Uninstalled
1293 LogMsg("GetmDNSManagedPrefKeyVal: mDNSManagedPrefs are NULL!");
1301 mDNSexport mDNSBool
GetmDNSManagedPref(CFStringRef key
)
1303 SCPreferencesRef managed
= NULL
;
1306 managed
= mDNSManagedPrefsGet();
1307 ret_value
= GetmDNSManagedPrefKeyVal(managed
, key
);
1313 #endif //TARGET_OS_EMBEDDED
1315 mDNSlocal
int myIfIndexToName(u_short ifindex
, char *name
)
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; }
1325 mDNSexport NetworkInterfaceInfoOSX
*IfindexToInterfaceInfoOSX(const mDNS
*const m
, mDNSInterfaceID ifindex
)
1327 mDNSu32 scope_id
= (mDNSu32
)(uintptr_t)ifindex
;
1328 NetworkInterfaceInfoOSX
*i
;
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
);
1337 mDNSexport mDNSInterfaceID
mDNSPlatformInterfaceIDfromInterfaceIndex(mDNS
*const m
, mDNSu32 ifindex
)
1339 if (ifindex
== kDNSServiceInterfaceIndexLocalOnly
) return(mDNSInterface_LocalOnly
);
1340 if (ifindex
== kDNSServiceInterfaceIndexP2P
) return(mDNSInterface_P2P
);
1341 if (ifindex
== kDNSServiceInterfaceIndexAny
) return(mDNSNULL
);
1343 NetworkInterfaceInfoOSX
* ifi
= IfindexToInterfaceInfoOSX(m
, (mDNSInterfaceID
)(uintptr_t)ifindex
);
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
);
1352 if (!ifi
) return(mDNSNULL
);
1354 return(ifi
->ifinfo
.InterfaceID
);
1358 mDNSexport mDNSu32
mDNSPlatformInterfaceIndexfromInterfaceID(mDNS
*const m
, mDNSInterfaceID id
, mDNSBool suppressNetworkChange
)
1360 NetworkInterfaceInfoOSX
*i
;
1361 if (id
== mDNSInterface_LocalOnly
) return(kDNSServiceInterfaceIndexLocalOnly
);
1362 if (id
== mDNSInterface_P2P
) return(kDNSServiceInterfaceIndexP2P
);
1363 if (id
== mDNSInterface_Any
) return(0);
1365 mDNSu32 scope_id
= (mDNSu32
)(uintptr_t)id
;
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
);
1371 // If we are supposed to suppress network change, return "id" back
1372 if (suppressNetworkChange
) return scope_id
;
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
);
1383 #if APPLE_OSX_mDNSResponder
1384 mDNSexport
void mDNSASLLog(uuid_t
*uuid
, const char *subdomain
, const char *result
, const char *signature
, const char *fmt
, ...)
1387 return; // No ASL on iOS
1389 static char buffer
[512];
1390 aslmsg asl_msg
= asl_new(ASL_TYPE_MSG
);
1392 if (!asl_msg
) { LogMsg("mDNSASLLog: asl_new failed"); return; }
1396 uuid_unparse(*uuid
, uuidStr
);
1397 asl_set (asl_msg
, "com.apple.message.uuid", uuidStr
);
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
);
1404 if (result
) asl_set(asl_msg
, "com.apple.message.result", result
);
1405 if (signature
) asl_set(asl_msg
, "com.apple.message.signature", signature
);
1409 mDNS_vsnprintf(buffer
, sizeof(buffer
), fmt
, ptr
);
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
);
1419 mDNSlocal
void mDNSLogDNSSECStatistics(mDNS
*const m
)
1423 aslmsg aslmsg
= asl_new(ASL_TYPE_MSG
);
1425 // If we failed to allocate an aslmsg structure, keep accumulating
1426 // the statistics and try again at the next log interval.
1429 LogMsg("mDNSLogDNSSECStatistics: asl_new() failed!");
1433 asl_set(aslmsg
,"com.apple.message.domain", "com.apple.mDNSResponder.DNSSECstatistics");
1435 if (m
->rrcache_totalused_unicast
)
1437 mDNS_snprintf(buffer
, sizeof(buffer
), "%u", (mDNSu32
) ((unsigned long)(m
->DNSSECStats
.TotalMemUsed
* 100))/m
->rrcache_totalused_unicast
);
1441 LogMsg("mDNSLogDNSSECStatistics: unicast is zero");
1444 asl_set(aslmsg
,"com.apple.message.MemUsage", buffer
);
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
);
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
);
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
);
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
);
1485 asl_log(NULL
, aslmsg
, ASL_LEVEL_NOTICE
, "");
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))
1495 // Put packet rate data in discrete buckets.
1496 mDNSlocal
int mDNSBucketData(int inputData
, int interval
)
1500 LogMsg("mDNSBucketData: interval is zero!");
1504 int ratePerHour
= PACKET_RATE(inputData
, interval
);
1507 if (ratePerHour
== 0)
1509 else if (ratePerHour
<= 10)
1511 else if (ratePerHour
<= 100)
1513 else if (ratePerHour
<= 1000)
1515 else if (ratePerHour
<= 5000)
1517 else if (ratePerHour
<= 10000)
1519 else if (ratePerHour
<= 50000)
1521 else if (ratePerHour
<= 100000)
1523 else if (ratePerHour
<= 250000)
1525 else if (ratePerHour
<= 500000)
1533 mDNSlocal
void mDNSLogBonjourStatistics(mDNS
*const m
)
1535 static mDNSs32 last_PktNum
, last_MPktNum
;
1536 static mDNSs32 last_UnicastPacketsSent
, last_MulticastPacketsSent
;
1537 static mDNSs32 last_RemoteSubnet
;
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
;
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
;
1555 // Need a non-zero active time interval.
1556 if (!m
->ActiveStatTime
)
1559 // Round interval time to nearest hour boundary. Less then 30 minutes rounds to zero.
1560 interval
= (m
->ActiveStatTime
+ ONE_HOUR
/2)/ONE_HOUR
;
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
1565 if ((interval
== 0) || (interval
> (kDefaultNextStatsticsLogTime
+ ONE_HOUR
/2)/ONE_HOUR
))
1568 aslmsg aslmsg
= asl_new(ASL_TYPE_MSG
);
1572 LogMsg("mDNSLogBonjourStatistics: asl_new() failed!");
1575 // log in MessageTracer format
1576 asl_set(aslmsg
,"com.apple.message.domain", "com.apple.mDNSResponder.statistics");
1578 snprintf(buffer
, sizeof(buffer
), "%d", interval
);
1579 asl_set(aslmsg
,"com.apple.message.interval", buffer
);
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
);
1586 snprintf(buffer
, sizeof(buffer
), "%d",
1587 mDNSBucketData(inMulticast
, m
->ActiveStatTime
));
1588 asl_set(aslmsg
,"com.apple.message.MulticastIn", buffer
);
1590 snprintf(buffer
, sizeof(buffer
), "%d",
1591 mDNSBucketData(outUnicast
, m
->ActiveStatTime
));
1592 asl_set(aslmsg
,"com.apple.message.UnicastOut", buffer
);
1594 snprintf(buffer
, sizeof(buffer
), "%d",
1595 mDNSBucketData(outMulticast
, m
->ActiveStatTime
));
1596 asl_set(aslmsg
,"com.apple.message.MulticastOut", buffer
);
1598 snprintf(buffer
, sizeof(buffer
), "%d",
1599 mDNSBucketData(remoteSubnet
, m
->ActiveStatTime
));
1600 asl_set(aslmsg
,"com.apple.message.RemoteSubnet", buffer
);
1602 asl_log(NULL
, aslmsg
, ASL_LEVEL_NOTICE
, "");
1607 // Log multicast and unicast traffic statistics to MessageTracer on OSX
1608 mDNSexport
void mDNSLogStatistics(mDNS
*const m
)
1610 // MessageTracer only available on OSX
1614 mDNSs32 currentUTC
= mDNSPlatformUTC();
1616 // log runtime statistics
1617 if ((currentUTC
- m
->NextStatLogTime
) >= 0)
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
)
1624 m
->ActiveStatTime
+= currentUTC
- m
->StatStartTime
;
1627 // Only log statistics if we have recorded some active time during
1628 // this statistics interval.
1629 if (m
->ActiveStatTime
)
1631 mDNSLogBonjourStatistics(m
);
1632 mDNSLogDNSSECStatistics(m
);
1635 // Start a new statistics gathering interval.
1636 m
->StatStartTime
= currentUTC
;
1637 m
->ActiveStatTime
= 0;
1641 #endif // APPLE_OSX_mDNSResponder
1643 #if COMPILER_LIKES_PRAGMA_MARK
1645 #pragma mark - UDP & TCP send & receive
1648 mDNSlocal mDNSBool
AddrRequiresPPPConnection(const struct sockaddr
*addr
)
1650 mDNSBool result
= mDNSfalse
;
1651 SCNetworkConnectionFlags flags
;
1652 CFDataRef remote_addr
;
1653 CFMutableDictionaryRef options
;
1654 SCNetworkReachabilityRef ReachRef
= NULL
;
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
);
1662 CFRelease(remote_addr
);
1666 LogMsg("ERROR: RequiresConnection - SCNetworkReachabilityCreateWithOptions");
1669 if (!SCNetworkReachabilityGetFlags(ReachRef
, &flags
))
1671 LogMsg("ERROR: AddrRequiresPPPConnection - SCNetworkReachabilityGetFlags");
1674 result
= flags
& kSCNetworkFlagsConnectionRequired
;
1678 CFRelease(ReachRef
);
1682 // Set traffic class for socket
1683 mDNSlocal
void setTrafficClass(int socketfd
, mDNSBool useBackgroundTrafficClass
)
1687 if (useBackgroundTrafficClass
)
1688 traffic_class
= SO_TC_BK_SYS
;
1690 traffic_class
= SO_TC_CTL
;
1692 (void) setsockopt(socketfd
, SOL_SOCKET
, SO_TRAFFIC_CLASS
, (void *)&traffic_class
, sizeof(traffic_class
));
1695 mDNSexport
void mDNSPlatformSetDelegatePID(UDPSocket
*src
, const mDNSAddr
*dst
, DNSQuestion
*q
)
1701 if (dst
->type
== mDNSAddrType_IPv4
)
1712 if (setsockopt(s
, SOL_SOCKET
, SO_DELEGATED
, &q
->pid
, sizeof(q
->pid
)) == -1)
1714 LogInfo("mDNSPlatformSetDelegatePID: Delegate PID failed %s for PID %d", strerror(errno
), q
->pid
);
1719 if (setsockopt(s
, SOL_SOCKET
, SO_DELEGATED_UUID
, &q
->uuid
, sizeof(q
->uuid
)) == -1)
1721 LogInfo("mDNSPlatformSetDelegatePID: Delegate UUID failed %s", strerror(errno
));
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
)
1735 NetworkInterfaceInfoOSX
*info
= mDNSNULL
;
1736 struct sockaddr_storage to
;
1738 mStatus result
= mStatus_NoError
;
1742 info
= IfindexToInterfaceInfoOSX(m
, InterfaceID
);
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
;
1754 char *ifa_name
= InterfaceID
? info
->ifinfo
.ifname
: "unicast";
1756 if (dst
->type
== mDNSAddrType_IPv4
)
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
;
1765 if (info
) // Specify outgoing interface
1767 if (!mDNSAddrIsDNSMulticast(dst
))
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
);
1773 setsockopt(s
, IPPROTO_IP
, IP_BOUND_IF
, &info
->scope_id
, sizeof(info
->scope_id
));
1776 static int displayed
= 0;
1777 if (displayed
< 1000)
1780 LogInfo("IP_BOUND_IF socket option not defined -- cannot specify interface for unicast packets");
1786 #ifdef IP_MULTICAST_IFINDEX
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
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
));
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
));
1810 else if (dst
->type
== mDNSAddrType_IPv6
)
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
1822 err
= setsockopt(s
, IPPROTO_IPV6
, IPV6_MULTICAST_IF
, &info
->scope_id
, sizeof(info
->scope_id
));
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
));
1829 LogInfo("setsockopt - IPV6_MUTLICAST_IF scopeid %d, not a valid interface", info
->scope_id
);
1836 LogMsg("mDNSPlatformSendUDP: dst is not an IPv4 or IPv6 address!");
1840 return mStatus_BadParamErr
;
1844 verbosedebugf("mDNSPlatformSendUDP: sending on InterfaceID %p %5s/%ld to %#a:%d skt %d",
1845 InterfaceID
, ifa_name
, dst
->type
, dst
, mDNSVal16(dstPort
), s
);
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
));
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
);
1854 // switch to background traffic class for this message if requested
1855 if (useBackgroundTrafficClass
)
1856 setTrafficClass(s
, useBackgroundTrafficClass
);
1858 err
= sendto(s
, msg
, (UInt8
*)end
- (UInt8
*)msg
, 0, (struct sockaddr
*)&to
, to
.ss_len
);
1860 // set traffic class back to default value
1861 if (useBackgroundTrafficClass
)
1862 setTrafficClass(s
, mDNSfalse
);
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
));
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
);
1890 result
= mStatus_UnknownErr
;
1894 if (dst
->type
== mDNSAddrType_IPv4
&& info
&& !mDNSAddrIsDNSMulticast(dst
))
1896 static const mDNSu32 ifindex
= 0;
1897 setsockopt(s
, IPPROTO_IP
, IP_BOUND_IF
, &ifindex
, sizeof(ifindex
));
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
)
1907 static unsigned int numLogMessages
= 0;
1908 struct iovec databuffers
= { (char *)buffer
, max
};
1911 struct cmsghdr
*cmPtr
;
1912 char ancillary
[1024];
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
1916 // Set up the message
1917 msg
.msg_name
= (caddr_t
)from
;
1918 msg
.msg_namelen
= *fromlen
;
1919 msg
.msg_iov
= &databuffers
;
1921 msg
.msg_control
= (caddr_t
)&ancillary
;
1922 msg
.msg_controllen
= sizeof(ancillary
);
1926 n
= recvmsg(s
, &msg
, 0);
1929 if (errno
!= EWOULDBLOCK
&& numLogMessages
++ < 100) LogMsg("mDNSMacOSX.c: recvmsg(%d) returned error %d errno %d", s
, n
, errno
);
1932 if (msg
.msg_controllen
< (int)sizeof(struct cmsghdr
))
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
);
1938 if (msg
.msg_flags
& MSG_CTRUNC
)
1940 if (numLogMessages
++ < 100) LogMsg("mDNSMacOSX.c: recvmsg(%d) msg.msg_flags & MSG_CTRUNC", s
);
1944 *fromlen
= msg
.msg_namelen
;
1946 // Parse each option out of the ancillary data.
1947 for (cmPtr
= CMSG_FIRSTHDR(&msg
); cmPtr
; cmPtr
= CMSG_NXTHDR(&msg
, cmPtr
))
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
)
1952 dstaddr
->type
= mDNSAddrType_IPv4
;
1953 dstaddr
->ip
.v4
= *(mDNSv4Addr
*)CMSG_DATA(cmPtr
);
1954 //LogMsg("mDNSMacOSX.c: recvmsg IP_RECVDSTADDR %.4a", &dstaddr->ip.v4);
1956 if (cmPtr
->cmsg_level
== IPPROTO_IP
&& cmPtr
->cmsg_type
== IP_RECVIF
)
1958 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*)CMSG_DATA(cmPtr
);
1959 if (sdl
->sdl_nlen
< IF_NAMESIZE
)
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);
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
)
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
);
1975 if (cmPtr
->cmsg_level
== IPPROTO_IPV6
&& cmPtr
->cmsg_type
== IPV6_HOPLIMIT
)
1976 *ttl
= *(int*)CMSG_DATA(cmPtr
);
1982 mDNSlocal mDNSInterfaceID
FindMyInterface(mDNS
*const m
, const mDNSAddr
*addr
)
1984 NetworkInterfaceInfo
*intf
;
1986 if (addr
->type
== mDNSAddrType_IPv4
)
1988 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
1990 if (intf
->ip
.type
== addr
->type
&& intf
->McastTxRx
)
1992 if ((intf
->ip
.ip
.v4
.NotAnInteger
^ addr
->ip
.v4
.NotAnInteger
) == 0)
1994 return(intf
->InterfaceID
);
2000 if (addr
->type
== mDNSAddrType_IPv6
)
2002 for (intf
= m
->HostInterfaces
; intf
; intf
= intf
->next
)
2004 if (intf
->ip
.type
== addr
->type
&& intf
->McastTxRx
)
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)))
2011 return(intf
->InterfaceID
);
2016 return(mDNSInterface_Any
);
2019 mDNSexport mDNSBool
mDNSPlatformPeekUDP(mDNS
*const m
, UDPSocket
*src
)
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).
2033 ret
= recv(src
->ss
.sktv4
, buffer
, sizeof(buffer
), MSG_PEEK
);
2040 mDNSexport
void myKQSocketCallBack(int s1
, short filter
, void *context
)
2042 KQSocketSet
*const ss
= (KQSocketSet
*)context
;
2043 mDNS
*const m
= ss
->m
;
2044 int err
= 0, count
= 0, closed
= 0;
2046 if (filter
!= EVFILT_READ
)
2047 LogMsg("myKQSocketCallBack: Why is filter %d not EVFILT_READ (%d)?", filter
, EVFILT_READ
);
2049 if (s1
!= ss
->sktv4
&& s1
!= ss
->sktv6
)
2051 LogMsg("myKQSocketCallBack: native socket %d", s1
);
2052 LogMsg("myKQSocketCallBack: sktv4 %d sktv6 %d", ss
->sktv4
, ss
->sktv6
);
2057 mDNSAddr senderAddr
, destAddr
;
2058 mDNSIPPort senderPort
;
2059 struct sockaddr_storage from
;
2060 size_t fromlen
= sizeof(from
);
2061 char packetifname
[IF_NAMESIZE
] = "";
2063 err
= myrecvfrom(s1
, &m
->imsg
, sizeof(m
->imsg
), (struct sockaddr
*)&from
, &fromlen
, &destAddr
, packetifname
, &ttl
);
2067 if (from
.ss_family
== AF_INET
)
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);
2075 else if (from
.ss_family
== AF_INET6
)
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);
2085 LogMsg("myKQSocketCallBack from is unknown address family %d", from
.ss_family
);
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
;
2094 if (intf
->Exists
&& !strcmp(intf
->ifinfo
.ifname
, packetifname
))
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.
2105 InterfaceID
= intf
->ifinfo
.InterfaceID
;
2106 else if (mDNSAddrIsDNSMulticast(&destAddr
))
2111 InterfaceID
= FindMyInterface(m
, &destAddr
);
2114 // LogMsg("myKQSocketCallBack got packet from %#a to %#a on interface %#a/%s",
2115 // &senderAddr, &destAddr, &ss->info->ifinfo.ip, ss->info->ifinfo.ifname);
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
;
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
);
2130 mDNSCoreReceive(m
, &m
->imsg
, (unsigned char*)&m
->imsg
+ err
, &senderAddr
, senderPort
, &destAddr
, ss
->port
, InterfaceID
);
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
;
2138 if (err
< 0 && (errno
!= EWOULDBLOCK
|| count
== 0))
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
;
2150 socklen_t solen
= sizeof(int);
2152 struct timeval timeout
;
2155 FD_SET(s1
, &readfds
);
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.");
2175 sleep(1); // After logging this error, rate limit so we don't flood syslog
2179 mDNSlocal
void doTcpSocketCallback(TCPSocket
*sock
)
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!
2187 #ifndef NO_SECURITYFRAMEWORK
2189 mDNSlocal OSStatus
tlsWriteSock(SSLConnectionRef connection
, const void *data
, size_t *dataLength
)
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
); }
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
);
2202 mDNSlocal OSStatus
tlsReadSock(SSLConnectionRef connection
, void *data
, size_t *dataLength
)
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
); }
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
);
2215 mDNSlocal OSStatus
tlsSetupSock(TCPSocket
*sock
, SSLProtocolSide pside
, SSLConnectionType ctype
)
2217 char domname_cstr
[MAX_ESCAPED_DOMAIN_NAME
];
2219 sock
->tlsContext
= SSLCreateContext(kCFAllocatorDefault
, pside
, ctype
);
2220 if (!sock
->tlsContext
)
2222 LogMsg("ERROR: tlsSetupSock: SSLCreateContext failed");
2223 return(mStatus_UnknownErr
);
2226 mStatus err
= SSLSetIOFuncs(sock
->tlsContext
, tlsReadSock
, tlsWriteSock
);
2229 LogMsg("ERROR: tlsSetupSock: SSLSetIOFuncs failed with error code: %d", err
);
2233 err
= SSLSetConnection(sock
->tlsContext
, (SSLConnectionRef
) sock
);
2236 LogMsg("ERROR: tlsSetupSock: SSLSetConnection failed with error code: %d", err
);
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);
2245 LogMsg("ERROR: tlsSetupSock: SSLSetAllowAnonymousCiphers failed with error code: %d", err
);
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])
2253 LogMsg("ERROR: tlsSetupSock: hostname NULL");
2258 ConvertDomainNameToCString(&sock
->hostname
, domname_cstr
);
2259 err
= SSLSetPeerDomainName(sock
->tlsContext
, domname_cstr
, strlen(domname_cstr
));
2262 LogMsg("ERROR: tlsSetupSock: SSLSetPeerDomainname: %s failed with error code: %d", domname_cstr
, err
);
2269 if (sock
->tlsContext
)
2270 CFRelease(sock
->tlsContext
);
2274 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2275 mDNSlocal
void doSSLHandshake(TCPSocket
*sock
)
2277 mStatus err
= SSLHandshake(sock
->tlsContext
);
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
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
2291 dispatch_async(dispatch_get_main_queue(), ^{
2293 LogInfo("doSSLHandshake %p: got lock", sock
); // Log *after* we get the lock
2295 if (sock
->handshake
== handshake_to_be_closed
)
2297 LogInfo("SSLHandshake completed after close");
2298 mDNSPlatformTCPCloseConnection(sock
);
2302 if (sock
->fd
!= -1) KQueueSet(sock
->fd
, EV_ADD
, EVFILT_READ
, sock
->kqEntry
);
2303 else LogMsg("doSSLHandshake: sock->fd is -1");
2305 if (err
== errSSLWouldBlock
)
2306 sock
->handshake
= handshake_required
;
2311 LogMsg("SSLHandshake failed: %d%s", err
, err
== errSSLPeerInternalError
? " (server busy)" : "");
2312 CFRelease(sock
->tlsContext
);
2313 sock
->tlsContext
= NULL
;
2316 sock
->err
= err
? mStatus_ConnFailed
: 0;
2317 sock
->handshake
= handshake_completed
;
2319 LogInfo("doSSLHandshake: %p calling doTcpSocketCallback fd %d", sock
, sock
->fd
);
2320 doTcpSocketCallback(sock
);
2324 LogInfo("SSLHandshake %p: dropping lock for fd %d", sock
, sock
->fd
);
2328 #else // MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2329 mDNSlocal
void *doSSLHandshake(TCPSocket
*sock
)
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
);
2337 debugf("doSSLHandshake %p: got lock", sock
); // Log *after* we get the lock
2339 if (sock
->handshake
== handshake_to_be_closed
)
2341 LogInfo("SSLHandshake completed after close");
2342 mDNSPlatformTCPCloseConnection(sock
);
2346 if (sock
->fd
!= -1) KQueueSet(sock
->fd
, EV_ADD
, EVFILT_READ
, sock
->kqEntry
);
2347 else LogMsg("doSSLHandshake: sock->fd is -1");
2349 if (err
== errSSLWouldBlock
)
2350 sock
->handshake
= handshake_required
;
2355 LogMsg("SSLHandshake failed: %d%s", err
, err
== errSSLPeerInternalError
? " (server busy)" : "");
2356 CFRelease(sock
->tlsContext
);
2357 sock
->tlsContext
= NULL
;
2360 sock
->err
= err
? mStatus_ConnFailed
: 0;
2361 sock
->handshake
= handshake_completed
;
2363 debugf("doSSLHandshake: %p calling doTcpSocketCallback fd %d", sock
, sock
->fd
);
2364 doTcpSocketCallback(sock
);
2368 debugf("SSLHandshake %p: dropping lock for fd %d", sock
, sock
->fd
);
2369 KQueueUnlock(m
, "doSSLHandshake");
2372 #endif // MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2374 mDNSlocal
void spawnSSLHandshake(TCPSocket
* sock
)
2376 debugf("spawnSSLHandshake %p: entry", sock
);
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
);
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
);});
2386 debugf("spawnSSLHandshake %p: done for %d", sock
, sock
->fd
);
2389 #endif /* NO_SECURITYFRAMEWORK */
2391 mDNSlocal
void tcpKQSocketCallback(__unused
int fd
, short filter
, void *context
)
2393 TCPSocket
*sock
= context
;
2394 sock
->err
= mStatus_NoError
;
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
);
2402 if (sock
->flags
& kTCPSocketFlags_UseTLS
)
2404 #ifndef NO_SECURITYFRAMEWORK
2407 sock
->setup
= mDNStrue
;
2408 sock
->err
= tlsSetupSock(sock
, kSSLClientSide
, kSSLStreamType
);
2411 LogMsg("ERROR: tcpKQSocketCallback: tlsSetupSock failed with error code: %d", sock
->err
);
2415 if (sock
->handshake
== handshake_required
)
2417 spawnSSLHandshake(sock
);
2420 else if (sock
->handshake
== handshake_in_progress
|| sock
->handshake
== handshake_to_be_closed
)
2424 else if (sock
->handshake
!= handshake_completed
)
2427 sock
->err
= mStatus_UnknownErr
;
2428 LogMsg("tcpKQSocketCallback called with unexpected SSLHandshake status: %d", sock
->handshake
);
2430 #else /* NO_SECURITYFRAMEWORK */
2431 sock
->err
= mStatus_UnsupportedErr
;
2432 #endif /* NO_SECURITYFRAMEWORK */
2435 doTcpSocketCallback(sock
);
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
)
2441 dispatch_queue_t queue
= dispatch_get_main_queue();
2442 dispatch_source_t source
;
2443 if (flags
== EV_DELETE
)
2445 if (filter
== EVFILT_READ
)
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
);
2452 else if (filter
== EVFILT_WRITE
)
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
);
2460 LogMsg("KQueueSet: ERROR: Wrong filter value %d for EV_DELETE", filter
);
2463 if (flags
!= EV_ADD
) LogMsg("KQueueSet: Invalid flags %d", flags
);
2465 if (filter
== EVFILT_READ
)
2467 source
= dispatch_source_create(DISPATCH_SOURCE_TYPE_READ
, fd
, 0, queue
);
2469 else if (filter
== EVFILT_WRITE
)
2471 source
= dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE
, fd
, 0, queue
);
2475 LogMsg("KQueueSet: ERROR: Wrong filter value %d for EV_ADD", filter
);
2478 if (!source
) return -1;
2479 dispatch_source_set_event_handler(source
, ^{
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
);
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
2490 TriggerEventCompletion();
2493 dispatch_source_set_cancel_handler(source
, ^{
2494 if (entryRef
->fdClosed
)
2496 //LogMsg("CancelHandler: closing fd %d", fd);
2500 dispatch_resume(source
);
2501 if (filter
== EVFILT_READ
)
2502 entryRef
->readSource
= source
;
2504 entryRef
->writeSource
= source
;
2509 mDNSexport
void KQueueLock(mDNS
*const m
)
2513 mDNSexport
void KQueueUnlock(mDNS
*const m
, const char const *task
)
2516 (void)task
; //unused
2519 mDNSexport
int KQueueSet(int fd
, u_short flags
, short filter
, const KQueueEntry
*const entryRef
)
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;
2526 mDNSexport
void KQueueLock(mDNS
*const m
)
2528 pthread_mutex_lock(&m
->p
->BigMutex
);
2529 m
->p
->BigMutexStartTime
= mDNSPlatformRawTime();
2532 mDNSexport
void KQueueUnlock(mDNS
*const m
, const char* task
)
2534 mDNSs32 end
= mDNSPlatformRawTime();
2536 if (end
- m
->p
->BigMutexStartTime
>= WatchDogReportingThreshold
)
2537 LogInfo("WARNING: %s took %dms to complete", task
, end
- m
->p
->BigMutexStartTime
);
2539 pthread_mutex_unlock(&m
->p
->BigMutex
);
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
));
2547 mDNSexport
void mDNSPlatformCloseFD(KQueueEntry
*kq
, int fd
)
2549 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
2553 dispatch_source_cancel(kq
->readSource
);
2554 kq
->readSource
= mDNSNULL
;
2556 if (kq
->writeSource
)
2558 dispatch_source_cancel(kq
->writeSource
);
2559 kq
->writeSource
= mDNSNULL
;
2561 // Close happens in the cancellation handler
2562 debugf("mDNSPlatformCloseFD: resetting sources for %d", fd
);
2563 kq
->fdClosed
= mDNStrue
;
2570 mDNSlocal mStatus
SetupTCPSocket(TCPSocket
*sock
, u_short sa_family
, mDNSIPPort
*port
, mDNSBool useBackgroundTrafficClass
)
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
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
); }
2581 // for TCP sockets, the traffic class is set once and not changed
2582 setTrafficClass(skt
, useBackgroundTrafficClass
);
2584 if (sa_family
== AF_INET
)
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
; }
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
; }
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
; }
2603 port
->NotAnInteger
= addr
.sin_port
;
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
; }
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
; }
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
; }
2624 port
->NotAnInteger
= addr6
.sin6_port
;
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
;
2636 return mStatus_NoError
;
2639 mDNSexport TCPSocket
*mDNSPlatformTCPSocket(mDNS
*const m
, TCPSocketFlags flags
, mDNSIPPort
*port
, mDNSBool useBackgroundTrafficClass
)
2644 TCPSocket
*sock
= mallocL("TCPSocket/mDNSPlatformTCPSocket", sizeof(TCPSocket
));
2645 if (!sock
) { LogMsg("mDNSPlatformTCPSocket: memory allocation failure"); return(mDNSNULL
); }
2647 mDNSPlatformMemZero(sock
, sizeof(TCPSocket
));
2650 sock
->ss
.sktv4
= -1;
2651 sock
->ss
.sktv6
= -1;
2652 err
= SetupTCPSocket(sock
, AF_INET
, port
, useBackgroundTrafficClass
);
2656 err
= SetupTCPSocket(sock
, AF_INET6
, port
, useBackgroundTrafficClass
);
2657 if (err
) { mDNSPlatformCloseFD(&sock
->ss
.kqsv4
, sock
->ss
.sktv4
); sock
->ss
.sktv4
= -1; }
2661 LogMsg("mDNSPlatformTCPSocket: socket error %d errno %d (%s)", sock
->fd
, errno
, strerror(errno
));
2662 freeL("TCPSocket/mDNSPlatformTCPSocket", sock
);
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
;
2674 sock
->err
= mStatus_NoError
;
2679 mDNSexport mStatus
mDNSPlatformTCPConnect(TCPSocket
*sock
, const mDNSAddr
*dst
, mDNSOpaque16 dstport
, domainname
*hostname
, mDNSInterfaceID InterfaceID
, TCPConnectionCallback callback
, void *context
)
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
;
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
;
2694 if (hostname
) { debugf("mDNSPlatformTCPConnect: hostname %##s", hostname
->c
); AssignDomainName(&sock
->hostname
, hostname
); }
2696 if (dst
->type
== mDNSAddrType_IPv4
)
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
;
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
;
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
))
2719 LogMsg("ERROR: mDNSPlatformTCPConnect - KQueueSet failed");
2723 // Watch for incoming data
2724 if (KQueueSet(*s
, EV_ADD
, EVFILT_READ
, k
))
2726 LogMsg("ERROR: mDNSPlatformTCPConnect - KQueueSet failed");
2730 if (fcntl(*s
, F_SETFL
, fcntl(*s
, F_GETFL
, 0) | O_NONBLOCK
) < 0) // set non-blocking
2732 LogMsg("ERROR: setsockopt O_NONBLOCK - %s", strerror(errno
));
2733 return mStatus_UnknownErr
;
2736 // We bind to the interface and all subsequent packets including the SYN will be sent out
2737 // on this interface
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
)
2743 NetworkInterfaceInfoOSX
*info
= IfindexToInterfaceInfoOSX(&mDNSStorage
, InterfaceID
);
2744 if (dst
->type
== mDNSAddrType_IPv4
)
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
; }
2750 (void)InterfaceID
; // Unused
2751 (void)info
; // Unused
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
; }
2760 (void)InterfaceID
; // Unused
2761 (void)info
; // Unused
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.
2771 // initiate connection wth peer
2772 if (connect(*s
, (struct sockaddr
*)&ss
, ss
.ss_len
) < 0)
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
));
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
;
2782 LogMsg("NOTE: mDNSPlatformTCPConnect completed synchronously");
2783 // kQueue should notify us, but this LogMsg is to help track down if it doesn't
2787 // Why doesn't mDNSPlatformTCPAccept actually call accept() ?
2788 mDNSexport TCPSocket
*mDNSPlatformTCPAccept(TCPSocketFlags flags
, int fd
)
2790 mStatus err
= mStatus_NoError
;
2792 TCPSocket
*sock
= mallocL("TCPSocket/mDNSPlatformTCPAccept", sizeof(TCPSocket
));
2793 if (!sock
) return(mDNSNULL
);
2795 mDNSPlatformMemZero(sock
, sizeof(*sock
));
2797 sock
->flags
= flags
;
2799 if (flags
& kTCPSocketFlags_UseTLS
)
2801 #ifndef NO_SECURITYFRAMEWORK
2802 if (!ServerCerts
) { LogMsg("ERROR: mDNSPlatformTCPAccept: unable to find TLS certificates"); err
= mStatus_UnknownErr
; goto exit
; }
2804 err
= tlsSetupSock(sock
, kSSLServerSide
, kSSLStreamType
);
2805 if (err
) { LogMsg("ERROR: mDNSPlatformTCPAccept: tlsSetupSock failed with error code: %d", err
); goto exit
; }
2807 err
= SSLSetCertificate(sock
->tlsContext
, ServerCerts
);
2808 if (err
) { LogMsg("ERROR: mDNSPlatformTCPAccept: SSLSetCertificate failed with error code: %d", err
); goto exit
; }
2810 err
= mStatus_UnsupportedErr
;
2811 #endif /* NO_SECURITYFRAMEWORK */
2813 #ifndef NO_SECURITYFRAMEWORK
2817 if (err
) { freeL("TCPSocket/mDNSPlatformTCPAccept", sock
); return(mDNSNULL
); }
2821 mDNSexport mDNSu16
mDNSPlatformGetUDPPort(UDPSocket
*sock
)
2828 port
= sock
->ss
.port
.NotAnInteger
;
2833 mDNSlocal
void CloseSocketSet(KQSocketSet
*ss
)
2835 if (ss
->sktv4
!= -1)
2837 mDNSPlatformCloseFD(&ss
->kqsv4
, ss
->sktv4
);
2840 if (ss
->sktv6
!= -1)
2842 mDNSPlatformCloseFD(&ss
->kqsv6
, ss
->sktv6
);
2845 if (ss
->closeFlag
) *ss
->closeFlag
= 1;
2848 mDNSexport
void mDNSPlatformTCPCloseConnection(TCPSocket
*sock
)
2852 #ifndef NO_SECURITYFRAMEWORK
2853 if (sock
->tlsContext
)
2855 if (sock
->handshake
== handshake_in_progress
) // SSLHandshake thread using this sock (esp. tlsContext)
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
;
2864 SSLClose(sock
->tlsContext
);
2865 CFRelease(sock
->tlsContext
);
2866 sock
->tlsContext
= NULL
;
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
);
2876 freeL("TCPSocket/mDNSPlatformTCPCloseConnection", sock
);
2880 mDNSexport
long mDNSPlatformReadTCP(TCPSocket
*sock
, void *buf
, unsigned long buflen
, mDNSBool
*closed
)
2883 *closed
= mDNSfalse
;
2885 if (sock
->flags
& kTCPSocketFlags_UseTLS
)
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
);
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
; }
2901 #endif /* NO_SECURITYFRAMEWORK */
2905 static int CLOSEDcount
= 0;
2906 static int EAGAINcount
= 0;
2907 nread
= recv(sock
->fd
, buf
, buflen
, 0);
2913 } // On success, clear our error counters
2914 else if (nread
== 0)
2917 if ((++CLOSEDcount
% 1000) == 0)
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
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
2934 if ((++EAGAINcount
% 1000) == 0) { LogMsg("ERROR: mDNSPlatformReadTCP - recv %d got EAGAIN %d times", sock
->fd
, EAGAINcount
); sleep(1); }
2941 mDNSexport
long mDNSPlatformWriteTCP(TCPSocket
*sock
, const char *msg
, unsigned long len
)
2945 if (sock
->flags
& kTCPSocketFlags_UseTLS
)
2947 #ifndef NO_SECURITYFRAMEWORK
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
);
2953 mStatus err
= SSLWrite(sock
->tlsContext
, msg
, len
, &processed
);
2955 if (!err
) nsent
= (int) processed
;
2956 else if (err
== errSSLWouldBlock
) nsent
= 0;
2957 else { LogMsg("ERROR: mDNSPlatformWriteTCP - SSLWrite returned %d", err
); nsent
= -1; }
2960 #endif /* NO_SECURITYFRAMEWORK */
2964 nsent
= send(sock
->fd
, msg
, len
, 0);
2967 if (errno
== EAGAIN
) nsent
= 0;
2968 else { LogMsg("ERROR: mDNSPlatformWriteTCP - send %s", strerror(errno
)); nsent
= -1; }
2975 mDNSexport
int mDNSPlatformTCPGetFD(TCPSocket
*sock
)
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
)
2984 int *s
= (sa_family
== AF_INET
) ? &cp
->sktv4
: &cp
->sktv6
;
2985 KQueueEntry
*k
= (sa_family
== AF_INET
) ? &cp
->kqsv4
: &cp
->kqsv6
;
2987 const int twofivefive
= 255;
2988 mStatus err
= mStatus_NoError
;
2989 char *errstr
= mDNSNULL
;
2992 cp
->closeFlag
= mDNSNULL
;
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
); }
2997 // set default traffic class
2998 setTrafficClass(skt
, mDNSfalse
);
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
))
3006 err
= setsockopt(skt
, SOL_SOCKET
, SO_RECV_ANYIF
, &on
, sizeof(on
));
3007 if (err
< 0) { errstr
= "setsockopt - SO_RECV_ANYIF"; goto fail
; }
3009 #endif // SO_RECV_ANYIF
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
; }
3015 if (sa_family
== AF_INET
)
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
; }
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
; }
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
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
; }
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
; }
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
;
3046 else if (sa_family
== AF_INET6
)
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
; }
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
; }
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
; }
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
; }
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
; }
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
; }
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
; }
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
));
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
;
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
3099 k
->KQcallback
= myKQSocketCallBack
;
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
;
3107 KQueueSet(*s
, EV_ADD
, EVFILT_READ
, k
);
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
));
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
)
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.");
3128 mDNSPlatformCloseFD(k
, skt
);
3132 mDNSexport UDPSocket
*mDNSPlatformUDPSocket(mDNS
*const m
, const mDNSIPPort requestedport
)
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
;
3145 p
->ss
.proxy
= mDNSfalse
;
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
);
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; }
3158 } while (err
== EADDRINUSE
&& randomizePort
&& i
);
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
);
3175 mDNSexport
void mDNSPlatformUDPClose(UDPSocket
*sock
)
3177 CloseSocketSet(&sock
->ss
);
3178 freeL("UDPSocket", sock
);
3181 #if COMPILER_LIKES_PRAGMA_MARK
3183 #pragma mark - BPF Raw packet sending/receiving
3186 #if APPLE_OSX_mDNSResponder
3188 mDNSexport
void mDNSPlatformSendRawPacket(const void *const msg
, const mDNSu8
*const end
, mDNSInterfaceID InterfaceID
)
3190 if (!InterfaceID
) { LogMsg("mDNSPlatformSendRawPacket: No InterfaceID specified"); return; }
3191 NetworkInterfaceInfoOSX
*info
;
3193 info
= IfindexToInterfaceInfoOSX(&mDNSStorage
, InterfaceID
);
3196 LogMsg("mDNSPlatformSendUDP: Invalid interface index %p", InterfaceID
);
3199 if (info
->BPF_fd
< 0)
3200 LogMsg("mDNSPlatformSendRawPacket: %s BPF_fd %d not ready", info
->ifinfo
.ifname
, info
->BPF_fd
);
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
));
3209 mDNSexport
void mDNSPlatformSetLocalAddressCacheEntry(mDNS
*const m
, const mDNSAddr
*const tpa
, const mDNSEthAddr
*const tha
, mDNSInterfaceID InterfaceID
)
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
);
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
);
3227 mDNSlocal
void CloseBPF(NetworkInterfaceInfoOSX
*const i
)
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
);
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
);
3244 if (i
->BPF_mcfd
>= 0) { close(i
->BPF_mcfd
); i
->BPF_mcfd
= -1; }
3247 mDNSlocal
void bpf_callback_common(NetworkInterfaceInfoOSX
*info
)
3249 KQueueLock(info
->m
);
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
;
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
);
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
3269 if (errno
== EAGAIN
)
3271 LogMsg("bpf_callback got EAGAIN bailing");
3274 LogMsg("Closing %s BPF fd %d due to error %d (%s)", info
->ifinfo
.ifname
, info
->BPF_fd
, errno
, strerror(errno
));
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
);
3292 KQueueUnlock(info
->m
, "bpf_callback");
3294 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
3295 mDNSlocal
void bpf_callback_dispatch(NetworkInterfaceInfoOSX
*const info
)
3297 bpf_callback_common(info
);
3300 mDNSlocal
void bpf_callback(const CFSocketRef cfs
, const CFSocketCallBackType CallBackType
, const CFDataRef address
, const void *const data
, void *const context
)
3306 bpf_callback_common((NetworkInterfaceInfoOSX
*)context
);
3310 mDNSexport
void mDNSPlatformSendKeepalive(mDNSAddr
*sadd
, mDNSAddr
*dadd
, mDNSIPPort
*lport
, mDNSIPPort
*rport
, mDNSu32 seq
, mDNSu32 ack
, mDNSu16 win
)
3312 LogMsg("mDNSPlatformSendKeepalive called\n");
3313 mDNSSendKeepalive(sadd
->ip
.v6
.b
, dadd
->ip
.v6
.b
, lport
->NotAnInteger
, rport
->NotAnInteger
, seq
, ack
, win
);
3316 mDNSexport mStatus
mDNSPlatformClearSPSMACAddr(void)
3318 SCDynamicStoreRef store
= NULL
;
3319 CFStringRef entityname
= NULL
;
3321 if ((store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:ClearSPSMACAddress"), NULL
, NULL
)))
3323 if ((entityname
= CFStringCreateWithFormat(kCFAllocatorDefault
, NULL
, CFSTR("%s%s%s"), "State:/Network/Interface/", "[^/]", "/BonjourSleepProxyAddress")))
3325 if (SCDynamicStoreRemoveValue(store
, entityname
) == false)
3326 LogMsg("mDNSPlatformClearSPSMACAddr: Unable to remove key");
3330 if (entityname
) CFRelease(entityname
);
3331 if (store
) CFRelease(store
);
3332 return KERN_SUCCESS
;
3335 mDNSexport mStatus
mDNSPlatformStoreSPSMACAddr(mDNSAddr
*spsaddr
, char *ifname
)
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
;
3343 mDNSexport mStatus
mDNSPlatformGetRemoteMacAddr(mDNS
*const m
, mDNSAddr
*raddr
)
3345 int family
= (raddr
->type
== mDNSAddrType_IPv4
) ? AF_INET
: AF_INET6
;
3347 mDNSGetRemoteMAC(m
, family
, raddr
->ip
.v6
.b
);
3348 return KERN_SUCCESS
;
3351 mDNSexport mStatus
mDNSPlatformRetrieveTCPInfo(mDNS
*const m
, mDNSAddr
*laddr
, mDNSIPPort
*lport
, mDNSAddr
*raddr
, mDNSIPPort
*rport
, mDNSTCPInfo
*mti
)
3355 int family
= (laddr
->type
== mDNSAddrType_IPv4
) ? AF_INET
: AF_INET6
;
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
)
3360 LogMsg("%s: mDNSRetrieveTCPInfo returned : %d", __func__
, error
);
3363 mti
->IntfId
= mDNSPlatformInterfaceIDfromInterfaceIndex(m
, intfid
);
3367 #define BPF_SetOffset(from, cond, to) (from)->cond = (to) - 1 - (from)
3369 mDNSlocal
int CountProxyTargets(mDNS
*const m
, NetworkInterfaceInfoOSX
*x
, int *p4
, int *p6
)
3371 int numv4
= 0, numv6
= 0;
3374 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
3375 if (rr
->resrec
.InterfaceID
== x
->ifinfo
.InterfaceID
&& rr
->AddressProxy
.type
== mDNSAddrType_IPv4
)
3377 if (p4
) LogSPS("CountProxyTargets: fd %d %-7s IP%2d %.4a", x
->BPF_fd
, x
->ifinfo
.ifname
, numv4
, &rr
->AddressProxy
.ip
.v4
);
3381 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
3382 if (rr
->resrec
.InterfaceID
== x
->ifinfo
.InterfaceID
&& rr
->AddressProxy
.type
== mDNSAddrType_IPv6
)
3384 if (p6
) LogSPS("CountProxyTargets: fd %d %-7s IP%2d %.16a", x
->BPF_fd
, x
->ifinfo
.ifname
, numv6
, &rr
->AddressProxy
.ip
.v6
);
3388 if (p4
) *p4
= numv4
;
3389 if (p6
) *p6
= numv6
;
3390 return(numv4
+ numv6
);
3393 mDNSexport
void mDNSPlatformUpdateProxyList(mDNS
*const m
, const mDNSInterfaceID InterfaceID
)
3395 NetworkInterfaceInfoOSX
*x
;
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;
3400 if (!x
) { LogMsg("mDNSPlatformUpdateProxyList: ERROR InterfaceID %p not found", InterfaceID
); return; }
3402 #define MAX_BPF_ADDRS 250
3403 int numv4
= 0, numv6
= 0;
3405 if (CountProxyTargets(m
, x
, &numv4
, &numv6
) > MAX_BPF_ADDRS
)
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
;
3412 LogSPS("mDNSPlatformUpdateProxyList: fd %d %-7s MAC %.6a %d v4 %d v6", x
->BPF_fd
, x
->ifinfo
.ifname
, &x
->ifinfo
.MAC
, numv4
, numv6
);
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
] =
3418 BPF_STMT(BPF_LD
+ BPF_H
+ BPF_ABS
, 12), // 0 Read Ethertype (bytes 12,13)
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
3423 BPF_JUMP(BPF_JMP
+ BPF_JEQ
+ BPF_K
, 0x0800, 4, 0), // 3 If Ethertype == IPv4 goto 8 (IPv4 address list check) else next
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
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)
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;
3440 static const struct bpf_insn rf
= BPF_STMT(BPF_RET
+ BPF_K
, 0); // No match: Return nothing
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)
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)
3449 static const struct bpf_insn r6a
= BPF_STMT(BPF_RET
+ BPF_K
, 94); // Success: Return Eth + IPv6 + TCP + 20 bytes spare
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
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.
3466 // IPSEC capture size notes:
3467 // 8 bytes UDP header
3468 // 4 bytes Non-ESP Marker
3469 // 28 bytes IKE Header
3471 // 40 Total. Capturing TCP Header + 20 gets us enough bytes to receive the IKE Header in a UDP-encapsulated IKE packet.
3474 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
3475 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->AddressProxy
.type
== mDNSAddrType_IPv4
)
3477 mDNSv4Addr a
= rr
->AddressProxy
.ip
.v4
;
3478 pc
->code
= BPF_JMP
+ BPF_JEQ
+ BPF_K
;
3479 BPF_SetOffset(pc
, jt
, ret4
);
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];
3486 if (pc
!= chk6
) LogMsg("mDNSPlatformUpdateProxyList: pc %p != chk6 %p", pc
, chk6
);
3487 *pc
++ = g6
; // chk6 points here
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);
3493 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
3494 if (rr
->resrec
.InterfaceID
== InterfaceID
&& rr
->AddressProxy
.type
== mDNSAddrType_IPv6
)
3496 const mDNSv6Addr
*const a
= &rr
->AddressProxy
.ip
.v6
;
3497 pc
->code
= BPF_JMP
+ BPF_JEQ
+ BPF_K
;
3498 BPF_SetOffset(pc
, jt
, ret6
);
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];
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];
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
);
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
);
3519 LogSPS("Joined IPv6 ND multicast group %.16a for %.16a", &i6mr
.ipv6mr_multiaddr
, a
);
3522 if (pc
!= fail
) LogMsg("mDNSPlatformUpdateProxyList: pc %p != fail %p", pc
, fail
);
3523 *pc
++ = rf
; // fail points here
3525 if (pc
!= ret4
) LogMsg("mDNSPlatformUpdateProxyList: pc %p != ret4 %p", pc
, ret4
);
3526 *pc
++ = r4a
; // ret4 points here
3531 if (pc
!= ret6
) LogMsg("mDNSPlatformUpdateProxyList: pc %p != ret6 %p", pc
, ret6
);
3532 *pc
++ = r6a
; // ret6 points here
3534 struct bpf_program prog
= { pc
- filter
, filter
};
3537 // For debugging BPF filter program
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
);
3543 if (!numv4
&& !numv6
)
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
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
);
3557 mDNSexport
void mDNSPlatformReceiveBPF_fd(mDNS
*const m
, int fd
)
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
); }
3566 LogSPS("%s using BPF fd %d", i
->ifinfo
.ifname
, fd
);
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
);
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
));
3578 if (i
->BPF_len
> sizeof(m
->imsg
))
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
));
3584 LogSPS("mDNSPlatformReceiveBPF_fd: %d %s BIOCSBLEN %d", fd
, i
->ifinfo
.ifname
, i
->BPF_len
);
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
));
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));
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));
3597 /* <rdar://problem/10287386>
3598 * make socket non blocking see comments in bpf_callback_common for more info
3600 if (fcntl(fd
, F_SETFL
, fcntl(fd
, F_GETFL
, 0) | O_NONBLOCK
) < 0) // set non-blocking
3602 LogMsg("mDNSPlatformReceiveBPF_fd: %d %s O_NONBLOCK failed %d (%s)", fd
, i
->ifinfo
.ifname
, errno
, strerror(errno
));
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; }
3612 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
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
);
3620 CFSocketContext myCFSocketContext
= { 0, i
, NULL
, NULL
, NULL
};
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
);
3626 mDNSPlatformUpdateProxyList(m
, i
->ifinfo
.InterfaceID
);
3633 #endif // APPLE_OSX_mDNSResponder
3635 #if COMPILER_LIKES_PRAGMA_MARK
3637 #pragma mark - Key Management
3640 #ifndef NO_SECURITYFRAMEWORK
3641 mDNSlocal CFArrayRef
GetCertChain(SecIdentityRef identity
)
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
);
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
);
3655 SecPolicyRef policy
;
3656 err
= SecPolicySearchCopyNext(searchRef
, &policy
);
3657 if (err
|| !policy
) LogMsg("getCertChain: SecPolicySearchCopyNext() returned %d", (int) err
);
3660 CFArrayRef wrappedCert
= CFArrayCreate(NULL
, (const void**) &cert
, 1, &kCFTypeArrayCallBacks
);
3661 if (!wrappedCert
) LogMsg("getCertChain: wrappedCert is NULL");
3665 err
= SecTrustCreateWithCertificates(wrappedCert
, policy
, &trust
);
3666 if (err
|| !trust
) LogMsg("getCertChain: SecTrustCreateWithCertificates() returned %d", (int) err
);
3669 err
= SecTrustEvaluate(trust
, NULL
);
3670 if (err
) LogMsg("getCertChain: SecTrustEvaluate() returned %d", (int) err
);
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
);
3679 certChain
= CFArrayCreateMutableCopy(NULL
, 0, rawCertChain
);
3680 if (!certChain
) LogMsg("getCertChain: certChain is NULL");
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);
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...
3698 CFRelease(wrappedCert
);
3702 CFRelease(searchRef
);
3708 #endif /* NO_SECURITYFRAMEWORK */
3710 mDNSexport mStatus
mDNSPlatformTLSSetupCerts(void)
3712 #ifdef NO_SECURITYFRAMEWORK
3713 return mStatus_UnsupportedErr
;
3715 SecIdentityRef identity
= nil
;
3716 SecIdentitySearchRef srchRef
= nil
;
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
; }
3724 err
= SecIdentitySearchCopyNext(srchRef
, &identity
);
3725 if (err
) { LogMsg("ERROR: mDNSPlatformTLSSetupCerts: SecIdentitySearchCopyNext returned %d", (int) err
); return err
; }
3727 if (CFGetTypeID(identity
) != SecIdentityGetTypeID())
3728 { LogMsg("ERROR: mDNSPlatformTLSSetupCerts: SecIdentitySearchCopyNext CFTypeID failure"); return mStatus_UnknownErr
; }
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
; }
3734 return mStatus_NoError
;
3735 #endif /* NO_SECURITYFRAMEWORK */
3738 mDNSexport
void mDNSPlatformTLSTearDownCerts(void)
3740 #ifndef NO_SECURITYFRAMEWORK
3741 if (ServerCerts
) { CFRelease(ServerCerts
); ServerCerts
= NULL
; }
3742 #endif /* NO_SECURITYFRAMEWORK */
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
)
3748 CFStringEncoding encoding
= kCFStringEncodingUTF8
;
3749 CFStringRef cfs
= SCDynamicStoreCopyComputerName(NULL
, &encoding
);
3752 CFStringGetPascalString(cfs
, namelabel
->c
, sizeof(*namelabel
), kCFStringEncodingUTF8
);
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
)
3760 CFStringRef cfs
= SCDynamicStoreCopyLocalHostName(NULL
);
3763 CFStringGetPascalString(cfs
, namelabel
->c
, sizeof(*namelabel
), kCFStringEncodingUTF8
);
3768 mDNSexport mDNSBool
DictionaryIsEnabled(CFDictionaryRef dict
)
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
;
3778 mDNSlocal mStatus
SetupAddr(mDNSAddr
*ip
, const struct sockaddr
*const sa
)
3780 if (!sa
) { LogMsg("SetupAddr ERROR: NULL sockaddr"); return(mStatus_Invalid
); }
3782 if (sa
->sa_family
== AF_INET
)
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
);
3790 if (sa
->sa_family
== AF_INET6
)
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
);
3804 LogMsg("SetupAddr invalid sa_family %d", sa
->sa_family
);
3805 return(mStatus_Invalid
);
3808 mDNSlocal mDNSEthAddr
GetBSSID(char *ifa_name
)
3810 mDNSEthAddr eth
= zeroEthAddr
;
3811 SCDynamicStoreRef store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:GetBSSID"), NULL
, NULL
);
3813 LogMsg("GetBSSID: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
3816 CFStringRef entityname
= CFStringCreateWithFormat(NULL
, NULL
, CFSTR("State:/Network/Interface/%s/AirPort"), ifa_name
);
3819 CFDictionaryRef dict
= SCDynamicStoreCopyValue(store
, entityname
);
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
);
3827 CFRelease(entityname
);
3834 mDNSlocal
int GetMAC(mDNSEthAddr
*eth
, u_short ifindex
)
3836 struct ifaddrs
*ifa
;
3837 for (ifa
= myGetIfAddrs(0); ifa
; ifa
= ifa
->ifa_next
)
3838 if (ifa
->ifa_addr
->sa_family
== AF_LINK
)
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; }
3848 #ifndef SIOCGIFWAKEFLAGS
3849 #define SIOCGIFWAKEFLAGS _IOWR('i', 136, struct ifreq) /* get interface wake property flags */
3852 #ifndef IF_WAKE_ON_MAGIC_PACKET
3853 #define IF_WAKE_ON_MAGIC_PACKET 0x01
3856 #ifndef ifr_wake_flags
3857 #define ifr_wake_flags ifr_ifru.ifru_intval
3860 mDNSlocal mDNSBool
CheckInterfaceSupport(NetworkInterfaceInfo
*const intf
, const char *key
)
3862 io_service_t service
= IOServiceGetMatchingService(kIOMasterPortDefault
, IOBSDNameMatching(kIOMasterPortDefault
, 0, intf
->ifname
));
3865 LogSPS("CheckInterfaceSupport: No service for interface %s", intf
->ifname
);
3870 IOObjectGetClass(service
, n1
);
3872 mDNSBool ret
= mDNSfalse
;
3873 kern_return_t kr
= IORegistryEntryGetParentEntry(service
, kIOServicePlane
, &parent
);
3874 if (kr
== KERN_SUCCESS
)
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
);
3882 LogSPS("CheckInterfaceSupport: No mDNS_IOREG_KEY for interface %s/%s/%s", intf
->ifname
, n1
, n2
);
3890 IOObjectRelease(parent
);
3895 LogSPS("CheckInterfaceSupport: IORegistryEntryGetParentEntry for %s/%s failed %d", intf
->ifname
, n1
, kr
);
3898 IOObjectRelease(service
);
3903 mDNSlocal mDNSBool
InterfaceSupportsKeepAlive(NetworkInterfaceInfo
*const intf
)
3905 return CheckInterfaceSupport(intf
, mDNS_IOREG_KA_KEY
);
3908 mDNSlocal mDNSBool
NetWakeInterface(NetworkInterfaceInfoOSX
*i
)
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
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
))
3918 LogSPS("NetWakeInterface: %s supports TCP Keepalive returning true", i
->ifinfo
.ifname
);
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
); }
3926 strlcpy(ifr
.ifr_name
, i
->ifinfo
.ifname
, sizeof(ifr
.ifr_name
));
3927 if (ioctl(s
, SIOCGIFWAKEFLAGS
, &ifr
) < 0)
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;
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
3944 LogSPS("%-6s %#-14a %s WOMP", i
->ifinfo
.ifname
, &i
->ifinfo
.ip
, (ifr
.ifr_wake_flags
& IF_WAKE_ON_MAGIC_PACKET
) ? "supports" : "no");
3946 return((ifr
.ifr_wake_flags
& IF_WAKE_ON_MAGIC_PACKET
) != 0);
3949 mDNSlocal u_int64_t
getExtendedFlags(char * ifa_name
)
3954 sockFD
= socket(AF_INET
, SOCK_DGRAM
, 0);
3957 LogMsg("getExtendedFlags: socket() call failed, errno = %d (%s)", errno
, strerror(errno
));
3961 ifr
.ifr_addr
.sa_family
= AF_INET
;
3962 strlcpy(ifr
.ifr_name
, ifa_name
, sizeof(ifr
.ifr_name
));
3964 if (ioctl(sockFD
, SIOCGIFEFLAGS
, (caddr_t
)&ifr
) == -1)
3966 LogMsg("getExtendedFlags: SIOCGIFEFLAGS failed, errno = %d (%s)", errno
, strerror(errno
));
3969 LogInfo("getExtendedFlags: %s ifr_eflags = 0x%x", ifa_name
, ifr
.ifr_eflags
);
3972 return ifr
.ifr_eflags
;
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
)
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
);
3986 if (SetupAddr(&ip
, ifa
->ifa_addr
) != mStatus_NoError
) return(NULL
);
3987 if (SetupAddr(&mask
, ifa
->ifa_netmask
) != mStatus_NoError
) return(NULL
);
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
))
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
;
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
)
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
)
4019 if (NetWake
) mDNS_ActivateNetWake_internal (m
, &(*p
)->ifinfo
);
4020 else mDNS_DeactivateNetWake_internal(m
, &(*p
)->ifinfo
);
4024 // Reset the flag if it has changed this time.
4025 (*p
)->ifinfo
.IgnoreIPv4LL
= ((eflags
& IFEF_ARPLL
) != 0) ? mDNSfalse
: mDNStrue
;
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
;
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
;
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
)
4055 AWDLInterfaceID
= i
->ifinfo
.InterfaceID
;
4056 LogInfo("AddInterfaceToList: AWDLInterfaceID = %d", (int) AWDLInterfaceID
);
4058 i
->AppearanceTime
= utc
; // Brand new interface; AppearanceTime is now
4060 i
->ifa_flags
= ifa
->ifa_flags
;
4061 i
->scope_id
= scope_id
;
4063 i
->sa_family
= ifa
->ifa_addr
->sa_family
;
4067 i
->Registered
= mDNSNULL
;
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
);
4079 #if APPLE_OSX_mDNSResponder
4081 #if COMPILER_LIKES_PRAGMA_MARK
4083 #pragma mark - AutoTunnel
4086 #define kRacoonPort 4500
4088 static DomainAuthInfo
* AnonymousRacoonConfig
= mDNSNULL
;
4090 #ifndef NO_SECURITYFRAMEWORK
4092 static CFMutableDictionaryRef domainStatusDict
= NULL
;
4094 mDNSlocal mStatus
CheckQuestionForStatus(const DNSQuestion
*const q
)
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
;
4106 return mStatus_NoError
;
4109 mDNSlocal mStatus
UpdateLLQStatus(const mDNS
*const m
, char *buffer
, int bufsz
, const DomainAuthInfo
*const info
)
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
)
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
; }
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
);
4129 mDNSlocal mStatus
UpdateRRStatus(const mDNS
*const m
, char *buffer
, int bufsz
, const DomainAuthInfo
*const info
)
4133 if (info
->deltime
) return mStatus_NoError
;
4134 for (r
= m
->ResourceRecords
; r
; r
= r
->next
)
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
;
4143 DomainAuthInfo
*ptr
;
4144 for (ptr
= m
->AuthInfoList
; ptr
; ptr
= ptr
->next
)
4145 if (SameDomainName(&ptr
->domain
, n
))
4147 if (ptr
== info
&& (r
->updateError
== mStatus_BadSig
|| r
->updateError
== mStatus_BadKey
|| r
->updateError
== mStatus_BadTime
))
4149 mDNS_snprintf(buffer
, bufsz
, "Resource record update failed for %##s", r
->resrec
.name
);
4150 return r
->updateError
;
4153 n
= (const domainname
*)(n
->c
+ 1 + n
->c
[0]);
4156 return mStatus_NoError
;
4159 #endif // ndef NO_SECURITYFRAMEWORK
4161 // MUST be called with lock held
4162 mDNSlocal
void UpdateAutoTunnelDomainStatus(const mDNS
*const m
, const DomainAuthInfo
*const info
)
4164 #ifdef NO_SECURITYFRAMEWORK
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
;
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];
4184 if (!domainStatusDict
)
4186 domainStatusDict
= CFDictionaryCreateMutable(NULL
, 0, &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
);
4187 if (!domainStatusDict
) { LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFDictionary domainStatusDict"); return; }
4190 if (!dict
) { LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFDictionary dict"); return; }
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; }
4198 if (CFDictionaryContainsKey(domainStatusDict
, domain
))
4200 CFDictionaryRemoveValue(domainStatusDict
, domain
);
4201 if (!m
->ShutdownTime
) mDNSDynamicStoreSetConfig(kmDNSBackToMyMacConfig
, mDNSNULL
, domainStatusDict
);
4209 mDNS_snprintf(buffer
, sizeof(buffer
), "%#a", &m
->Router
);
4210 tmp
= CFStringCreateWithCString(NULL
, buffer
, kCFStringEncodingUTF8
);
4212 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString RouterAddress");
4215 CFDictionarySetValue(dict
, CFSTR("RouterAddress"), tmp
);
4221 mDNSu32 port
= mDNSVal16(llq
->ExternalPort
);
4223 num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &port
);
4225 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber LLQExternalPort");
4228 CFDictionarySetValue(dict
, CFSTR("LLQExternalPort"), num
);
4234 num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &llq
->Result
);
4236 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber LLQNPMStatus");
4239 CFDictionarySetValue(dict
, CFSTR("LLQNPMStatus"), num
);
4247 mDNSu32 port
= mDNSVal16(tun
->ExternalPort
);
4249 num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &port
);
4251 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber AutoTunnelExternalPort");
4254 CFDictionarySetValue(dict
, CFSTR("AutoTunnelExternalPort"), num
);
4258 mDNS_snprintf(buffer
, sizeof(buffer
), "%.4a", &tun
->ExternalAddress
);
4259 tmp
= CFStringCreateWithCString(NULL
, buffer
, kCFStringEncodingUTF8
);
4261 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString ExternalAddress");
4264 CFDictionarySetValue(dict
, CFSTR("ExternalAddress"), tmp
);
4270 num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &tun
->Result
);
4272 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber AutoTunnelNPMStatus");
4275 CFDictionarySetValue(dict
, CFSTR("AutoTunnelNPMStatus"), num
);
4282 mDNSu32 code
= m
->LastNATMapResultCode
;
4284 num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &code
);
4286 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber LastNATMapResultCode");
4289 CFDictionarySetValue(dict
, CFSTR("LastNATMapResultCode"), num
);
4294 mDNS_snprintf(buffer
, sizeof(buffer
), "Success");
4295 llqStatus
= UpdateLLQStatus(m
, llqBuffer
, sizeof(llqBuffer
), info
);
4296 status
= UpdateRRStatus(m
, buffer
, sizeof(buffer
), info
);
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
)
4302 LogInfo("UpdateAutoTunnelDomainStatus: RR Status %d, %s", status
, buffer
);
4304 else if (m
->Router
.type
== mDNSAddrType_None
)
4306 status
= mStatus_NoRouter
;
4307 mDNS_snprintf(buffer
, sizeof(buffer
), "No network connection - none");
4309 else if (m
->Router
.type
== mDNSAddrType_IPv4
&& mDNSIPv4AddressIsZero(m
->Router
.ip
.v4
))
4311 status
= mStatus_NoRouter
;
4312 mDNS_snprintf(buffer
, sizeof(buffer
), "No network connection - v4 zero");
4314 else if (mDNSIPv6AddressIsZero(info
->AutoTunnelInnerAddress
))
4316 status
= mStatus_ServiceNotRunning
;
4317 mDNS_snprintf(buffer
, sizeof(buffer
), "No inner address");
4319 else if (!llq
&& !tun
)
4321 status
= mStatus_NotInitializedErr
;
4322 mDNS_snprintf(buffer
, sizeof(buffer
), "Neither LLQ nor AutoTunnel NAT port mapping is currently active");
4324 else if (llqStatus
== mStatus_NoSuchRecord
)
4327 mDNS_snprintf(buffer
, sizeof(buffer
), llqBuffer
);
4329 else if ((llq
&& llq
->Result
== mStatus_DoubleNAT
) || (tun
&& tun
->Result
== mStatus_DoubleNAT
))
4331 status
= mStatus_DoubleNAT
;
4332 mDNS_snprintf(buffer
, sizeof(buffer
), "Double NAT: Router is reporting a private address");
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
)))))
4338 status
= mStatus_NATPortMappingDisabled
;
4339 mDNS_snprintf(buffer
, sizeof(buffer
), "PCP/NAT-PMP is disabled on the router");
4341 else if ((llq
&& llq
->Result
) || (tun
&& tun
->Result
))
4343 status
= mStatus_NATTraversal
;
4344 mDNS_snprintf(buffer
, sizeof(buffer
), "Error obtaining NAT port mapping from router");
4346 else if ((llq
&& mDNSIPPortIsZero(llq
->ExternalPort
)) || (tun
&& mDNSIPPortIsZero(tun
->ExternalPort
)))
4348 status
= mStatus_NATTraversal
;
4349 mDNS_snprintf(buffer
, sizeof(buffer
), "Unable to obtain NAT port mapping from router");
4354 mDNS_snprintf(buffer
, sizeof(buffer
), llqBuffer
);
4355 LogInfo("UpdateAutoTunnelDomainStatus: LLQ Status %d, %s", status
, buffer
);
4358 num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &status
);
4360 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFNumber StatusCode");
4363 CFDictionarySetValue(dict
, CFSTR("StatusCode"), num
);
4367 tmp
= CFStringCreateWithCString(NULL
, buffer
, kCFStringEncodingUTF8
);
4369 LogMsg("UpdateAutoTunnelDomainStatus: Could not create CFString StatusMessage");
4372 CFDictionarySetValue(dict
, CFSTR("StatusMessage"), tmp
);
4376 if (!CFDictionaryContainsKey(domainStatusDict
, domain
) ||
4377 !CFEqual(dict
, (CFMutableDictionaryRef
)CFDictionaryGetValue(domainStatusDict
, domain
)))
4379 CFDictionarySetValue(domainStatusDict
, domain
, dict
);
4380 if (!m
->ShutdownTime
)
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
);
4392 debugf("UpdateAutoTunnelDomainStatus: %s", buffer
);
4393 #endif // def NO_SECURITYFRAMEWORK
4396 // MUST be called with lock held
4397 mDNSexport
void UpdateAutoTunnelDomainStatuses(const mDNS
*const m
)
4399 #ifdef NO_SECURITYFRAMEWORK
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
4410 mDNSlocal
void UpdateAnonymousRacoonConfig(mDNS
*m
) // Determine whether we need racoon to accept incoming connections
4412 DomainAuthInfo
*info
;
4414 for (info
= m
->AuthInfoList
; info
; info
= info
->next
)
4415 if (info
->AutoTunnel
&& !info
->deltime
&& (!mDNSIPPortIsZero(m
->AutoTunnelNAT
.ExternalPort
) || !mDNSIPv6AddressIsZero(m
->AutoTunnelRelayAddr
)))
4418 if (info
!= AnonymousRacoonConfig
)
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
);
4426 mDNSlocal
void AutoTunnelRecordCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
);
4428 // Caller must hold the lock
4429 mDNSlocal mDNSBool
DeregisterAutoTunnelRecord(mDNS
*m
, DomainAuthInfo
*info
, AuthRecord
* record
)
4433 LogInfo("DeregisterAutoTunnelRecord %##s %##s", &info
->domain
.c
, record
->namestorage
.c
);
4435 if (record
->resrec
.RecordType
> kDNSRecordTypeDeregistering
)
4437 mStatus err
= mDNS_Deregister_internal(m
, record
, mDNS_Dereg_normal
);
4440 record
->resrec
.RecordType
= kDNSRecordTypeUnregistered
;
4441 LogMsg("DeregisterAutoTunnelRecord error %d deregistering %##s %##s", err
, info
->domain
.c
, record
->namestorage
.c
);
4444 else LogInfo("DeregisterAutoTunnelRecord: Deregistered");
4446 else LogInfo("DeregisterAutoTunnelRecord: Not deregistering, state:%d", record
->resrec
.RecordType
);
4451 // Caller must hold the lock
4452 mDNSlocal
void DeregisterAutoTunnelHostRecord(mDNS
*m
, DomainAuthInfo
*info
)
4454 if (!DeregisterAutoTunnelRecord(m
, info
, &info
->AutoTunnelHostRecord
))
4456 info
->AutoTunnelHostRecord
.namestorage
.c
[0] = 0;
4457 m
->NextSRVUpdate
= NonZeroTime(m
->timenow
);
4461 // Caller must hold the lock
4462 mDNSlocal
void UpdateAutoTunnelHostRecord(mDNS
*m
, DomainAuthInfo
*info
)
4465 mDNSBool NATProblem
= mDNSIPPortIsZero(m
->AutoTunnelNAT
.ExternalPort
) || m
->AutoTunnelNAT
.Result
;
4469 if (!info
->AutoTunnelServiceStarted
|| info
->deltime
|| m
->ShutdownTime
|| mDNSIPv6AddressIsZero(info
->AutoTunnelInnerAddress
) || (m
->SleepState
!= SleepState_Awake
&& NATProblem
))
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
);
4475 else if (info
->AutoTunnelHostRecord
.resrec
.RecordType
== kDNSRecordTypeUnregistered
)
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
;
4485 err
= mDNS_Register_internal(m
, &info
->AutoTunnelHostRecord
);
4486 if (err
) LogMsg("UpdateAutoTunnelHostRecord error %d registering %##s", err
, info
->AutoTunnelHostRecord
.namestorage
.c
);
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
);
4494 else LogInfo("UpdateAutoTunnelHostRecord: Type %d", info
->AutoTunnelHostRecord
.resrec
.RecordType
);
4497 // Caller must hold the lock
4498 mDNSlocal
void DeregisterAutoTunnelServiceRecords(mDNS
*m
, DomainAuthInfo
*info
)
4500 LogInfo("DeregisterAutoTunnelServiceRecords %##s", info
->domain
.c
);
4502 DeregisterAutoTunnelRecord(m
, info
, &info
->AutoTunnelTarget
);
4503 DeregisterAutoTunnelRecord(m
, info
, &info
->AutoTunnelService
);
4504 UpdateAutoTunnelHostRecord(m
, info
);
4507 // Caller must hold the lock
4508 mDNSlocal
void UpdateAutoTunnelServiceRecords(mDNS
*m
, DomainAuthInfo
*info
)
4512 if (!info
->AutoTunnelServiceStarted
|| info
->deltime
|| m
->ShutdownTime
|| mDNSIPPortIsZero(m
->AutoTunnelNAT
.ExternalPort
) || m
->AutoTunnelNAT
.Result
)
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
);
4519 if (info
->AutoTunnelTarget
.resrec
.RecordType
== kDNSRecordTypeUnregistered
)
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
;
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
);
4535 else LogInfo("UpdateAutoTunnelServiceRecords: NOOP Target state(%d)", info
->AutoTunnelTarget
.resrec
.RecordType
);
4537 if (info
->AutoTunnelService
.resrec
.RecordType
== kDNSRecordTypeUnregistered
)
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
;
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
);
4555 else LogInfo("UpdateAutoTunnelServiceRecords: NOOP Service state(%d)", info
->AutoTunnelService
.resrec
.RecordType
);
4557 UpdateAutoTunnelHostRecord(m
, info
);
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
);
4566 // Caller must hold the lock
4567 mDNSlocal
void DeregisterAutoTunnelDeviceInfoRecord(mDNS
*m
, DomainAuthInfo
*info
)
4569 DeregisterAutoTunnelRecord(m
, info
, &info
->AutoTunnelDeviceInfo
);
4572 // Caller must hold the lock
4573 mDNSlocal
void UpdateAutoTunnelDeviceInfoRecord(mDNS
*m
, DomainAuthInfo
*info
)
4577 if (!info
->AutoTunnelServiceStarted
|| info
->deltime
|| m
->ShutdownTime
)
4578 DeregisterAutoTunnelDeviceInfoRecord(m
, info
);
4579 else if (info
->AutoTunnelDeviceInfo
.resrec
.RecordType
== kDNSRecordTypeUnregistered
)
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
);
4584 info
->AutoTunnelDeviceInfo
.resrec
.rdlength
= initializeDeviceInfoTXT(m
, info
->AutoTunnelDeviceInfo
.resrec
.rdata
->u
.data
);
4585 info
->AutoTunnelDeviceInfo
.resrec
.RecordType
= kDNSRecordTypeKnownUnique
;
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
);
4592 LogInfo("UpdateAutoTunnelDeviceInfoRecord: not in Unregistered state: %d",info
->AutoTunnelDeviceInfo
.resrec
.RecordType
);
4595 // Caller must hold the lock
4596 mDNSlocal
void DeregisterAutoTunnel6Record(mDNS
*m
, DomainAuthInfo
*info
)
4598 LogInfo("DeregisterAutoTunnel6Record %##s", info
->domain
.c
);
4600 DeregisterAutoTunnelRecord(m
, info
, &info
->AutoTunnel6Record
);
4601 UpdateAutoTunnelHostRecord(m
, info
);
4602 UpdateAutoTunnelDomainStatus(m
, info
);
4605 // Caller must hold the lock
4606 mDNSlocal
void UpdateAutoTunnel6Record(mDNS
*m
, DomainAuthInfo
*info
)
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
)
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
;
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
);
4626 UpdateAutoTunnelHostRecord(m
, info
);
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
);
4633 else LogInfo("UpdateAutoTunnel6Record NOOP state(%d)",info
->AutoTunnel6Record
.resrec
.RecordType
);
4636 mDNSlocal
void AutoTunnelRecordCallback(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
4638 DomainAuthInfo
*info
= (DomainAuthInfo
*)rr
->RecordContext
;
4639 if (result
== mStatus_MemFree
)
4641 LogInfo("AutoTunnelRecordCallback MemFree %s", ARDisplayString(m
, rr
));
4645 // Reset the host record namestorage to force high-level PTR/SRV/TXT to deregister
4646 if (rr
== &info
->AutoTunnelHostRecord
)
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
);
4652 if (m
->ShutdownTime
)
4654 LogInfo("AutoTunnelRecordCallback: Shutdown, returning");
4658 if (rr
== &info
->AutoTunnelHostRecord
)
4660 LogInfo("AutoTunnelRecordCallback: calling UpdateAutoTunnelHostRecord");
4661 UpdateAutoTunnelHostRecord(m
,info
);
4663 else if (rr
== &info
->AutoTunnelDeviceInfo
)
4665 LogInfo("AutoTunnelRecordCallback: Calling UpdateAutoTunnelDeviceInfoRecord");
4666 UpdateAutoTunnelDeviceInfoRecord(m
,info
);
4668 else if (rr
== &info
->AutoTunnelService
|| rr
== &info
->AutoTunnelTarget
)
4670 LogInfo("AutoTunnelRecordCallback: Calling UpdateAutoTunnelServiceRecords");
4671 UpdateAutoTunnelServiceRecords(m
,info
);
4673 else if (rr
== &info
->AutoTunnel6Record
)
4675 LogInfo("AutoTunnelRecordCallback: Calling UpdateAutoTunnel6Record");
4676 UpdateAutoTunnel6Record(m
,info
);
4683 mDNSlocal
void AutoTunnelNATCallback(mDNS
*m
, NATTraversalInfo
*n
)
4685 DomainAuthInfo
*info
;
4687 LogInfo("AutoTunnelNATCallback Result %d %.4a Internal %d External %d",
4688 n
->Result
, &n
->ExternalAddress
, mDNSVal16(n
->IntPort
), mDNSVal16(n
->ExternalPort
));
4692 m
->NextSRVUpdate
= NonZeroTime(m
->timenow
);
4693 LogInfo("AutoTunnelNATCallback: NextSRVUpdate in %d %d", m
->NextSRVUpdate
- m
->timenow
, m
->timenow
);
4695 for (info
= m
->AuthInfoList
; info
; info
= info
->next
)
4696 if (info
->AutoTunnel
)
4697 UpdateAutoTunnelServiceRecords(m
, info
);
4699 UpdateAnonymousRacoonConfig(m
); // Determine whether we need racoon to accept incoming connections
4701 UpdateAutoTunnelDomainStatuses(m
);
4706 mDNSlocal
void AutoTunnelHostNameChanged(mDNS
*m
, DomainAuthInfo
*info
)
4708 LogInfo("AutoTunnelHostNameChanged %#s.%##s", m
->hostlabel
.c
, info
->domain
.c
);
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
);
4722 // Must be called with the lock held
4723 mDNSexport
void StartServerTunnel(mDNS
*const m
, DomainAuthInfo
*const info
)
4725 if (info
->deltime
) return;
4727 if (info
->AutoTunnelServiceStarted
)
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
);
4735 info
->AutoTunnelServiceStarted
= mDNStrue
;
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
);
4748 // If the global AutoTunnel NAT-T is not yet started, start it.
4749 if (!m
->AutoTunnelNAT
.clientContext
)
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
);
4762 mDNSlocal mStatus
AutoTunnelSetKeys(ClientTunnel
*tun
, mDNSBool AddNew
)
4764 mDNSv6Addr loc_outer6
;
4765 mDNSv6Addr rmt_outer6
;
4767 // When we are tunneling over IPv6 Relay address, the port number is zero
4768 if (mDNSIPPortIsZero(tun
->rmt_outer_port
))
4770 loc_outer6
= tun
->loc_outer6
;
4771 rmt_outer6
= tun
->rmt_outer6
;
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];
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];
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)));
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])
4794 mDNSlocal
void ReissueBlockedQuestionWithType(mDNS
*const m
, domainname
*d
, mDNSBool success
, mDNSu16 qtype
)
4796 DNSQuestion
*q
= m
->Questions
;
4799 if (q
->NoAnswer
== NoAnswer_Suspended
&& q
->qtype
== qtype
&& q
->AuthInfo
&& q
->AuthInfo
->AutoTunnel
&& SameDomainName(&q
->qname
, d
))
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.
4821 mDNSlocal
void ReissueBlockedQuestions(mDNS
*const m
, domainname
*d
, mDNSBool success
)
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
);
4832 mDNSlocal
void UnlinkAndReissueBlockedQuestions(mDNS
*const m
, ClientTunnel
*tun
, mDNSBool success
)
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
);
4842 mDNSlocal mDNSBool
TunnelClientDeleteMatching(mDNS
*const m
, ClientTunnel
*tun
, mDNSBool v6Tunnel
)
4845 mDNSBool needSetKeys
= mDNStrue
;
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
;
4854 ClientTunnel
*old
= *p
;
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)
4861 LogInfo("TunnelClientDeleteMatching: Stopping query on IPv6 AutoTunnel for %##s %.16a", old
->dstname
.c
, &old
->rmt_inner
);
4862 mDNS_StopQuery(m
, &old
->q
);
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
))
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
);
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
,
4880 needSetKeys
= mDNSfalse
;
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)
4889 LogInfo("TunnelClientDeleteMatching: Stopping query on IPv4 AutoTunnel for %##s %.16a", old
->dstname
.c
, &old
->rmt_inner
);
4890 mDNS_StopQuery(m
, &old
->q
);
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
))
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
);
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
,
4909 needSetKeys
= mDNSfalse
;
4914 LogInfo("TunnelClientDeleteMatching: Disposing ClientTunnel %p", old
);
4915 freeL("ClientTunnel", old
);
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
)
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
;
4935 ClientTunnel
*old
= *p
;
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
);
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
);
4946 if (old
->q
.ThisQInterval
>= 0)
4948 LogInfo("TunnelClientDeleteAny: Stopping query on AutoTunnel for %##s %.16a", old
->dstname
.c
, &old
->rmt_inner
);
4949 mDNS_StopQuery(m
, &old
->q
);
4953 LogInfo("TunnelClientDeleteAny: Deleting existing AutoTunnel for %##s %.16a", old
->dstname
.c
, &old
->rmt_inner
);
4954 AutoTunnelSetKeys(old
, mDNSfalse
);
4957 LogInfo("TunnelClientDeleteAny: Disposing ClientTunnel %p", old
);
4958 freeL("ClientTunnel", old
);
4963 mDNSlocal
void TunnelClientFinish(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
)
4965 mDNSBool needSetKeys
= mDNStrue
;
4966 ClientTunnel
*tun
= (ClientTunnel
*)question
->QuestionContext
;
4967 mDNSBool v6Tunnel
= mDNSfalse
;
4968 DomainAuthInfo
*info
;
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
;
4976 LogInfo("TunnelClientFinish: Relay address %.16a", &answer
->rdata
->u
.ipv6
);
4977 tun
->rmt_outer6
= answer
->rdata
->u
.ipv6
;
4978 tun
->loc_outer6
= m
->AutoTunnelRelayAddr
;
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
;
4992 question
->ThisQInterval
= -1; // So we know this tunnel setup has completed
4994 info
= GetAuthInfoForName(m
, &tun
->dstname
);
4997 LogMsg("TunnelClientFinish: Could not get AuthInfo for %##s", tun
->dstname
.c
);
4998 ReissueBlockedQuestions(m
, &tun
->dstname
, mDNSfalse
);
5002 tun
->loc_inner
= info
->AutoTunnelInnerAddress
;
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
);
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
);
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
);
5022 mDNSexport
void AutoTunnelCallback(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
, QC_result AddRecord
)
5024 ClientTunnel
*tun
= (ClientTunnel
*)question
->QuestionContext
;
5025 DomainAuthInfo
*info
;
5027 LogInfo("AutoTunnelCallback tun %p AddRecord %d rdlength %d qtype %d", tun
, AddRecord
, answer
->rdlength
, question
->qtype
);
5029 if (!AddRecord
) return;
5030 mDNS_StopQuery(m
, question
);
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
)
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
);
5044 switch (tun
->tc_state
)
5046 case TC_STATE_AAAA_PEER
:
5047 if (question
->qtype
!= kDNSType_AAAA
)
5049 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_AAAA_PEER", question
->qtype
);
5051 info
= GetAuthInfoForName(m
, &tun
->dstname
);
5054 LogMsg("AutoTunnelCallback: Could not get AuthInfo for %##s", tun
->dstname
.c
);
5055 UnlinkAndReissueBlockedQuestions(m
, tun
, mDNStrue
);
5058 if (mDNSSameIPv6Address(answer
->rdata
->u
.ipv6
, info
->AutoTunnelInnerAddress
))
5060 LogInfo("AutoTunnelCallback: suppressing tunnel to self %.16a", &answer
->rdata
->u
.ipv6
);
5061 UnlinkAndReissueBlockedQuestions(m
, tun
, mDNStrue
);
5064 if (info
&& mDNSSameIPv6NetworkPart(answer
->rdata
->u
.ipv6
, info
->AutoTunnelInnerAddress
))
5066 LogInfo("AutoTunnelCallback: suppressing tunnel to peer %.16a", &answer
->rdata
->u
.ipv6
);
5067 UnlinkAndReissueBlockedQuestions(m
, tun
, mDNStrue
);
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
))
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");
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");
5086 AppendDomainName(&question
->qname
, &tun
->dstname
);
5087 mDNS_StartQuery(m
, &tun
->q
);
5089 case TC_STATE_AAAA_PEER_RELAY
:
5090 if (question
->qtype
!= kDNSType_AAAA
)
5092 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_AAAA_PEER_RELAY", question
->qtype
);
5094 // If it failed, look for the SRV record.
5095 if (!answer
->rdlength
)
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
);
5105 TunnelClientFinish(m
, question
, answer
);
5107 case TC_STATE_SRV_PEER
:
5108 if (question
->qtype
!= kDNSType_SRV
)
5110 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_SRV_PEER", question
->qtype
);
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
);
5119 case TC_STATE_ADDR_PEER
:
5120 if (question
->qtype
!= kDNSType_A
)
5122 LogMsg("AutoTunnelCallback: Bad question type %d in TC_STATE_ADDR_PEER", question
->qtype
);
5124 TunnelClientFinish(m
, question
, answer
);
5127 LogMsg("AutoTunnelCallback: Unknown question %p", question
);
5131 // Must be called with the lock held
5132 mDNSexport
void AddNewClientTunnel(mDNS
*const m
, DNSQuestion
*const q
)
5134 ClientTunnel
*p
= mallocL("ClientTunnel", sizeof(ClientTunnel
));
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
5149 p
->q
.InterfaceID
= mDNSInterface_Any
;
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
;
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
);
5179 #endif // APPLE_OSX_mDNSResponder
5181 #if COMPILER_LIKES_PRAGMA_MARK
5183 #pragma mark - Power State & Configuration Change Management
5186 mDNSlocal mStatus
UpdateInterfaceList(mDNS
*const m
, mDNSs32 utc
)
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
));
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
);
5224 if (ifa
->ifa_addr
->sa_family
== AF_LINK
)
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);
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
)
5234 if (!ifa
->ifa_netmask
)
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
);
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)
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
);
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)
5253 LogMsg("UpdateInterfaceList: if_nametoindex returned zero/negative value for %5s(%d)", ifa
->ifa_name
, if_nametoindex(ifa
->ifa_name
));
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;
5262 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)ifa
->ifa_addr
;
5263 if (ifa
->ifa_addr
->sa_family
== AF_INET6
&& InfoSocket
>= 0)
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
);
5274 if (!(ifru_flags6
& (IN6_IFF_NOTREADY
| IN6_IFF_DETACHED
| IN6_IFF_DEPRECATED
| IN6_IFF_TEMPORARY
)))
5276 if (ifa
->ifa_flags
& IFF_LOOPBACK
)
5278 if (ifa
->ifa_addr
->sa_family
== AF_INET
)
5280 else if (sin6
->sin6_addr
.s6_addr
[0] != 0xFD)
5285 NetworkInterfaceInfoOSX
*i
= AddInterfaceToList(m
, ifa
, utc
);
5286 if (i
&& MulticastInterface(i
) && i
->ifinfo
.Advertise
)
5288 if (ifa
->ifa_addr
->sa_family
== AF_INET
)
5289 foundav4
= mDNStrue
;
5291 foundav6
= mDNStrue
;
5297 ifa
= ifa
->ifa_next
;
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
);
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
)
5309 mDNSBool txrx
= MulticastInterface(i
);
5310 if (i
->ifinfo
.McastTxRx
!= txrx
)
5312 i
->ifinfo
.McastTxRx
= txrx
;
5313 i
->Exists
= 2; // State change; need to deregister and reregister this interface
5317 if (InfoSocket
>= 0)
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]);
5323 // Set up the nice label
5324 domainlabel nicelabel
;
5326 GetUserSpecifiedFriendlyComputerName(&nicelabel
);
5327 if (nicelabel
.c
[0] == 0)
5329 debugf("Couldn’t read user-specified Computer Name; using default “%s” instead", defaultname
);
5330 MakeDomainLabelFromLiteralString(&nicelabel
, defaultname
);
5333 // Set up the RFC 1034-compliant label
5334 domainlabel hostlabel
;
5336 GetUserSpecifiedLocalHostName(&hostlabel
);
5337 if (hostlabel
.c
[0] == 0)
5339 debugf("Couldn’t read user-specified Local Hostname; using default “%s.local” instead", defaultname
);
5340 MakeDomainLabelFromLiteralString(&hostlabel
, defaultname
);
5343 mDNSBool namechange
= mDNSfalse
;
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
);
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
;
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
);
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
;
5365 namechange
= mDNStrue
;
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
5371 DomainAuthInfo
*info
;
5372 for (info
= m
->AuthInfoList
; info
; info
= info
->next
)
5373 if (info
->AutoTunnel
) AutoTunnelHostNameChanged(m
, info
);
5375 #endif // APPLE_OSX_mDNSResponder
5377 return(mStatus_NoError
);
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
)
5384 int i
= 0, bits
= 0;
5385 int bytes
= mask
->type
== mDNSAddrType_IPv4
? 4 : mask
->type
== mDNSAddrType_IPv6
? 16 : 0;
5388 mDNSu8 b
= mask
->ip
.v6
.b
[i
++];
5389 while (b
& 0x80) { bits
++; b
<<= 1; }
5392 while (i
< bytes
) if (mask
->ip
.v6
.b
[i
++]) return(-1);
5396 // returns count of non-link local V4 addresses registered
5397 mDNSlocal
int SetupActiveInterfaces(mDNS
*const m
, mDNSs32 utc
)
5399 NetworkInterfaceInfoOSX
*i
;
5401 for (i
= m
->p
->InterfaceList
; i
; i
= i
->next
)
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
);
5408 if (i
->Registered
&& i
->Registered
!= primary
) // Sanity check
5410 LogMsg("SetupActiveInterfaces ERROR! n->Registered %p != primary %p", i
->Registered
, primary
);
5411 i
->Registered
= mDNSNULL
;
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
5421 i
->Registered
= primary
;
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);
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
)
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);
5443 mDNS_RegisterInterface(m
, n
, i
->Flashing
&& i
->Occulting
);
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)" : "");
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
);
5457 if (i
->sa_family
== AF_INET
)
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
;
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
)
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
));
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
);
5488 if (i
->sa_family
== AF_INET6
)
5490 struct ipv6_mreq i6mr
;
5491 i6mr
.ipv6mr_interface
= primary
->scope_id
;
5492 i6mr
.ipv6mr_multiaddr
= *(struct in6_addr
*)&AllDNSLinkGroup_v6
.ip
.v6
;
5494 if (SearchForInterfaceByName(m
, i
->ifinfo
.ifname
, AF_INET6
) == i
)
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
);
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
);
5515 mDNSlocal
void MarkAllInterfacesInactive(mDNS
*const m
, mDNSs32 utc
)
5517 NetworkInterfaceInfoOSX
*i
;
5518 for (i
= m
->p
->InterfaceList
; i
; i
= i
->next
)
5520 if (i
->Exists
) i
->LastSeen
= utc
;
5521 i
->Exists
= mDNSfalse
;
5525 // returns count of non-link local V4 addresses deregistered
5526 mDNSlocal
int ClearInactiveInterfaces(mDNS
*const m
, mDNSs32 utc
)
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
;
5535 for (i
= m
->p
->InterfaceList
; i
; i
= i
->next
)
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
);
5540 if (i
->Exists
== 0 || i
->Exists
== 2 || i
->Registered
!= primary
)
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)" : "");
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
)
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);
5565 mDNS_DeregisterInterface(m
, &i
->ifinfo
, i
->Flashing
&& i
->Occulting
);
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.
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.
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
;
5584 // If no longer active, delete interface from list and free memory
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
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
5608 mDNSlocal
void AppendDNameListElem(DNameListElem
***List
, mDNSu32 uid
, domainname
*name
)
5610 DNameListElem
*dnle
= (DNameListElem
*) mallocL("DNameListElem/AppendDNameListElem", sizeof(DNameListElem
));
5611 if (!dnle
) LogMsg("ERROR: AppendDNameListElem: memory exhausted");
5614 dnle
->next
= mDNSNULL
;
5616 AssignDomainName(&dnle
->name
, name
);
5618 *List
= &dnle
->next
;
5622 mDNSlocal
int compare_dns_configs(const void *aa
, const void *bb
)
5624 dns_resolver_t
*a
= *(dns_resolver_t
**)aa
;
5625 dns_resolver_t
*b
= *(dns_resolver_t
**)bb
;
5627 return (a
->search_order
< b
->search_order
) ? -1 : (a
->search_order
== b
->search_order
) ? 0 : 1;
5630 mDNSlocal
void UpdateSearchDomainHash(mDNS
*const m
, MD5_CTX
*sdc
, char *domain
, mDNSInterfaceID InterfaceID
)
5633 mDNSu32 scopeid
= 0;
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.
5643 // Note: We have to handle a few of these tricky cases.
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)
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.
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
);
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);
5664 mDNSlocal
void FinalizeSearchDomainHash(mDNS
*const m
, MD5_CTX
*sdc
)
5666 mDNSu8 md5_hash
[MD5_LEN
];
5668 MD5_Final(md5_hash
, sdc
);
5670 if (memcmp(md5_hash
, m
->SearchDomainsHash
, MD5_LEN
))
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
);
5679 else { LogInfo("FinalizeSearchDomains: The hash is same"); }
5682 mDNSexport
const char *DNSScopeToString(mDNSu32 scope
)
5688 case kScopeInterfaceID
:
5689 return "InterfaceScoped";
5690 case kScopeServiceID
:
5691 return "ServiceScoped";
5697 mDNSlocal
void ConfigSearchDomains(mDNS
*const m
, dns_resolver_t
*resolver
, mDNSInterfaceID interface
, mDNSu32 scope
, MD5_CTX
*sdc
)
5699 const char *scopeString
= DNSScopeToString(scope
);
5702 if (scope
!= kScopeNone
)
5704 LogInfo("ConfigSearchDomains: (%s) Ignoring search domain for Interface %p", scopeString
, interface
);
5707 for (j
= 0; j
< resolver
->n_search
; j
++)
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
);
5715 mDNSlocal mDNSInterfaceID
ConfigParseInterfaceID(mDNS
*const m
, mDNSu32 ifindex
)
5717 NetworkInterfaceInfoOSX
*ni
;
5718 mDNSInterfaceID interface
;
5720 for (ni
= m
->p
->InterfaceList
; ni
; ni
= ni
->next
)
5722 if (ni
->ifinfo
.InterfaceID
&& ni
->scope_id
== ifindex
)
5727 interface
= ni
->ifinfo
.InterfaceID
;
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.
5737 LogMsg("ConfigParseInterfaceID: interface specific index %d not found (interface may not be UP)",ifindex
);
5739 // Set the correct interface from configd before passing this to mDNS_AddDNSServer() below
5740 interface
= (mDNSInterfaceID
)(unsigned long)ifindex
;
5745 mDNSlocal
void ConfigNonUnicastResolver(mDNS
*const m
, dns_resolver_t
*r
)
5747 char *opt
= r
->options
;
5750 if (opt
&& !strncmp(opt
, "mdns", strlen(opt
)))
5752 if (!MakeDomainNameFromDNSNameString(&d
, r
->domain
))
5754 LogMsg("ConfigNonUnicastResolver: config->resolver bad domain %s", r
->domain
);
5757 mDNS_AddMcastResolver(m
, &d
, mDNSInterface_Any
, r
->timeout
);
5761 mDNSlocal
void ConfigDNSServers(mDNS
*const m
, dns_resolver_t
*r
, mDNSInterfaceID interface
, mDNSu32 scope
, mDNSu16 resGroupID
)
5766 mDNSBool cellIntf
= mDNSfalse
;
5767 mDNSBool scopedDNS
= mDNSfalse
;
5768 mDNSBool reqA
, reqAAAA
;
5770 if (!r
->domain
|| !*r
->domain
)
5774 else if (!MakeDomainNameFromDNSNameString(&d
, r
->domain
))
5776 LogMsg("ConfigDNSServers: bad domain %s", r
->domain
);
5779 // Parse the resolver specific attributes that affects all the DNS servers.
5780 if (scope
== kScopeInterfaceID
)
5782 scopedDNS
= mDNStrue
;
5784 else if (scope
== kScopeServiceID
)
5786 serviceID
= r
->service_identifier
;
5789 #if TARGET_OS_IPHONE
5790 cellIntf
= (r
->reach_flags
& kSCNetworkReachabilityFlagsIsWWAN
) ? mDNStrue
: mDNSfalse
;
5792 reqA
= (r
->flags
& DNS_RESOLVER_FLAGS_REQUEST_A_RECORDS
? mDNStrue
: mDNSfalse
);
5793 reqAAAA
= (r
->flags
& DNS_RESOLVER_FLAGS_REQUEST_AAAA_RECORDS
? mDNStrue
: mDNSfalse
);
5795 for (n
= 0; n
< r
->n_nameserver
; n
++)
5800 if (r
->nameserver
[n
]->sa_family
!= AF_INET
&& r
->nameserver
[n
]->sa_family
!= AF_INET6
)
5803 if (SetupAddr(&saddr
, r
->nameserver
[n
]))
5805 LogMsg("ConfigDNSServers: Bad address");
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
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
);
5820 LogInfo("ConfigDNSServers(%s): DNS server %#a:%d for domain %##s", DNSScopeToString(scope
), &s
->addr
, mDNSVal16(s
->port
), d
.c
);
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.
5828 // "resolver" has entries that should only be used for unscoped questions.
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)
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)
5836 mDNSlocal
void ConfigResolvers(mDNS
*const m
, dns_config_t
*config
, mDNSu32 scope
, mDNSBool setsearch
, mDNSBool setservers
, MD5_CTX
*sdc
, mDNSu16 resGroupID
)
5839 dns_resolver_t
**resolver
;
5841 const char *scopeString
= DNSScopeToString(scope
);
5842 mDNSInterfaceID interface
;
5847 resolver
= config
->resolver
;
5848 nresolvers
= config
->n_resolver
;
5850 case kScopeInterfaceID
:
5851 resolver
= config
->scoped_resolver
;
5852 nresolvers
= config
->n_scoped_resolver
;
5854 case kScopeServiceID
:
5855 resolver
= config
->service_specific_resolver
;
5856 nresolvers
= config
->n_service_specific_resolver
;
5861 qsort(resolver
, nresolvers
, sizeof(dns_resolver_t
*), compare_dns_configs
);
5863 for (i
= 0; i
< nresolvers
; i
++)
5865 dns_resolver_t
*r
= resolver
[i
];
5867 LogInfo("ConfigResolvers: %s resolver[%d] domain %s n_nameserver %d", scopeString
, i
, r
->domain
, r
->n_nameserver
);
5869 interface
= mDNSInterface_Any
;
5871 // Parse the interface index
5872 if (r
->if_index
!= 0)
5874 interface
= ConfigParseInterfaceID(m
, r
->if_index
);
5879 ConfigSearchDomains(m
, resolver
[i
], interface
, scope
, sdc
);
5880 // Parse other scoped resolvers for search lists
5885 if (r
->port
== 5353 || r
->n_nameserver
== 0)
5887 ConfigNonUnicastResolver(m
, r
);
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
)
5896 ConfigDNSServers(m
, r
, interface
, scope
, resGroupID
);
5901 #if APPLE_OSX_mDNSResponder
5902 mDNSlocal mDNSBool
QuestionValidForDNSTrigger(DNSQuestion
*q
)
5904 if (QuerySuppressed(q
))
5906 debugf("QuestionValidForDNSTrigger: Suppressed: %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
5909 if (mDNSOpaque16IsZero(q
->TargetQID
))
5911 debugf("QuestionValidForDNSTrigger: Multicast: %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
5914 // If we answered using LocalOnly records e.g., /etc/hosts, don't consider that a valid response
5916 if (q
->LOAddressAnswers
)
5918 debugf("QuestionValidForDNSTrigger: LocalOnly answers: %##s (%s)", q
->qname
.c
, DNSTypeName(q
->qtype
));
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
)
5931 if (!QuestionValidForDNSTrigger(q
))
5934 // Ignore applications that start and stop queries for no reason before we ever talk
5935 // to any DNS server.
5936 if (!q
->triedAllServersOnce
)
5938 LogInfo("QuestionValidForDNSTrigger: question %##s (%s) stopped too soon", q
->qname
.c
, DNSTypeName(q
->qtype
));
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
)
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
));
5953 mDNSlocal
void AckConfigd(mDNS
*const m
, dns_config_t
*config
)
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");
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
)
5967 mDNSBool trigger
= mDNSfalse
;
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.
5980 timenow
= m
->timenow
;
5981 if (m
->p
->DNSTrigger
&& (timenow
- m
->p
->DNSTrigger
) < DNS_TRIGGER_INTERVAL
)
5983 if (!m
->p
->v4answers
|| !m
->p
->v6answers
)
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
);
5992 if (v4q
!= NULL
&& QuestionValidForDNSTrigger(v4q
))
5994 int old
= m
->p
->v4answers
;
5996 m
->p
->v4answers
= 1;
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.
6003 LogInfo("mDNSPlatformTriggerDNSRetry: Triggering because of IPv4, last trigger %d ms, %##s (%s)", (timenow
- m
->p
->DNSTrigger
),
6004 v4q
->qname
.c
, DNSTypeName(v4q
->qtype
));
6008 if (v6q
!= NULL
&& QuestionValidForDNSTrigger(v6q
))
6010 int old
= m
->p
->v6answers
;
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.
6018 LogInfo("mDNSPlatformTriggerDNSRetry: Triggering because of IPv6, last trigger %d ms, %##s (%s)", (timenow
- m
->p
->DNSTrigger
),
6019 v6q
->qname
.c
, DNSTypeName(v6q
->qtype
));
6025 dns_config_t
*config
= dns_configuration_copy();
6029 AckConfigd(m
, config
);
6031 dns_configuration_free(config
);
6035 LogMsg("mDNSPlatformTriggerDNSRetry: ERROR!! configd did not return config");
6040 mDNSlocal
void SetupActiveDirectoryDomain(dns_config_t
*config
)
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])
6047 MakeDomainNameFromDNSNameString(&ActiveDirectoryPrimaryDomain
, config
->resolver
[0]->domain
);
6051 ActiveDirectoryPrimaryDomain
.c
[0] = 0;
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
))
6059 SetupAddr(&ActiveDirectoryPrimaryDomainServer
, config
->resolver
[0]->nameserver
[0]);
6063 AssignDomainName(&ActiveDirectoryPrimaryDomain
, (const domainname
*)"");
6064 ActiveDirectoryPrimaryDomainLabelCount
= 0;
6065 ActiveDirectoryPrimaryDomainServer
= zeroAddr
;
6070 mDNSlocal
void SetupDDNSDomains(domainname
*const fqdn
, DNameListElem
**RegDomains
, DNameListElem
**BrowseDomains
)
6073 char buf
[MAX_ESCAPED_DOMAIN_NAME
]; // Max legal C-string name, including terminating NUL
6076 SCDynamicStoreRef store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:mDNSPlatformSetDNSConfig"), NULL
, NULL
);
6079 LogMsg("SetupDDNSDomains: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6083 CFDictionaryRef ddnsdict
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_DynamicDNS
);
6088 CFArrayRef fqdnArray
= CFDictionaryGetValue(ddnsdict
, CFSTR("HostNames"));
6089 if (fqdnArray
&& CFArrayGetCount(fqdnArray
) > 0)
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
))
6095 CFStringRef name
= CFDictionaryGetValue(fqdnDict
, CFSTR("Domain"));
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
);
6109 CFArrayRef regArray
= CFDictionaryGetValue(ddnsdict
, CFSTR("RegistrationDomains"));
6110 if (regArray
&& CFArrayGetCount(regArray
) > 0)
6112 CFDictionaryRef regDict
= CFArrayGetValueAtIndex(regArray
, 0);
6113 if (regDict
&& DictionaryIsEnabled(regDict
))
6115 CFStringRef name
= CFDictionaryGetValue(regDict
, CFSTR("Domain"));
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)");
6123 debugf("GetUserSpecifiedDDNSConfig SCDynamicStore DDNS registration domain: %s", buf
);
6124 AppendDNameListElem(&RegDomains
, 0, &d
);
6133 CFArrayRef browseArray
= CFDictionaryGetValue(ddnsdict
, CFSTR("BrowseDomains"));
6136 for (i
= 0; i
< CFArrayGetCount(browseArray
); i
++)
6138 CFDictionaryRef browseDict
= CFArrayGetValueAtIndex(browseArray
, i
);
6139 if (browseDict
&& DictionaryIsEnabled(browseDict
))
6141 CFStringRef name
= CFDictionaryGetValue(browseDict
, CFSTR("Domain"));
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)");
6149 debugf("GetUserSpecifiedDDNSConfig SCDynamicStore DDNS browsing domain: %s", buf
);
6150 AppendDNameListElem(&BrowseDomains
, 0, &d
);
6157 CFRelease(ddnsdict
);
6162 CFDictionaryRef btmm
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_BackToMyMac
);
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
++)
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
);
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])
6181 LogInfo("BackToMyMac %d %d %##s", i
, uid
, d
.c
);
6182 AppendDNameListElem(&RegDomains
, uid
, &d
);
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
)
6197 MD5_CTX sdc
; // search domain context
6198 static mDNSu16 resolverGroupID
= 0;
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
;
6205 LogInfo("mDNSPlatformSetDNSConfig:%s%s%s%s%s",
6206 setservers
? " setservers" : "",
6207 setsearch
? " setsearch" : "",
6208 fqdn
? " fqdn" : "",
6209 RegDomains
? " RegDomains" : "",
6210 BrowseDomains
? " BrowseDomains" : "");
6212 if (setsearch
) MD5_Init(&sdc
);
6214 // Add the inferred address-based configuration discovery domains
6215 // (should really be in core code I think, not platform-specific)
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
;
6224 saddr
.sin_addr
.s_addr
= *(in_addr_t
*)&m
->Router
.ip
.v4
;
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);
6234 if (ifa
->ifa_addr
->sa_family
== AF_INET
&&
6236 !(ifa
->ifa_flags
& IFF_LOOPBACK
) &&
6237 !SetupAddr(&a
, ifa
->ifa_addr
) &&
6238 !mDNSv4AddressIsLinkLocal(&a
.ip
.v4
) )
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
);
6252 ifa
= ifa
->ifa_next
;
6256 #ifndef MDNS_NO_DNSINFO
6257 if (setservers
|| setsearch
)
6259 dns_config_t
*config
= dns_configuration_copy();
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");
6272 LogInfo("mDNSPlatformSetDNSConfig: config->n_resolver = %d, generation %llu", config
->n_resolver
, config
->generation
);
6273 if (m
->p
->LastConfigGeneration
== config
->generation
)
6275 LogInfo("mDNSPlatformSetDNSConfig: generation number %llu same, not processing", config
->generation
);
6276 dns_configuration_free(config
);
6277 SetupDDNSDomains(fqdn
, RegDomains
, BrowseDomains
);
6280 #if APPLE_OSX_mDNSResponder
6281 SetupActiveDirectoryDomain(config
);
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.
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
;
6294 ConfigResolvers(m
, config
, kScopeInterfaceID
, setsearch
, setservers
, &sdc
, resolverGroupID
);
6295 resolverGroupID
+= config
->n_scoped_resolver
;
6297 ConfigResolvers(m
, config
, kScopeServiceID
, setsearch
, setservers
, &sdc
, resolverGroupID
);
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.
6304 // Note: We have to set the generation number here when we are acking.
6305 // For every DNS configuration change, we do the following:
6307 // 1) Copy dns configuration, handle search domains change
6308 // 2) Copy dns configuration, handle dns server change
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
6314 m
->p
->LastConfigGeneration
= config
->generation
;
6315 LogInfo("mDNSPlatformSetDNSConfig: Acking configuration setservers %d, setsearch %d", setservers
, setsearch
);
6316 AckConfigd(m
, config
);
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
;
6324 #endif // MDNS_NO_DNSINFO
6325 SetupDDNSDomains(fqdn
, RegDomains
, BrowseDomains
);
6330 mDNSexport mStatus
mDNSPlatformGetPrimaryInterface(mDNS
*const m
, mDNSAddr
*v4
, mDNSAddr
*v6
, mDNSAddr
*r
)
6335 SCDynamicStoreRef store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:mDNSPlatformGetPrimaryInterface"), NULL
, NULL
);
6337 LogMsg("mDNSPlatformGetPrimaryInterface: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6340 CFDictionaryRef dict
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_IPv4
);
6343 r
->type
= mDNSAddrType_IPv4
;
6344 r
->ip
.v4
= zerov4Addr
;
6345 CFStringRef string
= CFDictionaryGetValue(dict
, kSCPropNetIPv4Router
);
6348 if (!CFStringGetCString(string
, buf
, 256, kCFStringEncodingUTF8
))
6349 LogMsg("Could not convert router to CString");
6352 struct sockaddr_in saddr
;
6353 saddr
.sin_len
= sizeof(saddr
);
6354 saddr
.sin_family
= AF_INET
;
6356 inet_aton(buf
, &saddr
.sin_addr
);
6358 *(in_addr_t
*)&r
->ip
.v4
= saddr
.sin_addr
.s_addr
;
6362 string
= CFDictionaryGetValue(dict
, kSCDynamicStorePropNetPrimaryInterface
);
6365 mDNSBool HavePrimaryGlobalv6
= mDNSfalse
; // does the primary interface have a global v6 address?
6366 struct ifaddrs
*ifa
= myGetIfAddrs(1);
6368 *v4
= *v6
= zeroAddr
;
6370 if (!CFStringGetCString(string
, buf
, 256, kCFStringEncodingUTF8
)) { LogMsg("Could not convert router to CString"); goto exit
; }
6372 // find primary interface in list
6373 while (ifa
&& (mDNSIPv4AddressIsZero(v4
->ip
.v4
) || mDNSv4AddressIsLinkLocal(&v4
->ip
.v4
) || !HavePrimaryGlobalv6
))
6375 mDNSAddr tmp6
= zeroAddr
;
6376 if (!strcmp(buf
, ifa
->ifa_name
))
6378 if (ifa
->ifa_addr
->sa_family
== AF_INET
)
6380 if (mDNSIPv4AddressIsZero(v4
->ip
.v4
) || mDNSv4AddressIsLinkLocal(&v4
->ip
.v4
)) SetupAddr(v4
, ifa
->ifa_addr
);
6382 else if (ifa
->ifa_addr
->sa_family
== AF_INET6
)
6384 SetupAddr(&tmp6
, ifa
->ifa_addr
);
6385 if (tmp6
.ip
.v6
.b
[0] >> 5 == 1) // global prefix: 001
6386 { HavePrimaryGlobalv6
= mDNStrue
; *v6
= tmp6
; }
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])
6394 SetupAddr(&tmp6
, ifa
->ifa_addr
);
6395 if (tmp6
.ip
.v6
.b
[0] >> 5 == 1) *v6
= tmp6
;
6398 ifa
= ifa
->ifa_next
;
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
6410 return mStatus_NoError
;
6413 mDNSexport
void mDNSPlatformDynDNSHostNameStatusChanged(const domainname
*const dname
, const mStatus status
)
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
);
6423 if (!(*(p
+1)) && *p
== '.') *p
= 0; // if last character, strip trailing dot
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).
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
);
6441 const CFNumberRef StatusVals
[1] = { CFNumberCreate(NULL
, kCFNumberSInt32Type
, &status
) };
6442 if (!StatusVals
[0]) LogMsg("SetDDNSNameStatus: CFNumberCreate(%d) failed", status
);
6445 const CFDictionaryRef HostVals
[1] = { CFDictionaryCreate(NULL
, (void*)StatusKeys
, (void*)StatusVals
, 1, &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
) };
6448 const CFDictionaryRef StateVals
[1] = { CFDictionaryCreate(NULL
, (void*)HostKeys
, (void*)HostVals
, 1, &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
) };
6451 CFDictionaryRef StateDict
= CFDictionaryCreate(NULL
, (void*)StateKeys
, (void*)StateVals
, 1, &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
);
6454 mDNSDynamicStoreSetConfig(kmDNSDynamicConfig
, mDNSNULL
, StateDict
);
6455 CFRelease(StateDict
);
6457 CFRelease(StateVals
[0]);
6459 CFRelease(HostVals
[0]);
6461 CFRelease(StatusVals
[0]);
6463 CFRelease(HostKeys
[0]);
6467 #if APPLE_OSX_mDNSResponder
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
6473 mDNSlocal mDNSBool
IsBTMMDomain(domainname
*d
)
6475 SCDynamicStoreRef store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:IsBTMMDomain"), NULL
, NULL
);
6478 LogMsg("IsBTMMDomain: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6481 CFDictionaryRef btmm
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_BackToMyMac
);
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
];
6490 CFDictionaryGetKeysAndValues(btmm
, key
, val
);
6491 for (i
= 0; i
< size
; i
++)
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
);
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])
6503 if (SameDomainName(&dom
, d
))
6505 LogInfo("IsBTMMDomain: Domain %##s is a btmm domain, uid %u", d
->c
, uid
);
6516 LogInfo("IsBTMMDomain: Domain %##s not a btmm domain", d
->c
);
6520 // Appends data to the buffer
6521 mDNSlocal
int AddOneItem(char *buf
, int bufsz
, char *data
, int *currlen
)
6525 len
= strlcpy(buf
+ *currlen
, data
, bufsz
- *currlen
);
6526 if (len
>= (bufsz
- *currlen
))
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;
6535 else { (*currlen
) += len
; }
6537 buf
[*currlen
] = ',';
6538 if (*currlen
>= bufsz
)
6540 LogMsg("AddOneItem: ERROR!! How can currlen be %d", *currlen
);
6541 *currlen
= bufsz
- 1;
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; }
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
)
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];
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.
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.
6573 for (FoundInList
= m
->AuthInfoList
; FoundInList
; FoundInList
= FoundInList
->next
)
6574 if (!FoundInList
->deltime
&& FoundInList
->AutoTunnel
&& IsBTMMDomain(&FoundInList
->domain
))
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;
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.
6590 if (currulen
!= (int)(sizeof(AllUsers
) - 1)) AllUsers
[currulen
- 1] = 0;
6591 if (currplen
!= (int)(sizeof(AllPass
) - 1)) AllPass
[currplen
- 1] = 0;
6593 LogInfo("UpdateBTMMRelayConnection: AWS_Connect for user %s", AllUsers
);
6594 AWACS_Connect(AllUsers
, AllPass
, "hello.connectivity.me.com");
6595 AWACSDConnected
= mDNStrue
;
6599 // Disconnect only if we connected previously
6600 if (AWACSDConnected
)
6602 LogInfo("UpdateBTMMRelayConnection: AWS_Disconnect");
6604 AWACSDConnected
= mDNSfalse
;
6606 else LogInfo("UpdateBTMMRelayConnection: Not calling AWS_Disconnect");
6610 mDNSlocal
void UpdateBTMMRelayConnection(mDNS
*const m
)
6613 LogInfo("UpdateBTMMRelayConnection: AWACS connection not started, no AWACS library");
6615 #endif // ! NO_AWACS
6617 mDNSlocal
void ProcessConndConfigChanges(mDNS
*const m
);
6619 #endif // APPLE_OSX_mDNSResponder
6621 // MUST be called holding the lock
6622 mDNSexport
void SetDomainSecrets(mDNS
*m
)
6624 #ifdef NO_SECURITYFRAMEWORK
6626 LogMsg("Note: SetDomainSecrets: no keychain support");
6628 mDNSBool haveAutoTunnels
= mDNSfalse
;
6630 LogInfo("SetDomainSecrets");
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);
6641 #if APPLE_OSX_mDNSResponder
6643 // Mark all TunnelClients for deletion
6644 ClientTunnel
*client
;
6645 for (client
= m
->TunnelClients
; client
; client
= client
->next
)
6647 LogInfo("SetDomainSecrets: tunnel to %##s marked for deletion", client
->dstname
.c
);
6648 client
->MarkedForDeletion
= mDNStrue
;
6651 #endif // APPLE_OSX_mDNSResponder
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; }
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
);
6665 CFIndex ArrayCount
= CFArrayGetCount(secrets
);
6666 // Iterate through the secrets
6667 for (i
= 0; i
< ArrayCount
; ++i
)
6669 mDNSBool AutoTunnel
;
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; }
6678 // The names have already been vetted by the helper, but checking them again here helps humans and automated tools verify correctness
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';
6689 AutoTunnel
= mDNSfalse
;
6691 if (!strncmp(stringbuf
, dnsprefix
, strlen(dnsprefix
)))
6692 offset
= strlen(dnsprefix
);
6693 else if (!strncmp(stringbuf
, btmmprefix
, strlen(btmmprefix
)))
6695 AutoTunnel
= mDNStrue
;
6696 offset
= strlen(btmmprefix
);
6699 if (!MakeDomainNameFromDNSNameString(&domain
, stringbuf
+ offset
)) { LogMsg("SetDomainSecrets: bad key domain %s", stringbuf
); continue; }
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';
6709 if (!MakeDomainNameFromDNSNameString(&keyname
, stringbuf
)) { LogMsg("SetDomainSecrets: bad key name %s", stringbuf
); continue; }
6711 // Get key data (kmDNSKcKey)
6712 data
= CFArrayGetValueAtIndex(entry
, kmDNSKcKey
);
6713 if (CFDataGetLength(data
) >= (int)sizeof(stringbuf
))
6715 LogMsg("SetDomainSecrets: Shared secret too long: %d", CFDataGetLength(data
));
6718 CFDataGetBytes(data
, CFRangeMake(0, CFDataGetLength(data
)), (UInt8
*)stringbuf
);
6719 stringbuf
[CFDataGetLength(data
)] = '\0'; // mDNS_SetSecretForDomain requires NULL-terminated C string for key
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
))
6727 LogMsg("SetDomainSecrets: host:port data too long: %d", CFDataGetLength(data
));
6730 CFDataGetBytes(data
, CFRangeMake(0,CFDataGetLength(data
)), (UInt8
*)hostbuf
);
6731 hostbuf
[CFDataGetLength(data
)] = '\0';
6733 domainname hostname
;
6736 hptr
= strchr(hostbuf
, ':');
6738 port
.NotAnInteger
= 0;
6745 while(hptr
&& *hptr
!= 0)
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';
6754 port
.NotAnInteger
= p
[0] << 8 | p
[1];
6756 // The hostbuf is of the format dsid@hostname:port. We don't care about the dsid.
6757 hptr
= strchr(hostbuf
, '@');
6762 if (!MakeDomainNameFromDNSNameString(&hostname
, hptr
)) { LogMsg("SetDomainSecrets: bad host name %s", hptr
); continue; }
6764 DomainAuthInfo
*FoundInList
;
6765 for (FoundInList
= m
->AuthInfoList
; FoundInList
; FoundInList
= FoundInList
->next
)
6766 if (SameDomainName(&FoundInList
->domain
, &domain
)) break;
6768 #if APPLE_OSX_mDNSResponder
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
))
6776 LogInfo("SetDomainSecrets: tunnel to %##s no longer marked for deletion", client
->dstname
.c
);
6777 client
->MarkedForDeletion
= mDNSfalse
;
6781 #endif // APPLE_OSX_mDNSResponder
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]));
6788 // If didn't find desired domain in the list, make a new entry
6790 if (FoundInList
&& FoundInList
->AutoTunnel
&& haveAutoTunnels
== mDNSfalse
) haveAutoTunnels
= mDNStrue
;
6793 ptr
= (DomainAuthInfo
*)mallocL("DomainAuthInfo", sizeof(*ptr
));
6794 if (!ptr
) { LogMsg("SetDomainSecrets: No memory"); continue; }
6797 //LogInfo("SetDomainSecrets: %d of %d %##s", i, ArrayCount, &domain);
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
)
6802 if (!FoundInList
) mDNSPlatformMemFree(ptr
); // If we made a new DomainAuthInfo here, and it turned out bad, dispose it immediately
6806 ConvertDomainNameToCString(&domain
, stringbuf
);
6807 CFStringRef cfs
= CFStringCreateWithCString(NULL
, stringbuf
, kCFStringEncodingUTF8
);
6808 if (cfs
) { CFArrayAppendValue(sa
, cfs
); CFRelease(cfs
); }
6813 if (!privateDnsArray
|| !CFEqual(privateDnsArray
, sa
))
6815 if (privateDnsArray
)
6816 CFRelease(privateDnsArray
);
6818 privateDnsArray
= sa
;
6819 CFRetain(privateDnsArray
);
6820 mDNSDynamicStoreSetConfig(kmDNSPrivateConfig
, mDNSNULL
, privateDnsArray
);
6824 #if APPLE_OSX_mDNSResponder
6826 // clean up ClientTunnels
6827 ClientTunnel
**pp
= &m
->TunnelClients
;
6830 if ((*pp
)->MarkedForDeletion
)
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
);
6837 freeL("ClientTunnel", cur
);
6843 mDNSBool needAutoTunnelNAT
= mDNSfalse
;
6844 DomainAuthInfo
*info
;
6845 for (info
= m
->AuthInfoList
; info
; info
= info
->next
)
6847 if (info
->AutoTunnel
)
6849 UpdateAutoTunnelDeviceInfoRecord(m
, info
);
6850 UpdateAutoTunnelHostRecord(m
, info
);
6851 UpdateAutoTunnelServiceRecords(m
, info
);
6852 UpdateAutoTunnel6Record(m
, info
);
6855 if (info
->AutoTunnelServiceStarted
) info
->AutoTunnelServiceStarted
= mDNSfalse
;
6857 else if (info
->AutoTunnelServiceStarted
)
6858 needAutoTunnelNAT
= true;
6860 UpdateAutoTunnelDomainStatus(m
, info
);
6864 // If the AutoTunnel NAT-T is no longer needed (& is currently running), stop it
6865 if (!needAutoTunnelNAT
&& m
->AutoTunnelNAT
.clientContext
)
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
;
6878 UpdateAnonymousRacoonConfig(m
); // Determine whether we need racoon to accept incoming connections
6879 ProcessConndConfigChanges(m
); // Update AutoTunnelInnerAddress values and default ipsec policies as necessary
6881 #endif // APPLE_OSX_mDNSResponder
6883 CheckSuppressUnusableQuestions(m
);
6885 #endif /* NO_SECURITYFRAMEWORK */
6888 mDNSlocal
void SetLocalDomains(void)
6890 CFMutableArrayRef sa
= CFArrayCreateMutable(NULL
, 0, &kCFTypeArrayCallBacks
);
6891 if (!sa
) { LogMsg("SetLocalDomains: CFArrayCreateMutable failed"); return; }
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"));
6900 mDNSDynamicStoreSetConfig(kmDNSMulticastConfig
, mDNSNULL
, sa
);
6904 mDNSlocal
void GetCurrentPMSetting(const CFStringRef name
, mDNSs32
*val
)
6906 #if USE_IOPMCOPYACTIVEPMPREFERENCES
6907 CFTypeRef blob
= NULL
;
6908 CFStringRef str
= NULL
;
6909 CFDictionaryRef odict
= NULL
;
6910 CFDictionaryRef idict
= NULL
;
6911 CFNumberRef number
= NULL
;
6913 blob
= IOPSCopyPowerSourcesInfo();
6914 if (!blob
) { LogMsg("GetCurrentPMSetting: IOPSCopyPowerSourcesInfo failed!"); goto end
; }
6916 odict
= IOPMCopyActivePMPreferences();
6917 if (!odict
) { LogMsg("GetCurrentPMSetting: IOPMCopyActivePMPreferences failed!"); goto end
; }
6919 str
= IOPSGetProvidingPowerSourceType(blob
);
6920 if (!str
) { LogMsg("GetCurrentPMSetting: IOPSGetProvidingPowerSourceType failed!"); goto end
; }
6922 idict
= CFDictionaryGetValue(odict
, str
);
6926 if (!CFStringGetCString(str
, buf
, sizeof(buf
), kCFStringEncodingUTF8
)) buf
[0] = 0;
6927 LogMsg("GetCurrentPMSetting: CFDictionaryGetValue (%s) failed!", buf
);
6931 number
= CFDictionaryGetValue(idict
, name
);
6932 if (!number
|| CFGetTypeID(number
) != CFNumberGetTypeID() || !CFNumberGetValue(number
, kCFNumberSInt32Type
, val
))
6935 if (blob
) CFRelease(blob
);
6936 if (odict
) CFRelease(odict
);
6940 SCDynamicStoreRef store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:GetCurrentPMSetting"), NULL
, NULL
);
6941 if (!store
) LogMsg("GetCurrentPMSetting: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
6944 CFDictionaryRef dict
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_PowerSettings
);
6945 if (!dict
) LogSPS("GetCurrentPMSetting: Could not get IOPM CurrentSettings dict");
6948 CFNumberRef number
= CFDictionaryGetValue(dict
, name
);
6949 if (!number
|| CFGetTypeID(number
) != CFNumberGetTypeID() || !CFNumberGetValue(number
, kCFNumberSInt32Type
, val
))
6959 #if APPLE_OSX_mDNSResponder
6961 static CFMutableDictionaryRef spsStatusDict
= NULL
;
6962 static const CFStringRef kMetricRef
= CFSTR("Metric");
6964 mDNSlocal
void SPSStatusPutNumber(CFMutableDictionaryRef dict
, const mDNSu8
* const ptr
, CFStringRef key
)
6966 mDNSu8 tmp
= (ptr
[0] - '0') * 10 + ptr
[1] - '0';
6967 CFNumberRef num
= CFNumberCreate(NULL
, kCFNumberSInt8Type
, &tmp
);
6969 LogMsg("SPSStatusPutNumber: Could not create CFNumber");
6972 CFDictionarySetValue(dict
, key
, num
);
6977 mDNSlocal CFMutableDictionaryRef
SPSCreateDict(const mDNSu8
* const ptr
)
6979 CFMutableDictionaryRef dict
= CFDictionaryCreateMutable(NULL
, 0, &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
);
6980 if (!dict
) { LogMsg("SPSCreateDict: Could not create CFDictionary dict"); return dict
; }
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
);
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"));
6994 mDNSu32 tmp
= SPSMetric(ptr
);
6995 CFNumberRef num
= CFNumberCreate(NULL
, kCFNumberSInt32Type
, &tmp
);
6997 LogMsg("SPSCreateDict: Could not create CFNumber");
7000 CFDictionarySetValue(dict
, kMetricRef
, num
);
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
; }
7012 CFDictionarySetValue(dict
, CFSTR("PrettyName"), spsname
);
7020 mDNSlocal CFComparisonResult
CompareSPSEntries(const void *val1
, const void *val2
, void *context
)
7023 return CFNumberCompare((CFNumberRef
)CFDictionaryGetValue((CFDictionaryRef
)val1
, kMetricRef
),
7024 (CFNumberRef
)CFDictionaryGetValue((CFDictionaryRef
)val2
, kMetricRef
),
7028 mDNSlocal
void UpdateSPSStatus(mDNS
*const m
, DNSQuestion
*question
, const ResourceRecord
*const answer
, QC_result AddRecord
)
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>");
7034 mDNS_UpdateAllowSleep(m
);
7037 if (answer
&& SPSMetric(answer
->rdata
->u
.name
.c
) > 999999) return; // Ignore instances with invalid names
7041 spsStatusDict
= CFDictionaryCreateMutable(NULL
, 0, &kCFTypeDictionaryKeyCallBacks
, &kCFTypeDictionaryValueCallBacks
);
7042 if (!spsStatusDict
) { LogMsg("UpdateSPSStatus: Could not create CFDictionary spsStatusDict"); return; }
7045 CFStringRef ifname
= CFStringCreateWithCString(NULL
, info
->ifname
, kCFStringEncodingUTF8
);
7046 if (!ifname
) { LogMsg("UpdateSPSStatus: Could not create CFString ifname"); return; }
7048 CFMutableArrayRef array
= NULL
;
7050 if (!CFDictionaryGetValueIfPresent(spsStatusDict
, ifname
, (const void**) &array
))
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
7058 if (!array
) { LogMsg("UpdateSPSStatus: Could not get CFMutableArray for %s", info
->ifname
); CFRelease(ifname
); return; }
7060 if (!answer
) // special call that means the question has been stopped (because the interface is going away)
7061 CFArrayRemoveAllValues(array
);
7064 CFMutableDictionaryRef dict
= SPSCreateDict(answer
->rdata
->u
.name
.c
);
7065 if (!dict
) { CFRelease(ifname
); return; }
7069 if (!CFArrayContainsValue(array
, CFRangeMake(0, CFArrayGetCount(array
)), dict
))
7072 for (i
=0; i
<CFArrayGetCount(array
); i
++)
7073 if (CompareSPSEntries(CFArrayGetValueAtIndex(array
, i
), dict
, NULL
) != kCFCompareLessThan
)
7075 CFArrayInsertValueAtIndex(array
, i
, dict
);
7077 else LogMsg("UpdateSPSStatus: %s array already contains %##s", info
->ifname
, answer
->rdata
->u
.name
.c
);
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
);
7089 if (!m
->ShutdownTime
) mDNSDynamicStoreSetConfig(kmDNSSleepProxyServersState
, info
->ifname
, array
);
7094 mDNSlocal mDNSs32
GetSystemSleepTimerSetting(void)
7097 SCDynamicStoreRef store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:GetSystemSleepTimerSetting"), NULL
, NULL
);
7099 LogMsg("GetSystemSleepTimerSetting: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
7102 CFDictionaryRef dict
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_PowerSettings
);
7105 CFNumberRef number
= CFDictionaryGetValue(dict
, CFSTR("System Sleep Timer"));
7106 if (number
) CFNumberGetValue(number
, kCFNumberSInt32Type
, &val
);
7114 mDNSlocal
void SetSPS(mDNS
*const m
)
7117 // If we ever want to know InternetSharing status in the future, use DNSXEnableProxy()
7118 mDNSu8 sps
= (OfferSleepProxyService
&& GetSystemSleepTimerSetting() == 0) ? mDNSSleepProxyMetric_IncidentalSoftware
: 0;
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;
7124 // If we decide to let laptops act as Sleep Proxy, we should do it only when running on AC power, not on battery
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
;
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
;
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.
7139 NetworkInterfaceInfo
*intf
= mDNSNULL
;
7140 mDNSEthAddr bssid
= zeroEthAddr
;
7141 for (intf
= GetFirstActiveInterface(m
->HostInterfaces
); intf
; intf
= GetFirstActiveInterface(intf
->next
))
7143 bssid
= GetBSSID(intf
->ifname
);
7144 if (!mDNSSameEthAddress(&bssid
, &zeroEthAddr
))
7146 LogMsg("SetSPS: AppleTV on WiFi - not advertising BSP services");
7152 #endif // NO_APPLETV_SLEEP_PROXY_ON_WIFI
7154 mDNSCoreBeSleepProxyServer(m
, sps
, SPMetricPortability
, SPMetricMarginalPower
, SPMetricTotalPower
, SPMetricFeatures
);
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.
7162 { // commands from the daemon to the driver
7163 cmd_mDNSOffloadRR
= 21, // give the mdns update buffer to the driver
7166 typedef union { void *ptr
; mDNSOpaque64 sixtyfourbits
; } FatPtr
;
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)
7181 #include <IOKit/IOKitLib.h>
7182 #include <dns_util.h>
7184 mDNSlocal mDNSu16
GetPortArray(mDNS
*const m
, int trans
, mDNSIPPort
*portarray
)
7186 const domainlabel
*const tp
= (trans
== mDNSTransport_UDP
) ? (const domainlabel
*)"\x4_udp" : (const domainlabel
*)"\x4_tcp";
7189 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
7190 if (rr
->resrec
.rrtype
== kDNSType_SRV
&& SameDomainLabel(ThirdLabel(rr
->resrec
.name
)->c
, tp
->c
))
7192 if (portarray
) portarray
[count
] = rr
->resrec
.rdata
->u
.srv
.port
;
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
)
7199 LogSPS("GetPortArray Back to My Mac at %d", count
);
7200 if (portarray
) portarray
[count
] = IPSECPort
;
7206 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7207 mDNSlocal mDNSBool
SupportsTCPKeepAlive()
7209 IOReturn ret
= kIOReturnSuccess
;
7210 CFTypeRef obj
= NULL
;
7211 mDNSBool supports
= mDNSfalse
;
7213 ret
= IOPlatformCopyFeatureActive(CFSTR("TCPKeepAliveDuringSleep"), &obj
);
7214 if ((kIOReturnSuccess
== ret
) && (obj
!= NULL
))
7216 supports
= (obj
== kCFBooleanTrue
)? mDNStrue
: mDNSfalse
;
7219 LogSPS("%s: The hardware %s TCP Keep Alive", __func__
, (supports
? "supports" : "does not support"));
7223 mDNSlocal mDNSBool
OnBattery(void)
7225 CFTypeRef powerInfo
= IOPSCopyPowerSourcesInfo();
7226 CFTypeRef powerSrc
= IOPSGetProvidingPowerSourceType(powerInfo
);
7227 mDNSBool result
= mDNSfalse
;
7229 if (powerInfo
!= NULL
)
7231 result
= CFEqual(CFSTR(kIOPSBatteryPowerValue
), powerSrc
);
7232 CFRelease(powerInfo
);
7234 LogSPS("%s: The system is on %s", __func__
, (result
)? "Battery" : "AC Power");
7238 #endif // !TARGET_OS_EMBEDDED
7240 #define TfrRecordToNIC(RR) \
7241 ((!(RR)->resrec.InterfaceID && ((RR)->ForceMCast || IsLocalDomain((RR)->resrec.name))))
7243 mDNSlocal mDNSu32
CountProxyRecords(mDNS
*const m
, uint32_t *const numbytes
, NetworkInterfaceInfo
*const intf
, mDNSBool TCPKAOnly
, mDNSBool supportsTCPKA
)
7250 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
7252 if (!(rr
->AuthFlags
& AuthFlagsWakeOnly
) && rr
->resrec
.RecordType
> kDNSRecordTypeDeregistering
)
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
))
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
));
7267 (void) TCPKAOnly
; // unused
7268 (void) supportsTCPKA
; // unused
7269 (void) intf
; // unused
7270 #endif // APPLE_OSX_mDNSResponder
7271 if (TfrRecordToNIC(rr
))
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
));
7283 mDNSlocal
void GetProxyRecords(mDNS
*const m
, DNSMessage
*const msg
, uint32_t *const numbytes
, FatPtr
*const records
, mDNSBool TCPKAOnly
, mDNSBool supportsTCPKA
)
7285 mDNSu8
*p
= msg
->data
;
7286 const mDNSu8
*const limit
= p
+ *numbytes
;
7287 InitializeDNSMessage(&msg
->h
, zeroID
, zeroID
);
7292 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
7294 if (!(rr
->AuthFlags
& AuthFlagsWakeOnly
) && rr
->resrec
.RecordType
> kDNSRecordTypeDeregistering
)
7296 #if APPLE_OSX_mDNSResponder && !TARGET_OS_EMBEDDED
7297 mDNSBool isKeepAliveRecord
= mDNS_KeepaliveRecord(&rr
->resrec
);
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
))
7304 (void) TCPKAOnly
; // unused
7305 (void) supportsTCPKA
; // unused
7306 #endif // APPLE_OSX_mDNSResponder
7308 if (TfrRecordToNIC(rr
))
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
));
7322 *numbytes
= p
- msg
->data
;
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
7340 (void)inputStructCnt
;
7342 (void)outputStructCnt
;
7343 LogMsg("Compiled without IOConnectCallStructMethod");
7344 return(KERN_FAILURE
);
7348 mDNSexport mDNSBool
SupportsInNICProxy(NetworkInterfaceInfo
*const intf
)
7350 if(!UseInternalSleepProxy
)
7352 LogSPS("SupportsInNICProxy: Internal Sleep Proxy is disabled");
7355 return CheckInterfaceSupport(intf
, mDNS_IOREG_KEY
);
7358 mDNSexport mStatus
ActivateLocalProxy(mDNS
*const m
, NetworkInterfaceInfo
*const intf
) // Called with the lock held
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
));
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());
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
);
7376 (void) onbattery
; // unused;
7378 if (!service
) { LogMsg("ActivateLocalProxy: No service for interface %s", intf
->ifname
); return(mStatus_UnknownErr
); }
7381 IOObjectGetClass(service
, n1
);
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
);
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
);
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
);
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
);
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
);
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
));
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
);
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
);
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
);
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
;
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
);
7451 IOObjectRelease(parent
);
7453 IOObjectRelease(service
);
7457 #endif // APPLE_OSX_mDNSResponder
7459 mDNSlocal mDNSu8
SystemWakeForNetworkAccess(void)
7462 mDNSu8 ret
= (mDNSu8
)mDNS_NoWake
;
7464 if (DisableSleepProxyClient
)
7466 LogSPS("SystemWakeForNetworkAccess: Sleep Proxy Client disabled by command-line option");
7470 GetCurrentPMSetting(CFSTR("Wake On LAN"), &val
);
7472 ret
= (mDNSu8
)(val
!= 0) ? mDNS_WakeOnAC
: mDNS_NoWake
;
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
7481 LogSPS("SystemWakeForNetworkAccess: Wake On LAN: %d", ret
);
7485 mDNSlocal mDNSBool
SystemSleepOnlyIfWakeOnLAN(void)
7488 GetCurrentPMSetting(CFSTR("PrioritizeNetworkReachabilityOverSleep"), &val
);
7489 return val
!= 0 ? mDNStrue
: mDNSfalse
;
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
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.
7503 // Also, the per-zone _kerberos TXT record is always there, including while sleeping, so
7504 // its presence shouldn't delay sleep.
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.
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
)
7512 if (!AuthRecord_uDNS(rr
)) return mDNStrue
;
7514 if ((rr
->resrec
.rrtype
== kDNSType_AAAA
) && SameDomainLabel(rr
->namestorage
.c
, (const mDNSu8
*)"\x0c_autotunnel6"))
7516 LogInfo("RecordReadyForSleep: %s not ready for sleep", ARDisplayString(m
, rr
));
7520 if ((mDNSIPPortIsZero(m
->AutoTunnelNAT
.ExternalPort
) || m
->AutoTunnelNAT
.Result
))
7522 if (rr
->resrec
.rrtype
== kDNSType_SRV
&& rr
->state
!= regState_NoTarget
&& rr
->zone
7523 && !SameDomainLabel(rr
->namestorage
.c
, (const mDNSu8
*)"\x0b_autotunnel"))
7525 DomainAuthInfo
*info
= GetAuthInfoForName_internal(m
, rr
->zone
);
7526 if (info
&& info
->AutoTunnel
)
7528 LogInfo("RecordReadyForSleep: %s not ready for sleep", ARDisplayString(m
, rr
));
7537 // Caller must hold the lock
7538 mDNSexport
void RemoveAutoTunnel6Record(mDNS
*const m
)
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
);
7549 mDNSlocal mDNSBool
IPv6AddressIsOnInterface(mDNSv6Addr ipv6Addr
, char *ifname
)
7551 struct ifaddrs
*ifa
;
7552 struct ifaddrs
*ifaddrs
;
7555 if (if_nametoindex(ifname
) == 0) {LogInfo("IPv6AddressIsOnInterface: Invalid name %s", ifname
); return mDNSfalse
;}
7557 if (getifaddrs(&ifaddrs
) < 0) {LogInfo("IPv6AddressIsOnInterface: getifaddrs failed"); return mDNSfalse
;}
7559 for (ifa
= ifaddrs
; ifa
!= NULL
; ifa
= ifa
->ifa_next
)
7561 if (strncmp(ifa
->ifa_name
, ifname
, IFNAMSIZ
) != 0)
7563 if ((ifa
->ifa_flags
& IFF_UP
) == 0 || !ifa
->ifa_addr
|| ifa
->ifa_addr
->sa_family
!= AF_INET6
)
7565 if (SetupAddr(&addr
, ifa
->ifa_addr
) != mStatus_NoError
)
7567 LogInfo("IPv6AddressIsOnInterface: SetupAddr error, continuing to the next address");
7570 if (mDNSSameIPv6Address(ipv6Addr
, *(mDNSv6Addr
*)&addr
.ip
.v6
))
7572 LogInfo("IPv6AddressIsOnInterface: found %.16a", &ipv6Addr
);
7576 freeifaddrs(ifaddrs
);
7580 mDNSlocal mDNSv6Addr
IPv6AddressFromString(char* buf
)
7583 struct addrinfo hints
;
7584 struct addrinfo
*res0
;
7586 memset(&hints
, 0, sizeof(hints
));
7587 hints
.ai_family
= AF_INET6
;
7588 hints
.ai_flags
= AI_NUMERICHOST
;
7590 int err
= getaddrinfo(buf
, NULL
, &hints
, &res0
);
7594 retVal
= *(mDNSv6Addr
*)&((struct sockaddr_in6
*)res0
->ai_addr
)->sin6_addr
;
7601 mDNSlocal CFDictionaryRef
CopyConnectivityBackToMyMacDict()
7603 SCDynamicStoreRef store
= NULL
;
7604 CFDictionaryRef connd
= NULL
;
7605 CFDictionaryRef BTMMDict
= NULL
;
7607 store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:CopyConnectivityBackToMyMacDict"), NULL
, NULL
);
7610 LogMsg("CopyConnectivityBackToMyMacDict: SCDynamicStoreCreate failed: %s", SCErrorString(SCError()));
7614 connd
= SCDynamicStoreCopyValue(store
, NetworkChangedKey_BTMMConnectivity
);
7617 LogInfo("CopyConnectivityBackToMyMacDict: SCDynamicStoreCopyValue failed: %s", SCErrorString(SCError()));
7621 BTMMDict
= CFDictionaryGetValue(connd
, CFSTR("BackToMyMac"));
7624 LogInfo("CopyConnectivityBackToMyMacDict: CFDictionaryGetValue: No value for BackToMyMac");
7628 // Non-dictionary is treated as non-existent dictionary
7629 if (CFGetTypeID(BTMMDict
) != CFDictionaryGetTypeID())
7632 LogMsg("CopyConnectivityBackToMyMacDict: BackToMyMac not a dictionary");
7639 if (connd
) CFRelease(connd
);
7640 if (store
) CFRelease(store
);
7645 #define MAX_IPV6_TEXTUAL 40
7647 mDNSlocal mDNSv6Addr
ParseBackToMyMacAddr(CFDictionaryRef BTMMDict
, CFStringRef ifKey
, CFStringRef addrKey
)
7649 mDNSv6Addr retVal
= zerov6Addr
;
7650 CFTypeRef string
= NULL
;
7651 char ifname
[IFNAMSIZ
];
7652 char address
[MAX_IPV6_TEXTUAL
];
7657 if (!CFDictionaryGetValueIfPresent(BTMMDict
, ifKey
, &string
))
7659 LogInfo("ParseBackToMyMacAddr: interface key does not exist");
7663 if (!CFStringGetCString(string
, ifname
, IFNAMSIZ
, kCFStringEncodingUTF8
))
7665 LogMsg("ParseBackToMyMacAddr: Could not convert interface to CString");
7669 if (!CFDictionaryGetValueIfPresent(BTMMDict
, addrKey
, &string
))
7671 LogMsg("ParseBackToMyMacAddr: address key does not exist, but interface key does");
7675 if (!CFStringGetCString(string
, address
, sizeof(address
), kCFStringEncodingUTF8
))
7677 LogMsg("ParseBackToMyMacAddr: Could not convert address to CString");
7681 retVal
= IPv6AddressFromString(address
);
7682 LogInfo("ParseBackToMyMacAddr: %s (%s) %.16a", ifname
, address
, &retVal
);
7684 if (mDNSIPv6AddressIsZero(retVal
))
7687 if (!IPv6AddressIsOnInterface(retVal
, ifname
))
7689 LogMsg("ParseBackToMyMacAddr: %.16a is not on %s", &retVal
, ifname
);
7696 mDNSlocal CFDictionaryRef
GetBackToMyMacZones(CFDictionaryRef BTMMDict
)
7698 CFTypeRef zones
= NULL
;
7703 if (!CFDictionaryGetValueIfPresent(BTMMDict
, CFSTR("Zones"), &zones
))
7705 LogInfo("CopyBTMMZones: Zones key does not exist");
7712 mDNSlocal mDNSv6Addr
ParseBackToMyMacZone(CFDictionaryRef zones
, DomainAuthInfo
* info
)
7714 mDNSv6Addr addr
= zerov6Addr
;
7715 char buffer
[MAX_ESCAPED_DOMAIN_NAME
];
7716 CFStringRef domain
= NULL
;
7717 CFTypeRef theZone
= NULL
;
7722 ConvertDomainNameToCString(&info
->domain
, buffer
);
7723 domain
= CFStringCreateWithCString(NULL
, buffer
, kCFStringEncodingUTF8
);
7727 if (CFDictionaryGetValueIfPresent(zones
, domain
, &theZone
))
7728 addr
= ParseBackToMyMacAddr(theZone
, CFSTR("Interface"), CFSTR("Address"));
7735 mDNSlocal
void SetupBackToMyMacInnerAddresses(mDNS
*const m
, CFDictionaryRef BTMMDict
)
7737 DomainAuthInfo
* info
;
7738 CFDictionaryRef zones
= GetBackToMyMacZones(BTMMDict
);
7741 for (info
= m
->AuthInfoList
; info
; info
= info
->next
)
7743 if (!info
->AutoTunnel
)
7746 newAddr
= ParseBackToMyMacZone(zones
, info
);
7748 if (mDNSSameIPv6Address(newAddr
, info
->AutoTunnelInnerAddress
))
7751 info
->AutoTunnelInnerAddress
= newAddr
;
7752 DeregisterAutoTunnelHostRecord(m
, info
);
7753 UpdateAutoTunnelHostRecord(m
, info
);
7754 UpdateAutoTunnelDomainStatus(m
, info
);
7758 // MUST be called holding the lock
7759 mDNSlocal
void ProcessConndConfigChanges(mDNS
*const m
)
7761 CFDictionaryRef dict
= CopyConnectivityBackToMyMacDict();
7763 LogInfo("ProcessConndConfigChanges: No BTMM dictionary");
7764 mDNSv6Addr relayAddr
= ParseBackToMyMacAddr(dict
, CFSTR("RelayInterface"), CFSTR("RelayAddress"));
7766 LogInfo("ProcessConndConfigChanges: relay %.16a", &relayAddr
);
7768 SetupBackToMyMacInnerAddresses(m
, dict
);
7770 if (dict
) CFRelease(dict
);
7772 if (!mDNSSameIPv6Address(relayAddr
, m
->AutoTunnelRelayAddr
))
7774 m
->AutoTunnelRelayAddr
= relayAddr
;
7776 DomainAuthInfo
* info
;
7777 for (info
= m
->AuthInfoList
; info
; info
= info
->next
)
7778 if (info
->AutoTunnel
)
7780 DeregisterAutoTunnel6Record(m
, info
);
7781 UpdateAutoTunnel6Record(m
, info
);
7782 UpdateAutoTunnelDomainStatus(m
, info
);
7785 // Determine whether we need racoon to accept incoming connections
7786 UpdateAnonymousRacoonConfig(m
);
7789 // If awacsd crashes or exits for some reason, restart it
7790 UpdateBTMMRelayConnection(m
);
7792 #endif /* APPLE_OSX_mDNSResponder */
7794 mDNSlocal mDNSBool
IsAppleNetwork(mDNS
*const m
)
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
)
7800 if (s
->addr
.ip
.v4
.b
[0] == 17)
7802 LogInfo("IsAppleNetwork: Found 17.x.y.z DNSServer concluding that we are on AppleNW: %##s %#a", s
->domain
.c
, &s
->addr
);
7809 mDNSexport
void mDNSMacOSXNetworkChanged(mDNS
*const m
)
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
);
7823 #if APPLE_OSX_mDNSResponder
7826 ProcessConndConfigChanges(m
);
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
7832 for (p
= m
->TunnelClients
; p
; p
= p
->next
)
7833 if (p
->q
.ThisQInterval
< 0)
7835 DomainAuthInfo
* info
= GetAuthInfoForName(m
, &p
->dstname
);
7838 LogMsg("mDNSMacOSXNetworkChanged: Could not get AuthInfo for %##s, removing tunnel keys", p
->dstname
.c
);
7839 AutoTunnelSetKeys(p
, mDNSfalse
);
7843 mDNSv6Addr inner
= info
->AutoTunnelInnerAddress
;
7845 if (!mDNSIPPortIsZero(p
->rmt_outer_port
))
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
))
7854 AutoTunnelSetKeys(p
, mDNSfalse
);
7855 p
->loc_inner
= inner
;
7856 p
->loc_outer
= tmpSrc
.ip
.v4
;
7857 AutoTunnelSetKeys(p
, mDNStrue
);
7862 if (!mDNSSameIPv6Address(p
->loc_inner
, inner
) ||
7863 !mDNSSameIPv6Address(p
->loc_outer6
, m
->AutoTunnelRelayAddr
))
7865 AutoTunnelSetKeys(p
, mDNSfalse
);
7866 p
->loc_inner
= inner
;
7867 p
->loc_outer6
= m
->AutoTunnelRelayAddr
;
7868 AutoTunnelSetKeys(p
, mDNStrue
);
7876 NetworkInterfaceInfoOSX
*i
;
7877 for (i
= m
->p
->InterfaceList
; i
; i
= i
->next
)
7879 if (!m
->SPSSocket
) // Not being Sleep Proxy Server; close any open BPF fds
7881 if (i
->BPF_fd
>= 0 && CountProxyTargets(m
, i
, mDNSNULL
, mDNSNULL
) == 0) CloseBPF(i
);
7883 else // else, we're Sleep Proxy Server; open BPF fds
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(); }
7890 #endif // APPLE_OSX_mDNSResponder
7892 uDNS_SetupDNSConfig(m
);
7893 mDNS_ConfigChanged(m
);
7895 if (IsAppleNetwork(m
) != mDNS_McastTracingEnabled
)
7897 mDNS_McastTracingEnabled
= mDNS_McastTracingEnabled
? mDNSfalse
: mDNStrue
;
7898 LogMsg("mDNSMacOSXNetworkChanged: Multicast Tracing %s", mDNS_McastTracingEnabled
? "Enabled" : "Disabled");
7904 // Called with KQueueLock & mDNS lock
7905 mDNSlocal
void SetNetworkChanged(mDNS
*const m
, mDNSs32 delay
)
7907 if (!m
->p
->NetworkChanged
|| m
->p
->NetworkChanged
- NonZeroTime(m
->timenow
+ delay
) < 0)
7909 m
->p
->NetworkChanged
= NonZeroTime(m
->timenow
+ delay
);
7910 LogInfo("SetNetworkChanged: scheduling in %d msec", delay
);
7914 // Called with KQueueLock & mDNS lock
7915 mDNSlocal
void SetKeyChainTimer(mDNS
*const m
, mDNSs32 delay
)
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)
7920 m
->p
->KeyChainTimer
= NonZeroTime(m
->timenow
+ delay
);
7921 LogInfo("SetKeyChainTimer: %d", delay
);
7925 // Copy the fourth slash-delimited element from either:
7926 // State:/Network/Interface/<bsdname>/IPv4
7928 // Setup:/Network/Service/<servicename>/Interface
7929 mDNSlocal CFStringRef
CopyNameFromKey(CFStringRef key
)
7932 CFStringRef name
= NULL
;
7934 a
= CFStringCreateArrayBySeparatingStrings(NULL
, key
, CFSTR("/"));
7935 if (a
&& CFArrayGetCount(a
) == 5) name
= CFRetain(CFArrayGetValueAtIndex(a
, 3));
7936 if (a
!= NULL
) CFRelease(a
);
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
)
7945 SCDynamicStoreRef store
= NULL
;
7946 CFDictionaryRef dict
= NULL
;
7947 CFMutableArrayRef a
;
7948 const void **keys
= NULL
, **vals
= NULL
;
7949 CFStringRef pattern
= NULL
;
7951 mDNSBool found
= mDNSfalse
;
7953 jc
= CFArrayGetCount(inkeys
);
7956 store
= SCDynamicStoreCreate(NULL
, CFSTR("mDNSResponder:ChangedKeysHaveIPv4LL"), NULL
, NULL
);
7957 if (store
== NULL
) goto done
;
7959 a
= CFArrayCreateMutable(NULL
, 0, &kCFTypeArrayCallBacks
);
7960 if (a
== NULL
) goto done
;
7962 // Setup:/Network/Service/[^/]+/Interface
7963 pattern
= SCDynamicStoreKeyCreateNetworkServiceEntity(NULL
, kSCDynamicStoreDomainSetup
, kSCCompAnyRegex
, kSCEntNetInterface
);
7964 if (pattern
== NULL
) goto done
;
7965 CFArrayAppendValue(a
, pattern
);
7968 // Setup:/Network/Service/[^/]+/IPv4
7969 pattern
= SCDynamicStoreKeyCreateNetworkServiceEntity(NULL
, kSCDynamicStoreDomainSetup
, kSCCompAnyRegex
, kSCEntNetIPv4
);
7970 if (pattern
== NULL
) goto done
;
7971 CFArrayAppendValue(a
, pattern
);
7974 dict
= SCDynamicStoreCopyMultiple(store
, NULL
, a
);
7979 LogMsg("ChangedKeysHaveIPv4LL: Empty dictionary");
7983 ic
= CFDictionaryGetCount(dict
);
7984 vals
= mDNSPlatformMemAllocate(sizeof (void *) * ic
);
7985 keys
= mDNSPlatformMemAllocate(sizeof (void *) * ic
);
7986 CFDictionaryGetKeysAndValues(dict
, keys
, vals
);
7988 for (j
= 0; j
< jc
&& !found
; j
++)
7990 CFStringRef key
= CFArrayGetValueAtIndex(inkeys
, j
);
7991 CFStringRef ifname
= NULL
;
7995 // It would be nice to use a regex here
7996 if (!CFStringHasPrefix(key
, CFSTR("State:/Network/Interface/")) || !CFStringHasSuffix(key
, kSCEntNetIPv4
)) continue;
7998 if ((ifname
= CopyNameFromKey(key
)) == NULL
) continue;
7999 if (mDNS_LoggingEnabled
)
8001 if (!CFStringGetCString(ifname
, buf
, sizeof(buf
), kCFStringEncodingUTF8
)) buf
[0] = 0;
8002 LogInfo("ChangedKeysHaveIPv4LL: potential ifname %s", buf
);
8005 for (i
= 0; i
< ic
; i
++)
8007 CFDictionaryRef ipv4dict
;
8009 CFStringRef serviceid
;
8010 CFStringRef configmethod
;
8012 if (!CFStringHasSuffix(keys
[i
], kSCEntNetInterface
)) continue;
8014 if (CFDictionaryGetTypeID() != CFGetTypeID(vals
[i
])) continue;
8016 if ((name
= CFDictionaryGetValue(vals
[i
], kSCPropNetInterfaceDeviceName
)) == NULL
) continue;
8018 if (!CFEqual(ifname
, name
)) continue;
8020 if ((serviceid
= CopyNameFromKey(keys
[i
])) == NULL
) continue;
8021 if (mDNS_LoggingEnabled
)
8023 if (!CFStringGetCString(serviceid
, buf
, sizeof(buf
), kCFStringEncodingUTF8
)) buf
[0] = 0;
8024 LogInfo("ChangedKeysHaveIPv4LL: found serviceid %s", buf
);
8027 pattern
= SCDynamicStoreKeyCreateNetworkServiceEntity(NULL
, kSCDynamicStoreDomainSetup
, serviceid
, kSCEntNetIPv4
);
8028 CFRelease(serviceid
);
8029 if (pattern
== NULL
) continue;
8031 ipv4dict
= CFDictionaryGetValue(dict
, pattern
);
8033 if (!ipv4dict
|| CFDictionaryGetTypeID() != CFGetTypeID(ipv4dict
)) continue;
8035 configmethod
= CFDictionaryGetValue(ipv4dict
, kSCPropNetIPv4ConfigMethod
);
8036 if (!configmethod
) continue;
8038 if (mDNS_LoggingEnabled
)
8040 if (!CFStringGetCString(configmethod
, buf
, sizeof(buf
), kCFStringEncodingUTF8
)) buf
[0] = 0;
8041 LogInfo("ChangedKeysHaveIPv4LL: configmethod %s", buf
);
8044 if (CFEqual(configmethod
, kSCValNetIPv4ConfigMethodLinkLocal
)) { found
= mDNStrue
; break; }
8051 if (vals
!= NULL
) mDNSPlatformMemFree(vals
);
8052 if (keys
!= NULL
) mDNSPlatformMemFree(keys
);
8053 if (dict
!= NULL
) CFRelease(dict
);
8054 if (store
!= NULL
) CFRelease(store
);
8059 mDNSlocal
void NetworkChanged(SCDynamicStoreRef store
, CFArrayRef changedKeys
, void *context
)
8061 (void)store
; // Parameter not used
8062 mDNSBool changeNow
= mDNSfalse
;
8063 mDNS
*const m
= (mDNS
*const)context
;
8067 mDNSs32 delay
= mDNSPlatformOneSecond
* 2; // Start off assuming a two-second delay
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
8078 // Do immediate network changed processing for "p2p*" interfaces and
8079 // for interfaces with the IFEF_DIRECTLINK flag set.
8083 for (int i
= 0; i
< c
; i
++)
8085 CFStringRef key
= CFArrayGetValueAtIndex(changedKeys
, i
);
8087 // Only look at keys with prefix "State:/Network/Interface/"
8088 if (!CFStringHasPrefix(key
, NetworkChangedKey_StateInterfacePrefix
))
8091 // And suffix "IPv6" or "IPv4".
8092 if (!CFStringHasSuffix(key
, kSCEntNetIPv6
) && !CFStringHasSuffix(key
, kSCEntNetIPv4
))
8095 labels
= CFStringCreateArrayBySeparatingStrings(NULL
, key
, CFSTR("/"));
8098 n
= CFArrayGetCount(labels
);
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.
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
)))
8111 LogInfo("NetworkChanged: interface %s, not delaying network change", buf
);
8112 changeNow
= mDNStrue
;
8121 mDNSBool btmmChanged
= CFArrayContainsValue(changedKeys
, range
, NetworkChangedKey_BackToMyMac
);
8122 if (btmmChanged
) delay
= 0;
8124 if (mDNS_LoggingEnabled
)
8130 if (!CFStringGetCString(CFArrayGetValueAtIndex(changedKeys
, i
), buf
, sizeof(buf
), kCFStringEncodingUTF8
)) buf
[0] = 0;
8131 LogInfo("*** NetworkChanged SC key: %s", buf
);
8133 LogInfo("*** NetworkChanged *** %d change%s %s%s%s%sdelay %d",
8135 c1
? "(Local Hostname) " : "",
8136 c2
? "(Computer Name) " : "",
8137 c3
? "(DynamicDNS) " : "",
8139 changeNow
? 0 : delay
);
8143 SetNetworkChanged(m
, delay
);
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
);
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
);
8159 KQueueUnlock(m
, "NetworkChanged");
8162 #if APPLE_OSX_mDNSResponder
8163 mDNSlocal
void RefreshSPSStatus(const void *key
, const void *value
, void *context
)
8168 CFStringRef ifnameStr
= (CFStringRef
)key
;
8169 CFArrayRef array
= (CFArrayRef
)value
;
8170 if (!CFStringGetCString(ifnameStr
, buf
, sizeof(buf
), kCFStringEncodingUTF8
))
8173 LogInfo("RefreshSPSStatus: Updating SPS state for key %s, array count %d", buf
, CFArrayGetCount(array
));
8174 mDNSDynamicStoreSetConfig(kmDNSSleepProxyServersState
, buf
, value
);
8178 mDNSlocal
void DynamicStoreReconnected(SCDynamicStoreRef store
, void *info
)
8180 mDNS
*const m
= (mDNS
*const)info
;
8183 LogInfo("DynamicStoreReconnected: Reconnected");
8185 // State:/Network/MulticastDNS
8188 // State:/Network/DynamicDNS
8190 mDNSPlatformDynDNSHostNameStatusChanged(&m
->FQDN
, 1);
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.
8196 // State:/Network/PrivateDNS
8197 if (privateDnsArray
)
8198 mDNSDynamicStoreSetConfig(kmDNSPrivateConfig
, mDNSNULL
, privateDnsArray
);
8200 #if APPLE_OSX_mDNSResponder
8202 // State:/Network/BackToMyMac
8203 UpdateAutoTunnelDomainStatuses(m
);
8206 // State:/Network/Interface/en0/SleepProxyServers
8208 CFDictionaryApplyFunction(spsStatusDict
, RefreshSPSStatus
, NULL
);
8212 mDNSlocal mStatus
WatchForNetworkChanges(mDNS
*const m
)
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
);
8222 if (!store
) { LogMsg("SCDynamicStoreCreate failed: %s", SCErrorString(SCError())); goto error
; }
8223 if (!keys
|| !pattern1
|| !pattern2
|| !patterns
) goto error
;
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
; }
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
; }
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
);
8248 SCDynamicStoreSetDisconnectCallBack(store
, DynamicStoreReconnected
);
8249 m
->p
->Store
= store
;
8254 if (store
) CFRelease(store
);
8257 if (patterns
) CFRelease(patterns
);
8258 if (pattern2
) CFRelease(pattern2
);
8259 if (pattern1
) CFRelease(pattern1
);
8260 if (keys
) CFRelease(keys
);
8265 #if 0 // <rdar://problem/6751656>
8266 mDNSlocal
void PMChanged(void *context
)
8268 mDNS
*const m
= (mDNS
*const)context
;
8273 LogSPS("PMChanged");
8275 SetNetworkChanged(m
, mDNSPlatformOneSecond
* 2);
8278 KQueueUnlock(m
, "PMChanged");
8281 mDNSlocal mStatus
WatchForPMChanges(mDNS
*const m
)
8283 m
->p
->PMRLS
= IOPMPrefsNotificationCreateRunLoopSource(PMChanged
, m
);
8284 if (!m
->p
->PMRLS
) { LogMsg("IOPMPrefsNotificationCreateRunLoopSource failed!"); return mStatus_UnknownErr
; }
8286 CFRunLoopAddSource(CFRunLoopGetCurrent(), m
->p
->PMRLS
, kCFRunLoopDefaultMode
);
8288 return mStatus_NoError
;
8292 #if !TARGET_OS_EMBEDDED // don't setup packet filter rules on embedded
8294 mDNSlocal
void mDNSSetPacketFilterRules(mDNS
*const m
, char * ifname
, const ResourceRecord
*const excludeRecord
)
8297 pfArray_t portArray
;
8298 pfArray_t protocolArray
;
8301 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
8303 if ((rr
->resrec
.rrtype
== kDNSServiceType_SRV
)
8304 && ((rr
->ARType
== AuthRecordAnyIncludeP2P
) || (rr
->ARType
== AuthRecordAnyIncludeAWDLandP2P
)))
8308 if (count
>= PFPortArraySize
)
8310 LogMsg("mDNSSetPacketFilterRules: %d service limit, skipping %s", PFPortArraySize
, ARDisplayString(m
, rr
));
8314 if (excludeRecord
&& IdenticalResourceRecord(&rr
->resrec
, excludeRecord
))
8316 LogInfo("mDNSSetPacketFilterRules: record being removed, skipping %s", ARDisplayString(m
, rr
));
8320 LogInfo("mDNSSetPacketFilterRules: found %s", ARDisplayString(m
, rr
));
8322 portArray
[count
] = rr
->resrec
.rdata
->u
.srv
.port
.NotAnInteger
;
8324 // Assume <Service Instance>.<App Protocol>.<Transport Protocol>.<Name>
8325 p
= rr
->resrec
.name
->c
;
8327 // Skip to App Protocol
8328 if (p
[0]) p
+= 1 + p
[0];
8330 // Skip to Transport Protocol
8331 if (p
[0]) p
+= 1 + p
[0];
8333 if (SameDomainLabel(p
, (mDNSu8
*)"\x4" "_tcp")) protocolArray
[count
] = IPPROTO_TCP
;
8334 else if (SameDomainLabel(p
, (mDNSu8
*)"\x4" "_udp")) protocolArray
[count
] = IPPROTO_UDP
;
8337 LogMsg("mDNSSetPacketFilterRules: could not determine transport protocol of service");
8338 LogMsg("mDNSSetPacketFilterRules: %s", ARDisplayString(m
, rr
));
8344 mDNSPacketFilterControl(PF_SET_RULES
, ifname
, count
, portArray
, protocolArray
);
8347 // If the p2p interface already exists, update the Bonjour packet filter rules for it.
8348 mDNSexport
void mDNSUpdatePacketFilter(const ResourceRecord
*const excludeRecord
)
8350 mDNS
*const m
= &mDNSStorage
;
8352 NetworkInterfaceInfo
*intf
= GetFirstActiveInterface(m
->HostInterfaces
);
8355 if (strncmp(intf
->ifname
, "p2p", 3) == 0)
8357 LogInfo("mDNSInitPacketFilter: Setting rules for ifname %s", intf
->ifname
);
8358 mDNSSetPacketFilterRules(m
, intf
->ifname
, excludeRecord
);
8361 intf
= GetFirstActiveInterface(intf
->next
);
8365 #else // !TARGET_OS_EMBEDDED
8367 // Currently no packet filter setup required on embedded platforms.
8368 mDNSexport
void mDNSUpdatePacketFilter(const ResourceRecord
*const excludeRecord
)
8370 (void) excludeRecord
; // unused
8373 #endif // !TARGET_OS_EMBEDDED
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
)
8379 char ifname
[IFNAMSIZ
];
8380 mDNSu32 interfaceIndex
;
8383 NetworkInterfaceInfoOSX
*infoOSX
;
8384 mDNSInterfaceID InterfaceID
;
8386 snprintf(ifname
, IFNAMSIZ
, "%s%d", ptr
->if_name
, ptr
->if_unit
);
8387 interfaceIndex
= if_nametoindex(ifname
);
8389 if (!interfaceIndex
)
8391 LogMsg("newMasterElected: if_nametoindex(%s) failed", ifname
);
8395 LogInfo("newMasterElected: ifname = %s, interfaceIndex = %d", ifname
, interfaceIndex
);
8396 infoOSX
= IfindexToInterfaceInfoOSX(m
, (mDNSInterfaceID
)(uintptr_t)interfaceIndex
);
8398 // Can get an KEV_DL_MASTER_ELECTED event prior to the interface existing
8399 // when it is first brought up.
8402 LogInfo("newMasterElected: interface not yet active");
8405 InterfaceID
= infoOSX
->ifinfo
.InterfaceID
;
8407 for (q
= m
->Questions
; q
; q
=q
->next
)
8409 if ((!q
->InterfaceID
&& (q
->flags
& kDNSServiceFlagsIncludeAWDL
))
8410 || q
->InterfaceID
== InterfaceID
)
8412 LogInfo("newMasterElected: restarting %s query for %##s", DNSTypeName(q
->qtype
), q
->qname
.c
);
8413 mDNSCoreRestartQuestion(m
, q
);
8417 for (rr
= m
->ResourceRecords
; rr
; rr
=rr
->next
)
8419 if ((!rr
->resrec
.InterfaceID
8420 && ((rr
->ARType
== AuthRecordAnyIncludeAWDL
) || ((rr
->ARType
== AuthRecordAnyIncludeAWDLandP2P
))))
8421 || rr
->resrec
.InterfaceID
== InterfaceID
)
8423 LogInfo("newMasterElected: restarting %s announcements for %##s", DNSTypeName(rr
->resrec
.rrtype
), rr
->namestorage
.c
);
8424 mDNSCoreRestartRegistration(m
, rr
, -1);
8429 // An ssth array of all zeroes indicates the peer has no services registered.
8430 mDNSlocal mDNSBool
allZeroSSTH(struct opaque_presence_indication
*op
)
8433 int *intp
= (int *) op
->ssth
;
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
8439 if (MAX_SSTH_SIZE
% sizeof(int))
8441 LogInfo("allZeroSSTH: MAX_SSTH_SIZE = %d not a multiple of sizeof(int)", MAX_SSTH_SIZE
);
8445 for (i
= 0; i
< (int)(MAX_SSTH_SIZE
/ sizeof(int)); i
++, intp
++)
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)
8457 // Mark records from this peer for deletion from the cache.
8458 mDNSlocal
void removeCachedPeerRecords(mDNS
*const m
, mDNSu32 ifindex
, mDNSAddr
*ap
)
8463 mDNSInterfaceID InterfaceID
= mDNSPlatformInterfaceIDfromInterfaceIndex(m
, ifindex
);
8467 LogInfo("removeCachedPeerRecords: Invalid ifindex: %d", ifindex
);
8471 FORALL_CACHERECORDS(slot
, cg
, cr
)
8473 if ((InterfaceID
== cr
->resrec
.InterfaceID
) && mDNSSameAddress(ap
, & cr
->sourceAddress
))
8475 LogInfo("removeCachedPeerRecords: %s %##s marking for deletion",
8476 DNSTypeName(cr
->resrec
.rrtype
), cr
->resrec
.name
->c
);
8477 mDNS_Reconfirm_internal(m
, cr
, kAWDLReconfirmTime
);
8482 // Handle KEV_DL_NODE_PRESENCE event.
8483 mDNSlocal
void nodePresence(mDNS
*const m
, struct kev_dl_node_presence
* p
)
8485 char buf
[INET6_ADDRSTRLEN
];
8486 struct opaque_presence_indication
*op
= (struct opaque_presence_indication
*) p
->node_service_info
;
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
);
8491 LogInfo("nodePresence: inet_ntop() error");
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
))
8499 peerAddr
.type
= mDNSAddrType_IPv6
;
8500 peerAddr
.ip
.v6
= *(mDNSv6Addr
*)&p
->sin6_node_address
.sin6_addr
;
8502 LogInfo("nodePresence: ssth is all zeroes, delete cached records from this peer");
8503 removeCachedPeerRecords(m
, p
->sdl_node_address
.sdl_index
, & peerAddr
);
8507 // Handle KEV_DL_NODE_ABSENCE event.
8508 mDNSlocal
void nodeAbsence(mDNS
*const m
, struct kev_dl_node_absence
* p
)
8511 char buf
[INET6_ADDRSTRLEN
];
8513 if (inet_ntop(AF_INET6
, & p
->sin6_node_address
.sin6_addr
, buf
, sizeof(buf
)))
8514 LogInfo("nodeAbsence: IPv6 address: %s", buf
);
8516 LogInfo("nodeAbsence: inet_ntop() error");
8518 peerAddr
.type
= mDNSAddrType_IPv6
;
8519 peerAddr
.ip
.v6
= *(mDNSv6Addr
*)&p
->sin6_node_address
.sin6_addr
;
8521 LogInfo("nodeAbsence: delete cached records from this peer");
8522 removeCachedPeerRecords(m
, p
->sdl_node_address
.sdl_index
, & peerAddr
);
8525 mDNSlocal
void SysEventCallBack(int s1
, short __unused filter
, void *context
)
8527 mDNS
*const m
= (mDNS
*const)context
;
8531 struct { struct kern_event_msg k
; char extra
[256]; } msg
;
8532 int bytes
= recv(s1
, &msg
, sizeof(msg
), 0);
8534 LogMsg("SysEventCallBack: recv error %d errno %d (%s)", bytes
, errno
, strerror(errno
));
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" :
8568 if (msg
.k
.event_code
== KEV_DL_NODE_PRESENCE
)
8569 nodePresence(m
, (struct kev_dl_node_presence
*) &msg
.k
.event_data
);
8571 if (msg
.k
.event_code
== KEV_DL_NODE_ABSENCE
)
8572 nodeAbsence(m
, (struct kev_dl_node_absence
*) &msg
.k
.event_data
);
8574 if (msg
.k
.event_code
== KEV_DL_MASTER_ELECTED
)
8575 newMasterElected(m
, (struct net_event_data
*) &msg
.k
.event_data
);
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.
8583 if (msg
.k
.event_code
== KEV_DL_WAKEFLAGS_CHANGED
|| msg
.k
.event_code
== KEV_DL_LINK_ON
)
8584 SetNetworkChanged(m
, mDNSPlatformOneSecond
* 2);
8586 #if !TARGET_OS_EMBEDDED // don't setup packet filter rules on embedded
8588 // For p2p interfaces, need to open the advertised service port in the firewall.
8589 if (msg
.k
.event_code
== KEV_DL_IF_ATTACHED
)
8591 struct net_event_data
* p
;
8592 p
= (struct net_event_data
*) &msg
.k
.event_data
;
8594 if (strncmp(p
->if_name
, "p2p", 3) == 0)
8596 char ifname
[IFNAMSIZ
];
8597 snprintf(ifname
, IFNAMSIZ
, "%s%d", p
->if_name
, p
->if_unit
);
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
);
8601 mDNSSetPacketFilterRules(m
, ifname
, NULL
);
8605 // For p2p interfaces, need to clear the firewall rules on interface detach
8606 if (msg
.k
.event_code
== KEV_DL_IF_DETACHED
)
8608 struct net_event_data
* p
;
8609 p
= (struct net_event_data
*) &msg
.k
.event_data
;
8611 if (strncmp(p
->if_name
, "p2p", 3) == 0)
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
);
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
);
8619 mDNSPacketFilterControl(PF_CLEAR_RULES
, ifname
, 0, portArray
, protocolArray
);
8622 #endif // !TARGET_OS_EMBEDDED
8629 mDNSlocal mStatus
WatchForSysEvents(mDNS
*const m
)
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
); }
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
);
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
);
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
);
8650 return(mStatus_NoError
);
8653 #ifndef NO_SECURITYFRAMEWORK
8654 mDNSlocal OSStatus
KeychainChanged(SecKeychainEvent keychainEvent
, SecKeychainCallbackInfo
*info
, void *context
)
8656 LogInfo("*** Keychain Changed ***");
8657 mDNS
*const m
= (mDNS
*const)context
;
8659 OSStatus err
= SecKeychainCopyDefault(&skc
);
8662 if (info
->keychain
== skc
)
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
);
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
);
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
);
8682 LogInfo("*** Keychain Changed *** KeychainEvent=%d %s",
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
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.
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.
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
);
8705 KQueueUnlock(m
, "KeychainChanged");
8715 mDNSlocal
void PowerOn(mDNS
*const m
)
8717 mDNSCoreMachineSleep(m
, false); // Will set m->SleepState = SleepState_Awake;
8718 if (m
->p
->WakeAtUTC
)
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)
8724 LogSPS("PowerChanged PowerOn %d seconds early, assuming not maintenance wake", m
->p
->WakeAtUTC
- utc
);
8726 else if (utc
- m
->p
->WakeAtUTC
> 30)
8728 LogSPS("PowerChanged PowerOn %d seconds late, assuming not maintenance wake", utc
- m
->p
->WakeAtUTC
);
8730 else if (IsAppleTV())
8732 LogSPS("PowerChanged PowerOn %d seconds late, device is an AppleTV running iOS so not re-sleeping", utc
- m
->p
->WakeAtUTC
);
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
;
8742 mDNSlocal
void PowerChanged(void *refcon
, io_service_t service
, natural_t messageType
, void *messageArgument
)
8744 mDNS
*const m
= (mDNS
*const)refcon
;
8746 (void)service
; // Parameter not used
8747 debugf("PowerChanged %X %lX", messageType
, messageArgument
);
8749 // Make sure our m->SystemWakeOnLANEnabled value correctly reflects the current system setting
8750 m
->SystemWakeOnLANEnabled
= SystemWakeForNetworkAccess();
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
);
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);
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
8769 LogMsg("PowerChanged kIOMessageSystemHasPoweredOn: ERROR m->SleepState %d", m
->SleepState
);
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
8776 if (!m
->p
->NetworkChanged
||
8777 m
->p
->NetworkChanged
- NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
* 2) < 0)
8778 m
->p
->NetworkChanged
= NonZeroTime(m
->timenow
+ mDNSPlatformOneSecond
* 2);
8782 case kIOMessageSystemWillRestart
: LogSPS("PowerChanged kIOMessageSystemWillRestart (no action)"); break; // E0000310
8783 case kIOMessageSystemWillPowerOn
: LogSPS("PowerChanged kIOMessageSystemWillPowerOn"); // E0000320
8785 // Make sure our interface list is cleared to the empty state, then tell mDNSCore to wake
8786 if (m
->SleepState
!= SleepState_Sleeping
)
8788 LogMsg("kIOMessageSystemWillPowerOn: ERROR m->SleepState %d", m
->SleepState
);
8789 m
->SleepState
= SleepState_Sleeping
;
8790 mDNSMacOSXNetworkChanged(m
);
8794 default: LogSPS("PowerChanged unknown message %X", messageType
); break;
8797 if (messageType
== kIOMessageSystemWillSleep
) m
->p
->SleepCookie
= (long)messageArgument
;
8798 else IOAllowPowerChange(m
->p
->PowerConnection
, (long)messageArgument
);
8800 KQueueUnlock(m
, "PowerChanged Sleep/Wake");
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
)
8808 mDNS
*const m
= (mDNS
*const)refcon
;
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" : "");
8818 // Make sure our m->SystemWakeOnLANEnabled value correctly reflects the current system setting
8819 m
->SystemWakeOnLANEnabled
= SystemWakeForNetworkAccess();
8821 if (eventDescriptor
& kIOPMSystemPowerStateCapabilityCPU
)
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.
8829 LogSPS("SnowLeopardPowerChanged: Waking up, Acking old Sleep, SleepLimit %d SleepState %d", m
->SleepLimit
, m
->SleepState
);
8830 IOPMConnectionAcknowledgeEvent(connection
, m
->p
->SleepCookie
);
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.
8837 SetNetworkChanged(m
, 2 * mDNSPlatformOneSecond
);
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
);
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
);
8849 //mDNSMacOSXNetworkChanged(m);
8850 mDNSCoreMachineSleep(m
, true);
8851 //if (m->SleepState == SleepState_Sleeping) mDNSMacOSXNetworkChanged(m);
8852 m
->p
->SleepCookie
= token
;
8855 KQueueUnlock(m
, "SnowLeopardPowerChanged Sleep/Wake");
8859 #if COMPILER_LIKES_PRAGMA_MARK
8861 #pragma mark - /etc/hosts support
8864 // Implementation Notes
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
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
8876 // 4. Don't maintain any local state about any records registered with the core to detect changes to /etc/hosts
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
8882 #define ETCHOSTS_BUFSIZE 1024 // Buffer size to parse a single line in /etc/hosts
8884 mDNSexport
void FreeEtcHosts(mDNS
*const m
, AuthRecord
*const rr
, mStatus result
)
8889 if (result
== mStatus_MemFree
)
8891 LogInfo("FreeEtcHosts: %s", ARDisplayString(m
, rr
));
8892 freeL("etchosts", rr
);
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
)
8903 mDNSInterfaceID InterfaceID
= mDNSInterface_LocalOnly
;
8908 LogMsg("mDNSMacOSXCreateEtcHostsEntry: ERROR!! name NULL");
8913 LogMsg("mDNSMacOSXCreateEtcHostsEntry: ERROR!! sa and cname both NULL");
8917 if (sa
&& sa
->sa_family
!= AF_INET
&& sa
->sa_family
!= AF_INET6
)
8919 LogMsg("mDNSMacOSXCreateEtcHostsEntry: ERROR!! sa with bad family %d", sa
->sa_family
);
8926 mDNSu32 ifindex
= if_nametoindex(ifname
);
8929 LogMsg("mDNSMacOSXCreateEtcHostsEntry: hosts entry %##s with invalid ifname %s", domain
->c
, ifname
);
8932 InterfaceID
= (mDNSInterfaceID
)(uintptr_t)ifindex
;
8936 rrtype
= (sa
->sa_family
== AF_INET
? kDNSType_A
: kDNSType_AAAA
);
8938 rrtype
= kDNSType_CNAME
;
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
);
8949 if (rr
->resrec
.rrtype
== rrtype
)
8951 if (rrtype
== kDNSType_A
)
8954 ip
.NotAnInteger
= ((struct sockaddr_in
*)sa
)->sin_addr
.s_addr
;
8955 if (mDNSSameIPv4Address(rr
->resrec
.rdata
->u
.ipv4
, ip
))
8957 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Same IPv4 address for name %##s", domain
->c
);
8961 else if (rrtype
== kDNSType_AAAA
)
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
))
8970 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Same IPv6 address for name %##s", domain
->c
);
8974 else if (rrtype
== kDNSType_CNAME
)
8976 if (SameDomainName(&rr
->resrec
.rdata
->u
.name
, cname
))
8978 LogInfo("mDNSMacOSXCreateEtcHostsEntry: Same cname %##s for name %##s", cname
->c
, domain
->c
);
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
);
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
;
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];
9007 rr
->resrec
.rdlength
= DomainNameLength(cname
);
9008 rr
->resrec
.rdata
->u
.name
.c
[0] = 0;
9009 AssignDomainName(&rr
->resrec
.rdata
->u
.name
, cname
);
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
);
9018 mDNSlocal
int EtcHostsParseOneName(int start
, int length
, char *buffer
, char **name
)
9023 for (i
= start
; i
< length
; i
++)
9025 if (buffer
[i
] == '#')
9027 if (buffer
[i
] != ' ' && buffer
[i
] != ',' && buffer
[i
] != '\t')
9031 // Found the start of a name, find the end and null terminate
9032 for (i
++; i
< length
; i
++)
9034 if (buffer
[i
] == ' ' || buffer
[i
] == ',' || buffer
[i
] == '\t')
9046 mDNSlocal
void mDNSMacOSXParseEtcHostsLine(mDNS
*const m
, char *buffer
, ssize_t length
, AuthHash
*auth
)
9050 char *ifname
= NULL
;
9057 //Ignore leading whitespaces and tabs
9058 while (*buffer
== ' ' || *buffer
== '\t')
9064 // Find the end of the address string
9065 for (i
= 0; i
< length
; i
++)
9067 if (buffer
[i
] == ' ' || buffer
[i
] == ',' || buffer
[i
] == '\t' || buffer
[i
] == '%')
9069 if (buffer
[i
] == '%')
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)
9083 LogInfo("mDNSMacOSXParseEtcHostsLine: getaddrinfo returning null");
9089 // Parse the interface
9090 ifname
= &buffer
[ifStart
];
9091 for (i
= ifStart
+ 1; i
< length
; i
++)
9093 if (buffer
[i
] == ' ' || buffer
[i
] == ',' || buffer
[i
] == '\t')
9101 i
= EtcHostsParseOneName(i
+ 1, length
, buffer
, &name1
);
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
))
9107 LogMsg("mDNSMacOSXParseEtcHostsLine: ERROR!! cannot convert to domain name %s", name1
);
9108 freeaddrinfo(gairesults
);
9111 mDNSMacOSXCreateEtcHostsEntry(m
, &name1d
, gairesults
->ai_addr
, mDNSNULL
, ifname
, auth
);
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
))
9121 LogMsg("mDNSMacOSXParseEtcHostsLine: ERROR!! cannot convert to domain name %s", name1
);
9122 freeaddrinfo(gairesults
);
9125 // If the /etc/hosts has an entry like this
9127 // 1.2.3.4 sun star bright
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")
9132 // To achieve this, we need to add the entry like this:
9134 // star CNAME bright
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.
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
);
9152 if (!MakeDomainNameFromDNSNameString(&name2d
, name2
))
9154 LogMsg("mDNSMacOSXParseEtcHostsLine: ERROR!! cannot convert to domain name %s", name2
);
9155 freeaddrinfo(gairesults
);
9160 else if (!aliasIndex
)
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
);
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
9172 AssignDomainName(&name2d
, &first
);
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.
9180 if (aliasIndex
> 1 || SameDomainName(&name2d
, &first
))
9182 // Ignore if it points to itself
9183 if (!SameDomainName(&name1d
, &name2d
))
9185 if (!mDNSMacOSXCreateEtcHostsEntry(m
, &name1d
, mDNSNULL
, &name2d
, ifname
, auth
))
9187 freeaddrinfo(gairesults
);
9192 LogMsg("mDNSMacOSXParseEtcHostsLine: Ignoring entry with same names name1 %##s, name2 %##s", name1d
.c
, name2d
.c
);
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;
9199 // Remember the current name so that we can set the CNAME record if we parse one
9202 AssignDomainName(&name1d
, &name2d
);
9204 // Added all the CNAMEs if any, add the "A/AAAA" record
9205 mDNSMacOSXCreateEtcHostsEntry(m
, &first
, gairesults
->ai_addr
, mDNSNULL
, ifname
, auth
);
9207 freeaddrinfo(gairesults
);
9210 mDNSlocal
void mDNSMacOSXParseEtcHosts(mDNS
*const m
, int fd
, AuthHash
*auth
)
9213 char buf
[ETCHOSTS_BUFSIZE
];
9217 if (fd
== -1) { LogInfo("mDNSMacOSXParseEtcHosts: fd is -1"); return; }
9219 fp
= fopen("/etc/hosts", "r");
9220 if (!fp
) { LogInfo("mDNSMacOSXParseEtcHosts: fp is NULL"); return; }
9224 good
= (fgets(buf
, ETCHOSTS_BUFSIZE
, fp
) != NULL
);
9227 // skip comment and empty lines
9228 if (buf
[0] == '#' || buf
[0] == '\r' || buf
[0] == '\n')
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')
9236 buf
[len
- 1] = '\0';
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.
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')
9249 buf
[len
- 1] = '\0';
9253 if (!len
) //Sanity Check: len should never be zero
9255 LogMsg("mDNSMacOSXParseEtcHosts: Length is zero!");
9258 mDNSMacOSXParseEtcHostsLine(m
, buf
, len
, auth
);
9263 mDNSlocal
void mDNSMacOSXUpdateEtcHosts(mDNS
*const m
);
9265 mDNSlocal
int mDNSMacOSXGetEtcHostsFD(mDNS
*const m
)
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;
9273 // First time through? just schedule ourselves on the main queue and we'll do the work later
9276 etcq
= dispatch_get_main_queue();
9279 // Do this work on the queue, not here - solves potential synchronization issues
9280 dispatch_async(etcq
, ^{mDNSMacOSXUpdateEtcHosts(m
);});
9285 if (hostssrc
) return dispatch_source_get_handle(hostssrc
);
9288 int fd
= open("/etc/hosts", O_RDONLY
);
9290 #ifdef __DISPATCH_GROUP__
9291 // Can't do this stuff to be notified of changes in /etc/hosts if we don't have libdispatch
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
; }
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
);
9306 dispatch_source_set_event_handler(etcsrc
,
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)
9312 dispatch_source_cancel(etcsrc
);
9313 dispatch_release(etcsrc
);
9315 dispatch_async(etcq
, ^{mDNSMacOSXUpdateEtcHosts(m
);});
9318 if ((flags
& DISPATCH_VNODE_WRITE
) != 0 && hostssrc
== NULL
)
9320 mDNSMacOSXUpdateEtcHosts(m
);
9323 dispatch_source_set_cancel_handler(etcsrc
, ^{close(fd
);});
9324 dispatch_resume(etcsrc
);
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; }
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
)
9340 dispatch_source_set_event_handler(hostssrc
,
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)
9346 dispatch_source_cancel(hostssrc
);
9347 dispatch_release(hostssrc
);
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
9357 dispatch_async(etcq
, ^{mDNSMacOSXUpdateEtcHosts(m
);});
9360 if ((flags
& DISPATCH_VNODE_WRITE
) != 0)
9362 mDNSMacOSXUpdateEtcHosts(m
);
9365 dispatch_source_set_cancel_handler(hostssrc
, ^{LogInfo("mDNSMacOSXGetEtcHostsFD: Closing etchosts fd %d", fd
); close(fd
);});
9366 dispatch_resume(hostssrc
);
9368 // Cleanup /etc source, no need to watch it if we already have /etc/hosts
9371 dispatch_source_cancel(etcsrc
);
9372 dispatch_release(etcsrc
);
9376 LogInfo("mDNSMacOSXGetEtcHostsFD: /etc/hosts being monitored, and not etc");
9377 return hostssrc
? (int)dispatch_source_get_handle(hostssrc
) : -1;
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
)
9392 FORALL_CACHERECORDS(slot
, cg
, cr
)
9395 if (cr
->resrec
.InterfaceID
) continue;
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
))
9402 LogInfo("FlushAllCacheRecords: Purging Resourcerecord %s", CRDisplayString(m
, cr
));
9403 mDNS_PurgeCacheResourceRecord(m
, cr
);
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
)
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
)
9418 for (rr
= ag
->members
; rr
; rr
= rrnext
)
9423 mDNSBool found
= mDNSfalse
;
9424 ag1
= AuthGroupForRecord(&m
->rrauth
, slot
, &rr
->resrec
);
9425 if (ag1
&& ag1
->members
)
9427 if (!primary
) primary
= ag1
->members
;
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
))
9439 LogInfo("EtcHostsAddNewEntries: Skipping, not adding %s", ARDisplayString(m
, rr1
));
9450 LogInfo("EtcHostsAddNewEntries: Entry %s not registered with core yet", ARDisplayString(m
, rr
));
9453 RemoveAuthRecord(m
, newhosts
, rr
);
9454 // if there is no primary, point to self
9455 rr
->RRSet
= (primary
? primary
: rr
);
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
));
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
)
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
)
9477 mDNSBool found
= mDNSfalse
;
9481 if (rr
->RecordCallback
!= FreeEtcHosts
) continue;
9482 ag1
= AuthGroupForRecord(newhosts
, slot
, &rr
->resrec
);
9485 primary
= rr1
= ag1
->members
;
9488 if (IdenticalResourceRecord(&rr1
->resrec
, &rr
->resrec
))
9490 LogInfo("EtcHostsDeleteOldEntries: Old record %s found in new, skipping", ARDisplayString(m
, rr
));
9497 // there is no corresponding record in newhosts for the same name. This means
9498 // we should delete this from the core.
9503 LogInfo("EtcHostsDeleteOldEntries: Record %s not found in new, deleting", ARDisplayString(m
, rr
));
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
)
9510 AuthRecord
*new_primary
= rr
->next
;
9511 AuthRecord
*r
= new_primary
;
9516 LogInfo("EtcHostsDeleteOldEntries: Updating Resource Record %s to primary", ARDisplayString(m
, r
));
9517 r
->RRSet
= new_primary
;
9519 else LogMsg("EtcHostsDeleteOldEntries: ERROR!! Resource Record %s not pointing to primary %##s", ARDisplayString(m
, r
), r
->resrec
.name
);
9523 LogInfo("EtcHostsDeleteOldEntries: Deleting %s", ARDisplayString(m
, rr
));
9524 mDNS_Deregister_internal(m
, rr
, mDNS_Dereg_normal
);
9530 mDNSlocal
void UpdateEtcHosts(mDNS
*const m
, void *context
)
9532 AuthHash
*newhosts
= (AuthHash
*)context
;
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
);
9542 mDNSlocal
void FreeNewHosts(AuthHash
*newhosts
)
9545 AuthGroup
*ag
, *agnext
;
9546 AuthRecord
*rr
, *rrnext
;
9548 for (slot
= 0; slot
< AUTH_HASH_SLOTS
; slot
++)
9549 for (ag
= newhosts
->rrauth_hash
[slot
]; ag
; ag
= agnext
)
9552 for (rr
= ag
->members
; rr
; rr
= rrnext
)
9555 freeL("etchosts", rr
);
9557 freeL("AuthGroups", ag
);
9561 mDNSlocal
void mDNSMacOSXUpdateEtcHosts(mDNS
*const m
)
9565 // As we will be modifying the core, we can only have one thread running at
9566 // any point in time.
9569 mDNSPlatformMemZero(&newhosts
, sizeof(AuthHash
));
9571 // Get the file desecriptor (will trigger us to start watching for changes)
9572 int fd
= mDNSMacOSXGetEtcHostsFD(m
);
9575 LogInfo("mDNSMacOSXUpdateEtcHosts: Parsing /etc/hosts fd %d", fd
);
9576 mDNSMacOSXParseEtcHosts(m
, fd
, &newhosts
);
9578 else LogInfo("mDNSMacOSXUpdateEtcHosts: /etc/hosts is not present");
9580 // Optimization: Detect whether /etc/hosts changed or not.
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.
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
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.
9595 // Add the new entries to the core if not already present in the core
9596 if (!EtcHostsAddNewEntries(m
, &newhosts
, mDNStrue
))
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
))
9602 LogInfo("mDNSMacOSXUpdateEtcHosts: No work");
9604 KQueueUnlock(m
, "/etc/hosts changed");
9605 FreeNewHosts(&newhosts
);
9610 // This will flush the cache, stop and start the query so that the queries
9611 // can look at the /etc/hosts again
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.
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
9627 mDNSCoreRestartAddressQueries(m
, mDNSfalse
, FlushAllCacheRecords
, UpdateEtcHosts
, &newhosts
);
9630 KQueueUnlock(m
, "/etc/hosts changed");
9631 FreeNewHosts(&newhosts
);
9634 #if COMPILER_LIKES_PRAGMA_MARK
9636 #pragma mark - Initialization & Teardown
9639 CF_EXPORT CFDictionaryRef
_CFCopySystemVersionDictionary(void);
9640 CF_EXPORT
const CFStringRef _kCFSystemVersionProductNameKey
;
9641 CF_EXPORT
const CFStringRef _kCFSystemVersionProductVersionKey
;
9642 CF_EXPORT
const CFStringRef _kCFSystemVersionBuildVersionKey
;
9644 // Major version 13 is 10.9.x
9645 mDNSexport
void mDNSMacOSXSystemBuildNumber(char *HINFO_SWstring
)
9647 int major
= 0, minor
= 0;
9648 char letter
= 0, prodname
[256]="<Unknown>", prodvers
[256]="<Unknown>", buildver
[256]="<Unknown>";
9649 CFDictionaryRef vers
= _CFCopySystemVersionDictionary();
9652 CFStringRef cfprodname
= CFDictionaryGetValue(vers
, _kCFSystemVersionProductNameKey
);
9653 CFStringRef cfprodvers
= CFDictionaryGetValue(vers
, _kCFSystemVersionProductVersionKey
);
9654 CFStringRef cfbuildver
= CFDictionaryGetValue(vers
, _kCFSystemVersionBuildVersionKey
);
9656 CFStringGetCString(cfprodname
, prodname
, sizeof(prodname
), kCFStringEncodingUTF8
);
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
);
9666 LogMsg("Note: No Major Build Version number found; assuming 13");
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);
9672 // If product name is "Mac OS X" (or similar) we set OSXVers, else we set iOSVers;
9673 if ((prodname
[0] & 0xDF) == 'M')
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)
9685 int s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
9687 LogMsg("mDNSPlatformInit_CanReceiveUnicast: socket error %d errno %d (%s)", s
, errno
, strerror(errno
));
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
));
9698 if (err
) LogMsg("No unicast UDP responses");
9699 else debugf("Unicast UDP responses okay");
9703 mDNSlocal
void CreatePTRRecord(mDNS
*const m
, const domainname
*domain
)
9706 const domainname
*pname
= (domainname
*)"\x9" "localhost";
9708 rr
= mallocL("localhosts", sizeof(*rr
));
9709 if (rr
== NULL
) return;
9710 mDNSPlatformMemZero(rr
, sizeof(*rr
));
9712 mDNS_SetupResourceRecord(rr
, mDNSNULL
, mDNSInterface_LocalOnly
, kDNSType_PTR
, kHostNameTTL
, kDNSRecordTypeKnownUnique
, AuthRecordLocalOnly
, mDNSNULL
, mDNSNULL
);
9713 AssignDomainName(&rr
->namestorage
, domain
);
9715 rr
->resrec
.rdlength
= DomainNameLength(pname
);
9716 rr
->resrec
.rdata
->u
.name
.c
[0] = 0;
9717 AssignDomainName(&rr
->resrec
.rdata
->u
.name
, pname
);
9719 rr
->resrec
.namehash
= DomainNameHashValue(rr
->resrec
.name
);
9720 SetNewRData(&rr
->resrec
, mDNSNULL
, 0); // Sets rr->rdatahash for us
9721 mDNS_Register(m
, rr
);
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
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
)
9733 char buffer
[MAX_REVERSE_MAPPING_NAME
];
9736 struct in6_addr addr
;
9737 mDNSu8
*ptr
= addr
.__u6_addr
.__u6_addr8
;
9739 if (inet_pton(AF_INET
, "127.0.0.1", &addr
) == 1)
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
);
9746 else LogMsg("SetupLocalHostRecords: ERROR!! inet_pton AF_INET failed");
9748 if (inet_pton(AF_INET6
, "::1", &addr
) == 1)
9750 for (i
= 0; i
< 16; i
++)
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] = '.';
9758 mDNS_snprintf(&buffer
[64], sizeof(buffer
)-64, "ip6.arpa.");
9759 MakeDomainNameFromDNSNameString(&name
, buffer
);
9760 CreatePTRRecord(m
, &name
);
9762 else LogMsg("SetupLocalHostRecords: ERROR!! inet_pton AF_INET6 failed");
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)
9775 mDNSlocal mStatus
mDNSPlatformInit_setup(mDNS
*const m
)
9778 m
->p
->CFRunLoop
= CFRunLoopGetCurrent();
9780 char HINFO_SWstring
[256] = "";
9781 mDNSMacOSXSystemBuildNumber(HINFO_SWstring
);
9783 err
= mDNSHelperInit();
9787 DynamicStoreQueue
= dispatch_queue_create("com.apple.mDNSResponder.DynamicStoreQueue", NULL
);
9788 if (DynamicStoreQueue
== NULL
)
9790 LogMsg("dispatch_queue_create: DynamicStoreQueue NULL!");
9791 return mStatus_NoMemoryErr
;
9794 // Store mDNSResponder Platform
9797 m
->mDNS_plat
= platform_OSX
;
9802 m
->mDNS_plat
= platform_Atv
;
9804 m
->mDNS_plat
= platform_iOS
;
9808 m
->mDNS_plat
= platform_NonApple
;
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.
9814 for (i
=0; i
<100; i
++)
9816 domainlabel testlabel
;
9818 GetUserSpecifiedLocalHostName(&testlabel
);
9819 if (testlabel
.c
[0]) break;
9823 m
->hostlabel
.c
[0] = 0;
9825 int get_model
[2] = { CTL_HW
, HW_MODEL
};
9826 size_t len_model
= sizeof(HINFO_HWstring_buffer
);
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
;
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
);
9840 if (mDNSPlatformInit_CanReceiveUnicast())
9841 m
->CanReceiveUnicastOn5353
= mDNStrue
;
9843 mDNSu32 hlen
= mDNSPlatformStrLen(HINFO_HWstring
);
9844 mDNSu32 slen
= mDNSPlatformStrLen(HINFO_SWstring
);
9845 if (hlen
+ slen
< 254)
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
);
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";
9864 err
= SetupSocket(&m
->p
->permanentsockets
, MulticastDNSPort
, AF_INET
, mDNSNULL
);
9865 err
= SetupSocket(&m
->p
->permanentsockets
, MulticastDNSPort
, AF_INET6
, mDNSNULL
);
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
));
9872 m
->UnicastPort4
.NotAnInteger
= s4
.sin_port
;
9874 if (m
->p
->permanentsockets
.sktv6
>= 0)
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
;
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;
9900 #if APPLE_OSX_mDNSResponder
9901 uuid_generate(m
->asl_uuid
);
9904 m
->AutoTunnelRelayAddr
= zerov6Addr
;
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
); }
9915 err
= WatchForNetworkChanges(m
);
9916 if (err
) { LogMsg("mDNSPlatformInit_setup: WatchForNetworkChanges failed %d", err
); return(err
); }
9918 #if 0 // <rdar://problem/6751656>
9919 err
= WatchForPMChanges(m
);
9920 if (err
) { LogMsg("mDNSPlatformInit_setup: WatchForPMChanges failed %d", err
); return(err
); }
9923 err
= WatchForSysEvents(m
);
9924 if (err
) { LogMsg("mDNSPlatformInit_setup: WatchForSysEvents failed %d", err
); return(err
); }
9926 mDNSs32 utc
= mDNSPlatformUTC();
9927 m
->SystemWakeOnLANEnabled
= SystemWakeForNetworkAccess();
9928 UpdateInterfaceList(m
, utc
);
9929 SetupActiveInterfaces(m
, utc
);
9931 // Explicitly ensure that our Keychain operations utilize the system domain.
9932 #ifndef NO_SECURITYFRAMEWORK
9933 SecKeychainSetPreferenceDomain(kSecPreferencesDomainSystem
);
9937 SetDomainSecrets(m
);
9941 #ifndef NO_SECURITYFRAMEWORK
9942 err
= SecKeychainAddCallback(KeychainChanged
, kSecAddEventMask
|kSecDeleteEventMask
|kSecUpdateEventMask
, m
);
9943 if (err
) { LogMsg("mDNSPlatformInit_setup: SecKeychainAddCallback failed %d", err
); return(err
); }
9946 #if !defined(kIOPMAcknowledgmentOptionSystemCapabilityRequirements) || TARGET_OS_EMBEDDED
9947 LogMsg("Note: Compiled without SnowLeopard Fine-Grained Power Management support");
9950 IOReturn iopmerr
= IOPMConnectionCreate(CFSTR("mDNSResponder"), kIOPMSystemPowerStateCapabilityCPU
, &c
);
9951 if (iopmerr
) LogMsg("IOPMConnectionCreate failed %d", iopmerr
);
9954 iopmerr
= IOPMConnectionSetNotification(c
, m
, SnowLeopardPowerChanged
);
9955 if (iopmerr
) LogMsg("IOPMConnectionSetNotification failed %d", iopmerr
);
9958 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
9959 IOPMConnectionSetDispatchQueue(c
, dispatch_get_main_queue());
9960 LogInfo("IOPMConnectionSetDispatchQueue is now running");
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 */
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
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); }
9976 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
9977 IONotificationPortSetDispatchQueue(m
->p
->PowerPortRef
, dispatch_get_main_queue());
9979 CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(m
->p
->PowerPortRef
), kCFRunLoopDefaultMode
);
9980 #endif /* MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM */
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
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
);
10009 SSLqueue
= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT
, 0);
10011 if (SSLqueue
== mDNSNULL
) LogMsg("dispatch_queue_create: SSL queue NULL");
10013 mDNSMacOSXUpdateEtcHosts(m
);
10014 SetupLocalHostRecords(m
);
10017 return(mStatus_NoError
);
10020 mDNSexport mStatus
mDNSPlatformInit(mDNS
*const m
)
10022 #if MDNS_NO_DNSINFO
10023 LogMsg("Note: Compiled without Apple-specific Split-DNS support");
10026 // Adding interfaces will use this flag, so set it now.
10027 m
->DivertMulticastAdvertisements
= !m
->AdvertiseLocalAddresses
;
10029 #if APPLE_OSX_mDNSResponder
10030 m
->SPSBrowseCallback
= UpdateSPSStatus
;
10031 #endif // APPLE_OSX_mDNSResponder
10033 mStatus result
= mDNSPlatformInit_setup(m
);
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
)
10039 mDNSCoreInitComplete(m
, mStatus_NoError
);
10042 // We only initialize if mDNSCore successfully initialized.
10045 D2DStatus ds
= D2DInitialize(m
->p
->CFRunLoop
, xD2DServiceCallback
, m
) ;
10046 if (ds
!= kD2DSuccess
)
10047 LogMsg("D2DInitialiize failed: %d", ds
);
10049 LogMsg("D2DInitialize succeeded");
10054 result
= DNSSECCryptoInit(m
);
10058 mDNSexport
void mDNSPlatformClose(mDNS
*const m
)
10060 if (m
->p
->PowerConnection
)
10062 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
10063 IONotificationPortSetDispatchQueue(m
->p
->PowerPortRef
, NULL
);
10065 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(m
->p
->PowerPortRef
), kCFRunLoopDefaultMode
);
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;
10077 #ifdef MDNSRESPONDER_USES_LIB_DISPATCH_AS_PRIMARY_EVENT_LOOP_MECHANISM
10078 if (!SCDynamicStoreSetDispatchQueue(m
->p
->Store
, NULL
))
10079 LogMsg("mDNSPlatformClose: SCDynamicStoreSetDispatchQueue failed");
10081 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m
->p
->StoreRLS
, kCFRunLoopDefaultMode
);
10082 CFRunLoopSourceInvalidate(m
->p
->StoreRLS
);
10083 CFRelease(m
->p
->StoreRLS
);
10084 m
->p
->StoreRLS
= NULL
;
10086 CFRelease(m
->p
->Store
);
10087 m
->p
->Store
= NULL
;
10092 CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m
->p
->PMRLS
, kCFRunLoopDefaultMode
);
10093 CFRunLoopSourceInvalidate(m
->p
->PMRLS
);
10094 CFRelease(m
->p
->PMRLS
);
10095 m
->p
->PMRLS
= NULL
;
10098 if (m
->p
->SysEventNotifier
>= 0) { close(m
->p
->SysEventNotifier
); m
->p
->SysEventNotifier
= -1; }
10103 D2DStatus ds
= D2DTerminate();
10104 if (ds
!= kD2DSuccess
)
10105 LogMsg("D2DTerminate failed: %d", ds
);
10107 LogMsg("D2DTerminate succeeded");
10111 mDNSs32 utc
= mDNSPlatformUTC();
10112 MarkAllInterfacesInactive(m
, utc
);
10113 ClearInactiveInterfaces(m
, utc
);
10114 CloseSocketSet(&m
->p
->permanentsockets
);
10116 #if APPLE_OSX_mDNSResponder
10117 // clean up tunnels
10118 while (m
->TunnelClients
)
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
);
10128 if (AnonymousRacoonConfig
)
10130 AnonymousRacoonConfig
= mDNSNULL
;
10131 LogInfo("mDNSPlatformClose: Deconfiguring autotunnel");
10132 (void)mDNSConfigureServer(kmDNSDown
, mDNSNULL
, mDNSNULL
);
10134 #endif // APPLE_OSX_mDNSResponder
10137 #if COMPILER_LIKES_PRAGMA_MARK
10139 #pragma mark - General Platform Support Layer functions
10142 mDNSexport mDNSu32
mDNSPlatformRandomNumber(void)
10144 return(arc4random());
10147 mDNSexport mDNSs32 mDNSPlatformOneSecond
= 1000;
10148 mDNSexport mDNSu32 mDNSPlatformClockDivisor
= 0;
10150 mDNSexport mStatus
mDNSPlatformTimeInit(void)
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
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
;
10176 mDNSexport mDNSs32
mDNSPlatformRawTime(void)
10178 if (mDNSPlatformClockDivisor
== 0) { LogMsg("mDNSPlatformRawTime called before mDNSPlatformTimeInit"); return(0); }
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)
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”.");
10196 last_mach_absolute_time
= this_mach_absolute_time
;
10198 return((mDNSs32
)(this_mach_absolute_time
/ mDNSPlatformClockDivisor
));
10201 mDNSexport mDNSs32
mDNSPlatformUTC(void)
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 *))
10217 return (qsort(base
, nel
, width
, compar
));
10219 #if !(APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING)
10220 mDNSexport
void * mDNSPlatformMemAllocate(mDNSu32 len
) { return(mallocL("mDNSPlatformMemAllocate", len
)); }
10222 mDNSexport
void mDNSPlatformMemFree (void *mem
) { freeL("mDNSPlatformMemFree", mem
); }
10224 mDNSexport
void mDNSPlatformSetAllowSleep(mDNS
*const m
, mDNSBool allowSleep
, const char *reason
)
10226 if (allowSleep
&& m
->p
->IOPMAssertion
)
10228 LogInfo("%s Destroying NoIdleSleep power assertion", __FUNCTION__
);
10229 IOPMAssertionRelease(m
->p
->IOPMAssertion
);
10230 m
->p
->IOPMAssertion
= 0;
10232 else if (!allowSleep
)
10234 #ifdef kIOPMAssertionTypeNoIdleSleep
10235 if (m
->p
->IOPMAssertion
)
10237 IOPMAssertionRelease(m
->p
->IOPMAssertion
);
10238 m
->p
->IOPMAssertion
= 0;
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__
);
10249 mDNSexport
void mDNSPlatformSendWakeupPacket(mDNS
*const m
, mDNSInterfaceID InterfaceID
, char *EthAddr
, char *IPAddr
, int iteration
)
10254 ifindex
= mDNSPlatformInterfaceIndexfromInterfaceID(m
, InterfaceID
, mDNStrue
);
10257 LogMsg("mDNSPlatformSendWakeupPacket: ERROR!! Invalid InterfaceID %u", ifindex
);
10260 mDNSSendWakeupPacket(ifindex
, EthAddr
, IPAddr
, iteration
);
10263 mDNSexport mDNSBool
mDNSPlatformInterfaceIsD2D(mDNSInterfaceID InterfaceID
)
10265 NetworkInterfaceInfoOSX
*info
;
10267 if (InterfaceID
== mDNSInterface_P2P
)
10270 if ( (InterfaceID
== mDNSInterface_Any
)
10271 || (InterfaceID
== mDNSInterfaceMark
)
10272 || (InterfaceID
== mDNSInterface_LocalOnly
)
10273 || (InterfaceID
== mDNSInterface_Unicast
))
10276 info
= IfindexToInterfaceInfoOSX(&mDNSStorage
, InterfaceID
);
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
);
10284 return (mDNSBool
) info
->D2DInterface
;
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
)
10291 // For an explicit match to a valid interface ID, return true.
10292 if (rr
->resrec
.InterfaceID
== intf
->InterfaceID
)
10295 // Only filtering records for D2D type interfaces, return true for all other interface types.
10296 if (!mDNSPlatformInterfaceIsD2D(intf
->InterfaceID
))
10299 // If it's an AWDL interface the record must be explicitly marked to include AWDL.
10300 if (intf
->InterfaceID
== AWDLInterfaceID
)
10302 if (rr
->ARType
== AuthRecordAnyIncludeAWDL
|| rr
->ARType
== AuthRecordAnyIncludeAWDLandP2P
)
10308 // Send record if it is explicitly marked to include all other P2P type interfaces.
10309 if (rr
->ARType
== AuthRecordAnyIncludeP2P
|| rr
->ARType
== AuthRecordAnyIncludeAWDLandP2P
)
10312 // Don't send the record over this interface.
10316 // Filter questions send over P2P (D2D) type interfaces.
10317 mDNSexport mDNSBool
mDNSPlatformValidQuestionForInterface(DNSQuestion
*q
, const NetworkInterfaceInfo
*intf
)
10319 // For an explicit match to a valid interface ID, return true.
10320 if (q
->InterfaceID
== intf
->InterfaceID
)
10323 // Only filtering questions for D2D type interfaces
10324 if (!mDNSPlatformInterfaceIsD2D(intf
->InterfaceID
))
10327 // If it's an AWDL interface the question must be explicitly marked to include AWDL.
10328 if (intf
->InterfaceID
== AWDLInterfaceID
)
10330 if (q
->flags
& kDNSServiceFlagsIncludeAWDL
)
10336 // Sent question if it is explicitly marked to include all other P2P type interfaces.
10337 if (q
->flags
& kDNSServiceFlagsIncludeP2P
)
10340 // Don't send the question over this interface.
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
)
10349 if (!rr
->InterfaceID
|| (rr
->InterfaceID
== q
->InterfaceID
))
10352 if ((rr
->InterfaceID
== AWDLInterfaceID
) && !(q
->flags
& kDNSServiceFlagsIncludeAWDL
))
10354 LogInfo("mDNSPlatformValidRecordForQuestion: Record recieved over AWDL not returned for %s %##s query",
10355 DNSTypeName(q
->qtype
), q
->qname
.c
);
10362 // formating time to RFC 4034 format
10363 mDNSexport
void mDNSPlatformFormatTime(unsigned long te
, mDNSu8
*buf
, int bufsize
)
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
);
10373 mDNSexport mDNSs32
mDNSPlatformGetPID()
10378 // Schedule a function asynchronously on the main queue
10379 mDNSexport
void mDNSPlatformDispatchAsync(mDNS
*const m
, void *context
, AsyncDispatchFunc func
)
10381 // KQueueLock/Unlock is used for two purposes
10383 // 1. We can't be running along with the KQueue thread and hence acquiring the lock
10384 // serializes the access to the "core"
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(), ^{
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();
10402 // definitions for device-info record construction
10403 #define DEVINFO_MODEL "model="
10404 #define DEVINFO_MODEL_LEN strlen(DEVINFO_MODEL)
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
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))
10414 // Initialize device-info TXT record contents and return total length of record data.
10415 mDNSexport mDNSu32
initializeDeviceInfoTXT(mDNS
*m
, mDNSu8
*ptr
)
10417 mDNSu8
*bufferStart
= ptr
;
10418 mDNSu8 len
= m
->HIHardware
.c
[0] < MAX_MODEL_NAME_LEN
? m
->HIHardware
.c
[0] : MAX_MODEL_NAME_LEN
;
10420 *ptr
= DEVINFO_MODEL_LEN
+ len
; // total length of DEVINFO_MODEL string plus the hardware name string
10422 mDNSPlatformMemCopy(ptr
, DEVINFO_MODEL
, DEVINFO_MODEL_LEN
);
10423 ptr
+= DEVINFO_MODEL_LEN
;
10424 mDNSPlatformMemCopy(ptr
, m
->HIHardware
.c
+ 1, len
);
10427 // only include this string for OSX
10430 char ver_num
[VER_NUM_LEN
+ 1]; // version digits + null written by snprintf
10431 *ptr
= OSX_VER_LEN
+ VER_NUM_LEN
; // length byte
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
;
10441 return (ptr
- bufferStart
);