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