]> git.saurik.com Git - apple/mdnsresponder.git/blob - mDNSWindows/mDNSWin32.c
projects / apple / mdnsresponder.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mDNSResponder-379.27.tar.gz
[apple/mdnsresponder.git] / mDNSWindows / mDNSWin32.c
1 /* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16
17 To Do:
18
19 - Get unicode name of machine for nice name instead of just the host name.
20 - Use the IPv6 Internet Connection Firewall API to allow IPv6 mDNS without manually changing the firewall.
21 - Get DNS server address(es) from Windows and provide them to the uDNS layer.
22 - Implement TCP support for truncated packets (only stubs now).
23
24 */
25
26 #define _CRT_RAND_S
27
28 #include <stdarg.h>
29 #include <stddef.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <crtdbg.h>
33 #include <string.h>
34
35 #include "Poll.h"
36 #include "CommonServices.h"
37 #include "DebugServices.h"
38 #include "Firewall.h"
39 #include "RegNames.h"
40 #include "Secret.h"
41 #include <dns_sd.h>
42
43 #include <Iphlpapi.h>
44 #include <mswsock.h>
45 #include <process.h>
46 #include <ntsecapi.h>
47 #include <lm.h>
48 #include <winioctl.h>
49 #include <ntddndis.h> // This defines the IOCTL constants.
50
51 #include "mDNSEmbeddedAPI.h"
52 #include "GenLinkedList.h"
53 #include "DNSCommon.h"
54 #include "mDNSWin32.h"
55 #include "dnssec.h"
56 #include "nsec.h"
57
58 #if 0
59 #pragma mark == Constants ==
60 #endif
61
62 //===========================================================================================================================
63 // Constants
64 //===========================================================================================================================
65
66 #define DEBUG_NAME "[mDNSWin32] "
67
68 #define MDNS_WINDOWS_USE_IPV6_IF_ADDRS 1
69 #define MDNS_WINDOWS_ENABLE_IPV4 1
70 #define MDNS_WINDOWS_ENABLE_IPV6 1
71 #define MDNS_FIX_IPHLPAPI_PREFIX_BUG 1
72 #define MDNS_SET_HINFO_STRINGS 0
73
74 #define kMDNSDefaultName "My Computer"
75
76 #define kWinSockMajorMin 2
77 #define kWinSockMinorMin 2
78
79 #define kRegistryMaxKeyLength 255
80 #define kRegistryMaxValueName 16383
81
82 static GUID kWSARecvMsgGUID = WSAID_WSARECVMSG;
83
84 #define kIPv6IfIndexBase (10000000L)
85 #define SMBPortAsNumber 445
86 #define DEVICE_PREFIX "\\\\.\\"
87
88 #if 0
89 #pragma mark == Prototypes ==
90 #endif
91
92 //===========================================================================================================================
93 // Prototypes
94 //===========================================================================================================================
95
96 mDNSlocal mStatus SetupNiceName( mDNS * const inMDNS );
97 mDNSlocal mStatus SetupHostName( mDNS * const inMDNS );
98 mDNSlocal mStatus SetupName( mDNS * const inMDNS );
99 mDNSlocal mStatus SetupInterface( mDNS * const inMDNS, const struct ifaddrs *inIFA, mDNSInterfaceData **outIFD );
100 mDNSlocal mStatus TearDownInterface( mDNS * const inMDNS, mDNSInterfaceData *inIFD );
101 mDNSlocal void CALLBACK FreeInterface( mDNSInterfaceData *inIFD );
102 mDNSlocal mStatus SetupSocket( mDNS * const inMDNS, const struct sockaddr *inAddr, mDNSIPPort port, SocketRef *outSocketRef );
103 mDNSlocal mStatus SockAddrToMDNSAddr( const struct sockaddr * const inSA, mDNSAddr *outIP, mDNSIPPort *outPort );
104 mDNSlocal OSStatus GetWindowsVersionString( char *inBuffer, size_t inBufferSize );
105 mDNSlocal int getifaddrs( struct ifaddrs **outAddrs );
106 mDNSlocal void freeifaddrs( struct ifaddrs *inAddrs );
107
108
109
110 // Platform Accessors
111
112 #ifdef __cplusplus
113 extern "C" {
114 #endif
115
116 typedef struct mDNSPlatformInterfaceInfo mDNSPlatformInterfaceInfo;
117 struct mDNSPlatformInterfaceInfo
118 {
119 const char * name;
120 mDNSAddr ip;
121 };
122
123
124 mDNSexport mStatus mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID );
125 mDNSexport mStatus mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo );
126
127
128 // Wakeup Structs
129
130 #define kUnicastWakeupNumTries ( 1 )
131 #define kUnicastWakeupSleepBetweenTries ( 0 )
132 #define kMulticastWakeupNumTries ( 18 )
133 #define kMulticastWakeupSleepBetweenTries ( 100 )
134
135 typedef struct MulticastWakeupStruct
136 {
137 mDNS *inMDNS;
138 struct sockaddr_in addr;
139 INT addrLen;
140 unsigned char data[ 102 ];
141 INT dataLen;
142 INT numTries;
143 INT msecSleep;
144 } MulticastWakeupStruct;
145
146
147 // Utilities
148
149 #if( MDNS_WINDOWS_USE_IPV6_IF_ADDRS )
150 mDNSlocal int getifaddrs_ipv6( struct ifaddrs **outAddrs );
151 #endif
152
153 mDNSlocal int getifaddrs_ipv4( struct ifaddrs **outAddrs );
154
155
156 mDNSlocal DWORD GetPrimaryInterface();
157 mDNSlocal mStatus AddressToIndexAndMask( struct sockaddr * address, uint32_t * index, struct sockaddr * mask );
158 mDNSlocal mDNSBool CanReceiveUnicast( void );
159 mDNSlocal mDNSBool IsPointToPoint( IP_ADAPTER_UNICAST_ADDRESS * addr );
160
161 mDNSlocal mStatus StringToAddress( mDNSAddr * ip, LPSTR string );
162 mDNSlocal mStatus RegQueryString( HKEY key, LPCSTR param, LPSTR * string, DWORD * stringLen, DWORD * enabled );
163 mDNSlocal struct ifaddrs* myGetIfAddrs(int refresh);
164 mDNSlocal OSStatus TCHARtoUTF8( const TCHAR *inString, char *inBuffer, size_t inBufferSize );
165 mDNSlocal OSStatus WindowsLatin1toUTF8( const char *inString, char *inBuffer, size_t inBufferSize );
166 mDNSlocal void CALLBACK TCPSocketNotification( SOCKET sock, LPWSANETWORKEVENTS event, void *context );
167 mDNSlocal void TCPCloseSocket( TCPSocket * socket );
168 mDNSlocal void CALLBACK UDPSocketNotification( SOCKET sock, LPWSANETWORKEVENTS event, void *context );
169 mDNSlocal void UDPCloseSocket( UDPSocket * sock );
170 mDNSlocal mStatus SetupAddr(mDNSAddr *ip, const struct sockaddr *const sa);
171 mDNSlocal void GetDDNSFQDN( domainname *const fqdn );
172 #ifdef UNICODE
173 mDNSlocal void GetDDNSDomains( DNameListElem ** domains, LPCWSTR lpSubKey );
174 #else
175 mDNSlocal void GetDDNSDomains( DNameListElem ** domains, LPCSTR lpSubKey );
176 #endif
177 mDNSlocal void SetDomainSecrets( mDNS * const inMDNS );
178 mDNSlocal void SetDomainSecret( mDNS * const m, const domainname * inDomain );
179 mDNSlocal VOID CALLBACK CheckFileSharesProc( LPVOID arg, DWORD dwTimerLowValue, DWORD dwTimerHighValue );
180 mDNSlocal void CheckFileShares( mDNS * const inMDNS );
181 mDNSlocal void SMBCallback(mDNS *const m, ServiceRecordSet *const srs, mStatus result);
182 mDNSlocal mDNSu8 IsWOMPEnabledForAdapter( const char * adapterName );
183 mDNSlocal void SendWakeupPacket( mDNS * const inMDNS, LPSOCKADDR addr, INT addrlen, const char * buf, INT buflen, INT numTries, INT msecSleep );
184 mDNSlocal void _cdecl SendMulticastWakeupPacket( void *arg );
185
186 #ifdef __cplusplus
187 }
188 #endif
189
190 #if 0
191 #pragma mark == Globals ==
192 #endif
193
194 //===========================================================================================================================
195 // Globals
196 //===========================================================================================================================
197
198 mDNSlocal mDNS_PlatformSupport gMDNSPlatformSupport;
199 mDNSs32 mDNSPlatformOneSecond = 0;
200 mDNSlocal UDPSocket * gUDPSockets = NULL;
201 mDNSlocal int gUDPNumSockets = 0;
202 mDNSlocal BOOL gEnableIPv6 = TRUE;
203
204 #if( MDNS_WINDOWS_USE_IPV6_IF_ADDRS )
205
206 typedef DWORD
207 ( WINAPI * GetAdaptersAddressesFunctionPtr )(
208 ULONG inFamily,
209 DWORD inFlags,
210 PVOID inReserved,
211 PIP_ADAPTER_ADDRESSES inAdapter,
212 PULONG outBufferSize );
213
214 mDNSlocal HMODULE gIPHelperLibraryInstance = NULL;
215 mDNSlocal GetAdaptersAddressesFunctionPtr gGetAdaptersAddressesFunctionPtr = NULL;
216
217 #endif
218
219
220 #ifndef HCRYPTPROV
221 typedef ULONG_PTR HCRYPTPROV; // WinCrypt.h, line 249
222 #endif
223
224
225 #ifndef CRYPT_MACHINE_KEYSET
226 # define CRYPT_MACHINE_KEYSET 0x00000020
227 #endif
228
229 #ifndef CRYPT_NEWKEYSET
230 # define CRYPT_NEWKEYSET 0x00000008
231 #endif
232
233 #ifndef PROV_RSA_FULL
234 # define PROV_RSA_FULL 1
235 #endif
236
237 typedef BOOL (__stdcall *fnCryptGenRandom)( HCRYPTPROV, DWORD, BYTE* );
238 typedef BOOL (__stdcall *fnCryptAcquireContext)( HCRYPTPROV*, LPCTSTR, LPCTSTR, DWORD, DWORD);
239 typedef BOOL (__stdcall *fnCryptReleaseContext)(HCRYPTPROV, DWORD);
240
241 static fnCryptAcquireContext g_lpCryptAcquireContext = NULL;
242 static fnCryptReleaseContext g_lpCryptReleaseContext = NULL;
243 static fnCryptGenRandom g_lpCryptGenRandom = NULL;
244 static HINSTANCE g_hAAPI32 = NULL;
245 static HCRYPTPROV g_hProvider = ( ULONG_PTR ) NULL;
246
247
248 typedef DNSServiceErrorType ( DNSSD_API *DNSServiceRegisterFunc )
249 (
250 DNSServiceRef *sdRef,
251 DNSServiceFlags flags,
252 uint32_t interfaceIndex,
253 const char *name, /* may be NULL */
254 const char *regtype,
255 const char *domain, /* may be NULL */
256 const char *host, /* may be NULL */
257 uint16_t port,
258 uint16_t txtLen,
259 const void *txtRecord, /* may be NULL */
260 DNSServiceRegisterReply callBack, /* may be NULL */
261 void *context /* may be NULL */
262 );
263
264
265 typedef void ( DNSSD_API *DNSServiceRefDeallocateFunc )( DNSServiceRef sdRef );
266
267 mDNSlocal HMODULE gDNSSDLibrary = NULL;
268 mDNSlocal DNSServiceRegisterFunc gDNSServiceRegister = NULL;
269 mDNSlocal DNSServiceRefDeallocateFunc gDNSServiceRefDeallocate = NULL;
270 mDNSlocal HANDLE gSMBThread = NULL;
271 mDNSlocal HANDLE gSMBThreadRegisterEvent = NULL;
272 mDNSlocal HANDLE gSMBThreadDeregisterEvent = NULL;
273 mDNSlocal HANDLE gSMBThreadStopEvent = NULL;
274 mDNSlocal HANDLE gSMBThreadQuitEvent = NULL;
275
276 #define kSMBStopEvent ( WAIT_OBJECT_0 + 0 )
277 #define kSMBRegisterEvent ( WAIT_OBJECT_0 + 1 )
278 #define kSMBDeregisterEvent ( WAIT_OBJECT_0 + 2 )
279
280
281 #if 0
282 #pragma mark -
283 #pragma mark == Platform Support ==
284 #endif
285
286 //===========================================================================================================================
287 // mDNSPlatformInit
288 //===========================================================================================================================
289
290 mDNSexport mStatus mDNSPlatformInit( mDNS * const inMDNS )
291 {
292 mStatus err;
293 OSVERSIONINFO osInfo;
294 BOOL ok;
295 WSADATA wsaData;
296 int supported;
297 struct sockaddr_in sa4;
298 struct sockaddr_in6 sa6;
299 int sa4len;
300 int sa6len;
301 DWORD size;
302
303 dlog( kDebugLevelTrace, DEBUG_NAME "platform init\n" );
304
305 // Initialize variables. If the PlatformSupport pointer is not null then just assume that a non-Apple client is
306 // calling mDNS_Init and wants to provide its own storage for the platform-specific data so do not overwrite it.
307
308 mDNSPlatformMemZero( &gMDNSPlatformSupport, sizeof( gMDNSPlatformSupport ) );
309 if( !inMDNS->p ) inMDNS->p = &gMDNSPlatformSupport;
310 inMDNS->p->mainThread = OpenThread( THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId() );
311 require_action( inMDNS->p->mainThread, exit, err = mStatus_UnknownErr );
312 inMDNS->p->checkFileSharesTimer = CreateWaitableTimer( NULL, FALSE, NULL );
313 require_action( inMDNS->p->checkFileSharesTimer, exit, err = mStatus_UnknownErr );
314 inMDNS->p->checkFileSharesTimeout = 10; // Retry time for CheckFileShares() in seconds
315 mDNSPlatformOneSecond = 1000; // Use milliseconds as the quantum of time
316
317 // Get OS version info
318
319 osInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
320 ok = GetVersionEx( &osInfo );
321 err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr );
322 require_noerr( err, exit );
323 inMDNS->p->osMajorVersion = osInfo.dwMajorVersion;
324 inMDNS->p->osMinorVersion = osInfo.dwMinorVersion;
325
326 // Don't enable IPv6 on anything less recent than Windows Vista
327
328 if ( inMDNS->p->osMajorVersion < 6 )
329 {
330 gEnableIPv6 = FALSE;
331 }
332
333 // Startup WinSock 2.2 or later.
334
335 err = WSAStartup( MAKEWORD( kWinSockMajorMin, kWinSockMinorMin ), &wsaData );
336 require_noerr( err, exit );
337
338 supported = ( ( LOBYTE( wsaData.wVersion ) == kWinSockMajorMin ) && ( HIBYTE( wsaData.wVersion ) == kWinSockMinorMin ) );
339 require_action( supported, exit, err = mStatus_UnsupportedErr );
340
341 inMDNS->CanReceiveUnicastOn5353 = CanReceiveUnicast();
342
343 // Setup the HINFO HW strings.
344 //<rdar://problem/7245119> device-info should have model=Windows
345
346 strcpy_s( ( char* ) &inMDNS->HIHardware.c[ 1 ], sizeof( inMDNS->HIHardware.c ) - 2, "Windows" );
347 inMDNS->HIHardware.c[ 0 ] = ( mDNSu8 ) mDNSPlatformStrLen( &inMDNS->HIHardware.c[ 1 ] );
348 dlog( kDebugLevelInfo, DEBUG_NAME "HIHardware: %#s\n", inMDNS->HIHardware.c );
349
350 // Setup the HINFO SW strings.
351 #if ( MDNS_SET_HINFO_STRINGS )
352 mDNS_snprintf( (char *) &inMDNS->HISoftware.c[ 1 ], sizeof( inMDNS->HISoftware.c ) - 2,
353 "mDNSResponder (%s %s)", __DATE__, __TIME__ );
354 inMDNS->HISoftware.c[ 0 ] = (mDNSu8) mDNSPlatformStrLen( &inMDNS->HISoftware.c[ 1 ] );
355 dlog( kDebugLevelInfo, DEBUG_NAME "HISoftware: %#s\n", inMDNS->HISoftware.c );
356 #endif
357
358 // Set up the IPv4 unicast socket
359
360 inMDNS->p->unicastSock4.fd = INVALID_SOCKET;
361 inMDNS->p->unicastSock4.recvMsgPtr = NULL;
362 inMDNS->p->unicastSock4.ifd = NULL;
363 inMDNS->p->unicastSock4.next = NULL;
364 inMDNS->p->unicastSock4.m = inMDNS;
365
366 #if ( MDNS_WINDOWS_ENABLE_IPV4 )
367
368 sa4.sin_family = AF_INET;
369 sa4.sin_addr.s_addr = INADDR_ANY;
370 err = SetupSocket( inMDNS, (const struct sockaddr*) &sa4, zeroIPPort, &inMDNS->p->unicastSock4.fd );
371 check_noerr( err );
372 sa4len = sizeof( sa4 );
373 err = getsockname( inMDNS->p->unicastSock4.fd, (struct sockaddr*) &sa4, &sa4len );
374 require_noerr( err, exit );
375 inMDNS->p->unicastSock4.port.NotAnInteger = sa4.sin_port;
376 inMDNS->UnicastPort4 = inMDNS->p->unicastSock4.port;
377 err = WSAIoctl( inMDNS->p->unicastSock4.fd, SIO_GET_EXTENSION_FUNCTION_POINTER, &kWSARecvMsgGUID, sizeof( kWSARecvMsgGUID ), &inMDNS->p->unicastSock4.recvMsgPtr, sizeof( inMDNS->p->unicastSock4.recvMsgPtr ), &size, NULL, NULL );
378
379 if ( err )
380 {
381 inMDNS->p->unicastSock4.recvMsgPtr = NULL;
382 }
383
384 err = mDNSPollRegisterSocket( inMDNS->p->unicastSock4.fd, FD_READ, UDPSocketNotification, &inMDNS->p->unicastSock4 );
385 require_noerr( err, exit );
386
387 #endif
388
389 // Set up the IPv6 unicast socket
390
391 inMDNS->p->unicastSock6.fd = INVALID_SOCKET;
392 inMDNS->p->unicastSock6.recvMsgPtr = NULL;
393 inMDNS->p->unicastSock6.ifd = NULL;
394 inMDNS->p->unicastSock6.next = NULL;
395 inMDNS->p->unicastSock6.m = inMDNS;
396
397 #if ( MDNS_WINDOWS_ENABLE_IPV6 )
398
399 if ( gEnableIPv6 )
400 {
401 sa6.sin6_family = AF_INET6;
402 sa6.sin6_addr = in6addr_any;
403 sa6.sin6_scope_id = 0;
404
405 // This call will fail if the machine hasn't installed IPv6. In that case,
406 // the error will be WSAEAFNOSUPPORT.
407
408 err = SetupSocket( inMDNS, (const struct sockaddr*) &sa6, zeroIPPort, &inMDNS->p->unicastSock6.fd );
409 require_action( !err || ( err == WSAEAFNOSUPPORT ), exit, err = (mStatus) WSAGetLastError() );
410 err = kNoErr;
411
412 // If we weren't able to create the socket (because IPv6 hasn't been installed) don't do this
413
414 if ( inMDNS->p->unicastSock6.fd != INVALID_SOCKET )
415 {
416 sa6len = sizeof( sa6 );
417 err = getsockname( inMDNS->p->unicastSock6.fd, (struct sockaddr*) &sa6, &sa6len );
418 require_noerr( err, exit );
419 inMDNS->p->unicastSock6.port.NotAnInteger = sa6.sin6_port;
420 inMDNS->UnicastPort6 = inMDNS->p->unicastSock6.port;
421
422 err = WSAIoctl( inMDNS->p->unicastSock6.fd, SIO_GET_EXTENSION_FUNCTION_POINTER, &kWSARecvMsgGUID, sizeof( kWSARecvMsgGUID ), &inMDNS->p->unicastSock6.recvMsgPtr, sizeof( inMDNS->p->unicastSock6.recvMsgPtr ), &size, NULL, NULL );
423
424 if ( err != 0 )
425 {
426 inMDNS->p->unicastSock6.recvMsgPtr = NULL;
427 }
428
429 err = mDNSPollRegisterSocket( inMDNS->p->unicastSock6.fd, FD_READ, UDPSocketNotification, &inMDNS->p->unicastSock6 );
430 require_noerr( err, exit );
431 }
432 }
433
434 #endif
435
436 // Notify core of domain secret keys
437
438 SetDomainSecrets( inMDNS );
439
440 // Success!
441
442 mDNSCoreInitComplete( inMDNS, err );
443
444
445 exit:
446
447 if ( err )
448 {
449 mDNSPlatformClose( inMDNS );
450 }
451
452 dlog( kDebugLevelTrace, DEBUG_NAME "platform init done (err=%d %m)\n", err, err );
453 return( err );
454 }
455
456 //===========================================================================================================================
457 // mDNSPlatformClose
458 //===========================================================================================================================
459
460 mDNSexport void mDNSPlatformClose( mDNS * const inMDNS )
461 {
462 mStatus err;
463
464 dlog( kDebugLevelTrace, DEBUG_NAME "platform close\n" );
465 check( inMDNS );
466
467 if ( gSMBThread != NULL )
468 {
469 dlog( kDebugLevelTrace, DEBUG_NAME "tearing down smb registration thread\n" );
470 SetEvent( gSMBThreadStopEvent );
471
472 if ( WaitForSingleObject( gSMBThreadQuitEvent, 5 * 1000 ) == WAIT_OBJECT_0 )
473 {
474 if ( gSMBThreadQuitEvent )
475 {
476 CloseHandle( gSMBThreadQuitEvent );
477 gSMBThreadQuitEvent = NULL;
478 }
479
480 if ( gSMBThreadStopEvent )
481 {
482 CloseHandle( gSMBThreadStopEvent );
483 gSMBThreadStopEvent = NULL;
484 }
485
486 if ( gSMBThreadDeregisterEvent )
487 {
488 CloseHandle( gSMBThreadDeregisterEvent );
489 gSMBThreadDeregisterEvent = NULL;
490 }
491
492 if ( gSMBThreadRegisterEvent )
493 {
494 CloseHandle( gSMBThreadRegisterEvent );
495 gSMBThreadRegisterEvent = NULL;
496 }
497
498 if ( gDNSSDLibrary )
499 {
500 FreeLibrary( gDNSSDLibrary );
501 gDNSSDLibrary = NULL;
502 }
503 }
504 else
505 {
506 LogMsg( "Unable to stop SMBThread" );
507 }
508
509 inMDNS->p->smbFileSharing = mDNSfalse;
510 inMDNS->p->smbPrintSharing = mDNSfalse;
511 }
512
513 // Tear everything down in reverse order to how it was set up.
514
515 err = TearDownInterfaceList( inMDNS );
516 check_noerr( err );
517 check( !inMDNS->p->inactiveInterfaceList );
518
519 #if ( MDNS_WINDOWS_ENABLE_IPV4 )
520
521 UDPCloseSocket( &inMDNS->p->unicastSock4 );
522
523 #endif
524
525 #if ( MDNS_WINDOWS_ENABLE_IPV6 )
526
527 if ( gEnableIPv6 )
528 {
529 UDPCloseSocket( &inMDNS->p->unicastSock6 );
530 }
531
532 #endif
533
534 // Free the DLL needed for IPv6 support.
535
536 #if( MDNS_WINDOWS_USE_IPV6_IF_ADDRS )
537 if( gIPHelperLibraryInstance )
538 {
539 gGetAdaptersAddressesFunctionPtr = NULL;
540
541 FreeLibrary( gIPHelperLibraryInstance );
542 gIPHelperLibraryInstance = NULL;
543 }
544 #endif
545
546 if ( g_hAAPI32 )
547 {
548 // Release any resources
549
550 if ( g_hProvider && g_lpCryptReleaseContext )
551 {
552 ( g_lpCryptReleaseContext )( g_hProvider, 0 );
553 }
554
555 // Free the AdvApi32.dll
556
557 FreeLibrary( g_hAAPI32 );
558
559 // And reset all the data
560
561 g_lpCryptAcquireContext = NULL;
562 g_lpCryptReleaseContext = NULL;
563 g_lpCryptGenRandom = NULL;
564 g_hProvider = ( ULONG_PTR ) NULL;
565 g_hAAPI32 = NULL;
566 }
567
568 WSACleanup();
569
570 dlog( kDebugLevelTrace, DEBUG_NAME "platform close done\n" );
571 }
572
573
574 //===========================================================================================================================
575 // mDNSPlatformLock
576 //===========================================================================================================================
577
578 mDNSexport void mDNSPlatformLock( const mDNS * const inMDNS )
579 {
580 ( void ) inMDNS;
581 }
582
583 //===========================================================================================================================
584 // mDNSPlatformUnlock
585 //===========================================================================================================================
586
587 mDNSexport void mDNSPlatformUnlock( const mDNS * const inMDNS )
588 {
589 ( void ) inMDNS;
590 }
591
592 //===========================================================================================================================
593 // mDNSPlatformStrCopy
594 //===========================================================================================================================
595
596 mDNSexport void mDNSPlatformStrCopy( void *inDst, const void *inSrc )
597 {
598 check( inSrc );
599 check( inDst );
600
601 strcpy( (char *) inDst, (const char*) inSrc );
602 }
603
604 //===========================================================================================================================
605 // mDNSPlatformStrLen
606 //===========================================================================================================================
607
608 mDNSexport mDNSu32 mDNSPlatformStrLen( const void *inSrc )
609 {
610 check( inSrc );
611
612 return( (mDNSu32) strlen( (const char *) inSrc ) );
613 }
614
615 //===========================================================================================================================
616 // mDNSPlatformMemCopy
617 //===========================================================================================================================
618
619 mDNSexport void mDNSPlatformMemCopy( void *inDst, const void *inSrc, mDNSu32 inSize )
620 {
621 check( inSrc );
622 check( inDst );
623
624 memcpy( inDst, inSrc, inSize );
625 }
626
627 //===========================================================================================================================
628 // mDNSPlatformMemSame
629 //===========================================================================================================================
630
631 mDNSexport mDNSBool mDNSPlatformMemSame( const void *inDst, const void *inSrc, mDNSu32 inSize )
632 {
633 check( inSrc );
634 check( inDst );
635
636 return( (mDNSBool)( memcmp( inSrc, inDst, inSize ) == 0 ) );
637 }
638
639 //===========================================================================================================================
640 // mDNSPlatformMemCmp
641 //===========================================================================================================================
642
643 mDNSexport int mDNSPlatformMemCmp( const void *inDst, const void *inSrc, mDNSu32 inSize )
644 {
645 check( inSrc );
646 check( inDst );
647
648 return( memcmp( inSrc, inDst, inSize ) );
649 }
650
651 mDNSexport void mDNSPlatformQsort(void *base, int nel, int width, int (*compar)(const void *, const void *))
652 {
653 (void)base;
654 (void)nel;
655 (void)width;
656 (void)compar;
657 }
658
659 // DNSSEC stub functions
660 mDNSexport void VerifySignature(mDNS *const m, DNSSECVerifier *dv, DNSQuestion *q)
661 {
662 (void)m;
663 (void)dv;
664 (void)q;
665 }
666
667 mDNSexport mDNSBool AddNSECSForCacheRecord(mDNS *const m, CacheRecord *crlist, CacheRecord *negcr, mDNSu8 rcode)
668 {
669 (void)m;
670 (void)crlist;
671 (void)negcr;
672 (void)rcode;
673 return mDNSfalse;
674 }
675
676 //===========================================================================================================================
677 // mDNSPlatformMemZero
678 //===========================================================================================================================
679
680 mDNSexport void mDNSPlatformMemZero( void *inDst, mDNSu32 inSize )
681 {
682 check( inDst );
683
684 memset( inDst, 0, inSize );
685 }
686
687 //===========================================================================================================================
688 // mDNSPlatformMemAllocate
689 //===========================================================================================================================
690
691 mDNSexport void * mDNSPlatformMemAllocate( mDNSu32 inSize )
692 {
693 void * mem;
694
695 check( inSize > 0 );
696
697 mem = malloc( inSize );
698 check( mem );
699
700 return( mem );
701 }
702
703 //===========================================================================================================================
704 // mDNSPlatformMemFree
705 //===========================================================================================================================
706
707 mDNSexport void mDNSPlatformMemFree( void *inMem )
708 {
709 check( inMem );
710
711 free( inMem );
712 }
713
714 //===========================================================================================================================
715 // mDNSPlatformRandomNumber
716 //===========================================================================================================================
717
718 mDNSexport mDNSu32 mDNSPlatformRandomNumber(void)
719 {
720 unsigned int randomNumber;
721 errno_t err;
722
723 err = rand_s( &randomNumber );
724 require_noerr( err, exit );
725
726 exit:
727
728 if ( err )
729 {
730 randomNumber = rand();
731 }
732
733 return ( mDNSu32 ) randomNumber;
734 }
735
736 //===========================================================================================================================
737 // mDNSPlatformTimeInit
738 //===========================================================================================================================
739
740 mDNSexport mStatus mDNSPlatformTimeInit( void )
741 {
742 // No special setup is required on Windows -- we just use GetTickCount().
743 return( mStatus_NoError );
744 }
745
746 //===========================================================================================================================
747 // mDNSPlatformRawTime
748 //===========================================================================================================================
749
750 mDNSexport mDNSs32 mDNSPlatformRawTime( void )
751 {
752 return( (mDNSs32) GetTickCount() );
753 }
754
755 //===========================================================================================================================
756 // mDNSPlatformUTC
757 //===========================================================================================================================
758
759 mDNSexport mDNSs32 mDNSPlatformUTC( void )
760 {
761 return ( mDNSs32 ) time( NULL );
762 }
763
764 //===========================================================================================================================
765 // mDNSPlatformInterfaceNameToID
766 //===========================================================================================================================
767
768 mDNSexport mStatus mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID )
769 {
770 mStatus err;
771 mDNSInterfaceData * ifd;
772
773 check( inMDNS );
774 check( inMDNS->p );
775 check( inName );
776
777 // Search for an interface with the specified name,
778
779 for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next )
780 {
781 if( strcmp( ifd->name, inName ) == 0 )
782 {
783 break;
784 }
785 }
786 require_action_quiet( ifd, exit, err = mStatus_NoSuchNameErr );
787
788 // Success!
789
790 if( outID )
791 {
792 *outID = (mDNSInterfaceID) ifd;
793 }
794 err = mStatus_NoError;
795
796 exit:
797 return( err );
798 }
799
800 //===========================================================================================================================
801 // mDNSPlatformInterfaceIDToInfo
802 //===========================================================================================================================
803
804 mDNSexport mStatus mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo )
805 {
806 mStatus err;
807 mDNSInterfaceData * ifd;
808
809 check( inMDNS );
810 check( inID );
811 check( outInfo );
812
813 // Search for an interface with the specified ID,
814
815 for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next )
816 {
817 if( ifd == (mDNSInterfaceData *) inID )
818 {
819 break;
820 }
821 }
822 require_action_quiet( ifd, exit, err = mStatus_NoSuchNameErr );
823
824 // Success!
825
826 outInfo->name = ifd->name;
827 outInfo->ip = ifd->interfaceInfo.ip;
828 err = mStatus_NoError;
829
830 exit:
831 return( err );
832 }
833
834 //===========================================================================================================================
835 // mDNSPlatformInterfaceIDfromInterfaceIndex
836 //===========================================================================================================================
837
838 mDNSexport mDNSInterfaceID mDNSPlatformInterfaceIDfromInterfaceIndex( mDNS * const inMDNS, mDNSu32 inIndex )
839 {
840 mDNSInterfaceID id;
841
842 id = mDNSNULL;
843 if( inIndex == kDNSServiceInterfaceIndexLocalOnly )
844 {
845 id = mDNSInterface_LocalOnly;
846 }
847 else if( inIndex != 0 )
848 {
849 mDNSInterfaceData * ifd;
850
851 for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next )
852 {
853 if( ( ifd->scopeID == inIndex ) && ifd->interfaceInfo.InterfaceActive )
854 {
855 id = ifd->interfaceInfo.InterfaceID;
856 break;
857 }
858 }
859 check( ifd );
860 }
861 return( id );
862 }
863
864 //===========================================================================================================================
865 // mDNSPlatformInterfaceIndexfromInterfaceID
866 //===========================================================================================================================
867
868 mDNSexport mDNSu32 mDNSPlatformInterfaceIndexfromInterfaceID( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSBool suppressNetworkChange )
869 {
870 mDNSu32 index;
871
872 (void) suppressNetworkChange;
873
874 index = 0;
875 if( inID == mDNSInterface_LocalOnly )
876 {
877 index = (mDNSu32) kDNSServiceInterfaceIndexLocalOnly;
878 }
879 else if( inID )
880 {
881 mDNSInterfaceData * ifd;
882
883 // Search active interfaces.
884 for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next )
885 {
886 if( (mDNSInterfaceID) ifd == inID )
887 {
888 index = ifd->scopeID;
889 break;
890 }
891 }
892
893 // Search inactive interfaces too so remove events for inactive interfaces report the old interface index.
894
895 if( !ifd )
896 {
897 for( ifd = inMDNS->p->inactiveInterfaceList; ifd; ifd = ifd->next )
898 {
899 if( (mDNSInterfaceID) ifd == inID )
900 {
901 index = ifd->scopeID;
902 break;
903 }
904 }
905 }
906 check( ifd );
907 }
908 return( index );
909 }
910
911
912 //===========================================================================================================================
913 // mDNSPlatformTCPSocket
914 //===========================================================================================================================
915
916 TCPSocket *
917 mDNSPlatformTCPSocket
918 (
919 mDNS * const m,
920 TCPSocketFlags flags,
921 mDNSIPPort * port,
922 mDNSBool useBackgroundTrafficClass
923 )
924 {
925 TCPSocket * sock = NULL;
926 u_long on = 1; // "on" for setsockopt
927 struct sockaddr_in saddr;
928 int len;
929 mStatus err = mStatus_NoError;
930
931 DEBUG_UNUSED( m );
932 DEBUG_UNUSED( useBackgroundTrafficClass );
933
934 require_action( flags == 0, exit, err = mStatus_UnsupportedErr );
935
936 // Setup connection data object
937
938 sock = (TCPSocket *) malloc( sizeof( TCPSocket ) );
939 require_action( sock, exit, err = mStatus_NoMemoryErr );
940 mDNSPlatformMemZero( sock, sizeof( TCPSocket ) );
941 sock->fd = INVALID_SOCKET;
942 sock->flags = flags;
943 sock->m = m;
944
945 mDNSPlatformMemZero(&saddr, sizeof(saddr));
946 saddr.sin_family = AF_INET;
947 saddr.sin_addr.s_addr = htonl( INADDR_ANY );
948 saddr.sin_port = port->NotAnInteger;
949
950 // Create the socket
951
952 sock->fd = socket(AF_INET, SOCK_STREAM, 0);
953 err = translate_errno( sock->fd != INVALID_SOCKET, WSAGetLastError(), mStatus_UnknownErr );
954 require_noerr( err, exit );
955
956 // bind
957
958 err = bind( sock->fd, ( struct sockaddr* ) &saddr, sizeof( saddr ) );
959 err = translate_errno( err == 0, WSAGetLastError(), mStatus_UnknownErr );
960 require_noerr( err, exit );
961
962 // Set it to be non-blocking
963
964 err = ioctlsocket( sock->fd, FIONBIO, &on );
965 err = translate_errno( err == 0, WSAGetLastError(), mStatus_UnknownErr );
966 require_noerr( err, exit );
967
968 // Get port number
969
970 mDNSPlatformMemZero( &saddr, sizeof( saddr ) );
971 len = sizeof( saddr );
972
973 err = getsockname( sock->fd, ( struct sockaddr* ) &saddr, &len );
974 err = translate_errno( err == 0, WSAGetLastError(), mStatus_UnknownErr );
975 require_noerr( err, exit );
976
977 port->NotAnInteger = saddr.sin_port;
978
979 exit:
980
981 if ( err && sock )
982 {
983 TCPCloseSocket( sock );
984 free( sock );
985 sock = mDNSNULL;
986 }
987
988 return sock;
989 }
990
991 //===========================================================================================================================
992 // mDNSPlatformTCPConnect
993 //===========================================================================================================================
994
995 mStatus
996 mDNSPlatformTCPConnect
997 (
998 TCPSocket * sock,
999 const mDNSAddr * inDstIP,
1000 mDNSOpaque16 inDstPort,
1001 domainname * hostname,
1002 mDNSInterfaceID inInterfaceID,
1003 TCPConnectionCallback inCallback,
1004 void * inContext
1005 )
1006 {
1007 struct sockaddr_in saddr;
1008 mStatus err = mStatus_NoError;
1009
1010 DEBUG_UNUSED( hostname );
1011 DEBUG_UNUSED( inInterfaceID );
1012
1013 if ( inDstIP->type != mDNSAddrType_IPv4 )
1014 {
1015 LogMsg("ERROR: mDNSPlatformTCPConnect - attempt to connect to an IPv6 address: operation not supported");
1016 return mStatus_UnknownErr;
1017 }
1018
1019 // Setup connection data object
1020
1021 sock->userCallback = inCallback;
1022 sock->userContext = inContext;
1023
1024 mDNSPlatformMemZero(&saddr, sizeof(saddr));
1025 saddr.sin_family = AF_INET;
1026 saddr.sin_port = inDstPort.NotAnInteger;
1027 memcpy(&saddr.sin_addr, &inDstIP->ip.v4.NotAnInteger, sizeof(saddr.sin_addr));
1028
1029 // Try and do connect
1030
1031 err = connect( sock->fd, ( struct sockaddr* ) &saddr, sizeof( saddr ) );
1032 require_action( !err || ( WSAGetLastError() == WSAEWOULDBLOCK ), exit, err = mStatus_ConnFailed );
1033 sock->connected = !err ? TRUE : FALSE;
1034
1035 err = mDNSPollRegisterSocket( sock->fd, FD_CONNECT | FD_READ | FD_CLOSE, TCPSocketNotification, sock );
1036 require_noerr( err, exit );
1037
1038 exit:
1039
1040 if ( !err )
1041 {
1042 err = sock->connected ? mStatus_ConnEstablished : mStatus_ConnPending;
1043 }
1044
1045 return err;
1046 }
1047
1048
1049 //===========================================================================================================================
1050 // mDNSPlatformTCPAccept
1051 //===========================================================================================================================
1052
1053 mDNSexport
1054 mDNSexport TCPSocket *mDNSPlatformTCPAccept( TCPSocketFlags flags, int fd )
1055 {
1056 TCPSocket * sock = NULL;
1057 mStatus err = mStatus_NoError;
1058
1059 require_action( !flags, exit, err = mStatus_UnsupportedErr );
1060
1061 sock = malloc( sizeof( TCPSocket ) );
1062 require_action( sock, exit, err = mStatus_NoMemoryErr );
1063
1064 mDNSPlatformMemZero( sock, sizeof( *sock ) );
1065
1066 sock->fd = fd;
1067 sock->flags = flags;
1068
1069 exit:
1070
1071 if ( err && sock )
1072 {
1073 free( sock );
1074 sock = NULL;
1075 }
1076
1077 return sock;
1078 }
1079
1080
1081 //===========================================================================================================================
1082 // mDNSPlatformTCPCloseConnection
1083 //===========================================================================================================================
1084
1085 mDNSexport void mDNSPlatformTCPCloseConnection( TCPSocket *sock )
1086 {
1087 check( sock );
1088
1089 if ( sock )
1090 {
1091 dlog( kDebugLevelChatty, DEBUG_NAME "mDNSPlatformTCPCloseConnection 0x%x:%d\n", sock, sock->fd );
1092
1093 if ( sock->fd != INVALID_SOCKET )
1094 {
1095 mDNSPollUnregisterSocket( sock->fd );
1096 closesocket( sock->fd );
1097 sock->fd = INVALID_SOCKET;
1098 }
1099
1100 free( sock );
1101 }
1102 }
1103
1104
1105 //===========================================================================================================================
1106 // mDNSPlatformReadTCP
1107 //===========================================================================================================================
1108
1109 mDNSexport long mDNSPlatformReadTCP( TCPSocket *sock, void *inBuffer, unsigned long inBufferSize, mDNSBool * closed )
1110 {
1111 int nread;
1112 OSStatus err;
1113
1114 *closed = mDNSfalse;
1115 nread = recv( sock->fd, inBuffer, inBufferSize, 0 );
1116 err = translate_errno( ( nread >= 0 ), WSAGetLastError(), mStatus_UnknownErr );
1117
1118 if ( nread > 0 )
1119 {
1120 dlog( kDebugLevelChatty, DEBUG_NAME "mDNSPlatformReadTCP: 0x%x:%d read %d bytes\n", sock, sock->fd, nread );
1121 }
1122 else if ( !nread )
1123 {
1124 *closed = mDNStrue;
1125 }
1126 else if ( err == WSAECONNRESET )
1127 {
1128 *closed = mDNStrue;
1129 nread = 0;
1130 }
1131 else if ( err == WSAEWOULDBLOCK )
1132 {
1133 nread = 0;
1134 }
1135 else
1136 {
1137 LogMsg( "ERROR: mDNSPlatformReadTCP - recv: %d\n", err );
1138 nread = -1;
1139 }
1140
1141 return nread;
1142 }
1143
1144
1145 //===========================================================================================================================
1146 // mDNSPlatformWriteTCP
1147 //===========================================================================================================================
1148
1149 mDNSexport long mDNSPlatformWriteTCP( TCPSocket *sock, const char *inMsg, unsigned long inMsgSize )
1150 {
1151 int nsent;
1152 OSStatus err;
1153
1154 nsent = send( sock->fd, inMsg, inMsgSize, 0 );
1155
1156 err = translate_errno( ( nsent >= 0 ) || ( WSAGetLastError() == WSAEWOULDBLOCK ), WSAGetLastError(), mStatus_UnknownErr );
1157 require_noerr( err, exit );
1158
1159 if ( nsent < 0)
1160 {
1161 nsent = 0;
1162 }
1163
1164 exit:
1165
1166 return nsent;
1167 }
1168
1169 //===========================================================================================================================
1170 // mDNSPlatformTCPGetFD
1171 //===========================================================================================================================
1172
1173 mDNSexport int mDNSPlatformTCPGetFD(TCPSocket *sock )
1174 {
1175 return ( int ) sock->fd;
1176 }
1177
1178
1179
1180 //===========================================================================================================================
1181 // TCPSocketNotification
1182 //===========================================================================================================================
1183
1184 mDNSlocal void CALLBACK
1185 TCPSocketNotification( SOCKET sock, LPWSANETWORKEVENTS event, void *context )
1186 {
1187 TCPSocket *tcpSock = ( TCPSocket* ) context;
1188 TCPConnectionCallback callback;
1189 int err;
1190
1191 DEBUG_UNUSED( sock );
1192
1193 require_action( tcpSock, exit, err = mStatus_BadParamErr );
1194 callback = ( TCPConnectionCallback ) tcpSock->userCallback;
1195 require_action( callback, exit, err = mStatus_BadParamErr );
1196
1197 if ( event && ( event->lNetworkEvents & FD_CONNECT ) )
1198 {
1199 if ( event->iErrorCode[ FD_CONNECT_BIT ] == 0 )
1200 {
1201 callback( tcpSock, tcpSock->userContext, mDNStrue, 0 );
1202 tcpSock->connected = mDNStrue;
1203 }
1204 else
1205 {
1206 callback( tcpSock, tcpSock->userContext, mDNSfalse, event->iErrorCode[ FD_CONNECT_BIT ] );
1207 }
1208 }
1209 else
1210 {
1211 callback( tcpSock, tcpSock->userContext, mDNSfalse, 0 );
1212 }
1213
1214 exit:
1215
1216 return;
1217 }
1218
1219
1220
1221 //===========================================================================================================================
1222 // mDNSPlatformUDPSocket
1223 //===========================================================================================================================
1224
1225 mDNSexport UDPSocket* mDNSPlatformUDPSocket(mDNS *const m, const mDNSIPPort requestedport)
1226 {
1227 UDPSocket* sock = NULL;
1228 mDNSIPPort port = requestedport;
1229 mStatus err = mStatus_NoError;
1230 unsigned i;
1231
1232 // Setup connection data object
1233
1234 sock = ( UDPSocket* ) malloc(sizeof( UDPSocket ) );
1235 require_action( sock, exit, err = mStatus_NoMemoryErr );
1236 memset( sock, 0, sizeof( UDPSocket ) );
1237
1238 // Create the socket
1239
1240 sock->fd = INVALID_SOCKET;
1241 sock->recvMsgPtr = m->p->unicastSock4.recvMsgPtr;
1242 sock->addr = m->p->unicastSock4.addr;
1243 sock->ifd = NULL;
1244 sock->m = m;
1245
1246 // Try at most 10000 times to get a unique random port
1247
1248 for (i=0; i<10000; i++)
1249 {
1250 struct sockaddr_in saddr;
1251
1252 saddr.sin_family = AF_INET;
1253 saddr.sin_addr.s_addr = 0;
1254
1255 // The kernel doesn't do cryptographically strong random port
1256 // allocation, so we do it ourselves here
1257
1258 if (mDNSIPPortIsZero(requestedport))
1259 {
1260 port = mDNSOpaque16fromIntVal( ( mDNSu16 ) ( 0xC000 + mDNSRandom(0x3FFF) ) );
1261 }
1262
1263 saddr.sin_port = port.NotAnInteger;
1264
1265 err = SetupSocket(m, ( struct sockaddr* ) &saddr, port, &sock->fd );
1266 if (!err) break;
1267 }
1268
1269 require_noerr( err, exit );
1270
1271 // Set the port
1272
1273 sock->port = port;
1274
1275 // Arm the completion routine
1276
1277 err = mDNSPollRegisterSocket( sock->fd, FD_READ, UDPSocketNotification, sock );
1278 require_noerr( err, exit );
1279
1280 // Bookkeeping
1281
1282 sock->next = gUDPSockets;
1283 gUDPSockets = sock;
1284 gUDPNumSockets++;
1285
1286 exit:
1287
1288 if ( err && sock )
1289 {
1290 UDPCloseSocket( sock );
1291 free( sock );
1292 sock = NULL;
1293 }
1294
1295 return sock;
1296 }
1297
1298 //===========================================================================================================================
1299 // mDNSPlatformUDPClose
1300 //===========================================================================================================================
1301
1302 mDNSexport void mDNSPlatformUDPClose( UDPSocket *sock )
1303 {
1304 UDPSocket * current = gUDPSockets;
1305 UDPSocket * last = NULL;
1306
1307 while ( current )
1308 {
1309 if ( current == sock )
1310 {
1311 if ( last == NULL )
1312 {
1313 gUDPSockets = sock->next;
1314 }
1315 else
1316 {
1317 last->next = sock->next;
1318 }
1319
1320 UDPCloseSocket( sock );
1321 free( sock );
1322
1323 gUDPNumSockets--;
1324
1325 break;
1326 }
1327
1328 last = current;
1329 current = current->next;
1330 }
1331 }
1332
1333
1334 //===========================================================================================================================
1335 // mDNSPlatformSendUDP
1336 //===========================================================================================================================
1337
1338 mDNSexport mStatus
1339 mDNSPlatformSendUDP(
1340 const mDNS * const inMDNS,
1341 const void * const inMsg,
1342 const mDNSu8 * const inMsgEnd,
1343 mDNSInterfaceID inInterfaceID,
1344 UDPSocket * inSrcSocket,
1345 const mDNSAddr * inDstIP,
1346 mDNSIPPort inDstPort,
1347 mDNSBool useBackgroundTrafficClass )
1348 {
1349 SOCKET sendingsocket = INVALID_SOCKET;
1350 mStatus err = mStatus_NoError;
1351 mDNSInterfaceData * ifd = (mDNSInterfaceData*) inInterfaceID;
1352 struct sockaddr_storage addr;
1353 int n;
1354
1355 DEBUG_USE_ONLY( inMDNS );
1356 DEBUG_USE_ONLY( useBackgroundTrafficClass );
1357
1358 n = (int)( inMsgEnd - ( (const mDNSu8 * const) inMsg ) );
1359 check( inMDNS );
1360 check( inMsg );
1361 check( inMsgEnd );
1362 check( inDstIP );
1363
1364 dlog( kDebugLevelChatty, DEBUG_NAME "platform send %d bytes to %#a:%u\n", n, inDstIP, ntohs( inDstPort.NotAnInteger ) );
1365
1366 if( inDstIP->type == mDNSAddrType_IPv4 )
1367 {
1368 struct sockaddr_in * sa4;
1369
1370 sa4 = (struct sockaddr_in *) &addr;
1371 sa4->sin_family = AF_INET;
1372 sa4->sin_port = inDstPort.NotAnInteger;
1373 sa4->sin_addr.s_addr = inDstIP->ip.v4.NotAnInteger;
1374 sendingsocket = ifd ? ifd->sock.fd : inMDNS->p->unicastSock4.fd;
1375
1376 if (inSrcSocket) { sendingsocket = inSrcSocket->fd; debugf("mDNSPlatformSendUDP using port %d, static port %d, sock %d", mDNSVal16(inSrcSocket->port), inMDNS->p->unicastSock4.fd, sendingsocket); }
1377 }
1378 else if( inDstIP->type == mDNSAddrType_IPv6 )
1379 {
1380 struct sockaddr_in6 * sa6;
1381
1382 sa6 = (struct sockaddr_in6 *) &addr;
1383 sa6->sin6_family = AF_INET6;
1384 sa6->sin6_port = inDstPort.NotAnInteger;
1385 sa6->sin6_flowinfo = 0;
1386 sa6->sin6_addr = *( (struct in6_addr *) &inDstIP->ip.v6 );
1387 sa6->sin6_scope_id = 0; // Windows requires the scope ID to be zero. IPV6_MULTICAST_IF specifies interface.
1388 sendingsocket = ifd ? ifd->sock.fd : inMDNS->p->unicastSock6.fd;
1389 }
1390 else
1391 {
1392 dlog( kDebugLevelError, DEBUG_NAME "%s: dst is not an IPv4 or IPv6 address (type=%d)\n", __ROUTINE__, inDstIP->type );
1393 err = mStatus_BadParamErr;
1394 goto exit;
1395 }
1396
1397 if (IsValidSocket(sendingsocket))
1398 {
1399 n = sendto( sendingsocket, (char *) inMsg, n, 0, (struct sockaddr *) &addr, sizeof( addr ) );
1400 err = translate_errno( n > 0, errno_compat(), kWriteErr );
1401
1402 if ( err )
1403 {
1404 // Don't report EHOSTDOWN (i.e. ARP failure), ENETDOWN, or no route to host for unicast destinations
1405
1406 if ( !mDNSAddressIsAllDNSLinkGroup( inDstIP ) && ( WSAGetLastError() == WSAEHOSTDOWN || WSAGetLastError() == WSAENETDOWN || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAENETUNREACH ) )
1407 {
1408 err = mStatus_TransientErr;
1409 }
1410 else
1411 {
1412 require_noerr( err, exit );
1413 }
1414 }
1415 }
1416
1417 exit:
1418 return( err );
1419 }
1420
1421
1422 mDNSexport void mDNSPlatformUpdateProxyList(mDNS *const m, const mDNSInterfaceID InterfaceID)
1423 {
1424 DEBUG_UNUSED( m );
1425 DEBUG_UNUSED( InterfaceID );
1426 }
1427
1428
1429 mDNSexport void mDNSPlatformSetAllowSleep(mDNS *const m, mDNSBool allowSleep, const char *reason)
1430 {
1431 DEBUG_UNUSED( m );
1432 DEBUG_UNUSED( allowSleep );
1433 DEBUG_UNUSED( reason );
1434 }
1435
1436 //===========================================================================================================================
1437 // mDNSPlatformSendRawPacket
1438 //===========================================================================================================================
1439
1440 mDNSexport void mDNSPlatformSendWakeupPacket(mDNS *const m, mDNSInterfaceID InterfaceID, char *ethaddr, char *ipaddr, int iteration)
1441 {
1442 unsigned char mac[ 6 ];
1443 unsigned char buf[ 102 ];
1444 char hex[ 3 ] = { 0 };
1445 unsigned char *bufPtr = buf;
1446 struct sockaddr_storage saddr;
1447 INT len = sizeof( saddr );
1448 mDNSBool unicast = mDNSfalse;
1449 MulticastWakeupStruct *info;
1450 int i;
1451 mStatus err;
1452
1453 (void) InterfaceID;
1454
1455 require_action( ethaddr, exit, err = mStatus_BadParamErr );
1456
1457 for ( i = 0; i < 6; i++ )
1458 {
1459 memcpy( hex, ethaddr + ( i * 3 ), 2 );
1460 mac[ i ] = ( unsigned char ) strtoul( hex, NULL, 16 );
1461 }
1462
1463 memset( buf, 0, sizeof( buf ) );
1464
1465 for ( i = 0; i < 6; i++ )
1466 {
1467 *bufPtr++ = 0xff;
1468 }
1469
1470 for ( i = 0; i < 16; i++ )
1471 {
1472 memcpy( bufPtr, mac, sizeof( mac ) );
1473 bufPtr += sizeof( mac );
1474 }
1475
1476 if ( ipaddr )
1477 {
1478 if ( WSAStringToAddressA( ipaddr, AF_INET, NULL, ( LPSOCKADDR ) &saddr, &len ) == 0 )
1479 {
1480 struct sockaddr_in * saddr4 = ( struct sockaddr_in* ) &saddr;
1481 saddr4->sin_port = htons( 9 );
1482 len = sizeof( *saddr4 );
1483
1484 if ( saddr4->sin_addr.s_addr != htonl( INADDR_ANY ) )
1485 {
1486 unicast = mDNStrue;
1487 }
1488 }
1489 else if ( WSAStringToAddressA( ipaddr, AF_INET6, NULL, ( LPSOCKADDR ) &saddr, &len ) == 0 )
1490 {
1491 mDNSInterfaceData *ifd = ( mDNSInterfaceData* ) InterfaceID;
1492 struct sockaddr_in6 * saddr6 = ( struct sockaddr_in6* ) &saddr;
1493 saddr6->sin6_port = htons( 9 );
1494
1495 if ( ifd != NULL )
1496 {
1497 saddr6->sin6_scope_id = ifd->scopeID;
1498 }
1499
1500 len = sizeof( *saddr6 );
1501
1502 if ( memcmp( &saddr6->sin6_addr, &in6addr_any, sizeof( IN6_ADDR ) ) != 0 )
1503 {
1504 unicast = mDNStrue;
1505 }
1506 }
1507 }
1508
1509 if ( ( iteration < 2 ) && ( unicast ) )
1510 {
1511 SendWakeupPacket( m, ( LPSOCKADDR ) &saddr, len, ( const char* ) buf, sizeof( buf ), kUnicastWakeupNumTries, kUnicastWakeupSleepBetweenTries );
1512 }
1513
1514 info = ( MulticastWakeupStruct* ) malloc( sizeof( MulticastWakeupStruct ) );
1515 require_action( info, exit, err = mStatus_NoMemoryErr );
1516 info->inMDNS = m;
1517 memset( &info->addr, 0, sizeof( info->addr ) );
1518 info->addr.sin_family = AF_INET;
1519 info->addr.sin_addr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
1520 info->addr.sin_port = htons( 9 );
1521 info->addrLen = sizeof( info->addr );
1522 memcpy( info->data, buf, sizeof( buf ) );
1523 info->dataLen = sizeof( buf );
1524 info->numTries = kMulticastWakeupNumTries;
1525 info->msecSleep = kMulticastWakeupSleepBetweenTries;
1526
1527 _beginthread( SendMulticastWakeupPacket, 0, ( void* ) info );
1528
1529 exit:
1530
1531 return;
1532 }
1533
1534
1535 mDNSexport mDNSBool mDNSPlatformValidRecordForInterface(AuthRecord *rr, const NetworkInterfaceInfo *intf)
1536 {
1537 DEBUG_UNUSED( rr );
1538 DEBUG_UNUSED( intf );
1539
1540 return mDNStrue;
1541 }
1542
1543 mDNSexport mDNSBool mDNSPlatformValidQuestionForInterface(DNSQuestion *q, const NetworkInterfaceInfo *intf)
1544 {
1545 DEBUG_UNUSED( q );
1546 DEBUG_UNUSED( intf );
1547
1548 return mDNStrue;
1549 }
1550
1551 mDNSexport void mDNSPlatformSendRawPacket(const void *const msg, const mDNSu8 *const end, mDNSInterfaceID InterfaceID)
1552 {
1553 DEBUG_UNUSED( msg );
1554 DEBUG_UNUSED( end );
1555 DEBUG_UNUSED( InterfaceID );
1556 }
1557
1558 // Used for debugging purposes. For now, just set the buffer to zero
1559 mDNSexport void mDNSPlatformFormatTime(unsigned long te, mDNSu8 *buf, int bufsize)
1560 {
1561 DEBUG_UNUSED( te );
1562 if (bufsize) buf[0] = 0;
1563 }
1564
1565
1566 mDNSexport void mDNSPlatformSetLocalAddressCacheEntry(mDNS *const m, const mDNSAddr *const tpa, const mDNSEthAddr *const tha, mDNSInterfaceID InterfaceID)
1567 {
1568 DEBUG_UNUSED( m );
1569 DEBUG_UNUSED( tpa );
1570 DEBUG_UNUSED( tha );
1571 DEBUG_UNUSED( InterfaceID );
1572 }
1573
1574
1575 mDNSexport void mDNSPlatformReceiveRawPacket(const void *const msg, const mDNSu8 *const end, mDNSInterfaceID InterfaceID)
1576 {
1577 DEBUG_UNUSED( msg );
1578 DEBUG_UNUSED( end );
1579 DEBUG_UNUSED( InterfaceID );
1580 }
1581
1582 mDNSexport void mDNSPlatformSetLocalARP( const mDNSv4Addr * const tpa, const mDNSEthAddr * const tha, mDNSInterfaceID InterfaceID )
1583 {
1584 DEBUG_UNUSED( tpa );
1585 DEBUG_UNUSED( tha );
1586 DEBUG_UNUSED( InterfaceID );
1587 }
1588
1589 mDNSexport void mDNSPlatformWriteDebugMsg(const char *msg)
1590 {
1591 dlog( kDebugLevelInfo, "%s\n", msg );
1592 }
1593
1594 mDNSexport void mDNSPlatformWriteLogMsg( const char * ident, const char * msg, mDNSLogLevel_t loglevel )
1595 {
1596 extern mDNS mDNSStorage;
1597 int type;
1598
1599 DEBUG_UNUSED( ident );
1600
1601 type = EVENTLOG_ERROR_TYPE;
1602
1603 switch (loglevel)
1604 {
1605 case MDNS_LOG_MSG: type = EVENTLOG_ERROR_TYPE; break;
1606 case MDNS_LOG_OPERATION: type = EVENTLOG_WARNING_TYPE; break;
1607 case MDNS_LOG_SPS: type = EVENTLOG_INFORMATION_TYPE; break;
1608 case MDNS_LOG_INFO: type = EVENTLOG_INFORMATION_TYPE; break;
1609 case MDNS_LOG_DEBUG: type = EVENTLOG_INFORMATION_TYPE; break;
1610 default:
1611 fprintf(stderr, "Unknown loglevel %d, assuming LOG_ERR\n", loglevel);
1612 fflush(stderr);
1613 }
1614
1615 mDNSStorage.p->reportStatusFunc( type, msg );
1616 dlog( kDebugLevelInfo, "%s\n", msg );
1617 }
1618
1619 mDNSexport void mDNSPlatformSourceAddrForDest( mDNSAddr * const src, const mDNSAddr * const dst )
1620 {
1621 DEBUG_UNUSED( src );
1622 DEBUG_UNUSED( dst );
1623 }
1624
1625 //===========================================================================================================================
1626 // mDNSPlatformTLSSetupCerts
1627 //===========================================================================================================================
1628
1629 mDNSexport mStatus
1630 mDNSPlatformTLSSetupCerts(void)
1631 {
1632 return mStatus_UnsupportedErr;
1633 }
1634
1635 //===========================================================================================================================
1636 // mDNSPlatformTLSTearDownCerts
1637 //===========================================================================================================================
1638
1639 mDNSexport void
1640 mDNSPlatformTLSTearDownCerts(void)
1641 {
1642 }
1643
1644 //===========================================================================================================================
1645 // mDNSPlatformSetDNSConfig
1646 //===========================================================================================================================
1647
1648 mDNSlocal void SetDNSServers( mDNS *const m );
1649 mDNSlocal void SetSearchDomainList( void );
1650
1651 mDNSexport void mDNSPlatformSetDNSConfig(mDNS *const m, mDNSBool setservers, mDNSBool setsearch, domainname *const fqdn, DNameListElem **regDomains, DNameListElem **browseDomains)
1652 {
1653 if (setservers) SetDNSServers(m);
1654 if (setsearch) SetSearchDomainList();
1655
1656 if ( fqdn )
1657 {
1658 GetDDNSFQDN( fqdn );
1659 }
1660
1661 if ( browseDomains )
1662 {
1663 GetDDNSDomains( browseDomains, kServiceParametersNode TEXT("\\DynDNS\\Setup\\") kServiceDynDNSBrowseDomains );
1664 }
1665
1666 if ( regDomains )
1667 {
1668 GetDDNSDomains( regDomains, kServiceParametersNode TEXT("\\DynDNS\\Setup\\") kServiceDynDNSRegistrationDomains );
1669 }
1670 }
1671
1672
1673 //===========================================================================================================================
1674 // mDNSPlatformDynDNSHostNameStatusChanged
1675 //===========================================================================================================================
1676
1677 mDNSexport void
1678 mDNSPlatformDynDNSHostNameStatusChanged(const domainname *const dname, const mStatus status)
1679 {
1680 char uname[MAX_ESCAPED_DOMAIN_NAME];
1681 BYTE bStatus;
1682 LPCTSTR name;
1683 HKEY key = NULL;
1684 mStatus err;
1685 char * p;
1686
1687 ConvertDomainNameToCString(dname, uname);
1688
1689 p = uname;
1690
1691 while (*p)
1692 {
1693 *p = (char) tolower(*p);
1694 if (!(*(p+1)) && *p == '.') *p = 0; // if last character, strip trailing dot
1695 p++;
1696 }
1697
1698 check( strlen( p ) <= MAX_ESCAPED_DOMAIN_NAME );
1699 name = kServiceParametersNode TEXT("\\DynDNS\\State\\HostNames");
1700 err = RegCreateKey( HKEY_LOCAL_MACHINE, name, &key );
1701 require_noerr( err, exit );
1702
1703 bStatus = ( status ) ? 0 : 1;
1704 err = RegSetValueEx( key, kServiceDynDNSStatus, 0, REG_DWORD, (const LPBYTE) &bStatus, sizeof(DWORD) );
1705 require_noerr( err, exit );
1706
1707 exit:
1708
1709 if ( key )
1710 {
1711 RegCloseKey( key );
1712 }
1713
1714 return;
1715 }
1716
1717
1718 //===========================================================================================================================
1719 // SetDomainSecrets
1720 //===========================================================================================================================
1721
1722 // This routine needs to be called whenever the system secrets database changes.
1723 // We call it from DynDNSConfigDidChange and mDNSPlatformInit
1724
1725 void
1726 SetDomainSecrets( mDNS * const m )
1727 {
1728 DomainAuthInfo *ptr;
1729 domainname fqdn;
1730 DNameListElem * regDomains = NULL;
1731
1732 // Rather than immediately deleting all keys now, we mark them for deletion in ten seconds.
1733 // In the case where the user simultaneously removes their DDNS host name and the key
1734 // for it, this gives mDNSResponder ten seconds to gracefully delete the name from the
1735 // server before it loses access to the necessary key. Otherwise, we'd leave orphaned
1736 // address records behind that we no longer have permission to delete.
1737
1738 for (ptr = m->AuthInfoList; ptr; ptr = ptr->next)
1739 ptr->deltime = NonZeroTime(m->timenow + mDNSPlatformOneSecond*10);
1740
1741 GetDDNSFQDN( &fqdn );
1742
1743 if ( fqdn.c[ 0 ] )
1744 {
1745 SetDomainSecret( m, &fqdn );
1746 }
1747
1748 GetDDNSDomains( &regDomains, kServiceParametersNode TEXT("\\DynDNS\\Setup\\") kServiceDynDNSRegistrationDomains );
1749
1750 while ( regDomains )
1751 {
1752 DNameListElem * current = regDomains;
1753 SetDomainSecret( m, &current->name );
1754 regDomains = regDomains->next;
1755 free( current );
1756 }
1757 }
1758
1759
1760 //===========================================================================================================================
1761 // SetSearchDomainList
1762 //===========================================================================================================================
1763
1764 mDNSlocal void SetDomainFromDHCP( void );
1765 mDNSlocal void SetReverseMapSearchDomainList( void );
1766
1767 mDNSlocal void
1768 SetSearchDomainList( void )
1769 {
1770 char * searchList = NULL;
1771 DWORD searchListLen;
1772 //DNameListElem * head = NULL;
1773 //DNameListElem * current = NULL;
1774 char * tok;
1775 HKEY key;
1776 mStatus err;
1777
1778 err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters"), &key );
1779 require_noerr( err, exit );
1780
1781 err = RegQueryString( key, "SearchList", &searchList, &searchListLen, NULL );
1782 require_noerr( err, exit );
1783
1784 // Windows separates the search domains with ','
1785
1786 tok = strtok( searchList, "," );
1787 while ( tok )
1788 {
1789 if ( ( strcmp( tok, "" ) != 0 ) && ( strcmp( tok, "." ) != 0 ) )
1790 mDNS_AddSearchDomain_CString(tok, mDNSNULL);
1791 tok = strtok( NULL, "," );
1792 }
1793
1794 exit:
1795
1796 if ( searchList )
1797 {
1798 free( searchList );
1799 }
1800
1801 if ( key )
1802 {
1803 RegCloseKey( key );
1804 }
1805
1806 SetDomainFromDHCP();
1807 SetReverseMapSearchDomainList();
1808 }
1809
1810
1811 //===========================================================================================================================
1812 // SetReverseMapSearchDomainList
1813 //===========================================================================================================================
1814
1815 mDNSlocal void
1816 SetReverseMapSearchDomainList( void )
1817 {
1818 struct ifaddrs * ifa;
1819
1820 ifa = myGetIfAddrs( 1 );
1821 while (ifa)
1822 {
1823 mDNSAddr addr;
1824
1825 if (ifa->ifa_addr->sa_family == AF_INET && !SetupAddr(&addr, ifa->ifa_addr) && !(ifa->ifa_flags & IFF_LOOPBACK) && ifa->ifa_netmask)
1826 {
1827 mDNSAddr netmask;
1828 char buffer[256];
1829
1830 if (!SetupAddr(&netmask, ifa->ifa_netmask))
1831 {
1832 sprintf(buffer, "%d.%d.%d.%d.in-addr.arpa.", addr.ip.v4.b[3] & netmask.ip.v4.b[3],
1833 addr.ip.v4.b[2] & netmask.ip.v4.b[2],
1834 addr.ip.v4.b[1] & netmask.ip.v4.b[1],
1835 addr.ip.v4.b[0] & netmask.ip.v4.b[0]);
1836 mDNS_AddSearchDomain_CString(buffer, mDNSNULL);
1837 }
1838 }
1839
1840 ifa = ifa->ifa_next;
1841 }
1842
1843 return;
1844 }
1845
1846
1847 //===========================================================================================================================
1848 // SetDNSServers
1849 //===========================================================================================================================
1850
1851 mDNSlocal void
1852 SetDNSServers( mDNS *const m )
1853 {
1854 PIP_PER_ADAPTER_INFO pAdapterInfo = NULL;
1855 FIXED_INFO * fixedInfo = NULL;
1856 ULONG bufLen = 0;
1857 IP_ADDR_STRING * dnsServerList;
1858 IP_ADDR_STRING * ipAddr;
1859 DWORD index;
1860 int i = 0;
1861 mStatus err = kUnknownErr;
1862
1863 // Get the primary interface.
1864
1865 index = GetPrimaryInterface();
1866
1867 // This should have the interface index of the primary index. Fall back in cases where
1868 // it can't be determined.
1869
1870 if ( index )
1871 {
1872 bufLen = 0;
1873
1874 for ( i = 0; i < 100; i++ )
1875 {
1876 err = GetPerAdapterInfo( index, pAdapterInfo, &bufLen );
1877
1878 if ( err != ERROR_BUFFER_OVERFLOW )
1879 {
1880 break;
1881 }
1882
1883 pAdapterInfo = (PIP_PER_ADAPTER_INFO) realloc( pAdapterInfo, bufLen );
1884 require_action( pAdapterInfo, exit, err = mStatus_NoMemoryErr );
1885 }
1886
1887 require_noerr( err, exit );
1888
1889 dnsServerList = &pAdapterInfo->DnsServerList;
1890 }
1891 else
1892 {
1893 bufLen = sizeof( FIXED_INFO );
1894
1895 for ( i = 0; i < 100; i++ )
1896 {
1897 if ( fixedInfo )
1898 {
1899 GlobalFree( fixedInfo );
1900 fixedInfo = NULL;
1901 }
1902
1903 fixedInfo = (FIXED_INFO*) GlobalAlloc( GPTR, bufLen );
1904 require_action( fixedInfo, exit, err = mStatus_NoMemoryErr );
1905
1906 err = GetNetworkParams( fixedInfo, &bufLen );
1907
1908 if ( err != ERROR_BUFFER_OVERFLOW )
1909 {
1910 break;
1911 }
1912 }
1913
1914 require_noerr( err, exit );
1915
1916 dnsServerList = &fixedInfo->DnsServerList;
1917 }
1918
1919 for ( ipAddr = dnsServerList; ipAddr; ipAddr = ipAddr->Next )
1920 {
1921 mDNSAddr addr;
1922 err = StringToAddress( &addr, ipAddr->IpAddress.String );
1923 if ( !err ) mDNS_AddDNSServer(m, mDNSNULL, mDNSInterface_Any, &addr, UnicastDNSPort, mDNSfalse, DEFAULT_UDNS_TIMEOUT, mDNSfalse, 0);
1924 }
1925
1926 exit:
1927
1928 if ( pAdapterInfo )
1929 {
1930 free( pAdapterInfo );
1931 }
1932
1933 if ( fixedInfo )
1934 {
1935 GlobalFree( fixedInfo );
1936 }
1937 }
1938
1939
1940 //===========================================================================================================================
1941 // SetDomainFromDHCP
1942 //===========================================================================================================================
1943
1944 mDNSlocal void
1945 SetDomainFromDHCP( void )
1946 {
1947 int i = 0;
1948 IP_ADAPTER_INFO * pAdapterInfo;
1949 IP_ADAPTER_INFO * pAdapter;
1950 DWORD bufLen;
1951 DWORD index;
1952 HKEY key = NULL;
1953 LPSTR domain = NULL;
1954 DWORD dwSize;
1955 mStatus err = mStatus_NoError;
1956
1957 pAdapterInfo = NULL;
1958
1959 for ( i = 0; i < 100; i++ )
1960 {
1961 err = GetAdaptersInfo( pAdapterInfo, &bufLen);
1962
1963 if ( err != ERROR_BUFFER_OVERFLOW )
1964 {
1965 break;
1966 }
1967
1968 pAdapterInfo = (IP_ADAPTER_INFO*) realloc( pAdapterInfo, bufLen );
1969 require_action( pAdapterInfo, exit, err = kNoMemoryErr );
1970 }
1971
1972 require_noerr( err, exit );
1973
1974 index = GetPrimaryInterface();
1975
1976 for ( pAdapter = pAdapterInfo; pAdapter; pAdapter = pAdapter->Next )
1977 {
1978 if ( pAdapter->IpAddressList.IpAddress.String &&
1979 pAdapter->IpAddressList.IpAddress.String[0] &&
1980 pAdapter->GatewayList.IpAddress.String &&
1981 pAdapter->GatewayList.IpAddress.String[0] &&
1982 ( !index || ( pAdapter->Index == index ) ) )
1983 {
1984 // Found one that will work
1985
1986 char keyName[1024];
1987
1988 _snprintf( keyName, 1024, "%s%s", "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\", pAdapter->AdapterName );
1989
1990 err = RegCreateKeyA( HKEY_LOCAL_MACHINE, keyName, &key );
1991 require_noerr( err, exit );
1992
1993 err = RegQueryString( key, "Domain", &domain, &dwSize, NULL );
1994 check_noerr( err );
1995
1996 if ( !domain || !domain[0] )
1997 {
1998 if ( domain )
1999 {
2000 free( domain );
2001 domain = NULL;
2002 }
2003
2004 err = RegQueryString( key, "DhcpDomain", &domain, &dwSize, NULL );
2005 check_noerr( err );
2006 }
2007
2008 if ( domain && domain[0] ) mDNS_AddSearchDomain_CString(domain, mDNSNULL);
2009
2010 break;
2011 }
2012 }
2013
2014 exit:
2015
2016 if ( pAdapterInfo )
2017 {
2018 free( pAdapterInfo );
2019 }
2020
2021 if ( domain )
2022 {
2023 free( domain );
2024 }
2025
2026 if ( key )
2027 {
2028 RegCloseKey( key );
2029 }
2030 }
2031
2032
2033 //===========================================================================================================================
2034 // mDNSPlatformGetPrimaryInterface
2035 //===========================================================================================================================
2036
2037 mDNSexport mStatus
2038 mDNSPlatformGetPrimaryInterface( mDNS * const m, mDNSAddr * v4, mDNSAddr * v6, mDNSAddr * router )
2039 {
2040 IP_ADAPTER_INFO * pAdapterInfo;
2041 IP_ADAPTER_INFO * pAdapter;
2042 DWORD bufLen;
2043 int i;
2044 BOOL found;
2045 DWORD index;
2046 mStatus err = mStatus_NoError;
2047
2048 DEBUG_UNUSED( m );
2049
2050 *v6 = zeroAddr;
2051
2052 pAdapterInfo = NULL;
2053 bufLen = 0;
2054 found = FALSE;
2055
2056 for ( i = 0; i < 100; i++ )
2057 {
2058 err = GetAdaptersInfo( pAdapterInfo, &bufLen);
2059
2060 if ( err != ERROR_BUFFER_OVERFLOW )
2061 {
2062 break;
2063 }
2064
2065 pAdapterInfo = (IP_ADAPTER_INFO*) realloc( pAdapterInfo, bufLen );
2066 require_action( pAdapterInfo, exit, err = kNoMemoryErr );
2067 }
2068
2069 require_noerr( err, exit );
2070
2071 index = GetPrimaryInterface();
2072
2073 for ( pAdapter = pAdapterInfo; pAdapter; pAdapter = pAdapter->Next )
2074 {
2075 if ( pAdapter->IpAddressList.IpAddress.String &&
2076 pAdapter->IpAddressList.IpAddress.String[0] &&
2077 pAdapter->GatewayList.IpAddress.String &&
2078 pAdapter->GatewayList.IpAddress.String[0] &&
2079 ( StringToAddress( v4, pAdapter->IpAddressList.IpAddress.String ) == mStatus_NoError ) &&
2080 ( StringToAddress( router, pAdapter->GatewayList.IpAddress.String ) == mStatus_NoError ) &&
2081 ( !index || ( pAdapter->Index == index ) ) )
2082 {
2083 // Found one that will work
2084
2085 if ( pAdapter->AddressLength == sizeof( m->PrimaryMAC ) )
2086 {
2087 memcpy( &m->PrimaryMAC, pAdapter->Address, pAdapter->AddressLength );
2088 }
2089
2090 found = TRUE;
2091 break;
2092 }
2093 }
2094
2095 exit:
2096
2097 if ( pAdapterInfo )
2098 {
2099 free( pAdapterInfo );
2100 }
2101
2102 return err;
2103 }
2104
2105 mDNSexport void mDNSPlatformSendKeepalive(mDNSAddr *sadd, mDNSAddr *dadd, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu32 seq, mDNSu32 ack, mDNSu16 win)
2106 {
2107 (void) sadd; // Unused
2108 (void) dadd; // Unused
2109 (void) lport; // Unused
2110 (void) rport; // Unused
2111 (void) seq; // Unused
2112 (void) ack; // Unused
2113 (void) win; // Unused
2114 }
2115
2116 mDNSexport mStatus mDNSPlatformRetrieveTCPInfo(mDNS *const m, mDNSAddr *laddr, mDNSIPPort *lport, mDNSAddr *raddr, mDNSIPPort *rport, mDNSTCPInfo *mti)
2117 {
2118 (void) m; // Unused
2119 (void) laddr; // Unused
2120 (void) raddr; // Unused
2121 (void) lport; // Unused
2122 (void) rport; // Unused
2123 (void) mti; // Unused
2124 }
2125
2126 #if 0
2127 #pragma mark -
2128 #endif
2129
2130 //===========================================================================================================================
2131 // debugf_
2132 //===========================================================================================================================
2133 #if( MDNS_DEBUGMSGS )
2134 mDNSexport void debugf_( const char *inFormat, ... )
2135 {
2136 char buffer[ 512 ];
2137 va_list args;
2138 mDNSu32 length;
2139
2140 va_start( args, inFormat );
2141 length = mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
2142 va_end( args );
2143
2144 dlog( kDebugLevelInfo, "%s\n", buffer );
2145 }
2146 #endif
2147
2148 //===========================================================================================================================
2149 // verbosedebugf_
2150 //===========================================================================================================================
2151
2152 #if( MDNS_DEBUGMSGS > 1 )
2153 mDNSexport void verbosedebugf_( const char *inFormat, ... )
2154 {
2155 char buffer[ 512 ];
2156 va_list args;
2157 mDNSu32 length;
2158
2159 va_start( args, inFormat );
2160 length = mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
2161 va_end( args );
2162
2163 dlog( kDebugLevelVerbose, "%s\n", buffer );
2164 }
2165 #endif
2166
2167
2168 #if 0
2169 #pragma mark -
2170 #pragma mark == Platform Internals ==
2171 #endif
2172
2173
2174 //===========================================================================================================================
2175 // SetupNiceName
2176 //===========================================================================================================================
2177
2178 mStatus SetupNiceName( mDNS * const inMDNS )
2179 {
2180 HKEY descKey = NULL;
2181 char utf8[ 256 ];
2182 LPCTSTR s;
2183 LPWSTR joinName;
2184 NETSETUP_JOIN_STATUS joinStatus;
2185 mStatus err = 0;
2186 DWORD namelen;
2187 BOOL ok;
2188
2189 check( inMDNS );
2190
2191 // Set up the nice name.
2192 utf8[0] = '\0';
2193
2194 // First try and open the registry key that contains the computer description value
2195 s = TEXT("SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\parameters");
2196 err = RegOpenKeyEx( HKEY_LOCAL_MACHINE, s, 0, KEY_READ, &descKey);
2197 check_translated_errno( err == 0, errno_compat(), kNameErr );
2198
2199 if ( !err )
2200 {
2201 TCHAR desc[256];
2202 DWORD descSize = sizeof( desc );
2203
2204 // look for the computer description
2205 err = RegQueryValueEx( descKey, TEXT("srvcomment"), 0, NULL, (LPBYTE) &desc, &descSize);
2206
2207 if ( !err )
2208 {
2209 err = TCHARtoUTF8( desc, utf8, sizeof( utf8 ) );
2210 }
2211
2212 if ( err )
2213 {
2214 utf8[ 0 ] = '\0';
2215 }
2216 }
2217
2218 // if we can't find it in the registry, then use the hostname of the machine
2219 if ( err || ( utf8[ 0 ] == '\0' ) )
2220 {
2221 TCHAR hostname[256];
2222
2223 namelen = sizeof( hostname ) / sizeof( TCHAR );
2224
2225 ok = GetComputerNameExW( ComputerNamePhysicalDnsHostname, hostname, &namelen );
2226 err = translate_errno( ok, (mStatus) GetLastError(), kNameErr );
2227 check_noerr( err );
2228
2229 if( !err )
2230 {
2231 err = TCHARtoUTF8( hostname, utf8, sizeof( utf8 ) );
2232 }
2233
2234 if ( err )
2235 {
2236 utf8[ 0 ] = '\0';
2237 }
2238 }
2239
2240 // if we can't get the hostname
2241 if ( err || ( utf8[ 0 ] == '\0' ) )
2242 {
2243 // Invalidate name so fall back to a default name.
2244
2245 strcpy( utf8, kMDNSDefaultName );
2246 }
2247
2248 utf8[ sizeof( utf8 ) - 1 ] = '\0';
2249 inMDNS->nicelabel.c[ 0 ] = (mDNSu8) (strlen( utf8 ) < MAX_DOMAIN_LABEL ? strlen( utf8 ) : MAX_DOMAIN_LABEL);
2250 memcpy( &inMDNS->nicelabel.c[ 1 ], utf8, inMDNS->nicelabel.c[ 0 ] );
2251
2252 dlog( kDebugLevelInfo, DEBUG_NAME "nice name \"%.*s\"\n", inMDNS->nicelabel.c[ 0 ], &inMDNS->nicelabel.c[ 1 ] );
2253
2254 if ( descKey )
2255 {
2256 RegCloseKey( descKey );
2257 }
2258
2259 ZeroMemory( inMDNS->p->nbname, sizeof( inMDNS->p->nbname ) );
2260 ZeroMemory( inMDNS->p->nbdomain, sizeof( inMDNS->p->nbdomain ) );
2261
2262 namelen = sizeof( inMDNS->p->nbname );
2263 ok = GetComputerNameExA( ComputerNamePhysicalNetBIOS, inMDNS->p->nbname, &namelen );
2264 check( ok );
2265 if ( ok ) dlog( kDebugLevelInfo, DEBUG_NAME "netbios name \"%s\"\n", inMDNS->p->nbname );
2266
2267 err = NetGetJoinInformation( NULL, &joinName, &joinStatus );
2268 check ( err == NERR_Success );
2269 if ( err == NERR_Success )
2270 {
2271 if ( ( joinStatus == NetSetupWorkgroupName ) || ( joinStatus == NetSetupDomainName ) )
2272 {
2273 err = TCHARtoUTF8( joinName, inMDNS->p->nbdomain, sizeof( inMDNS->p->nbdomain ) );
2274 check( !err );
2275 if ( !err ) dlog( kDebugLevelInfo, DEBUG_NAME "netbios domain/workgroup \"%s\"\n", inMDNS->p->nbdomain );
2276 }
2277
2278 NetApiBufferFree( joinName );
2279 joinName = NULL;
2280 }
2281
2282 err = 0;
2283
2284 return( err );
2285 }
2286
2287 //===========================================================================================================================
2288 // SetupHostName
2289 //===========================================================================================================================
2290
2291 mDNSlocal mStatus SetupHostName( mDNS * const inMDNS )
2292 {
2293 mStatus err = 0;
2294 char tempString[ 256 ];
2295 DWORD tempStringLen;
2296 domainlabel tempLabel;
2297 BOOL ok;
2298
2299 check( inMDNS );
2300
2301 // Set up the nice name.
2302 tempString[ 0 ] = '\0';
2303
2304 // use the hostname of the machine
2305 tempStringLen = sizeof( tempString );
2306 ok = GetComputerNameExA( ComputerNamePhysicalDnsHostname, tempString, &tempStringLen );
2307 err = translate_errno( ok, (mStatus) GetLastError(), kNameErr );
2308 check_noerr( err );
2309
2310 // if we can't get the hostname
2311 if( err || ( tempString[ 0 ] == '\0' ) )
2312 {
2313 // Invalidate name so fall back to a default name.
2314
2315 strcpy( tempString, kMDNSDefaultName );
2316 }
2317
2318 tempString[ sizeof( tempString ) - 1 ] = '\0';
2319 tempLabel.c[ 0 ] = (mDNSu8) (strlen( tempString ) < MAX_DOMAIN_LABEL ? strlen( tempString ) : MAX_DOMAIN_LABEL );
2320 memcpy( &tempLabel.c[ 1 ], tempString, tempLabel.c[ 0 ] );
2321
2322 // Set up the host name.
2323
2324 ConvertUTF8PstringToRFC1034HostLabel( tempLabel.c, &inMDNS->hostlabel );
2325 if( inMDNS->hostlabel.c[ 0 ] == 0 )
2326 {
2327 // Nice name has no characters that are representable as an RFC1034 name (e.g. Japanese) so use the default.
2328
2329 MakeDomainLabelFromLiteralString( &inMDNS->hostlabel, kMDNSDefaultName );
2330 }
2331
2332 check( inMDNS->hostlabel.c[ 0 ] != 0 );
2333
2334 mDNS_SetFQDN( inMDNS );
2335
2336 dlog( kDebugLevelInfo, DEBUG_NAME "host name \"%.*s\"\n", inMDNS->hostlabel.c[ 0 ], &inMDNS->hostlabel.c[ 1 ] );
2337
2338 return( err );
2339 }
2340
2341 //===========================================================================================================================
2342 // SetupName
2343 //===========================================================================================================================
2344
2345 mDNSlocal mStatus SetupName( mDNS * const inMDNS )
2346 {
2347 mStatus err = 0;
2348
2349 check( inMDNS );
2350
2351 err = SetupNiceName( inMDNS );
2352 check_noerr( err );
2353
2354 err = SetupHostName( inMDNS );
2355 check_noerr( err );
2356
2357 return err;
2358 }
2359
2360
2361 //===========================================================================================================================
2362 // SetupInterfaceList
2363 //===========================================================================================================================
2364
2365 mStatus SetupInterfaceList( mDNS * const inMDNS )
2366 {
2367 mStatus err;
2368 mDNSInterfaceData ** next;
2369 mDNSInterfaceData * ifd;
2370 struct ifaddrs * addrs;
2371 struct ifaddrs * p;
2372 struct ifaddrs * loopbackv4;
2373 struct ifaddrs * loopbackv6;
2374 u_int flagMask;
2375 u_int flagTest;
2376 mDNSBool foundv4;
2377 mDNSBool foundv6;
2378 mDNSBool foundUnicastSock4DestAddr;
2379 mDNSBool foundUnicastSock6DestAddr;
2380
2381 dlog( kDebugLevelTrace, DEBUG_NAME "setting up interface list\n" );
2382 check( inMDNS );
2383 check( inMDNS->p );
2384
2385 inMDNS->p->registeredLoopback4 = mDNSfalse;
2386 inMDNS->p->nextDHCPLeaseExpires = 0x7FFFFFFF;
2387 addrs = NULL;
2388 foundv4 = mDNSfalse;
2389 foundv6 = mDNSfalse;
2390 foundUnicastSock4DestAddr = mDNSfalse;
2391 foundUnicastSock6DestAddr = mDNSfalse;
2392
2393 // Tear down any existing interfaces that may be set up.
2394
2395 TearDownInterfaceList( inMDNS );
2396
2397 // Set up the name of this machine.
2398
2399 err = SetupName( inMDNS );
2400 check_noerr( err );
2401
2402 // Set up IPv4 interface(s). We have to set up IPv4 first so any IPv6 interface with an IPv4-routable address
2403 // can refer to the IPv4 interface when it registers to allow DNS AAAA records over the IPv4 interface.
2404
2405 err = getifaddrs( &addrs );
2406 require_noerr( err, exit );
2407
2408 loopbackv4 = NULL;
2409 loopbackv6 = NULL;
2410 next = &inMDNS->p->interfaceList;
2411
2412 flagMask = IFF_UP | IFF_MULTICAST;
2413 flagTest = IFF_UP | IFF_MULTICAST;
2414
2415 #if( MDNS_WINDOWS_ENABLE_IPV4 )
2416 for( p = addrs; p; p = p->ifa_next )
2417 {
2418 if( !p->ifa_addr || ( p->ifa_addr->sa_family != AF_INET ) || ( ( p->ifa_flags & flagMask ) != flagTest ) )
2419 {
2420 continue;
2421 }
2422 if( p->ifa_flags & IFF_LOOPBACK )
2423 {
2424 if( !loopbackv4 )
2425 {
2426 loopbackv4 = p;
2427 }
2428 continue;
2429 }
2430 dlog( kDebugLevelVerbose, DEBUG_NAME "Interface %40s (0x%08X) %##a\n",
2431 p->ifa_name ? p->ifa_name : "<null>", p->ifa_extra.index, p->ifa_addr );
2432
2433 err = SetupInterface( inMDNS, p, &ifd );
2434 require_noerr( err, exit );
2435
2436 // If this guy is point-to-point (ifd->interfaceInfo.McastTxRx == 0 ) we still want to
2437 // register him, but we also want to note that we haven't found a v4 interface
2438 // so that we register loopback so same host operations work
2439
2440 if ( ifd->interfaceInfo.McastTxRx == mDNStrue )
2441 {
2442 foundv4 = mDNStrue;
2443 }
2444
2445 if ( p->ifa_dhcpEnabled && ( p->ifa_dhcpLeaseExpires < inMDNS->p->nextDHCPLeaseExpires ) )
2446 {
2447 inMDNS->p->nextDHCPLeaseExpires = p->ifa_dhcpLeaseExpires;
2448 }
2449
2450 // If we're on a platform that doesn't have WSARecvMsg(), there's no way
2451 // of determing the destination address of a packet that is sent to us.
2452 // For multicast packets, that's easy to determine. But for the unicast
2453 // sockets, we'll fake it by taking the address of the first interface
2454 // that is successfully setup.
2455
2456 if ( !foundUnicastSock4DestAddr )
2457 {
2458 inMDNS->p->unicastSock4.addr = ifd->interfaceInfo.ip;
2459 foundUnicastSock4DestAddr = TRUE;
2460 }
2461
2462 *next = ifd;
2463 next = &ifd->next;
2464 ++inMDNS->p->interfaceCount;
2465 }
2466 #endif
2467
2468 // Set up IPv6 interface(s) after IPv4 is set up (see IPv4 notes above for reasoning).
2469
2470 #if( MDNS_WINDOWS_ENABLE_IPV6 )
2471
2472 if ( gEnableIPv6 )
2473 {
2474 for( p = addrs; p; p = p->ifa_next )
2475 {
2476 if( !p->ifa_addr || ( p->ifa_addr->sa_family != AF_INET6 ) || ( ( p->ifa_flags & flagMask ) != flagTest ) )
2477 {
2478 continue;
2479 }
2480 if( p->ifa_flags & IFF_LOOPBACK )
2481 {
2482 if( !loopbackv6 )
2483 {
2484 loopbackv6 = p;
2485 }
2486 continue;
2487 }
2488 dlog( kDebugLevelVerbose, DEBUG_NAME "Interface %40s (0x%08X) %##a\n",
2489 p->ifa_name ? p->ifa_name : "<null>", p->ifa_extra.index, p->ifa_addr );
2490
2491 err = SetupInterface( inMDNS, p, &ifd );
2492 require_noerr( err, exit );
2493
2494 // If this guy is point-to-point (ifd->interfaceInfo.McastTxRx == 0 ) we still want to
2495 // register him, but we also want to note that we haven't found a v4 interface
2496 // so that we register loopback so same host operations work
2497
2498 if ( ifd->interfaceInfo.McastTxRx == mDNStrue )
2499 {
2500 foundv6 = mDNStrue;
2501 }
2502
2503 // If we're on a platform that doesn't have WSARecvMsg(), there's no way
2504 // of determing the destination address of a packet that is sent to us.
2505 // For multicast packets, that's easy to determine. But for the unicast
2506 // sockets, we'll fake it by taking the address of the first interface
2507 // that is successfully setup.
2508
2509 if ( !foundUnicastSock6DestAddr )
2510 {
2511 inMDNS->p->unicastSock6.addr = ifd->interfaceInfo.ip;
2512 foundUnicastSock6DestAddr = TRUE;
2513 }
2514
2515 *next = ifd;
2516 next = &ifd->next;
2517 ++inMDNS->p->interfaceCount;
2518 }
2519 }
2520
2521 #endif
2522
2523 // If there are no real interfaces, but there is a loopback interface, use that so same-machine operations work.
2524
2525 #if( !MDNS_WINDOWS_ENABLE_IPV4 && !MDNS_WINDOWS_ENABLE_IPV6 )
2526
2527 flagMask |= IFF_LOOPBACK;
2528 flagTest |= IFF_LOOPBACK;
2529
2530 for( p = addrs; p; p = p->ifa_next )
2531 {
2532 if( !p->ifa_addr || ( ( p->ifa_flags & flagMask ) != flagTest ) )
2533 {
2534 continue;
2535 }
2536 if( ( p->ifa_addr->sa_family != AF_INET ) && ( p->ifa_addr->sa_family != AF_INET6 ) )
2537 {
2538 continue;
2539 }
2540
2541 v4loopback = p;
2542 break;
2543 }
2544
2545 #endif
2546
2547 if ( !foundv4 && loopbackv4 )
2548 {
2549 dlog( kDebugLevelInfo, DEBUG_NAME "Interface %40s (0x%08X) %##a\n",
2550 loopbackv4->ifa_name ? loopbackv4->ifa_name : "<null>", loopbackv4->ifa_extra.index, loopbackv4->ifa_addr );
2551
2552 err = SetupInterface( inMDNS, loopbackv4, &ifd );
2553 require_noerr( err, exit );
2554
2555 inMDNS->p->registeredLoopback4 = mDNStrue;
2556
2557 #if( MDNS_WINDOWS_ENABLE_IPV4 )
2558
2559 // If we're on a platform that doesn't have WSARecvMsg(), there's no way
2560 // of determing the destination address of a packet that is sent to us.
2561 // For multicast packets, that's easy to determine. But for the unicast
2562 // sockets, we'll fake it by taking the address of the first interface
2563 // that is successfully setup.
2564
2565 if ( !foundUnicastSock4DestAddr )
2566 {
2567 inMDNS->p->unicastSock4.addr = ifd->sock.addr;
2568 foundUnicastSock4DestAddr = TRUE;
2569 }
2570 #endif
2571
2572 *next = ifd;
2573 next = &ifd->next;
2574 ++inMDNS->p->interfaceCount;
2575 }
2576
2577 if ( !foundv6 && loopbackv6 )
2578 {
2579 dlog( kDebugLevelInfo, DEBUG_NAME "Interface %40s (0x%08X) %##a\n",
2580 loopbackv6->ifa_name ? loopbackv6->ifa_name : "<null>", loopbackv6->ifa_extra.index, loopbackv6->ifa_addr );
2581
2582 err = SetupInterface( inMDNS, loopbackv6, &ifd );
2583 require_noerr( err, exit );
2584
2585 #if( MDNS_WINDOWS_ENABLE_IPV6 )
2586
2587 if ( gEnableIPv6 )
2588 {
2589 // If we're on a platform that doesn't have WSARecvMsg(), there's no way
2590 // of determing the destination address of a packet that is sent to us.
2591 // For multicast packets, that's easy to determine. But for the unicast
2592 // sockets, we'll fake it by taking the address of the first interface
2593 // that is successfully setup.
2594
2595 if ( !foundUnicastSock6DestAddr )
2596 {
2597 inMDNS->p->unicastSock6.addr = ifd->sock.addr;
2598 foundUnicastSock6DestAddr = TRUE;
2599 }
2600 }
2601
2602 #endif
2603
2604 *next = ifd;
2605 next = &ifd->next;
2606 ++inMDNS->p->interfaceCount;
2607 }
2608
2609 CheckFileShares( inMDNS );
2610
2611 exit:
2612 if( err )
2613 {
2614 TearDownInterfaceList( inMDNS );
2615 }
2616 if( addrs )
2617 {
2618 freeifaddrs( addrs );
2619 }
2620 dlog( kDebugLevelTrace, DEBUG_NAME "setting up interface list done (err=%d %m)\n", err, err );
2621 return( err );
2622 }
2623
2624 //===========================================================================================================================
2625 // TearDownInterfaceList
2626 //===========================================================================================================================
2627
2628 mStatus TearDownInterfaceList( mDNS * const inMDNS )
2629 {
2630 mDNSInterfaceData ** p;
2631 mDNSInterfaceData * ifd;
2632
2633 dlog( kDebugLevelTrace, DEBUG_NAME "tearing down interface list\n" );
2634 check( inMDNS );
2635 check( inMDNS->p );
2636
2637 // Free any interfaces that were previously marked inactive and are no longer referenced by the mDNS cache.
2638 // Interfaces are marked inactive, but not deleted immediately if they were still referenced by the mDNS cache
2639 // so that remove events that occur after an interface goes away can still report the correct interface.
2640
2641 p = &inMDNS->p->inactiveInterfaceList;
2642 while( *p )
2643 {
2644 ifd = *p;
2645 if( NumCacheRecordsForInterfaceID( inMDNS, (mDNSInterfaceID) ifd ) > 0 )
2646 {
2647 p = &ifd->next;
2648 continue;
2649 }
2650
2651 dlog( kDebugLevelInfo, DEBUG_NAME "freeing unreferenced, inactive interface %#p %#a\n", ifd, &ifd->interfaceInfo.ip );
2652 *p = ifd->next;
2653
2654 QueueUserAPC( ( PAPCFUNC ) FreeInterface, inMDNS->p->mainThread, ( ULONG_PTR ) ifd );
2655 }
2656
2657 // Tear down all the interfaces.
2658
2659 while( inMDNS->p->interfaceList )
2660 {
2661 ifd = inMDNS->p->interfaceList;
2662 inMDNS->p->interfaceList = ifd->next;
2663
2664 TearDownInterface( inMDNS, ifd );
2665 }
2666 inMDNS->p->interfaceCount = 0;
2667
2668 dlog( kDebugLevelTrace, DEBUG_NAME "tearing down interface list done\n" );
2669 return( mStatus_NoError );
2670 }
2671
2672 //===========================================================================================================================
2673 // SetupInterface
2674 //===========================================================================================================================
2675
2676 mDNSlocal mStatus SetupInterface( mDNS * const inMDNS, const struct ifaddrs *inIFA, mDNSInterfaceData **outIFD )
2677 {
2678 mDNSInterfaceData * ifd;
2679 mDNSInterfaceData * p;
2680 mStatus err;
2681
2682 ifd = NULL;
2683 dlog( kDebugLevelTrace, DEBUG_NAME "setting up interface\n" );
2684 check( inMDNS );
2685 check( inMDNS->p );
2686 check( inIFA );
2687 check( inIFA->ifa_addr );
2688 check( outIFD );
2689
2690 // Allocate memory for the interface and initialize it.
2691
2692 ifd = (mDNSInterfaceData *) calloc( 1, sizeof( *ifd ) );
2693 require_action( ifd, exit, err = mStatus_NoMemoryErr );
2694 ifd->sock.fd = kInvalidSocketRef;
2695 ifd->sock.ifd = ifd;
2696 ifd->sock.next = NULL;
2697 ifd->sock.m = inMDNS;
2698 ifd->index = inIFA->ifa_extra.index;
2699 ifd->scopeID = inIFA->ifa_extra.index;
2700 check( strlen( inIFA->ifa_name ) < sizeof( ifd->name ) );
2701 strncpy( ifd->name, inIFA->ifa_name, sizeof( ifd->name ) - 1 );
2702 ifd->name[ sizeof( ifd->name ) - 1 ] = '\0';
2703
2704 strncpy(ifd->interfaceInfo.ifname, inIFA->ifa_name, sizeof(ifd->interfaceInfo.ifname));
2705 ifd->interfaceInfo.ifname[sizeof(ifd->interfaceInfo.ifname)-1] = 0;
2706
2707 // We always send and receive using IPv4, but to reduce traffic, we send and receive using IPv6 only on interfaces
2708 // that have no routable IPv4 address. Having a routable IPv4 address assigned is a reasonable indicator of being
2709 // on a large configured network, which means there's a good chance that most or all the other devices on that
2710 // network should also have v4. By doing this we lose the ability to talk to true v6-only devices on that link,
2711 // but we cut the packet rate in half. At this time, reducing the packet rate is more important than v6-only
2712 // devices on a large configured network, so we are willing to make that sacrifice.
2713
2714 ifd->interfaceInfo.McastTxRx = ( ( inIFA->ifa_flags & IFF_MULTICAST ) && !( inIFA->ifa_flags & IFF_POINTTOPOINT ) ) ? mDNStrue : mDNSfalse;
2715 ifd->interfaceInfo.InterfaceID = NULL;
2716
2717 for( p = inMDNS->p->interfaceList; p; p = p->next )
2718 {
2719 if ( strcmp( p->name, ifd->name ) == 0 )
2720 {
2721 if (!ifd->interfaceInfo.InterfaceID)
2722 {
2723 ifd->interfaceInfo.InterfaceID = (mDNSInterfaceID) p;
2724 }
2725
2726 if ( ( inIFA->ifa_addr->sa_family != AF_INET ) &&
2727 ( p->interfaceInfo.ip.type == mDNSAddrType_IPv4 ) &&
2728 ( p->interfaceInfo.ip.ip.v4.b[ 0 ] != 169 || p->interfaceInfo.ip.ip.v4.b[ 1 ] != 254 ) )
2729 {
2730 ifd->interfaceInfo.McastTxRx = mDNSfalse;
2731 }
2732
2733 break;
2734 }
2735 }
2736
2737 if ( !ifd->interfaceInfo.InterfaceID )
2738 {
2739 ifd->interfaceInfo.InterfaceID = (mDNSInterfaceID) ifd;
2740 }
2741
2742 // Set up a socket for this interface (if needed).
2743
2744 if( ifd->interfaceInfo.McastTxRx )
2745 {
2746 DWORD size;
2747
2748 err = SetupSocket( inMDNS, inIFA->ifa_addr, MulticastDNSPort, &ifd->sock.fd );
2749 require_noerr( err, exit );
2750 ifd->sock.addr = ( inIFA->ifa_addr->sa_family == AF_INET6 ) ? AllDNSLinkGroup_v6 : AllDNSLinkGroup_v4;
2751 ifd->sock.port = MulticastDNSPort;
2752
2753 // Get a ptr to the WSARecvMsg function, if supported. Otherwise, we'll fallback to recvfrom.
2754
2755 err = WSAIoctl( ifd->sock.fd, SIO_GET_EXTENSION_FUNCTION_POINTER, &kWSARecvMsgGUID, sizeof( kWSARecvMsgGUID ), &ifd->sock.recvMsgPtr, sizeof( ifd->sock.recvMsgPtr ), &size, NULL, NULL );
2756
2757 if ( err )
2758 {
2759 ifd->sock.recvMsgPtr = NULL;
2760 }
2761 }
2762
2763 if ( inIFA->ifa_dhcpEnabled && ( inIFA->ifa_dhcpLeaseExpires < inMDNS->p->nextDHCPLeaseExpires ) )
2764 {
2765 inMDNS->p->nextDHCPLeaseExpires = inIFA->ifa_dhcpLeaseExpires;
2766 }
2767
2768 ifd->interfaceInfo.NetWake = inIFA->ifa_womp;
2769
2770 // Register this interface with mDNS.
2771
2772 err = SockAddrToMDNSAddr( inIFA->ifa_addr, &ifd->interfaceInfo.ip, NULL );
2773 require_noerr( err, exit );
2774
2775 err = SockAddrToMDNSAddr( inIFA->ifa_netmask, &ifd->interfaceInfo.mask, NULL );
2776 require_noerr( err, exit );
2777
2778 memcpy( ifd->interfaceInfo.MAC.b, inIFA->ifa_physaddr, sizeof( ifd->interfaceInfo.MAC.b ) );
2779
2780 ifd->interfaceInfo.Advertise = ( mDNSu8 ) inMDNS->AdvertiseLocalAddresses;
2781
2782 if ( ifd->sock.fd != kInvalidSocketRef )
2783 {
2784 err = mDNSPollRegisterSocket( ifd->sock.fd, FD_READ, UDPSocketNotification, &ifd->sock );
2785 require_noerr( err, exit );
2786 }
2787
2788 err = mDNS_RegisterInterface( inMDNS, &ifd->interfaceInfo, mDNSfalse );
2789 require_noerr( err, exit );
2790 ifd->hostRegistered = mDNStrue;
2791
2792 dlog( kDebugLevelInfo, DEBUG_NAME "Registered interface %##a with mDNS\n", inIFA->ifa_addr );
2793
2794 // Success!
2795
2796 *outIFD = ifd;
2797 ifd = NULL;
2798
2799 exit:
2800
2801 if( ifd )
2802 {
2803 TearDownInterface( inMDNS, ifd );
2804 }
2805 dlog( kDebugLevelTrace, DEBUG_NAME "setting up interface done (err=%d %m)\n", err, err );
2806 return( err );
2807 }
2808
2809 //===========================================================================================================================
2810 // TearDownInterface
2811 //===========================================================================================================================
2812
2813 mDNSlocal mStatus TearDownInterface( mDNS * const inMDNS, mDNSInterfaceData *inIFD )
2814 {
2815 check( inMDNS );
2816 check( inIFD );
2817
2818 // Deregister this interface with mDNS.
2819
2820 dlog( kDebugLevelInfo, DEBUG_NAME "Deregistering interface %#a with mDNS\n", &inIFD->interfaceInfo.ip );
2821
2822 if( inIFD->hostRegistered )
2823 {
2824 inIFD->hostRegistered = mDNSfalse;
2825 mDNS_DeregisterInterface( inMDNS, &inIFD->interfaceInfo, mDNSfalse );
2826 }
2827
2828 // Tear down the multicast socket.
2829
2830 UDPCloseSocket( &inIFD->sock );
2831
2832 // If the interface is still referenced by items in the mDNS cache then put it on the inactive list. This keeps
2833 // the InterfaceID valid so remove events report the correct interface. If it is no longer referenced, free it.
2834
2835 if( NumCacheRecordsForInterfaceID( inMDNS, (mDNSInterfaceID) inIFD ) > 0 )
2836 {
2837 inIFD->next = inMDNS->p->inactiveInterfaceList;
2838 inMDNS->p->inactiveInterfaceList = inIFD;
2839 dlog( kDebugLevelInfo, DEBUG_NAME "deferring free of interface %#p %#a\n", inIFD, &inIFD->interfaceInfo.ip );
2840 }
2841 else
2842 {
2843 dlog( kDebugLevelInfo, DEBUG_NAME "freeing interface %#p %#a immediately\n", inIFD, &inIFD->interfaceInfo.ip );
2844 QueueUserAPC( ( PAPCFUNC ) FreeInterface, inMDNS->p->mainThread, ( ULONG_PTR ) inIFD );
2845 }
2846
2847 return( mStatus_NoError );
2848 }
2849
2850 mDNSlocal void CALLBACK FreeInterface( mDNSInterfaceData *inIFD )
2851 {
2852 free( inIFD );
2853 }
2854
2855 //===========================================================================================================================
2856 // SetupSocket
2857 //===========================================================================================================================
2858
2859 mDNSlocal mStatus SetupSocket( mDNS * const inMDNS, const struct sockaddr *inAddr, mDNSIPPort port, SocketRef *outSocketRef )
2860 {
2861 mStatus err;
2862 SocketRef sock;
2863 int option;
2864 DWORD bytesReturned = 0;
2865 BOOL behavior = FALSE;
2866
2867 DEBUG_UNUSED( inMDNS );
2868
2869 dlog( kDebugLevelTrace, DEBUG_NAME "setting up socket %##a\n", inAddr );
2870 check( inMDNS );
2871 check( outSocketRef );
2872
2873 // Set up an IPv4 or IPv6 UDP socket.
2874
2875 sock = socket( inAddr->sa_family, SOCK_DGRAM, IPPROTO_UDP );
2876 err = translate_errno( IsValidSocket( sock ), errno_compat(), kUnknownErr );
2877 require_noerr( err, exit );
2878
2879 // Turn on reuse address option so multiple servers can listen for Multicast DNS packets,
2880 // if we're creating a multicast socket
2881
2882 if ( !mDNSIPPortIsZero( port ) )
2883 {
2884 option = 1;
2885 err = setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, (char *) &option, sizeof( option ) );
2886 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2887 }
2888
2889 // <rdar://problem/7894393> Bonjour for Windows broken on Windows XP
2890 //
2891 // Not sure why, but the default behavior for sockets is to behave incorrectly
2892 // when using them in Overlapped I/O mode on XP. According to MSDN:
2893 //
2894 // SIO_UDP_CONNRESET (opcode setting: I, T==3)
2895 // Windows XP: Controls whether UDP PORT_UNREACHABLE messages are reported. Set to TRUE to enable reporting.
2896 // Set to FALSE to disable reporting.
2897 //
2898 // Packet traces from misbehaving Bonjour installations showed that ICMP port unreachable
2899 // messages were being sent to us after we sent out packets to a multicast address. This is clearly
2900 // incorrect behavior, but should be harmless. However, after receiving a port unreachable error, WinSock
2901 // will no longer receive any packets from that socket, which is not harmless. This behavior is only
2902 // seen on XP.
2903 //
2904 // So we turn off port unreachable reporting to make sure our sockets that are reading
2905 // multicast packets function correctly under all circumstances.
2906
2907 err = WSAIoctl( sock, SIO_UDP_CONNRESET, &behavior, sizeof(behavior), NULL, 0, &bytesReturned, NULL, NULL );
2908 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2909
2910 if( inAddr->sa_family == AF_INET )
2911 {
2912 mDNSv4Addr ipv4;
2913 struct sockaddr_in sa4;
2914 struct ip_mreq mreqv4;
2915
2916 // Bind the socket to the desired port
2917
2918 ipv4.NotAnInteger = ( (const struct sockaddr_in *) inAddr )->sin_addr.s_addr;
2919 mDNSPlatformMemZero( &sa4, sizeof( sa4 ) );
2920 sa4.sin_family = AF_INET;
2921 sa4.sin_port = port.NotAnInteger;
2922 sa4.sin_addr.s_addr = ipv4.NotAnInteger;
2923
2924 err = bind( sock, (struct sockaddr *) &sa4, sizeof( sa4 ) );
2925 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
2926
2927 // Turn on option to receive destination addresses and receiving interface.
2928
2929 option = 1;
2930 err = setsockopt( sock, IPPROTO_IP, IP_PKTINFO, (char *) &option, sizeof( option ) );
2931 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2932
2933 if ( !mDNSIPPortIsZero( port ) )
2934 {
2935 // Join the all-DNS multicast group so we receive Multicast DNS packets
2936
2937 mreqv4.imr_multiaddr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
2938 mreqv4.imr_interface.s_addr = ipv4.NotAnInteger;
2939 err = setsockopt( sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreqv4, sizeof( mreqv4 ) );
2940 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2941
2942 // Specify the interface to send multicast packets on this socket.
2943
2944 sa4.sin_addr.s_addr = ipv4.NotAnInteger;
2945 err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_IF, (char *) &sa4.sin_addr, sizeof( sa4.sin_addr ) );
2946 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2947
2948 // Enable multicast loopback so we receive multicast packets we send (for same-machine operations).
2949
2950 option = 1;
2951 err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &option, sizeof( option ) );
2952 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2953 }
2954
2955 // Send unicast packets with TTL 255 (helps against spoofing).
2956
2957 option = 255;
2958 err = setsockopt( sock, IPPROTO_IP, IP_TTL, (char *) &option, sizeof( option ) );
2959 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2960
2961 // Send multicast packets with TTL 255 (helps against spoofing).
2962
2963 option = 255;
2964 err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &option, sizeof( option ) );
2965 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2966
2967 }
2968 else if( inAddr->sa_family == AF_INET6 )
2969 {
2970 struct sockaddr_in6 * sa6p;
2971 struct sockaddr_in6 sa6;
2972 struct ipv6_mreq mreqv6;
2973
2974 sa6p = (struct sockaddr_in6 *) inAddr;
2975
2976 // Bind the socket to the desired port
2977
2978 mDNSPlatformMemZero( &sa6, sizeof( sa6 ) );
2979 sa6.sin6_family = AF_INET6;
2980 sa6.sin6_port = port.NotAnInteger;
2981 sa6.sin6_flowinfo = 0;
2982 sa6.sin6_addr = sa6p->sin6_addr;
2983 sa6.sin6_scope_id = sa6p->sin6_scope_id;
2984
2985 err = bind( sock, (struct sockaddr *) &sa6, sizeof( sa6 ) );
2986 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
2987
2988 // Turn on option to receive destination addresses and receiving interface.
2989
2990 option = 1;
2991 err = setsockopt( sock, IPPROTO_IPV6, IPV6_PKTINFO, (char *) &option, sizeof( option ) );
2992 check_translated_errno( err == 0, errno_compat(), kOptionErr );
2993
2994 // We only want to receive IPv6 packets (not IPv4-mapped IPv6 addresses) because we have a separate socket
2995 // for IPv4, but the IPv6 stack in Windows currently doesn't support IPv4-mapped IPv6 addresses and doesn't
2996 // support the IPV6_V6ONLY socket option so the following code would typically not be executed (or needed).
2997
2998 #if( defined( IPV6_V6ONLY ) )
2999 option = 1;
3000 err = setsockopt( sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &option, sizeof( option ) );
3001 check_translated_errno( err == 0, errno_compat(), kOptionErr );
3002 #endif
3003
3004 if ( !mDNSIPPortIsZero( port ) )
3005 {
3006 // Join the all-DNS multicast group so we receive Multicast DNS packets.
3007
3008 mreqv6.ipv6mr_multiaddr = *( (struct in6_addr *) &AllDNSLinkGroup_v6.ip.v6 );
3009 mreqv6.ipv6mr_interface = sa6p->sin6_scope_id;
3010 err = setsockopt( sock, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *) &mreqv6, sizeof( mreqv6 ) );
3011 check_translated_errno( err == 0, errno_compat(), kOptionErr );
3012
3013 // Specify the interface to send multicast packets on this socket.
3014
3015 option = (int) sa6p->sin6_scope_id;
3016 err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *) &option, sizeof( option ) );
3017 check_translated_errno( err == 0, errno_compat(), kOptionErr );
3018
3019 // Enable multicast loopback so we receive multicast packets we send (for same-machine operations).
3020
3021 option = 1;
3022 err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &option, sizeof( option ) );
3023 check_translated_errno( err == 0, errno_compat(), kOptionErr );
3024 }
3025
3026 // Send unicast packets with TTL 255 (helps against spoofing).
3027
3028 option = 255;
3029 err = setsockopt( sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char *) &option, sizeof( option ) );
3030 check_translated_errno( err == 0, errno_compat(), kOptionErr );
3031
3032 // Send multicast packets with TTL 255 (helps against spoofing).
3033
3034 option = 255;
3035 err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &option, sizeof( option ) );
3036 check_translated_errno( err == 0, errno_compat(), kOptionErr );
3037 }
3038 else
3039 {
3040 dlog( kDebugLevelError, DEBUG_NAME "%s: unsupport socket family (%d)\n", __ROUTINE__, inAddr->sa_family );
3041 err = kUnsupportedErr;
3042 goto exit;
3043 }
3044
3045 // Success!
3046
3047 *outSocketRef = sock;
3048 sock = kInvalidSocketRef;
3049 err = mStatus_NoError;
3050
3051 exit:
3052 if( IsValidSocket( sock ) )
3053 {
3054 close_compat( sock );
3055 }
3056 return( err );
3057 }
3058
3059 //===========================================================================================================================
3060 // SetupSocket
3061 //===========================================================================================================================
3062
3063 mDNSlocal mStatus SockAddrToMDNSAddr( const struct sockaddr * const inSA, mDNSAddr *outIP, mDNSIPPort *outPort )
3064 {
3065 mStatus err;
3066
3067 check( inSA );
3068 check( outIP );
3069
3070 if( inSA->sa_family == AF_INET )
3071 {
3072 struct sockaddr_in * sa4;
3073
3074 sa4 = (struct sockaddr_in *) inSA;
3075 outIP->type = mDNSAddrType_IPv4;
3076 outIP->ip.v4.NotAnInteger = sa4->sin_addr.s_addr;
3077 if( outPort )
3078 {
3079 outPort->NotAnInteger = sa4->sin_port;
3080 }
3081 err = mStatus_NoError;
3082 }
3083 else if( inSA->sa_family == AF_INET6 )
3084 {
3085 struct sockaddr_in6 * sa6;
3086
3087 sa6 = (struct sockaddr_in6 *) inSA;
3088 outIP->type = mDNSAddrType_IPv6;
3089 outIP->ip.v6 = *( (mDNSv6Addr *) &sa6->sin6_addr );
3090 if( IN6_IS_ADDR_LINKLOCAL( &sa6->sin6_addr ) )
3091 {
3092 outIP->ip.v6.w[ 1 ] = 0;
3093 }
3094 if( outPort )
3095 {
3096 outPort->NotAnInteger = sa6->sin6_port;
3097 }
3098 err = mStatus_NoError;
3099 }
3100 else
3101 {
3102 dlog( kDebugLevelError, DEBUG_NAME "%s: invalid sa_family %d", __ROUTINE__, inSA->sa_family );
3103 err = mStatus_BadParamErr;
3104 }
3105 return( err );
3106 }
3107
3108
3109 #if 0
3110 #pragma mark -
3111 #endif
3112
3113 //===========================================================================================================================
3114 // UDPSocketNotification
3115 //===========================================================================================================================
3116
3117 mDNSlocal void CALLBACK
3118 UDPSocketNotification( SOCKET sock, LPWSANETWORKEVENTS event, void *context )
3119 {
3120 UDPSocket *udpSock = ( UDPSocket* ) context;
3121 WSAMSG wmsg;
3122 WSABUF wbuf;
3123 struct sockaddr_storage sockSrcAddr; // This is filled in by the WSARecv* function
3124 INT sockSrcAddrLen; // See above
3125 mDNSAddr srcAddr;
3126 mDNSInterfaceID iid;
3127 mDNSIPPort srcPort;
3128 mDNSAddr dstAddr;
3129 mDNSIPPort dstPort;
3130 uint8_t controlBuffer[ 128 ];
3131 mDNSu8 * end;
3132 int num;
3133 DWORD numTries;
3134 mStatus err;
3135
3136 DEBUG_UNUSED( sock );
3137 DEBUG_UNUSED( event );
3138
3139 require_action( udpSock != NULL, exit, err = mStatus_BadStateErr );
3140
3141 dlog( kDebugLevelChatty, DEBUG_NAME "%s: sock = %d\n", __ROUTINE__, udpSock->fd );
3142
3143 // Initialize the buffer structure
3144
3145 wbuf.buf = (char *) &udpSock->packet;
3146 wbuf.len = (u_long) sizeof( udpSock->packet );
3147 sockSrcAddrLen = sizeof( sockSrcAddr );
3148
3149 numTries = 0;
3150
3151 do
3152 {
3153 if ( udpSock->recvMsgPtr )
3154 {
3155 DWORD size;
3156
3157 wmsg.name = ( LPSOCKADDR ) &sockSrcAddr;
3158 wmsg.namelen = sockSrcAddrLen;
3159 wmsg.lpBuffers = &wbuf;
3160 wmsg.dwBufferCount = 1;
3161 wmsg.Control.buf = ( CHAR* ) controlBuffer;
3162 wmsg.Control.len = sizeof( controlBuffer );
3163 wmsg.dwFlags = 0;
3164
3165 err = udpSock->recvMsgPtr( udpSock->fd, &wmsg, &size, NULL, NULL );
3166 err = translate_errno( ( err == 0 ), (OSStatus) WSAGetLastError(), kUnknownErr );
3167 num = ( int ) size;
3168
3169 // <rdar://problem/7824093> iTunes 9.1 fails to install with Bonjour service on Windows 7 Ultimate
3170 //
3171 // There seems to be a bug in some network device drivers that involves calling WSARecvMsg().
3172 // Although all the parameters to WSARecvMsg() are correct, it returns a
3173 // WSAEFAULT error code when there is no actual error. We have found experientially that falling
3174 // back to using WSARecvFrom() when this happens will work correctly.
3175
3176 if ( err == WSAEFAULT ) udpSock->recvMsgPtr = NULL;
3177 }
3178 else
3179 {
3180 DWORD flags = 0;
3181
3182 num = WSARecvFrom( udpSock->fd, &wbuf, 1, NULL, &flags, ( LPSOCKADDR ) &sockSrcAddr, &sockSrcAddrLen, NULL, NULL );
3183 err = translate_errno( ( num >= 0 ), ( OSStatus ) WSAGetLastError(), kUnknownErr );
3184 }
3185
3186 // According to MSDN <http://msdn.microsoft.com/en-us/library/ms741687(VS.85).aspx>:
3187 //
3188 // "WSAECONNRESET: For a UDP datagram socket, this error would indicate that a previous
3189 // send operation resulted in an ICMP "Port Unreachable" message."
3190 //
3191 // Because this is the case, we want to ignore this error and try again. Just in case
3192 // this is some kind of pathological condition, we'll break out of the retry loop
3193 // after 100 iterations
3194
3195 require_action( !err || ( err == WSAECONNRESET ) || ( err == WSAEFAULT ), exit, err = WSAGetLastError() );
3196 }
3197 while ( ( ( err == WSAECONNRESET ) || ( err == WSAEFAULT ) ) && ( numTries++ < 100 ) );
3198
3199 require_noerr( err, exit );
3200
3201 // Translate the source of this packet into mDNS data types
3202
3203 SockAddrToMDNSAddr( (struct sockaddr* ) &sockSrcAddr, &srcAddr, &srcPort );
3204
3205 // Initialize the destination of this packet. Just in case
3206 // we can't determine this info because we couldn't call
3207 // WSARecvMsg (recvMsgPtr)
3208
3209 dstAddr = udpSock->addr;
3210 dstPort = udpSock->port;
3211
3212 if ( udpSock->recvMsgPtr )
3213 {
3214 LPWSACMSGHDR header;
3215 LPWSACMSGHDR last = NULL;
3216 int count = 0;
3217
3218 // Parse the control information. Reject packets received on the wrong interface.
3219
3220 // <rdar://problem/7832196> INSTALL: Bonjour 2.0 on Windows can not start / stop
3221 //
3222 // There seems to be an interaction between Bullguard and this next bit of code.
3223 // When a user's machine is running Bullguard, the control information that is
3224 // returned is corrupted, and the code would go into an infinite loop. We'll add
3225 // two bits of defensive coding here. The first will check that each pointer to
3226 // the LPWSACMSGHDR that is returned in the for loop is different than the last.
3227 // This fixes the problem with Bullguard. The second will break out of this loop
3228 // after 100 iterations, just in case the corruption isn't caught by the first
3229 // check.
3230
3231 for ( header = WSA_CMSG_FIRSTHDR( &wmsg ); header; header = WSA_CMSG_NXTHDR( &wmsg, header ) )
3232 {
3233 if ( ( header != last ) && ( ++count < 100 ) )
3234 {
3235 last = header;
3236
3237 if ( ( header->cmsg_level == IPPROTO_IP ) && ( header->cmsg_type == IP_PKTINFO ) )
3238 {
3239 IN_PKTINFO * ipv4PacketInfo;
3240
3241 ipv4PacketInfo = (IN_PKTINFO *) WSA_CMSG_DATA( header );
3242
3243 if ( udpSock->ifd != NULL )
3244 {
3245 require_action( ipv4PacketInfo->ipi_ifindex == udpSock->ifd->index, exit, err = ( DWORD ) kMismatchErr );
3246 }
3247
3248 dstAddr.type = mDNSAddrType_IPv4;
3249 dstAddr.ip.v4.NotAnInteger = ipv4PacketInfo->ipi_addr.s_addr;
3250 }
3251 else if( ( header->cmsg_level == IPPROTO_IPV6 ) && ( header->cmsg_type == IPV6_PKTINFO ) )
3252 {
3253 IN6_PKTINFO * ipv6PacketInfo;
3254
3255 ipv6PacketInfo = (IN6_PKTINFO *) WSA_CMSG_DATA( header );
3256
3257 if ( udpSock->ifd != NULL )
3258 {
3259 require_action( ipv6PacketInfo->ipi6_ifindex == ( udpSock->ifd->index - kIPv6IfIndexBase ), exit, err = ( DWORD ) kMismatchErr );
3260 }
3261
3262 dstAddr.type = mDNSAddrType_IPv6;
3263 dstAddr.ip.v6 = *( (mDNSv6Addr *) &ipv6PacketInfo->ipi6_addr );
3264 }
3265 }
3266 else
3267 {
3268 static BOOL loggedMessage = FALSE;
3269
3270 if ( !loggedMessage )
3271 {
3272 LogMsg( "UDPEndRecv: WSARecvMsg control information error." );
3273 loggedMessage = TRUE;
3274 }
3275
3276 break;
3277 }
3278 }
3279 }
3280
3281 dlog( kDebugLevelChatty, DEBUG_NAME "packet received\n" );
3282 dlog( kDebugLevelChatty, DEBUG_NAME " size = %d\n", num );
3283 dlog( kDebugLevelChatty, DEBUG_NAME " src = %#a:%u\n", &srcAddr, ntohs( srcPort.NotAnInteger ) );
3284 dlog( kDebugLevelChatty, DEBUG_NAME " dst = %#a:%u\n", &dstAddr, ntohs( dstPort.NotAnInteger ) );
3285
3286 if ( udpSock->ifd != NULL )
3287 {
3288 dlog( kDebugLevelChatty, DEBUG_NAME " interface = %#a (index=0x%08X)\n", &udpSock->ifd->interfaceInfo.ip, udpSock->ifd->index );
3289 }
3290
3291 dlog( kDebugLevelChatty, DEBUG_NAME "\n" );
3292
3293 iid = udpSock->ifd ? udpSock->ifd->interfaceInfo.InterfaceID : NULL;
3294 end = ( (mDNSu8 *) &udpSock->packet ) + num;
3295
3296 mDNSCoreReceive( udpSock->m, &udpSock->packet, end, &srcAddr, srcPort, &dstAddr, dstPort, iid );
3297
3298 exit:
3299
3300 return;
3301 }
3302
3303
3304 //===========================================================================================================================
3305 // InterfaceListDidChange
3306 //===========================================================================================================================
3307 void InterfaceListDidChange( mDNS * const inMDNS )
3308 {
3309 mStatus err;
3310
3311 dlog( kDebugLevelInfo, DEBUG_NAME "interface list changed\n" );
3312 check( inMDNS );
3313
3314 // Tear down the existing interfaces and set up new ones using the new IP info.
3315
3316 err = TearDownInterfaceList( inMDNS );
3317 check_noerr( err );
3318
3319 err = SetupInterfaceList( inMDNS );
3320 check_noerr( err );
3321
3322 err = uDNS_SetupDNSConfig( inMDNS );
3323 check_noerr( err );
3324
3325 // Inform clients of the change.
3326
3327 mDNS_ConfigChanged(inMDNS);
3328
3329 // Force mDNS to update.
3330
3331 mDNSCoreMachineSleep( inMDNS, mDNSfalse ); // What is this for? Mac OS X does not do this
3332 }
3333
3334
3335 //===========================================================================================================================
3336 // ComputerDescriptionDidChange
3337 //===========================================================================================================================
3338 void ComputerDescriptionDidChange( mDNS * const inMDNS )
3339 {
3340 dlog( kDebugLevelInfo, DEBUG_NAME "computer description has changed\n" );
3341 check( inMDNS );
3342
3343 // redo the names
3344 SetupNiceName( inMDNS );
3345 }
3346
3347
3348 //===========================================================================================================================
3349 // TCPIPConfigDidChange
3350 //===========================================================================================================================
3351 void TCPIPConfigDidChange( mDNS * const inMDNS )
3352 {
3353 mStatus err;
3354
3355 dlog( kDebugLevelInfo, DEBUG_NAME "TCP/IP config has changed\n" );
3356 check( inMDNS );
3357
3358 err = uDNS_SetupDNSConfig( inMDNS );
3359 check_noerr( err );
3360 }
3361
3362
3363 //===========================================================================================================================
3364 // DynDNSConfigDidChange
3365 //===========================================================================================================================
3366 void DynDNSConfigDidChange( mDNS * const inMDNS )
3367 {
3368 mStatus err;
3369
3370 dlog( kDebugLevelInfo, DEBUG_NAME "DynDNS config has changed\n" );
3371 check( inMDNS );
3372
3373 SetDomainSecrets( inMDNS );
3374
3375 err = uDNS_SetupDNSConfig( inMDNS );
3376 check_noerr( err );
3377 }
3378
3379
3380 //===========================================================================================================================
3381 // FileSharingDidChange
3382 //===========================================================================================================================
3383 void FileSharingDidChange( mDNS * const inMDNS )
3384 {
3385 dlog( kDebugLevelInfo, DEBUG_NAME "File shares has changed\n" );
3386 check( inMDNS );
3387
3388 CheckFileShares( inMDNS );
3389 }
3390
3391
3392 //===========================================================================================================================
3393 // FilewallDidChange
3394 //===========================================================================================================================
3395 void FirewallDidChange( mDNS * const inMDNS )
3396 {
3397 dlog( kDebugLevelInfo, DEBUG_NAME "Firewall has changed\n" );
3398 check( inMDNS );
3399
3400 CheckFileShares( inMDNS );
3401 }
3402
3403
3404 #if 0
3405 #pragma mark -
3406 #pragma mark == Utilities ==
3407 #endif
3408
3409 //===========================================================================================================================
3410 // getifaddrs
3411 //===========================================================================================================================
3412
3413 mDNSlocal int getifaddrs( struct ifaddrs **outAddrs )
3414 {
3415 int err;
3416
3417 #if( MDNS_WINDOWS_USE_IPV6_IF_ADDRS )
3418
3419 // Try to the load the GetAdaptersAddresses function from the IP Helpers DLL. This API is only available on Windows
3420 // XP or later. Looking up the symbol at runtime allows the code to still work on older systems without that API.
3421
3422 if( !gIPHelperLibraryInstance )
3423 {
3424 gIPHelperLibraryInstance = LoadLibrary( TEXT( "Iphlpapi" ) );
3425 if( gIPHelperLibraryInstance )
3426 {
3427 gGetAdaptersAddressesFunctionPtr =
3428 (GetAdaptersAddressesFunctionPtr) GetProcAddress( gIPHelperLibraryInstance, "GetAdaptersAddresses" );
3429 if( !gGetAdaptersAddressesFunctionPtr )
3430 {
3431 BOOL ok;
3432
3433 ok = FreeLibrary( gIPHelperLibraryInstance );
3434 check_translated_errno( ok, GetLastError(), kUnknownErr );
3435 gIPHelperLibraryInstance = NULL;
3436 }
3437 }
3438 }
3439
3440 // Use the new IPv6-capable routine if supported. Otherwise, fall back to the old and compatible IPv4-only code.
3441 // <rdar://problem/4278934> Fall back to using getifaddrs_ipv4 if getifaddrs_ipv6 fails
3442 // <rdar://problem/6145913> Fall back to using getifaddrs_ipv4 if getifaddrs_ipv6 returns no addrs
3443
3444 if( !gGetAdaptersAddressesFunctionPtr || ( ( ( err = getifaddrs_ipv6( outAddrs ) ) != mStatus_NoError ) || ( ( outAddrs != NULL ) && ( *outAddrs == NULL ) ) ) )
3445 {
3446 err = getifaddrs_ipv4( outAddrs );
3447 require_noerr( err, exit );
3448 }
3449
3450 #else
3451
3452 err = getifaddrs_ipv4( outAddrs );
3453 require_noerr( err, exit );
3454
3455 #endif
3456
3457 exit:
3458 return( err );
3459 }
3460
3461 #if( MDNS_WINDOWS_USE_IPV6_IF_ADDRS )
3462 //===========================================================================================================================
3463 // getifaddrs_ipv6
3464 //===========================================================================================================================
3465
3466 mDNSlocal int getifaddrs_ipv6( struct ifaddrs **outAddrs )
3467 {
3468 DWORD err;
3469 int i;
3470 DWORD flags;
3471 struct ifaddrs * head;
3472 struct ifaddrs ** next;
3473 IP_ADAPTER_ADDRESSES * iaaList;
3474 ULONG iaaListSize;
3475 IP_ADAPTER_ADDRESSES * iaa;
3476 size_t size;
3477 struct ifaddrs * ifa;
3478
3479 check( gGetAdaptersAddressesFunctionPtr );
3480
3481 head = NULL;
3482 next = &head;
3483 iaaList = NULL;
3484
3485 // Get the list of interfaces. The first call gets the size and the second call gets the actual data.
3486 // This loops to handle the case where the interface changes in the window after getting the size, but before the
3487 // second call completes. A limit of 100 retries is enforced to prevent infinite loops if something else is wrong.
3488
3489 flags = GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
3490 i = 0;
3491 for( ;; )
3492 {
3493 iaaListSize = 0;
3494 err = gGetAdaptersAddressesFunctionPtr( AF_UNSPEC, flags, NULL, NULL, &iaaListSize );
3495 check( err == ERROR_BUFFER_OVERFLOW );
3496 check( iaaListSize >= sizeof( IP_ADAPTER_ADDRESSES ) );
3497
3498 iaaList = (IP_ADAPTER_ADDRESSES *) malloc( iaaListSize );
3499 require_action( iaaList, exit, err = ERROR_NOT_ENOUGH_MEMORY );
3500
3501 err = gGetAdaptersAddressesFunctionPtr( AF_UNSPEC, flags, NULL, iaaList, &iaaListSize );
3502 if( err == ERROR_SUCCESS ) break;
3503
3504 free( iaaList );
3505 iaaList = NULL;
3506 ++i;
3507 require( i < 100, exit );
3508 dlog( kDebugLevelWarning, "%s: retrying GetAdaptersAddresses after %d failure(s) (%d %m)\n", __ROUTINE__, i, err, err );
3509 }
3510
3511 for( iaa = iaaList; iaa; iaa = iaa->Next )
3512 {
3513 int addrIndex;
3514 IP_ADAPTER_UNICAST_ADDRESS * addr;
3515 DWORD ipv6IfIndex;
3516 IP_ADAPTER_PREFIX * firstPrefix;
3517
3518 if( iaa->IfIndex > 0xFFFFFF )
3519 {
3520 dlog( kDebugLevelAlert, DEBUG_NAME "%s: IPv4 ifindex out-of-range (0x%08X)\n", __ROUTINE__, iaa->IfIndex );
3521 }
3522 if( iaa->Ipv6IfIndex > 0xFF )
3523 {
3524 dlog( kDebugLevelAlert, DEBUG_NAME "%s: IPv6 ifindex out-of-range (0x%08X)\n", __ROUTINE__, iaa->Ipv6IfIndex );
3525 }
3526
3527 // For IPv4 interfaces, there seems to be a bug in iphlpapi.dll that causes the
3528 // following code to crash when iterating through the prefix list. This seems
3529 // to occur when iaa->Ipv6IfIndex != 0 when IPv6 is not installed on the host.
3530 // This shouldn't happen according to Microsoft docs which states:
3531 //
3532 // "Ipv6IfIndex contains 0 if IPv6 is not available on the interface."
3533 //
3534 // So the data structure seems to be corrupted when we return from
3535 // GetAdaptersAddresses(). The bug seems to occur when iaa->Length <
3536 // sizeof(IP_ADAPTER_ADDRESSES), so when that happens, we'll manually
3537 // modify iaa to have the correct values.
3538
3539 if ( iaa->Length >= sizeof( IP_ADAPTER_ADDRESSES ) )
3540 {
3541 ipv6IfIndex = iaa->Ipv6IfIndex;
3542 firstPrefix = iaa->FirstPrefix;
3543 }
3544 else
3545 {
3546 ipv6IfIndex = 0;
3547 firstPrefix = NULL;
3548 }
3549
3550 // Skip pseudo and tunnel interfaces.
3551
3552 if( ( ( ipv6IfIndex == 1 ) && ( iaa->IfType != IF_TYPE_SOFTWARE_LOOPBACK ) ) || ( iaa->IfType == IF_TYPE_TUNNEL ) )
3553 {
3554 continue;
3555 }
3556
3557 // Add each address as a separate interface to emulate the way getifaddrs works.
3558
3559 for( addrIndex = 0, addr = iaa->FirstUnicastAddress; addr; ++addrIndex, addr = addr->Next )
3560 {
3561 int family;
3562 IP_ADAPTER_PREFIX * prefix;
3563 uint32_t ipv4Index;
3564 struct sockaddr_in ipv4Netmask;
3565
3566 family = addr->Address.lpSockaddr->sa_family;
3567 if( ( family != AF_INET ) && ( family != AF_INET6 ) ) continue;
3568
3569 // <rdar://problem/6220642> iTunes 8: Bonjour doesn't work after upgrading iTunes 8
3570 // Seems as if the problem here is a buggy implementation of some network interface
3571 // driver. It is reporting that is has a link-local address when it is actually
3572 // disconnected. This was causing a problem in AddressToIndexAndMask.
3573 // The solution is to call AddressToIndexAndMask first, and if unable to lookup
3574 // the address, to ignore that address.
3575
3576 ipv4Index = 0;
3577 memset( &ipv4Netmask, 0, sizeof( ipv4Netmask ) );
3578
3579 if ( family == AF_INET )
3580 {
3581 err = AddressToIndexAndMask( addr->Address.lpSockaddr, &ipv4Index, ( struct sockaddr* ) &ipv4Netmask );
3582
3583 if ( err )
3584 {
3585 err = 0;
3586 continue;
3587 }
3588 }
3589
3590 ifa = (struct ifaddrs *) calloc( 1, sizeof( struct ifaddrs ) );
3591 require_action( ifa, exit, err = WSAENOBUFS );
3592
3593 *next = ifa;
3594 next = &ifa->ifa_next;
3595
3596 // Get the name.
3597
3598 size = strlen( iaa->AdapterName ) + 1;
3599 ifa->ifa_name = (char *) malloc( size );
3600 require_action( ifa->ifa_name, exit, err = WSAENOBUFS );
3601 memcpy( ifa->ifa_name, iaa->AdapterName, size );
3602
3603 // Get interface flags.
3604
3605 ifa->ifa_flags = 0;
3606 if( iaa->OperStatus == IfOperStatusUp ) ifa->ifa_flags |= IFF_UP;
3607 if( iaa->IfType == IF_TYPE_SOFTWARE_LOOPBACK ) ifa->ifa_flags |= IFF_LOOPBACK;
3608 else if ( IsPointToPoint( addr ) ) ifa->ifa_flags |= IFF_POINTTOPOINT;
3609 if( !( iaa->Flags & IP_ADAPTER_NO_MULTICAST ) ) ifa->ifa_flags |= IFF_MULTICAST;
3610
3611
3612 // <rdar://problem/4045657> Interface index being returned is 512
3613 //
3614 // Windows does not have a uniform scheme for IPv4 and IPv6 interface indexes.
3615 // This code used to shift the IPv4 index up to ensure uniqueness between
3616 // it and IPv6 indexes. Although this worked, it was somewhat confusing to developers, who
3617 // then see interface indexes passed back that don't correspond to anything
3618 // that is seen in Win32 APIs or command line tools like "route". As a relatively
3619 // small percentage of developers are actively using IPv6, it seems to
3620 // make sense to make our use of IPv4 as confusion free as possible.
3621 // So now, IPv6 interface indexes will be shifted up by a
3622 // constant value which will serve to uniquely identify them, and we will
3623 // leave IPv4 interface indexes unmodified.
3624
3625 switch( family )
3626 {
3627 case AF_INET: ifa->ifa_extra.index = iaa->IfIndex; break;
3628 case AF_INET6: ifa->ifa_extra.index = ipv6IfIndex + kIPv6IfIndexBase; break;
3629 default: break;
3630 }
3631
3632 // Get lease lifetime
3633
3634 if ( ( iaa->IfType != IF_TYPE_SOFTWARE_LOOPBACK ) && ( addr->LeaseLifetime != 0 ) && ( addr->ValidLifetime != 0xFFFFFFFF ) )
3635 {
3636 ifa->ifa_dhcpEnabled = TRUE;
3637 ifa->ifa_dhcpLeaseExpires = time( NULL ) + addr->ValidLifetime;
3638 }
3639 else
3640 {
3641 ifa->ifa_dhcpEnabled = FALSE;
3642 ifa->ifa_dhcpLeaseExpires = 0;
3643 }
3644
3645 if ( iaa->PhysicalAddressLength == sizeof( ifa->ifa_physaddr ) )
3646 {
3647 memcpy( ifa->ifa_physaddr, iaa->PhysicalAddress, iaa->PhysicalAddressLength );
3648 }
3649
3650 // Because we don't get notified of womp changes, we're going to just assume
3651 // that all wired interfaces have it enabled. Before we go to sleep, we'll check
3652 // if the interface actually supports it, and update mDNS->SystemWakeOnLANEnabled
3653 // accordingly
3654
3655 ifa->ifa_womp = ( iaa->IfType == IF_TYPE_ETHERNET_CSMACD ) ? mDNStrue : mDNSfalse;
3656
3657 // Get address.
3658
3659 switch( family )
3660 {
3661 case AF_INET:
3662 case AF_INET6:
3663 ifa->ifa_addr = (struct sockaddr *) calloc( 1, (size_t) addr->Address.iSockaddrLength );
3664 require_action( ifa->ifa_addr, exit, err = WSAENOBUFS );
3665 memcpy( ifa->ifa_addr, addr->Address.lpSockaddr, (size_t) addr->Address.iSockaddrLength );
3666 break;
3667
3668 default:
3669 break;
3670 }
3671 check( ifa->ifa_addr );
3672
3673 // Get subnet mask (IPv4)/link prefix (IPv6). It is specified as a bit length (e.g. 24 for 255.255.255.0).
3674
3675 switch ( family )
3676 {
3677 case AF_INET:
3678 {
3679 struct sockaddr_in * sa4;
3680
3681 sa4 = (struct sockaddr_in *) calloc( 1, sizeof( *sa4 ) );
3682 require_action( sa4, exit, err = WSAENOBUFS );
3683 sa4->sin_family = AF_INET;
3684 sa4->sin_addr.s_addr = ipv4Netmask.sin_addr.s_addr;
3685
3686 dlog( kDebugLevelInfo, DEBUG_NAME "%s: IPv4 mask = %s\n", __ROUTINE__, inet_ntoa( sa4->sin_addr ) );
3687 ifa->ifa_netmask = (struct sockaddr *) sa4;
3688 break;
3689 }
3690
3691 case AF_INET6:
3692 {
3693 struct sockaddr_in6 *sa6;
3694 char buf[ 256 ] = { 0 };
3695 DWORD buflen = sizeof( buf );
3696
3697 sa6 = (struct sockaddr_in6 *) calloc( 1, sizeof( *sa6 ) );
3698 require_action( sa6, exit, err = WSAENOBUFS );
3699 sa6->sin6_family = AF_INET6;
3700 memset( sa6->sin6_addr.s6_addr, 0xFF, sizeof( sa6->sin6_addr.s6_addr ) );
3701 ifa->ifa_netmask = (struct sockaddr *) sa6;
3702
3703 for ( prefix = firstPrefix; prefix; prefix = prefix->Next )
3704 {
3705 IN6_ADDR mask;
3706 IN6_ADDR maskedAddr;
3707 int maskIndex;
3708 DWORD len;
3709
3710 // According to MSDN:
3711 // "On Windows Vista and later, the linked IP_ADAPTER_PREFIX structures pointed to by the FirstPrefix member
3712 // include three IP adapter prefixes for each IP address assigned to the adapter. These include the host IP address prefix,
3713 // the subnet IP address prefix, and the subnet broadcast IP address prefix.
3714 // In addition, for each adapter there is a multicast address prefix and a broadcast address prefix.
3715 // On Windows XP with SP1 and later prior to Windows Vista, the linked IP_ADAPTER_PREFIX structures pointed to by the FirstPrefix member
3716 // include only a single IP adapter prefix for each IP address assigned to the adapter."
3717
3718 // We're only interested in the subnet IP address prefix. We'll determine if the prefix is the
3719 // subnet prefix by masking our address with a mask (computed from the prefix length) and see if that is the same
3720 // as the prefix address.
3721
3722 if ( ( prefix->PrefixLength == 0 ) ||
3723 ( prefix->PrefixLength > 128 ) ||
3724 ( addr->Address.iSockaddrLength != prefix->Address.iSockaddrLength ) ||
3725 ( memcmp( addr->Address.lpSockaddr, prefix->Address.lpSockaddr, addr->Address.iSockaddrLength ) == 0 ) )
3726 {
3727 continue;
3728 }
3729
3730 // Compute the mask
3731
3732 memset( mask.s6_addr, 0, sizeof( mask.s6_addr ) );
3733
3734 for ( len = (int) prefix->PrefixLength, maskIndex = 0; len > 0; len -= 8 )
3735 {
3736 uint8_t maskByte = ( len >= 8 ) ? 0xFF : (uint8_t)( ( 0xFFU << ( 8 - len ) ) & 0xFFU );
3737 mask.s6_addr[ maskIndex++ ] = maskByte;
3738 }
3739
3740 // Apply the mask
3741
3742 for ( i = 0; i < 16; i++ )
3743 {
3744 maskedAddr.s6_addr[ i ] = ( ( struct sockaddr_in6* ) addr->Address.lpSockaddr )->sin6_addr.s6_addr[ i ] & mask.s6_addr[ i ];
3745 }
3746
3747 // Compare
3748
3749 if ( memcmp( ( ( struct sockaddr_in6* ) prefix->Address.lpSockaddr )->sin6_addr.s6_addr, maskedAddr.s6_addr, sizeof( maskedAddr.s6_addr ) ) == 0 )
3750 {
3751 memcpy( sa6->sin6_addr.s6_addr, mask.s6_addr, sizeof( mask.s6_addr ) );
3752 break;
3753 }
3754 }
3755
3756 WSAAddressToStringA( ( LPSOCKADDR ) sa6, sizeof( struct sockaddr_in6 ), NULL, buf, &buflen );
3757 dlog( kDebugLevelInfo, DEBUG_NAME "%s: IPv6 mask = %s\n", __ROUTINE__, buf );
3758
3759 break;
3760 }
3761
3762 default:
3763 break;
3764 }
3765 }
3766 }
3767
3768 // Success!
3769
3770 if( outAddrs )
3771 {
3772 *outAddrs = head;
3773 head = NULL;
3774 }
3775 err = ERROR_SUCCESS;
3776
3777 exit:
3778 if( head )
3779 {
3780 freeifaddrs( head );
3781 }
3782 if( iaaList )
3783 {
3784 free( iaaList );
3785 }
3786 return( (int) err );
3787 }
3788
3789 #endif // MDNS_WINDOWS_USE_IPV6_IF_ADDRS
3790
3791 //===========================================================================================================================
3792 // getifaddrs_ipv4
3793 //===========================================================================================================================
3794
3795 mDNSlocal int getifaddrs_ipv4( struct ifaddrs **outAddrs )
3796 {
3797 int err;
3798 SOCKET sock;
3799 DWORD size;
3800 DWORD actualSize;
3801 INTERFACE_INFO * buffer;
3802 INTERFACE_INFO * tempBuffer;
3803 INTERFACE_INFO * ifInfo;
3804 int n;
3805 int i;
3806 struct ifaddrs * head;
3807 struct ifaddrs ** next;
3808 struct ifaddrs * ifa;
3809
3810 sock = INVALID_SOCKET;
3811 buffer = NULL;
3812 head = NULL;
3813 next = &head;
3814
3815 // Get the interface list. WSAIoctl is called with SIO_GET_INTERFACE_LIST, but since this does not provide a
3816 // way to determine the size of the interface list beforehand, we have to start with an initial size guess and
3817 // call WSAIoctl repeatedly with increasing buffer sizes until it succeeds. Limit this to 100 tries for safety.
3818
3819 sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
3820 err = translate_errno( IsValidSocket( sock ), errno_compat(), kUnknownErr );
3821 require_noerr( err, exit );
3822
3823 n = 0;
3824 size = 16 * sizeof( INTERFACE_INFO );
3825 for( ;; )
3826 {
3827 tempBuffer = (INTERFACE_INFO *) realloc( buffer, size );
3828 require_action( tempBuffer, exit, err = WSAENOBUFS );
3829 buffer = tempBuffer;
3830
3831 err = WSAIoctl( sock, SIO_GET_INTERFACE_LIST, NULL, 0, buffer, size, &actualSize, NULL, NULL );
3832 if( err == 0 )
3833 {
3834 break;
3835 }
3836
3837 ++n;
3838 require_action( n < 100, exit, err = WSAEADDRNOTAVAIL );
3839
3840 size += ( 16 * sizeof( INTERFACE_INFO ) );
3841 }
3842 check( actualSize <= size );
3843 check( ( actualSize % sizeof( INTERFACE_INFO ) ) == 0 );
3844 n = (int)( actualSize / sizeof( INTERFACE_INFO ) );
3845
3846 // Process the raw interface list and build a linked list of IPv4 interfaces.
3847
3848 for( i = 0; i < n; ++i )
3849 {
3850 uint32_t ifIndex;
3851 struct sockaddr_in netmask;
3852
3853 ifInfo = &buffer[ i ];
3854 if( ifInfo->iiAddress.Address.sa_family != AF_INET )
3855 {
3856 continue;
3857 }
3858
3859 // <rdar://problem/6220642> iTunes 8: Bonjour doesn't work after upgrading iTunes 8
3860 // See comment in getifaddrs_ipv6
3861
3862 ifIndex = 0;
3863 memset( &netmask, 0, sizeof( netmask ) );
3864 err = AddressToIndexAndMask( ( struct sockaddr* ) &ifInfo->iiAddress.AddressIn, &ifIndex, ( struct sockaddr* ) &netmask );
3865
3866 if ( err )
3867 {
3868 continue;
3869 }
3870
3871 ifa = (struct ifaddrs *) calloc( 1, sizeof( struct ifaddrs ) );
3872 require_action( ifa, exit, err = WSAENOBUFS );
3873
3874 *next = ifa;
3875 next = &ifa->ifa_next;
3876
3877 // Get the name.
3878
3879 ifa->ifa_name = (char *) malloc( 16 );
3880 require_action( ifa->ifa_name, exit, err = WSAENOBUFS );
3881 sprintf( ifa->ifa_name, "%d", i + 1 );
3882
3883 // Get interface flags.
3884
3885 ifa->ifa_flags = (u_int) ifInfo->iiFlags;
3886
3887 // Get addresses.
3888
3889 if ( ifInfo->iiAddress.Address.sa_family == AF_INET )
3890 {
3891 struct sockaddr_in * sa4;
3892
3893 sa4 = &ifInfo->iiAddress.AddressIn;
3894 ifa->ifa_addr = (struct sockaddr *) calloc( 1, sizeof( *sa4 ) );
3895 require_action( ifa->ifa_addr, exit, err = WSAENOBUFS );
3896 memcpy( ifa->ifa_addr, sa4, sizeof( *sa4 ) );
3897
3898 ifa->ifa_netmask = (struct sockaddr*) calloc(1, sizeof( *sa4 ) );
3899 require_action( ifa->ifa_netmask, exit, err = WSAENOBUFS );
3900
3901 // <rdar://problem/4076478> Service won't start on Win2K. The address
3902 // family field was not being initialized.
3903
3904 ifa->ifa_netmask->sa_family = AF_INET;
3905 ( ( struct sockaddr_in* ) ifa->ifa_netmask )->sin_addr = netmask.sin_addr;
3906 ifa->ifa_extra.index = ifIndex;
3907 }
3908 else
3909 {
3910 // Emulate an interface index.
3911
3912 ifa->ifa_extra.index = (uint32_t)( i + 1 );
3913 }
3914 }
3915
3916 // Success!
3917
3918 if( outAddrs )
3919 {
3920 *outAddrs = head;
3921 head = NULL;
3922 }
3923 err = 0;
3924
3925 exit:
3926
3927 if( head )
3928 {
3929 freeifaddrs( head );
3930 }
3931 if( buffer )
3932 {
3933 free( buffer );
3934 }
3935 if( sock != INVALID_SOCKET )
3936 {
3937 closesocket( sock );
3938 }
3939 return( err );
3940 }
3941
3942 //===========================================================================================================================
3943 // freeifaddrs
3944 //===========================================================================================================================
3945
3946 mDNSlocal void freeifaddrs( struct ifaddrs *inIFAs )
3947 {
3948 struct ifaddrs * p;
3949 struct ifaddrs * q;
3950
3951 // Free each piece of the structure. Set to null after freeing to handle macro-aliased fields.
3952
3953 for( p = inIFAs; p; p = q )
3954 {
3955 q = p->ifa_next;
3956
3957 if( p->ifa_name )
3958 {
3959 free( p->ifa_name );
3960 p->ifa_name = NULL;
3961 }
3962 if( p->ifa_addr )
3963 {
3964 free( p->ifa_addr );
3965 p->ifa_addr = NULL;
3966 }
3967 if( p->ifa_netmask )
3968 {
3969 free( p->ifa_netmask );
3970 p->ifa_netmask = NULL;
3971 }
3972 if( p->ifa_broadaddr )
3973 {
3974 free( p->ifa_broadaddr );
3975 p->ifa_broadaddr = NULL;
3976 }
3977 if( p->ifa_dstaddr )
3978 {
3979 free( p->ifa_dstaddr );
3980 p->ifa_dstaddr = NULL;
3981 }
3982 if( p->ifa_data )
3983 {
3984 free( p->ifa_data );
3985 p->ifa_data = NULL;
3986 }
3987 free( p );
3988 }
3989 }
3990
3991
3992 //===========================================================================================================================
3993 // GetPrimaryInterface
3994 //===========================================================================================================================
3995
3996 mDNSlocal DWORD
3997 GetPrimaryInterface()
3998 {
3999 PMIB_IPFORWARDTABLE pIpForwardTable = NULL;
4000 DWORD dwSize = 0;
4001 BOOL bOrder = FALSE;
4002 OSStatus err;
4003 DWORD index = 0;
4004 DWORD metric = 0;
4005 unsigned long int i;
4006
4007 // Find out how big our buffer needs to be.
4008
4009 err = GetIpForwardTable(NULL, &dwSize, bOrder);
4010 require_action( err == ERROR_INSUFFICIENT_BUFFER, exit, err = kUnknownErr );
4011
4012 // Allocate the memory for the table
4013
4014 pIpForwardTable = (PMIB_IPFORWARDTABLE) malloc( dwSize );
4015 require_action( pIpForwardTable, exit, err = kNoMemoryErr );
4016
4017 // Now get the table.
4018
4019 err = GetIpForwardTable(pIpForwardTable, &dwSize, bOrder);
4020 require_noerr( err, exit );
4021
4022
4023 // Search for the row in the table we want.
4024
4025 for ( i = 0; i < pIpForwardTable->dwNumEntries; i++)
4026 {
4027 // Look for a default route
4028
4029 if ( pIpForwardTable->table[i].dwForwardDest == 0 )
4030 {
4031 if ( index && ( pIpForwardTable->table[i].dwForwardMetric1 >= metric ) )
4032 {
4033 continue;
4034 }
4035
4036 index = pIpForwardTable->table[i].dwForwardIfIndex;
4037 metric = pIpForwardTable->table[i].dwForwardMetric1;
4038 }
4039 }
4040
4041 exit:
4042
4043 if ( pIpForwardTable != NULL )
4044 {
4045 free( pIpForwardTable );
4046 }
4047
4048 return index;
4049 }
4050
4051
4052 //===========================================================================================================================
4053 // AddressToIndexAndMask
4054 //===========================================================================================================================
4055
4056 mDNSlocal mStatus
4057 AddressToIndexAndMask( struct sockaddr * addr, uint32_t * ifIndex, struct sockaddr * mask )
4058 {
4059 // Before calling AddIPAddress we use GetIpAddrTable to get
4060 // an adapter to which we can add the IP.
4061
4062 PMIB_IPADDRTABLE pIPAddrTable = NULL;
4063 DWORD dwSize = 0;
4064 mStatus err = mStatus_UnknownErr;
4065 DWORD i;
4066
4067 // For now, this is only for IPv4 addresses. That is why we can safely cast
4068 // addr's to sockaddr_in.
4069
4070 require_action( addr->sa_family == AF_INET, exit, err = mStatus_UnknownErr );
4071
4072 // Make an initial call to GetIpAddrTable to get the
4073 // necessary size into the dwSize variable
4074
4075 for ( i = 0; i < 100; i++ )
4076 {
4077 err = GetIpAddrTable( pIPAddrTable, &dwSize, 0 );
4078
4079 if ( err != ERROR_INSUFFICIENT_BUFFER )
4080 {
4081 break;
4082 }
4083
4084 pIPAddrTable = (MIB_IPADDRTABLE *) realloc( pIPAddrTable, dwSize );
4085 require_action( pIPAddrTable, exit, err = WSAENOBUFS );
4086 }
4087
4088 require_noerr( err, exit );
4089 err = mStatus_UnknownErr;
4090
4091 for ( i = 0; i < pIPAddrTable->dwNumEntries; i++ )
4092 {
4093 if ( ( ( struct sockaddr_in* ) addr )->sin_addr.s_addr == pIPAddrTable->table[i].dwAddr )
4094 {
4095 *ifIndex = pIPAddrTable->table[i].dwIndex;
4096 ( ( struct sockaddr_in*) mask )->sin_addr.s_addr = pIPAddrTable->table[i].dwMask;
4097 err = mStatus_NoError;
4098 break;
4099 }
4100 }
4101
4102 exit:
4103
4104 if ( pIPAddrTable )
4105 {
4106 free( pIPAddrTable );
4107 }
4108
4109 return err;
4110 }
4111
4112
4113 //===========================================================================================================================
4114 // CanReceiveUnicast
4115 //===========================================================================================================================
4116
4117 mDNSlocal mDNSBool CanReceiveUnicast( void )
4118 {
4119 mDNSBool ok;
4120 SocketRef sock;
4121 struct sockaddr_in addr;
4122
4123 // Try to bind to the port without the SO_REUSEADDR option to test if someone else has already bound to it.
4124
4125 sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
4126 check_translated_errno( IsValidSocket( sock ), errno_compat(), kUnknownErr );
4127 ok = IsValidSocket( sock );
4128 if( ok )
4129 {
4130 mDNSPlatformMemZero( &addr, sizeof( addr ) );
4131 addr.sin_family = AF_INET;
4132 addr.sin_port = MulticastDNSPort.NotAnInteger;
4133 addr.sin_addr.s_addr = htonl( INADDR_ANY );
4134
4135 ok = ( bind( sock, (struct sockaddr *) &addr, sizeof( addr ) ) == 0 );
4136 close_compat( sock );
4137 }
4138
4139 dlog( kDebugLevelInfo, DEBUG_NAME "Unicast UDP responses %s\n", ok ? "okay" : "*not allowed*" );
4140 return( ok );
4141 }
4142
4143
4144 //===========================================================================================================================
4145 // IsPointToPoint
4146 //===========================================================================================================================
4147
4148 mDNSlocal mDNSBool IsPointToPoint( IP_ADAPTER_UNICAST_ADDRESS * addr )
4149 {
4150 struct ifaddrs * addrs = NULL;
4151 struct ifaddrs * p = NULL;
4152 OSStatus err;
4153 mDNSBool ret = mDNSfalse;
4154
4155 // For now, only works for IPv4 interfaces
4156
4157 if ( addr->Address.lpSockaddr->sa_family == AF_INET )
4158 {
4159 // The getifaddrs_ipv4 call will give us correct information regarding IFF_POINTTOPOINT flags.
4160
4161 err = getifaddrs_ipv4( &addrs );
4162 require_noerr( err, exit );
4163
4164 for ( p = addrs; p; p = p->ifa_next )
4165 {
4166 if ( ( addr->Address.lpSockaddr->sa_family == p->ifa_addr->sa_family ) &&
4167 ( ( ( struct sockaddr_in* ) addr->Address.lpSockaddr )->sin_addr.s_addr == ( ( struct sockaddr_in* ) p->ifa_addr )->sin_addr.s_addr ) )
4168 {
4169 ret = ( p->ifa_flags & IFF_POINTTOPOINT ) ? mDNStrue : mDNSfalse;
4170 break;
4171 }
4172 }
4173 }
4174
4175 exit:
4176
4177 if ( addrs )
4178 {
4179 freeifaddrs( addrs );
4180 }
4181
4182 return ret;
4183 }
4184
4185
4186 //===========================================================================================================================
4187 // GetWindowsVersionString
4188 //===========================================================================================================================
4189
4190 mDNSlocal OSStatus GetWindowsVersionString( char *inBuffer, size_t inBufferSize )
4191 {
4192 #if( !defined( VER_PLATFORM_WIN32_CE ) )
4193 #define VER_PLATFORM_WIN32_CE 3
4194 #endif
4195
4196 OSStatus err;
4197 OSVERSIONINFO osInfo;
4198 BOOL ok;
4199 const char * versionString;
4200 DWORD platformID;
4201 DWORD majorVersion;
4202 DWORD minorVersion;
4203 DWORD buildNumber;
4204
4205 versionString = "unknown Windows version";
4206
4207 osInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
4208 ok = GetVersionEx( &osInfo );
4209 err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr );
4210 require_noerr( err, exit );
4211
4212 platformID = osInfo.dwPlatformId;
4213 majorVersion = osInfo.dwMajorVersion;
4214 minorVersion = osInfo.dwMinorVersion;
4215 buildNumber = osInfo.dwBuildNumber & 0xFFFF;
4216
4217 if( ( platformID == VER_PLATFORM_WIN32_WINDOWS ) && ( majorVersion == 4 ) )
4218 {
4219 if( ( minorVersion < 10 ) && ( buildNumber == 950 ) )
4220 {
4221 versionString = "Windows 95";
4222 }
4223 else if( ( minorVersion < 10 ) && ( ( buildNumber > 950 ) && ( buildNumber <= 1080 ) ) )
4224 {
4225 versionString = "Windows 95 SP1";
4226 }
4227 else if( ( minorVersion < 10 ) && ( buildNumber > 1080 ) )
4228 {
4229 versionString = "Windows 95 OSR2";
4230 }
4231 else if( ( minorVersion == 10 ) && ( buildNumber == 1998 ) )
4232 {
4233 versionString = "Windows 98";
4234 }
4235 else if( ( minorVersion == 10 ) && ( ( buildNumber > 1998 ) && ( buildNumber < 2183 ) ) )
4236 {
4237 versionString = "Windows 98 SP1";
4238 }
4239 else if( ( minorVersion == 10 ) && ( buildNumber >= 2183 ) )
4240 {
4241 versionString = "Windows 98 SE";
4242 }
4243 else if( minorVersion == 90 )
4244 {
4245 versionString = "Windows ME";
4246 }
4247 }
4248 else if( platformID == VER_PLATFORM_WIN32_NT )
4249 {
4250 if( ( majorVersion == 3 ) && ( minorVersion == 51 ) )
4251 {
4252 versionString = "Windows NT 3.51";
4253 }
4254 else if( ( majorVersion == 4 ) && ( minorVersion == 0 ) )
4255 {
4256 versionString = "Windows NT 4";
4257 }
4258 else if( ( majorVersion == 5 ) && ( minorVersion == 0 ) )
4259 {
4260 versionString = "Windows 2000";
4261 }
4262 else if( ( majorVersion == 5 ) && ( minorVersion == 1 ) )
4263 {
4264 versionString = "Windows XP";
4265 }
4266 else if( ( majorVersion == 5 ) && ( minorVersion == 2 ) )
4267 {
4268 versionString = "Windows Server 2003";
4269 }
4270 }
4271 else if( platformID == VER_PLATFORM_WIN32_CE )
4272 {
4273 versionString = "Windows CE";
4274 }
4275
4276 exit:
4277 if( inBuffer && ( inBufferSize > 0 ) )
4278 {
4279 inBufferSize -= 1;
4280 strncpy( inBuffer, versionString, inBufferSize );
4281 inBuffer[ inBufferSize ] = '\0';
4282 }
4283 return( err );
4284 }
4285
4286
4287 //===========================================================================================================================
4288 // RegQueryString
4289 //===========================================================================================================================
4290
4291 mDNSlocal mStatus
4292 RegQueryString( HKEY key, LPCSTR valueName, LPSTR * string, DWORD * stringLen, DWORD * enabled )
4293 {
4294 DWORD type;
4295 int i;
4296 mStatus err;
4297
4298 *stringLen = MAX_ESCAPED_DOMAIN_NAME;
4299 *string = NULL;
4300 i = 0;
4301
4302 do
4303 {
4304 if ( *string )
4305 {
4306 free( *string );
4307 }
4308
4309 *string = (char*) malloc( *stringLen );
4310 require_action( *string, exit, err = mStatus_NoMemoryErr );
4311
4312 err = RegQueryValueExA( key, valueName, 0, &type, (LPBYTE) *string, stringLen );
4313
4314 i++;
4315 }
4316 while ( ( err == ERROR_MORE_DATA ) && ( i < 100 ) );
4317
4318 require_noerr_quiet( err, exit );
4319
4320 if ( enabled )
4321 {
4322 DWORD dwSize = sizeof( DWORD );
4323
4324 err = RegQueryValueEx( key, TEXT("Enabled"), NULL, NULL, (LPBYTE) enabled, &dwSize );
4325 check_noerr( err );
4326
4327 err = kNoErr;
4328 }
4329
4330 exit:
4331
4332 return err;
4333 }
4334
4335
4336 //===========================================================================================================================
4337 // StringToAddress
4338 //===========================================================================================================================
4339
4340 mDNSlocal mStatus StringToAddress( mDNSAddr * ip, LPSTR string )
4341 {
4342 struct sockaddr_in6 sa6;
4343 struct sockaddr_in sa4;
4344 INT dwSize;
4345 mStatus err;
4346
4347 sa6.sin6_family = AF_INET6;
4348 dwSize = sizeof( sa6 );
4349
4350 err = WSAStringToAddressA( string, AF_INET6, NULL, (struct sockaddr*) &sa6, &dwSize );
4351
4352 if ( err == mStatus_NoError )
4353 {
4354 err = SetupAddr( ip, (struct sockaddr*) &sa6 );
4355 require_noerr( err, exit );
4356 }
4357 else
4358 {
4359 sa4.sin_family = AF_INET;
4360 dwSize = sizeof( sa4 );
4361
4362 err = WSAStringToAddressA( string, AF_INET, NULL, (struct sockaddr*) &sa4, &dwSize );
4363 err = translate_errno( err == 0, WSAGetLastError(), kUnknownErr );
4364 require_noerr( err, exit );
4365
4366 err = SetupAddr( ip, (struct sockaddr*) &sa4 );
4367 require_noerr( err, exit );
4368 }
4369
4370 exit:
4371
4372 return err;
4373 }
4374
4375
4376 //===========================================================================================================================
4377 // myGetIfAddrs
4378 //===========================================================================================================================
4379
4380 mDNSlocal struct ifaddrs*
4381 myGetIfAddrs(int refresh)
4382 {
4383 static struct ifaddrs *ifa = NULL;
4384
4385 if (refresh && ifa)
4386 {
4387 freeifaddrs(ifa);
4388 ifa = NULL;
4389 }
4390
4391 if (ifa == NULL)
4392 {
4393 getifaddrs(&ifa);
4394 }
4395
4396 return ifa;
4397 }
4398
4399
4400 //===========================================================================================================================
4401 // TCHARtoUTF8
4402 //===========================================================================================================================
4403
4404 mDNSlocal OSStatus
4405 TCHARtoUTF8( const TCHAR *inString, char *inBuffer, size_t inBufferSize )
4406 {
4407 #if( defined( UNICODE ) || defined( _UNICODE ) )
4408 OSStatus err;
4409 int len;
4410
4411 len = WideCharToMultiByte( CP_UTF8, 0, inString, -1, inBuffer, (int) inBufferSize, NULL, NULL );
4412 err = translate_errno( len > 0, errno_compat(), kUnknownErr );
4413 require_noerr( err, exit );
4414
4415 exit:
4416 return( err );
4417 #else
4418 return( WindowsLatin1toUTF8( inString, inBuffer, inBufferSize ) );
4419 #endif
4420 }
4421
4422
4423 //===========================================================================================================================
4424 // WindowsLatin1toUTF8
4425 //===========================================================================================================================
4426
4427 mDNSlocal OSStatus
4428 WindowsLatin1toUTF8( const char *inString, char *inBuffer, size_t inBufferSize )
4429 {
4430 OSStatus err;
4431 WCHAR * utf16;
4432 int len;
4433
4434 utf16 = NULL;
4435
4436 // Windows doesn't support going directly from Latin-1 to UTF-8 so we have to go from Latin-1 to UTF-16 first.
4437
4438 len = MultiByteToWideChar( CP_ACP, 0, inString, -1, NULL, 0 );
4439 err = translate_errno( len > 0, errno_compat(), kUnknownErr );
4440 require_noerr( err, exit );
4441
4442 utf16 = (WCHAR *) malloc( len * sizeof( *utf16 ) );
4443 require_action( utf16, exit, err = kNoMemoryErr );
4444
4445 len = MultiByteToWideChar( CP_ACP, 0, inString, -1, utf16, len );
4446 err = translate_errno( len > 0, errno_compat(), kUnknownErr );
4447 require_noerr( err, exit );
4448
4449 // Now convert the temporary UTF-16 to UTF-8.
4450
4451 len = WideCharToMultiByte( CP_UTF8, 0, utf16, -1, inBuffer, (int) inBufferSize, NULL, NULL );
4452 err = translate_errno( len > 0, errno_compat(), kUnknownErr );
4453 require_noerr( err, exit );
4454
4455 exit:
4456 if( utf16 ) free( utf16 );
4457 return( err );
4458 }
4459
4460
4461 //===========================================================================================================================
4462 // TCPCloseSocket
4463 //===========================================================================================================================
4464
4465 mDNSlocal void
4466 TCPCloseSocket( TCPSocket * sock )
4467 {
4468 dlog( kDebugLevelChatty, DEBUG_NAME "closing TCPSocket 0x%x:%d\n", sock, sock->fd );
4469
4470 if ( sock->fd != INVALID_SOCKET )
4471 {
4472 closesocket( sock->fd );
4473 sock->fd = INVALID_SOCKET;
4474 }
4475 }
4476
4477
4478 //===========================================================================================================================
4479 // UDPCloseSocket
4480 //===========================================================================================================================
4481
4482 mDNSlocal void
4483 UDPCloseSocket( UDPSocket * sock )
4484 {
4485 dlog( kDebugLevelChatty, DEBUG_NAME "closing UDPSocket %d\n", sock->fd );
4486
4487 if ( sock->fd != INVALID_SOCKET )
4488 {
4489 mDNSPollUnregisterSocket( sock->fd );
4490 closesocket( sock->fd );
4491 sock->fd = INVALID_SOCKET;
4492 }
4493 }
4494
4495
4496 //===========================================================================================================================
4497 // SetupAddr
4498 //===========================================================================================================================
4499
4500 mDNSlocal mStatus SetupAddr(mDNSAddr *ip, const struct sockaddr *const sa)
4501 {
4502 if (!sa) { LogMsg("SetupAddr ERROR: NULL sockaddr"); return(mStatus_Invalid); }
4503
4504 if (sa->sa_family == AF_INET)
4505 {
4506 struct sockaddr_in *ifa_addr = (struct sockaddr_in *)sa;
4507 ip->type = mDNSAddrType_IPv4;
4508 ip->ip.v4.NotAnInteger = ifa_addr->sin_addr.s_addr;
4509 return(mStatus_NoError);
4510 }
4511
4512 if (sa->sa_family == AF_INET6)
4513 {
4514 struct sockaddr_in6 *ifa_addr = (struct sockaddr_in6 *)sa;
4515 ip->type = mDNSAddrType_IPv6;
4516 if (IN6_IS_ADDR_LINKLOCAL(&ifa_addr->sin6_addr)) ifa_addr->sin6_addr.u.Word[1] = 0;
4517 ip->ip.v6 = *(mDNSv6Addr*)&ifa_addr->sin6_addr;
4518 return(mStatus_NoError);
4519 }
4520
4521 LogMsg("SetupAddr invalid sa_family %d", sa->sa_family);
4522 return(mStatus_Invalid);
4523 }
4524
4525
4526 mDNSlocal void GetDDNSFQDN( domainname *const fqdn )
4527 {
4528 LPSTR name = NULL;
4529 DWORD dwSize;
4530 DWORD enabled;
4531 HKEY key = NULL;
4532 OSStatus err;
4533
4534 check( fqdn );
4535
4536 // Initialize
4537
4538 fqdn->c[0] = '\0';
4539
4540 // Get info from Bonjour registry key
4541
4542 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode TEXT("\\DynDNS\\Setup\\") kServiceDynDNSHostNames, &key );
4543 require_noerr( err, exit );
4544
4545 err = RegQueryString( key, "", &name, &dwSize, &enabled );
4546 if ( !err && ( name[0] != '\0' ) && enabled )
4547 {
4548 if ( !MakeDomainNameFromDNSNameString( fqdn, name ) || !fqdn->c[0] )
4549 {
4550 dlog( kDebugLevelError, "bad DDNS host name in registry: %s", name[0] ? name : "(unknown)");
4551 }
4552 }
4553
4554 exit:
4555
4556 if ( key )
4557 {
4558 RegCloseKey( key );
4559 key = NULL;
4560 }
4561
4562 if ( name )
4563 {
4564 free( name );
4565 name = NULL;
4566 }
4567 }
4568
4569
4570 #ifdef UNICODE
4571 mDNSlocal void GetDDNSDomains( DNameListElem ** domains, LPCWSTR lpSubKey )
4572 #else
4573 mDNSlocal void GetDDNSConfig( DNameListElem ** domains, LPCSTR lpSubKey )
4574 #endif
4575 {
4576 char subKeyName[kRegistryMaxKeyLength + 1];
4577 DWORD cSubKeys = 0;
4578 DWORD cbMaxSubKey;
4579 DWORD cchMaxClass;
4580 DWORD dwSize;
4581 HKEY key = NULL;
4582 HKEY subKey = NULL;
4583 domainname dname;
4584 DWORD i;
4585 OSStatus err;
4586
4587 check( domains );
4588
4589 // Initialize
4590
4591 *domains = NULL;
4592
4593 err = RegCreateKey( HKEY_LOCAL_MACHINE, lpSubKey, &key );
4594 require_noerr( err, exit );
4595
4596 // Get information about this node
4597
4598 err = RegQueryInfoKey( key, NULL, NULL, NULL, &cSubKeys, &cbMaxSubKey, &cchMaxClass, NULL, NULL, NULL, NULL, NULL );
4599 require_noerr( err, exit );
4600
4601 for ( i = 0; i < cSubKeys; i++)
4602 {
4603 DWORD enabled;
4604
4605 dwSize = kRegistryMaxKeyLength;
4606
4607 err = RegEnumKeyExA( key, i, subKeyName, &dwSize, NULL, NULL, NULL, NULL );
4608
4609 if ( !err )
4610 {
4611 err = RegOpenKeyExA( key, subKeyName, 0, KEY_READ, &subKey );
4612 require_noerr( err, exit );
4613
4614 dwSize = sizeof( DWORD );
4615 err = RegQueryValueExA( subKey, "Enabled", NULL, NULL, (LPBYTE) &enabled, &dwSize );
4616
4617 if ( !err && ( subKeyName[0] != '\0' ) && enabled )
4618 {
4619 if ( !MakeDomainNameFromDNSNameString( &dname, subKeyName ) || !dname.c[0] )
4620 {
4621 dlog( kDebugLevelError, "bad DDNS domain in registry: %s", subKeyName[0] ? subKeyName : "(unknown)");
4622 }
4623 else
4624 {
4625 DNameListElem * domain = (DNameListElem*) malloc( sizeof( DNameListElem ) );
4626 require_action( domain, exit, err = mStatus_NoMemoryErr );
4627
4628 AssignDomainName(&domain->name, &dname);
4629 domain->next = *domains;
4630
4631 *domains = domain;
4632 }
4633 }
4634
4635 RegCloseKey( subKey );
4636 subKey = NULL;
4637 }
4638 }
4639
4640 exit:
4641
4642 if ( subKey )
4643 {
4644 RegCloseKey( subKey );
4645 }
4646
4647 if ( key )
4648 {
4649 RegCloseKey( key );
4650 }
4651 }
4652
4653
4654 mDNSlocal void SetDomainSecret( mDNS * const m, const domainname * inDomain )
4655 {
4656 char domainUTF8[ 256 ];
4657 DomainAuthInfo *foundInList;
4658 DomainAuthInfo *ptr;
4659 char outDomain[ 256 ];
4660 char outKey[ 256 ];
4661 char outSecret[ 256 ];
4662 OSStatus err;
4663
4664 ConvertDomainNameToCString( inDomain, domainUTF8 );
4665
4666 // If we're able to find a secret for this domain
4667
4668 if ( LsaGetSecret( domainUTF8, outDomain, sizeof( outDomain ), outKey, sizeof( outKey ), outSecret, sizeof( outSecret ) ) )
4669 {
4670 domainname domain;
4671 domainname key;
4672
4673 // Tell the core about this secret
4674
4675 MakeDomainNameFromDNSNameString( &domain, outDomain );
4676 MakeDomainNameFromDNSNameString( &key, outKey );
4677
4678 for (foundInList = m->AuthInfoList; foundInList; foundInList = foundInList->next)
4679 if (SameDomainName(&foundInList->domain, &domain ) ) break;
4680
4681 ptr = foundInList;
4682
4683 if (!ptr)
4684 {
4685 ptr = (DomainAuthInfo*)malloc(sizeof(DomainAuthInfo));
4686 require_action( ptr, exit, err = mStatus_NoMemoryErr );
4687 }
4688
4689 err = mDNS_SetSecretForDomain(m, ptr, &domain, &key, outSecret, NULL, NULL, FALSE );
4690 require_action( err != mStatus_BadParamErr, exit, if (!foundInList ) mDNSPlatformMemFree( ptr ) );
4691
4692 debugf("Setting shared secret for zone %s with key %##s", outDomain, key.c);
4693 }
4694
4695 exit:
4696
4697 return;
4698 }
4699
4700
4701 mDNSlocal VOID CALLBACK
4702 CheckFileSharesProc( LPVOID arg, DWORD dwTimerLowValue, DWORD dwTimerHighValue )
4703 {
4704 mDNS * const m = ( mDNS * const ) arg;
4705
4706 ( void ) dwTimerLowValue;
4707 ( void ) dwTimerHighValue;
4708
4709 CheckFileShares( m );
4710 }
4711
4712
4713 mDNSlocal unsigned __stdcall
4714 SMBRegistrationThread( void * arg )
4715 {
4716 mDNS * const m = ( mDNS * const ) arg;
4717 DNSServiceRef sref = NULL;
4718 HANDLE handles[ 3 ];
4719 mDNSu8 txtBuf[ 256 ];
4720 mDNSu8 * txtPtr;
4721 size_t keyLen;
4722 size_t valLen;
4723 mDNSIPPort port = { { SMBPortAsNumber >> 8, SMBPortAsNumber & 0xFF } };
4724 DNSServiceErrorType err;
4725
4726 DEBUG_UNUSED( arg );
4727
4728 handles[ 0 ] = gSMBThreadStopEvent;
4729 handles[ 1 ] = gSMBThreadRegisterEvent;
4730 handles[ 2 ] = gSMBThreadDeregisterEvent;
4731
4732 memset( txtBuf, 0, sizeof( txtBuf ) );
4733 txtPtr = txtBuf;
4734 keyLen = strlen( "netbios=" );
4735 valLen = strlen( m->p->nbname );
4736 require_action( valLen < 32, exit, err = kUnknownErr ); // This should never happen, but check to avoid further memory corruption
4737 *txtPtr++ = ( mDNSu8 ) ( keyLen + valLen );
4738 memcpy( txtPtr, "netbios=", keyLen );
4739 txtPtr += keyLen;
4740 if ( valLen ) { memcpy( txtPtr, m->p->nbname, valLen ); txtPtr += ( mDNSu8 ) valLen; }
4741 keyLen = strlen( "domain=" );
4742 valLen = strlen( m->p->nbdomain );
4743 require_action( valLen < 32, exit, err = kUnknownErr ); // This should never happen, but check to avoid further memory corruption
4744 *txtPtr++ = ( mDNSu8 )( keyLen + valLen );
4745 memcpy( txtPtr, "domain=", keyLen );
4746 txtPtr += keyLen;
4747 if ( valLen ) { memcpy( txtPtr, m->p->nbdomain, valLen ); txtPtr += valLen; }
4748
4749 for ( ;; )
4750 {
4751 DWORD ret;
4752
4753 ret = WaitForMultipleObjects( 3, handles, FALSE, INFINITE );
4754
4755 if ( ret != WAIT_FAILED )
4756 {
4757 if ( ret == kSMBStopEvent )
4758 {
4759 break;
4760 }
4761 else if ( ret == kSMBRegisterEvent )
4762 {
4763 err = gDNSServiceRegister( &sref, 0, 0, NULL, "_smb._tcp,_file", NULL, NULL, ( uint16_t ) port.NotAnInteger, ( mDNSu16 )( txtPtr - txtBuf ), txtBuf, NULL, NULL );
4764
4765 if ( err )
4766 {
4767 LogMsg( "SMBRegistrationThread: DNSServiceRegister returned %d\n", err );
4768 sref = NULL;
4769 break;
4770 }
4771 }
4772 else if ( ret == kSMBDeregisterEvent )
4773 {
4774 if ( sref )
4775 {
4776 gDNSServiceRefDeallocate( sref );
4777 sref = NULL;
4778 }
4779 }
4780 }
4781 else
4782 {
4783 LogMsg( "SMBRegistrationThread: WaitForMultipleObjects returned %d\n", GetLastError() );
4784 break;
4785 }
4786 }
4787
4788 exit:
4789
4790 if ( sref != NULL )
4791 {
4792 gDNSServiceRefDeallocate( sref );
4793 sref = NULL;
4794 }
4795
4796 SetEvent( gSMBThreadQuitEvent );
4797 _endthreadex( 0 );
4798 return 0;
4799 }
4800
4801
4802 mDNSlocal void
4803 CheckFileShares( mDNS * const m )
4804 {
4805 PSHARE_INFO_1 bufPtr = ( PSHARE_INFO_1 ) NULL;
4806 DWORD entriesRead = 0;
4807 DWORD totalEntries = 0;
4808 DWORD resume = 0;
4809 mDNSBool advertise = mDNSfalse;
4810 mDNSBool fileSharing = mDNSfalse;
4811 mDNSBool printSharing = mDNSfalse;
4812 HKEY key = NULL;
4813 BOOL retry = FALSE;
4814 NET_API_STATUS res;
4815 mStatus err;
4816
4817 check( m );
4818
4819 // Only do this if we're not shutting down
4820
4821 require_action_quiet( m->AdvertiseLocalAddresses && !m->ShutdownTime, exit, err = kNoErr );
4822
4823 err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode L"\\Services\\SMB", &key );
4824
4825 if ( !err )
4826 {
4827 DWORD dwSize = sizeof( DWORD );
4828 RegQueryValueEx( key, L"Advertise", NULL, NULL, (LPBYTE) &advertise, &dwSize );
4829 }
4830
4831 if ( advertise && mDNSIsFileAndPrintSharingEnabled( &retry ) )
4832 {
4833 dlog( kDebugLevelTrace, DEBUG_NAME "Sharing is enabled\n" );
4834
4835 res = NetShareEnum( NULL, 1, ( LPBYTE* )&bufPtr, MAX_PREFERRED_LENGTH, &entriesRead, &totalEntries, &resume );
4836
4837 if ( ( res == ERROR_SUCCESS ) || ( res == ERROR_MORE_DATA ) )
4838 {
4839 PSHARE_INFO_1 p = bufPtr;
4840 DWORD i;
4841
4842 for( i = 0; i < entriesRead; i++ )
4843 {
4844 // We are only interested if the user is sharing anything other
4845 // than the built-in "print$" source
4846
4847 if ( ( p->shi1_type == STYPE_DISKTREE ) && ( wcscmp( p->shi1_netname, TEXT( "print$" ) ) != 0 ) )
4848 {
4849 fileSharing = mDNStrue;
4850 }
4851 else if ( p->shi1_type == STYPE_PRINTQ )
4852 {
4853 printSharing = mDNStrue;
4854 }
4855
4856 p++;
4857 }
4858
4859 NetApiBufferFree( bufPtr );
4860 bufPtr = NULL;
4861 retry = FALSE;
4862 }
4863 else if ( res == NERR_ServerNotStarted )
4864 {
4865 retry = TRUE;
4866 }
4867 }
4868
4869 if ( retry )
4870 {
4871 __int64 qwTimeout;
4872 LARGE_INTEGER liTimeout;
4873
4874 qwTimeout = -m->p->checkFileSharesTimeout * 10000000;
4875 liTimeout.LowPart = ( DWORD )( qwTimeout & 0xFFFFFFFF );
4876 liTimeout.HighPart = ( LONG )( qwTimeout >> 32 );
4877
4878 SetWaitableTimer( m->p->checkFileSharesTimer, &liTimeout, 0, CheckFileSharesProc, m, FALSE );
4879 }
4880
4881 if ( !m->p->smbFileSharing && fileSharing )
4882 {
4883 if ( !gSMBThread )
4884 {
4885 if ( !gDNSSDLibrary )
4886 {
4887 gDNSSDLibrary = LoadLibrary( TEXT( "dnssd.dll" ) );
4888 require_action( gDNSSDLibrary, exit, err = GetLastError() );
4889 }
4890
4891 if ( !gDNSServiceRegister )
4892 {
4893 gDNSServiceRegister = ( DNSServiceRegisterFunc ) GetProcAddress( gDNSSDLibrary, "DNSServiceRegister" );
4894 require_action( gDNSServiceRegister, exit, err = GetLastError() );
4895 }
4896
4897 if ( !gDNSServiceRefDeallocate )
4898 {
4899 gDNSServiceRefDeallocate = ( DNSServiceRefDeallocateFunc ) GetProcAddress( gDNSSDLibrary, "DNSServiceRefDeallocate" );
4900 require_action( gDNSServiceRefDeallocate, exit, err = GetLastError() );
4901 }
4902
4903 if ( !gSMBThreadRegisterEvent )
4904 {
4905 gSMBThreadRegisterEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
4906 require_action( gSMBThreadRegisterEvent != NULL, exit, err = GetLastError() );
4907 }
4908
4909 if ( !gSMBThreadDeregisterEvent )
4910 {
4911 gSMBThreadDeregisterEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
4912 require_action( gSMBThreadDeregisterEvent != NULL, exit, err = GetLastError() );
4913 }
4914
4915 if ( !gSMBThreadStopEvent )
4916 {
4917 gSMBThreadStopEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
4918 require_action( gSMBThreadStopEvent != NULL, exit, err = GetLastError() );
4919 }
4920
4921 if ( !gSMBThreadQuitEvent )
4922 {
4923 gSMBThreadQuitEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
4924 require_action( gSMBThreadQuitEvent != NULL, exit, err = GetLastError() );
4925 }
4926
4927 gSMBThread = ( HANDLE ) _beginthreadex( NULL, 0, SMBRegistrationThread, m, 0, NULL );
4928 require_action( gSMBThread != NULL, exit, err = GetLastError() );
4929 }
4930
4931 SetEvent( gSMBThreadRegisterEvent );
4932
4933 m->p->smbFileSharing = mDNStrue;
4934 }
4935 else if ( m->p->smbFileSharing && !fileSharing )
4936 {
4937 dlog( kDebugLevelTrace, DEBUG_NAME "deregistering smb type\n" );
4938
4939 if ( gSMBThreadDeregisterEvent != NULL )
4940 {
4941 SetEvent( gSMBThreadDeregisterEvent );
4942 }
4943
4944 m->p->smbFileSharing = mDNSfalse;
4945 }
4946
4947 exit:
4948
4949 if ( key )
4950 {
4951 RegCloseKey( key );
4952 }
4953 }
4954
4955
4956 BOOL
4957 IsWOMPEnabled( mDNS * const m )
4958 {
4959 BOOL enabled;
4960
4961 mDNSInterfaceData * ifd;
4962
4963 enabled = FALSE;
4964
4965 for( ifd = m->p->interfaceList; ifd; ifd = ifd->next )
4966 {
4967 if ( IsWOMPEnabledForAdapter( ifd->name ) )
4968 {
4969 enabled = TRUE;
4970 break;
4971 }
4972 }
4973
4974 return enabled;
4975 }
4976
4977
4978 mDNSlocal mDNSu8
4979 IsWOMPEnabledForAdapter( const char * adapterName )
4980 {
4981 char fileName[80];
4982 NDIS_OID oid;
4983 DWORD count;
4984 HANDLE handle = INVALID_HANDLE_VALUE;
4985 NDIS_PNP_CAPABILITIES * pNPC = NULL;
4986 int err;
4987 mDNSu8 ok = TRUE;
4988
4989 require_action( adapterName != NULL, exit, ok = FALSE );
4990
4991 dlog( kDebugLevelTrace, DEBUG_NAME "IsWOMPEnabledForAdapter: %s\n", adapterName );
4992
4993 // Construct a device name to pass to CreateFile
4994
4995 strncpy_s( fileName, sizeof( fileName ), DEVICE_PREFIX, strlen( DEVICE_PREFIX ) );
4996 strcat_s( fileName, sizeof( fileName ), adapterName );
4997 handle = CreateFileA( fileName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, INVALID_HANDLE_VALUE );
4998 require_action ( handle != INVALID_HANDLE_VALUE, exit, ok = FALSE );
4999
5000 // We successfully opened the driver, format the IOCTL to pass the driver.
5001
5002 oid = OID_PNP_CAPABILITIES;
5003 pNPC = ( NDIS_PNP_CAPABILITIES * ) malloc( sizeof( NDIS_PNP_CAPABILITIES ) );
5004 require_action( pNPC != NULL, exit, ok = FALSE );
5005 ok = ( mDNSu8 ) DeviceIoControl( handle, IOCTL_NDIS_QUERY_GLOBAL_STATS, &oid, sizeof( oid ), pNPC, sizeof( NDIS_PNP_CAPABILITIES ), &count, NULL );
5006 err = translate_errno( ok, GetLastError(), kUnknownErr );
5007 require_action( !err, exit, ok = FALSE );
5008 ok = ( mDNSu8 ) ( ( count == sizeof( NDIS_PNP_CAPABILITIES ) ) && ( pNPC->Flags & NDIS_DEVICE_WAKE_ON_MAGIC_PACKET_ENABLE ) );
5009
5010 exit:
5011
5012 if ( pNPC != NULL )
5013 {
5014 free( pNPC );
5015 }
5016
5017 if ( handle != INVALID_HANDLE_VALUE )
5018 {
5019 CloseHandle( handle );
5020 }
5021
5022 dlog( kDebugLevelTrace, DEBUG_NAME "IsWOMPEnabledForAdapter returns %s\n", ok ? "true" : "false" );
5023
5024 return ( mDNSu8 ) ok;
5025 }
5026
5027
5028 mDNSlocal void
5029 SendWakeupPacket( mDNS * const inMDNS, LPSOCKADDR addr, INT addrlen, const char * buf, INT buflen, INT numTries, INT msecSleep )
5030 {
5031 mDNSBool repeat = ( numTries == 1 ) ? mDNStrue : mDNSfalse;
5032 SOCKET sock;
5033 int num;
5034 mStatus err;
5035
5036 ( void ) inMDNS;
5037
5038 sock = socket( addr->sa_family, SOCK_DGRAM, IPPROTO_UDP );
5039 require_action( sock != INVALID_SOCKET, exit, err = mStatus_UnknownErr );
5040
5041 while ( numTries-- )
5042 {
5043 num = sendto( sock, ( const char* ) buf, buflen, 0, addr, addrlen );
5044
5045 if ( num != buflen )
5046 {
5047 LogMsg( "SendWakeupPacket error: sent %d bytes: %d\n", num, WSAGetLastError() );
5048 }
5049
5050 if ( repeat )
5051 {
5052 num = sendto( sock, buf, buflen, 0, addr, addrlen );
5053
5054 if ( num != buflen )
5055 {
5056 LogMsg( "SendWakeupPacket error: sent %d bytes: %d\n", num, WSAGetLastError() );
5057 }
5058 }
5059
5060 if ( msecSleep )
5061 {
5062 Sleep( msecSleep );
5063 }
5064 }
5065
5066 exit:
5067
5068 if ( sock != INVALID_SOCKET )
5069 {
5070 closesocket( sock );
5071 }
5072 }
5073
5074
5075 mDNSlocal void _cdecl
5076 SendMulticastWakeupPacket( void *arg )
5077 {
5078 MulticastWakeupStruct *info = ( MulticastWakeupStruct* ) arg;
5079
5080 if ( info )
5081 {
5082 SendWakeupPacket( info->inMDNS, ( LPSOCKADDR ) &info->addr, sizeof( info->addr ), ( const char* ) info->data, sizeof( info->data ), info->numTries, info->msecSleep );
5083 free( info );
5084 }
5085
5086 _endthread();
5087 }
5088
5089
5090 mDNSexport void FreeEtcHosts(mDNS *const m, AuthRecord *const rr, mStatus result)
5091 {
5092 DEBUG_UNUSED( m );
5093 DEBUG_UNUSED( rr );
5094 DEBUG_UNUSED( result );
5095 }
mirror of mDNSResponder