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 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 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 555 mDNSexport void mDNSPlatformLock( const mDNS * const inMDNS ) 556 { 557 ( void ) inMDNS; 558 } 559 560 //=========================================================================================================================== 561 // mDNSPlatformUnlock 562 //=========================================================================================================================== 563 564 mDNSexport void mDNSPlatformUnlock( const mDNS * const inMDNS ) 565 { 566 ( void ) inMDNS; 567 } 568 569 //=========================================================================================================================== 570 // mDNSPlatformStrCopy 571 //=========================================================================================================================== 572 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 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 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 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 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 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 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 680 mDNSexport void mDNSPlatformMemFree( void *inMem ) 681 { 682 check( inMem ); 683 684 free( inMem ); 685 } 686 687 //=========================================================================================================================== 688 // mDNSPlatformRandomNumber 689 //=========================================================================================================================== 690 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 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 780 mDNSexport mDNSs32 mDNSPlatformRawTime( void ) 781 { 782 return( (mDNSs32) GetTickCount() ); 783 } 784 785 //=========================================================================================================================== 786 // mDNSPlatformUTC 787 //=========================================================================================================================== 788 789 mDNSexport mDNSs32 mDNSPlatformUTC( void ) 790 { 791 return ( mDNSs32 ) time( NULL ); 792 } 793 794 //=========================================================================================================================== 795 // mDNSPlatformInterfaceNameToID 796 //=========================================================================================================================== 797 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 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 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 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 * 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 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 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 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 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 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 1239 mDNSexport int mDNSPlatformTCPGetFD(TCPSocket *sock ) 1240 { 1241 return ( int ) sock->fd; 1242 } 1243 1244 1245 //=========================================================================================================================== 1246 // TCPAddConnection 1247 //=========================================================================================================================== 1248 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 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 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 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 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 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 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 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 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 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 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 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 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 1644 mDNSexport void mDNSPlatformWriteDebugMsg(const char *msg) 1645 { 1646 dlog( kDebugLevelInfo, "%s\n", msg ); 1647 } 1648 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 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 1685 mDNSPlatformTLSSetupCerts(void) 1686 { 1687 return mStatus_UnsupportedErr; 1688 } 1689 1690 //=========================================================================================================================== 1691 // mDNSPlatformTLSTearDownCerts 1692 //=========================================================================================================================== 1693 1694 mDNSexport 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 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 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 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 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 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 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 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 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 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 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 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 ) 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 ) 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 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 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 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 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 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 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 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 2903 mDNSlocal void CALLBACK FreeInterface( mDNSInterfaceData *inIFD ) 2904 { 2905 free( inIFD ); 2906 } 2907 2908 //=========================================================================================================================== 2909 // SetupSocket 2910 //=========================================================================================================================== 2911 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 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 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 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 //=========================================================================================================================== 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 //=========================================================================================================================== 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 //=========================================================================================================================== 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 //=========================================================================================================================== 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 //=========================================================================================================================== 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 //=========================================================================================================================== 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 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 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 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 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 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 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 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 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 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 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 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* 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
