mDNSWindows/mDNSWin32.c

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