/* -*- Mode: C; tab-width: 4 -*- * * Copyright (c) 2003-2004 Apple Computer, Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include "CommonServices.h" #include "DebugServices.h" #include "RegNames.h" #include "uds_daemon.h" #include "GenLinkedList.h" #include "Service.h" #include "EventLog.h" #include "Resource.h" #include "mDNSEmbeddedAPI.h" #include "uDNS.h" #include "mDNSWin32.h" #include "Firewall.h" #if( !TARGET_OS_WINDOWS_CE ) #include #include #include #include #include #include #include #include #include #endif #ifndef HeapEnableTerminationOnCorruption # define HeapEnableTerminationOnCorruption (HEAP_INFORMATION_CLASS)1 #endif #if 0 #pragma mark == Constants == #endif //=========================================================================================================================== // Constants //=========================================================================================================================== #define DEBUG_NAME "[mDNSWin32] " #define kServiceFirewallName L"Bonjour" #define kServiceDependencies TEXT("Tcpip\0\0") #define kDNSServiceCacheEntryCountDefault 512 #define kRetryFirewallPeriod 30 * 1000 #define kDefValueSize MAX_PATH + 1 #define kZeroIndex 0 #define kDefaultRouteMetric 399 #define kSecondsTo100NSUnits ( 10 * 1000 * 1000 ) #define kSPSMaintenanceWakePeriod -30 #define RR_CACHE_SIZE 500 static CacheEntity gRRCache[RR_CACHE_SIZE]; #if 0 #pragma mark == Structures == #endif //=========================================================================================================================== // Structures //=========================================================================================================================== typedef struct EventSource { HANDLE event; void * context; RegisterWaitableEventHandler handler; struct EventSource * next; } EventSource; static BOOL gEventSourceListChanged = FALSE; static EventSource * gEventSourceList = NULL; static EventSource * gCurrentSource = NULL; static int gEventSources = 0; #define kWaitListStopEvent ( WAIT_OBJECT_0 + 0 ) #define kWaitListInterfaceListChangedEvent ( WAIT_OBJECT_0 + 1 ) #define kWaitListComputerDescriptionEvent ( WAIT_OBJECT_0 + 2 ) #define kWaitListTCPIPEvent ( WAIT_OBJECT_0 + 3 ) #define kWaitListDynDNSEvent ( WAIT_OBJECT_0 + 4 ) #define kWaitListFileShareEvent ( WAIT_OBJECT_0 + 5 ) #define kWaitListFirewallEvent ( WAIT_OBJECT_0 + 6 ) #define kWaitListAdvertisedServicesEvent ( WAIT_OBJECT_0 + 7 ) #define kWaitListSPSWakeupEvent ( WAIT_OBJECT_0 + 8 ) #define kWaitListSPSSleepEvent ( WAIT_OBJECT_0 + 9 ) #define kWaitListFixedItemCount 10 #if 0 #pragma mark == Prototypes == #endif //=========================================================================================================================== // Prototypes //=========================================================================================================================== static void Usage( void ); static BOOL WINAPI ConsoleControlHandler( DWORD inControlEvent ); static OSStatus InstallService( LPCTSTR inName, LPCTSTR inDisplayName, LPCTSTR inDescription, LPCTSTR inPath ); static OSStatus RemoveService( LPCTSTR inName ); static OSStatus SetServiceParameters(); static OSStatus GetServiceParameters(); static OSStatus CheckFirewall(); static OSStatus SetServiceInfo( SC_HANDLE inSCM, LPCTSTR inServiceName, LPCTSTR inDescription ); static void ReportStatus( int inType, const char *inFormat, ... ); static void WINAPI ServiceMain( DWORD argc, LPTSTR argv[] ); static OSStatus ServiceSetupEventLogging( void ); static DWORD WINAPI ServiceControlHandler( DWORD inControl, DWORD inEventType, LPVOID inEventData, LPVOID inContext ); static OSStatus ServiceRun( int argc, LPTSTR argv[] ); static void ServiceStop( void ); static OSStatus ServiceSpecificInitialize( int argc, LPTSTR argv[] ); static OSStatus ServiceSpecificRun( int argc, LPTSTR argv[] ); static OSStatus ServiceSpecificStop( void ); static void ServiceSpecificFinalize( int argc, LPTSTR argv[] ); static mStatus SetupNotifications(); static mStatus TearDownNotifications(); static mStatus RegisterWaitableEvent( mDNS * const inMDNS, HANDLE event, void * context, RegisterWaitableEventHandler handler ); static void UnregisterWaitableEvent( mDNS * const inMDNS, HANDLE event ); static mStatus SetupWaitList( mDNS * const inMDNS, HANDLE **outWaitList, int *outWaitListCount ); static void UDSCanAccept( mDNS * const inMDNS, HANDLE event, void * context ); static void UDSCanRead( TCPSocket * sock ); static void HandlePowerSuspend( void * v ); static void HandlePowerResumeSuspend( void * v ); static void CoreCallback(mDNS * const inMDNS, mStatus result); static mDNSu8 SystemWakeForNetworkAccess( LARGE_INTEGER * timeout ); static OSStatus GetRouteDestination(DWORD * ifIndex, DWORD * address); static OSStatus SetLLRoute( mDNS * const inMDNS ); static bool HaveRoute( PMIB_IPFORWARDROW rowExtant, unsigned long addr, unsigned long metric ); static bool IsValidAddress( const char * addr ); static bool IsNortelVPN( IP_ADAPTER_INFO * pAdapter ); static bool IsJuniperVPN( IP_ADAPTER_INFO * pAdapter ); static bool IsCiscoVPN( IP_ADAPTER_INFO * pAdapter ); static const char * strnistr( const char * string, const char * subString, size_t max ); #if defined(UNICODE) # define StrLen(X) wcslen(X) # define StrCmp(X,Y) wcscmp(X,Y) #else # define StrLen(X) strlen(X) # define StrCmp(X,Y) strcmp(X,Y) #endif #define kLLNetworkAddr "169.254.0.0" #define kLLNetworkAddrMask "255.255.0.0" #include "mDNSEmbeddedAPI.h" #if 0 #pragma mark == Globals == #endif //=========================================================================================================================== // Globals //=========================================================================================================================== #define gMDNSRecord mDNSStorage DEBUG_LOCAL mDNS_PlatformSupport gPlatformStorage; DEBUG_LOCAL BOOL gServiceQuietMode = FALSE; DEBUG_LOCAL SERVICE_TABLE_ENTRY gServiceDispatchTable[] = { { kServiceName, ServiceMain }, { NULL, NULL } }; DEBUG_LOCAL SOCKET gInterfaceListChangedSocket = INVALID_SOCKET; DEBUG_LOCAL HANDLE gInterfaceListChangedEvent = NULL; DEBUG_LOCAL HKEY gDescKey = NULL; DEBUG_LOCAL HANDLE gDescChangedEvent = NULL; // Computer description changed event DEBUG_LOCAL HKEY gTcpipKey = NULL; DEBUG_LOCAL HANDLE gTcpipChangedEvent = NULL; // TCP/IP config changed DEBUG_LOCAL HKEY gDdnsKey = NULL; DEBUG_LOCAL HANDLE gDdnsChangedEvent = NULL; // DynDNS config changed DEBUG_LOCAL HKEY gFileSharingKey = NULL; DEBUG_LOCAL HANDLE gFileSharingChangedEvent = NULL; // File Sharing changed DEBUG_LOCAL HKEY gFirewallKey = NULL; DEBUG_LOCAL HANDLE gFirewallChangedEvent = NULL; // Firewall changed DEBUG_LOCAL HKEY gAdvertisedServicesKey = NULL; DEBUG_LOCAL HANDLE gAdvertisedServicesChangedEvent = NULL; // Advertised services changed DEBUG_LOCAL SERVICE_STATUS gServiceStatus; DEBUG_LOCAL SERVICE_STATUS_HANDLE gServiceStatusHandle = NULL; DEBUG_LOCAL HANDLE gServiceEventSource = NULL; DEBUG_LOCAL bool gServiceAllowRemote = false; DEBUG_LOCAL int gServiceCacheEntryCount = 0; // 0 means to use the DNS-SD default. DEBUG_LOCAL bool gServiceManageLLRouting = true; DEBUG_LOCAL int gWaitCount = 0; DEBUG_LOCAL HANDLE * gWaitList = NULL; DEBUG_LOCAL HANDLE gStopEvent = NULL; DEBUG_LOCAL HANDLE gSPSWakeupEvent = NULL; DEBUG_LOCAL HANDLE gSPSSleepEvent = NULL; DEBUG_LOCAL HANDLE gUDSEvent = NULL; DEBUG_LOCAL SocketRef gUDSSocket = 0; DEBUG_LOCAL udsEventCallback gUDSCallback = NULL; DEBUG_LOCAL BOOL gRetryFirewall = FALSE; DEBUG_LOCAL DWORD gOSMajorVersion; DEBUG_LOCAL DWORD gOSMinorVersion; typedef DWORD ( WINAPI * GetIpInterfaceEntryFunctionPtr )( PMIB_IPINTERFACE_ROW ); mDNSlocal HMODULE gIPHelperLibraryInstance = NULL; mDNSlocal GetIpInterfaceEntryFunctionPtr gGetIpInterfaceEntryFunctionPtr = NULL; #if 0 #pragma mark - #endif //=========================================================================================================================== // Main //=========================================================================================================================== int Main( int argc, LPTSTR argv[] ) { OSStatus err; BOOL ok; BOOL start; int i; HeapSetInformation( NULL, HeapEnableTerminationOnCorruption, NULL, 0 ); debug_initialize( kDebugOutputTypeMetaConsole ); debug_set_property( kDebugPropertyTagPrintLevel, kDebugLevelVerbose ); // Default to automatically starting the service dispatcher if no extra arguments are specified. start = ( argc <= 1 ); // Parse arguments. for( i = 1; i < argc; ++i ) { if( StrCmp( argv[ i ], TEXT("-install") ) == 0 ) // Install { TCHAR desc[ 256 ]; desc[ 0 ] = 0; LoadString( GetModuleHandle( NULL ), IDS_SERVICE_DESCRIPTION, desc, sizeof( desc ) ); err = InstallService( kServiceName, kServiceName, desc, argv[0] ); if( err ) { ReportStatus( EVENTLOG_ERROR_TYPE, "install service failed (%d)\n", err ); goto exit; } } else if( StrCmp( argv[ i ], TEXT("-remove") ) == 0 ) // Remove { err = RemoveService( kServiceName ); if( err ) { ReportStatus( EVENTLOG_ERROR_TYPE, "remove service failed (%d)\n", err ); goto exit; } } else if( StrCmp( argv[ i ], TEXT("-start") ) == 0 ) // Start { start = TRUE; } else if( StrCmp( argv[ i ], TEXT("-server") ) == 0 ) // Server { err = RunDirect( argc, argv ); if( err ) { ReportStatus( EVENTLOG_ERROR_TYPE, "run service directly failed (%d)\n", err ); } goto exit; } else if( StrCmp( argv[ i ], TEXT("-q") ) == 0 ) // Quiet Mode (toggle) { gServiceQuietMode = !gServiceQuietMode; } else if( ( StrCmp( argv[ i ], TEXT("-help") ) == 0 ) || // Help ( StrCmp( argv[ i ], TEXT("-h") ) == 0 ) ) { Usage(); err = 0; break; } else { Usage(); err = kParamErr; break; } } // Start the service dispatcher if requested. This does not return until all services have terminated. If any // global initialization is needed, it should be done before starting the service dispatcher, but only if it // will take less than 30 seconds. Otherwise, use a separate thread for it and start the dispatcher immediately. if( start ) { ok = StartServiceCtrlDispatcher( gServiceDispatchTable ); err = translate_errno( ok, (OSStatus) GetLastError(), kInUseErr ); if( err != kNoErr ) { ReportStatus( EVENTLOG_ERROR_TYPE, "start service dispatcher failed (%d)\n", err ); goto exit; } } err = 0; exit: dlog( kDebugLevelTrace, DEBUG_NAME "exited (%d %m)\n", err, err ); _CrtDumpMemoryLeaks(); return( (int) err ); } //=========================================================================================================================== // Usage //=========================================================================================================================== static void Usage( void ) { fprintf( stderr, "\n" ); fprintf( stderr, "mDNSResponder 1.0d1\n" ); fprintf( stderr, "\n" ); fprintf( stderr, " Runs the service normally\n" ); fprintf( stderr, " -install Creates the service and starts it\n" ); fprintf( stderr, " -remove Stops the service and deletes it\n" ); fprintf( stderr, " -start Starts the service dispatcher after processing all other arguments\n" ); fprintf( stderr, " -server Runs the service directly as a server (for debugging)\n" ); fprintf( stderr, " -q Toggles Quiet Mode (no events or output)\n" ); fprintf( stderr, " -remote Allow remote connections\n" ); fprintf( stderr, " -cache n Number of mDNS cache entries (defaults to %d)\n", kDNSServiceCacheEntryCountDefault ); fprintf( stderr, " -h[elp] Display Help/Usage\n" ); fprintf( stderr, "\n" ); } //=========================================================================================================================== // ConsoleControlHandler //=========================================================================================================================== static BOOL WINAPI ConsoleControlHandler( DWORD inControlEvent ) { BOOL handled; OSStatus err; handled = FALSE; switch( inControlEvent ) { case CTRL_C_EVENT: case CTRL_BREAK_EVENT: case CTRL_CLOSE_EVENT: case CTRL_LOGOFF_EVENT: case CTRL_SHUTDOWN_EVENT: err = ServiceSpecificStop(); require_noerr( err, exit ); handled = TRUE; break; default: break; } exit: return( handled ); } //=========================================================================================================================== // InstallService //=========================================================================================================================== static OSStatus InstallService( LPCTSTR inName, LPCTSTR inDisplayName, LPCTSTR inDescription, LPCTSTR inPath ) { OSStatus err; SC_HANDLE scm; SC_HANDLE service; BOOL ok; TCHAR fullPath[ MAX_PATH ]; TCHAR * namePtr; DWORD size; scm = NULL; service = NULL; // Get a full path to the executable since a relative path may have been specified. size = GetFullPathName( inPath, MAX_PATH, fullPath, &namePtr ); err = translate_errno( size > 0, (OSStatus) GetLastError(), kPathErr ); require_noerr( err, exit ); // Create the service and start it. scm = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); err = translate_errno( scm, (OSStatus) GetLastError(), kOpenErr ); require_noerr( err, exit ); service = CreateService( scm, inName, inDisplayName, SERVICE_ALL_ACCESS, SERVICE_WIN32_SHARE_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, fullPath, NULL, NULL, kServiceDependencies, NULL, NULL ); err = translate_errno( service, (OSStatus) GetLastError(), kDuplicateErr ); require_noerr( err, exit ); err = SetServiceParameters(); check_noerr( err ); if( inDescription ) { err = SetServiceInfo( scm, inName, inDescription ); check_noerr( err ); } ok = StartService( service, 0, NULL ); err = translate_errno( ok, (OSStatus) GetLastError(), kInUseErr ); require_noerr( err, exit ); ReportStatus( EVENTLOG_SUCCESS, "installed service\n" ); err = kNoErr; exit: if( service ) { CloseServiceHandle( service ); } if( scm ) { CloseServiceHandle( scm ); } return( err ); } //=========================================================================================================================== // RemoveService //=========================================================================================================================== static OSStatus RemoveService( LPCTSTR inName ) { OSStatus err; SC_HANDLE scm; SC_HANDLE service; BOOL ok; SERVICE_STATUS status; scm = NULL; service = NULL; // Open a connection to the service. scm = OpenSCManager( 0, 0, SC_MANAGER_ALL_ACCESS ); err = translate_errno( scm, (OSStatus) GetLastError(), kOpenErr ); require_noerr( err, exit ); service = OpenService( scm, inName, SERVICE_STOP | SERVICE_QUERY_STATUS | DELETE ); err = translate_errno( service, (OSStatus) GetLastError(), kNotFoundErr ); require_noerr( err, exit ); // Stop the service, if it is not already stopped, then delete it. ok = QueryServiceStatus( service, &status ); err = translate_errno( ok, (OSStatus) GetLastError(), kAuthenticationErr ); require_noerr( err, exit ); if( status.dwCurrentState != SERVICE_STOPPED ) { ok = ControlService( service, SERVICE_CONTROL_STOP, &status ); check_translated_errno( ok, (OSStatus) GetLastError(), kAuthenticationErr ); } ok = DeleteService( service ); err = translate_errno( ok, (OSStatus) GetLastError(), kDeletedErr ); require_noerr( err, exit ); ReportStatus( EVENTLOG_SUCCESS, "Removed service\n" ); err = ERROR_SUCCESS; exit: if( service ) { CloseServiceHandle( service ); } if( scm ) { CloseServiceHandle( scm ); } return( err ); } //=========================================================================================================================== // SetServiceParameters //=========================================================================================================================== static OSStatus SetServiceParameters() { DWORD value; DWORD valueLen = sizeof(DWORD); DWORD type; OSStatus err; HKEY key; key = NULL; // // Add/Open Parameters section under service entry in registry // err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode, &key ); require_noerr( err, exit ); // // If the value isn't already there, then we create it // err = RegQueryValueEx(key, kServiceManageLLRouting, 0, &type, (LPBYTE) &value, &valueLen); if (err != ERROR_SUCCESS) { value = 1; err = RegSetValueEx( key, kServiceManageLLRouting, 0, REG_DWORD, (const LPBYTE) &value, sizeof(DWORD) ); require_noerr( err, exit ); } exit: if ( key ) { RegCloseKey( key ); } return( err ); } //=========================================================================================================================== // GetServiceParameters //=========================================================================================================================== static OSStatus GetServiceParameters() { DWORD value; DWORD valueLen; DWORD type; OSStatus err; HKEY key; key = NULL; // // Add/Open Parameters section under service entry in registry // err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode, &key ); require_noerr( err, exit ); valueLen = sizeof(DWORD); err = RegQueryValueEx(key, kServiceManageLLRouting, 0, &type, (LPBYTE) &value, &valueLen); if (err == ERROR_SUCCESS) { gServiceManageLLRouting = (value) ? true : false; } valueLen = sizeof(DWORD); err = RegQueryValueEx(key, kServiceCacheEntryCount, 0, &type, (LPBYTE) &value, &valueLen); if (err == ERROR_SUCCESS) { gServiceCacheEntryCount = value; } exit: if ( key ) { RegCloseKey( key ); } return( err ); } //=========================================================================================================================== // CheckFirewall //=========================================================================================================================== static OSStatus CheckFirewall() { DWORD value; DWORD valueLen; DWORD type; ENUM_SERVICE_STATUS * lpService = NULL; SC_HANDLE sc = NULL; HKEY key = NULL; BOOL ok; DWORD bytesNeeded = 0; DWORD srvCount; DWORD resumeHandle = 0; DWORD srvType; DWORD srvState; DWORD dwBytes = 0; DWORD i; BOOL isRunning = FALSE; OSStatus err = kUnknownErr; // Check to see if the firewall service is running. If it isn't, then // we want to return immediately sc = OpenSCManager( NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE ); err = translate_errno( sc, GetLastError(), kUnknownErr ); require_noerr( err, exit ); srvType = SERVICE_WIN32; srvState = SERVICE_STATE_ALL; for ( ;; ) { // Call EnumServicesStatus using the handle returned by OpenSCManager ok = EnumServicesStatus ( sc, srvType, srvState, lpService, dwBytes, &bytesNeeded, &srvCount, &resumeHandle ); if ( ok || ( GetLastError() != ERROR_MORE_DATA ) ) { break; } if ( lpService ) { free( lpService ); } dwBytes = bytesNeeded; lpService = ( ENUM_SERVICE_STATUS* ) malloc( dwBytes ); require_action( lpService, exit, err = mStatus_NoMemoryErr ); } err = translate_errno( ok, GetLastError(), kUnknownErr ); require_noerr( err, exit ); for ( i = 0; i < srvCount; i++ ) { if ( wcscmp( lpService[i].lpServiceName, L"SharedAccess" ) == 0 ) { if ( lpService[i].ServiceStatus.dwCurrentState == SERVICE_RUNNING ) { isRunning = TRUE; } break; } } require_action( isRunning, exit, err = kUnknownErr ); // Check to see if we've managed the firewall. // This package might have been installed, then // the OS was upgraded to SP2 or above. If that's // the case, then we need to manipulate the firewall // so networking works correctly. err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode, &key ); require_noerr( err, exit ); valueLen = sizeof(DWORD); err = RegQueryValueEx(key, kServiceManageFirewall, 0, &type, (LPBYTE) &value, &valueLen); if ((err != ERROR_SUCCESS) || (value == 0)) { wchar_t fullPath[ MAX_PATH ]; DWORD size; // Get a full path to the executable size = GetModuleFileNameW( NULL, fullPath, MAX_PATH ); err = translate_errno( size > 0, (OSStatus) GetLastError(), kPathErr ); require_noerr( err, exit ); err = mDNSAddToFirewall(fullPath, kServiceFirewallName); require_noerr( err, exit ); value = 1; err = RegSetValueEx( key, kServiceManageFirewall, 0, REG_DWORD, (const LPBYTE) &value, sizeof( DWORD ) ); require_noerr( err, exit ); } exit: if ( key ) { RegCloseKey( key ); } if ( lpService ) { free( lpService ); } if ( sc ) { CloseServiceHandle ( sc ); } return( err ); } //=========================================================================================================================== // SetServiceInfo //=========================================================================================================================== static OSStatus SetServiceInfo( SC_HANDLE inSCM, LPCTSTR inServiceName, LPCTSTR inDescription ) { OSStatus err; SC_LOCK lock; SC_HANDLE service; SERVICE_DESCRIPTION description; SERVICE_FAILURE_ACTIONS actions; SC_ACTION action; BOOL ok; check( inServiceName ); check( inDescription ); lock = NULL; service = NULL; // Open the database (if not provided) and lock it to prevent other access while re-configuring. if( !inSCM ) { inSCM = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); err = translate_errno( inSCM, (OSStatus) GetLastError(), kOpenErr ); require_noerr( err, exit ); } lock = LockServiceDatabase( inSCM ); err = translate_errno( lock, (OSStatus) GetLastError(), kInUseErr ); require_noerr( err, exit ); // Open a handle to the service. service = OpenService( inSCM, inServiceName, SERVICE_CHANGE_CONFIG|SERVICE_START ); err = translate_errno( service, (OSStatus) GetLastError(), kNotFoundErr ); require_noerr( err, exit ); // Change the description. description.lpDescription = (LPTSTR) inDescription; ok = ChangeServiceConfig2( service, SERVICE_CONFIG_DESCRIPTION, &description ); err = translate_errno( ok, (OSStatus) GetLastError(), kParamErr ); require_noerr( err, exit ); actions.dwResetPeriod = INFINITE; actions.lpRebootMsg = NULL; actions.lpCommand = NULL; actions.cActions = 1; actions.lpsaActions = &action; action.Delay = 500; action.Type = SC_ACTION_RESTART; ok = ChangeServiceConfig2( service, SERVICE_CONFIG_FAILURE_ACTIONS, &actions ); err = translate_errno( ok, (OSStatus) GetLastError(), kParamErr ); require_noerr( err, exit ); err = ERROR_SUCCESS; exit: // Close the service and release the lock. if( service ) { CloseServiceHandle( service ); } if( lock ) { UnlockServiceDatabase( lock ); } return( err ); } //=========================================================================================================================== // ReportStatus //=========================================================================================================================== static void ReportStatus( int inType, const char *inFormat, ... ) { if( !gServiceQuietMode ) { va_list args; va_start( args, inFormat ); if( gServiceEventSource ) { char s[ 1024 ]; BOOL ok; const char * array[ 1 ]; vsprintf( s, inFormat, args ); array[ 0 ] = s; ok = ReportEventA( gServiceEventSource, (WORD) inType, 0, MDNSRESPONDER_LOG, NULL, 1, 0, array, NULL ); check_translated_errno( ok, GetLastError(), kUnknownErr ); } else { int n; n = vfprintf( stderr, inFormat, args ); check( n >= 0 ); } va_end( args ); } } //=========================================================================================================================== // RunDirect //=========================================================================================================================== int RunDirect( int argc, LPTSTR argv[] ) { OSStatus err; BOOL initialized; BOOL ok; initialized = FALSE; // Install a Console Control Handler to handle things like control-c signals. ok = SetConsoleCtrlHandler( ConsoleControlHandler, TRUE ); err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = ServiceSpecificInitialize( argc, argv ); require_noerr( err, exit ); initialized = TRUE; // Run the service. This does not return until the service quits or is stopped. ReportStatus( EVENTLOG_INFORMATION_TYPE, "Running service directly\n" ); err = ServiceSpecificRun( argc, argv ); require_noerr( err, exit ); // Clean up. exit: if( initialized ) { ServiceSpecificFinalize( argc, argv ); } return( err ); } #if 0 #pragma mark - #endif //=========================================================================================================================== // ServiceMain //=========================================================================================================================== static void WINAPI ServiceMain( DWORD argc, LPTSTR argv[] ) { OSStatus err; BOOL ok; err = ServiceSetupEventLogging(); check_noerr( err ); err = GetServiceParameters(); check_noerr( err ); // Initialize the service status and register the service control handler with the name of the service. gServiceStatus.dwServiceType = SERVICE_WIN32_SHARE_PROCESS; gServiceStatus.dwCurrentState = 0; gServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_SHUTDOWN|SERVICE_ACCEPT_POWEREVENT; gServiceStatus.dwWin32ExitCode = NO_ERROR; gServiceStatus.dwServiceSpecificExitCode = NO_ERROR; gServiceStatus.dwCheckPoint = 0; gServiceStatus.dwWaitHint = 0; gServiceStatusHandle = RegisterServiceCtrlHandlerEx( argv[ 0 ], ServiceControlHandler, NULL ); err = translate_errno( gServiceStatusHandle, (OSStatus) GetLastError(), kInUseErr ); require_noerr( err, exit ); // Mark the service as starting. gServiceStatus.dwCurrentState = SERVICE_START_PENDING; gServiceStatus.dwCheckPoint = 0; gServiceStatus.dwWaitHint = 5000; // 5 seconds ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); check_translated_errno( ok, GetLastError(), kParamErr ); // Run the service. This does not return until the service quits or is stopped. err = ServiceRun( (int) argc, argv ); if( err != kNoErr ) { gServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR; gServiceStatus.dwServiceSpecificExitCode = (DWORD) err; } // Service-specific work is done so mark the service as stopped. gServiceStatus.dwCurrentState = SERVICE_STOPPED; ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); check_translated_errno( ok, GetLastError(), kParamErr ); // Note: The service status handle should not be closed according to Microsoft documentation. exit: if( gServiceEventSource ) { ok = DeregisterEventSource( gServiceEventSource ); check_translated_errno( ok, GetLastError(), kUnknownErr ); gServiceEventSource = NULL; } } //=========================================================================================================================== // ServiceSetupEventLogging //=========================================================================================================================== static OSStatus ServiceSetupEventLogging( void ) { OSStatus err; HKEY key; LPCTSTR s; DWORD typesSupported; TCHAR path[ MAX_PATH ]; DWORD n; key = NULL; // Add/Open source name as a sub-key under the Application key in the EventLog registry key. s = TEXT("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\") kServiceName; err = RegCreateKey( HKEY_LOCAL_MACHINE, s, &key ); require_noerr( err, exit ); // Add the name to the EventMessageFile subkey. path[ 0 ] = '\0'; GetModuleFileName( NULL, path, MAX_PATH ); n = (DWORD) ( ( StrLen( path ) + 1 ) * sizeof( TCHAR ) ); err = RegSetValueEx( key, TEXT("EventMessageFile"), 0, REG_EXPAND_SZ, (const LPBYTE) path, n ); require_noerr( err, exit ); // Set the supported event types in the TypesSupported subkey. typesSupported = 0 | EVENTLOG_SUCCESS | EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE | EVENTLOG_AUDIT_SUCCESS | EVENTLOG_AUDIT_FAILURE; err = RegSetValueEx( key, TEXT("TypesSupported"), 0, REG_DWORD, (const LPBYTE) &typesSupported, sizeof( DWORD ) ); require_noerr( err, exit ); // Set up the event source. gServiceEventSource = RegisterEventSource( NULL, kServiceName ); err = translate_errno( gServiceEventSource, (OSStatus) GetLastError(), kParamErr ); require_noerr( err, exit ); exit: if( key ) { RegCloseKey( key ); } return( err ); } //=========================================================================================================================== // HandlePowerSuspend //=========================================================================================================================== static void HandlePowerSuspend( void * v ) { LARGE_INTEGER timeout; BOOL ok; ( void ) v; dlog( kDebugLevelInfo, DEBUG_NAME "HandlePowerSuspend\n" ); gMDNSRecord.SystemWakeOnLANEnabled = SystemWakeForNetworkAccess( &timeout ); if ( gMDNSRecord.SystemWakeOnLANEnabled ) { ok = SetWaitableTimer( gSPSWakeupEvent, &timeout, 0, NULL, NULL, TRUE ); check( ok ); } mDNSCoreMachineSleep(&gMDNSRecord, TRUE); } //=========================================================================================================================== // HandlePowerResumeSuspend //=========================================================================================================================== static void HandlePowerResumeSuspend( void * v ) { ( void ) v; dlog( kDebugLevelInfo, DEBUG_NAME "HandlePowerResumeSuspend\n" ); if ( gSPSWakeupEvent ) { CancelWaitableTimer( gSPSWakeupEvent ); } if ( gSPSSleepEvent ) { CancelWaitableTimer( gSPSSleepEvent ); } mDNSCoreMachineSleep(&gMDNSRecord, FALSE); } //=========================================================================================================================== // ServiceControlHandler //=========================================================================================================================== static DWORD WINAPI ServiceControlHandler( DWORD inControl, DWORD inEventType, LPVOID inEventData, LPVOID inContext ) { BOOL setStatus; BOOL ok; DEBUG_UNUSED( inEventData ); DEBUG_UNUSED( inContext ); setStatus = TRUE; switch( inControl ) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: dlog( kDebugLevelInfo, DEBUG_NAME "ServiceControlHandler: SERVICE_CONTROL_STOP|SERVICE_CONTROL_SHUTDOWN\n" ); ServiceStop(); setStatus = FALSE; break; case SERVICE_CONTROL_POWEREVENT: if (inEventType == PBT_APMSUSPEND) { dlog( kDebugLevelInfo, DEBUG_NAME "ServiceControlHandler: PBT_APMSUSPEND\n" ); QueueUserAPC( ( PAPCFUNC ) HandlePowerSuspend, gMDNSRecord.p->mainThread, ( ULONG_PTR ) NULL ); } else if (inEventType == PBT_APMRESUMESUSPEND) { dlog( kDebugLevelInfo, DEBUG_NAME "ServiceControlHandler: PBT_APMRESUMESUSPEND\n" ); QueueUserAPC( ( PAPCFUNC ) HandlePowerResumeSuspend, gMDNSRecord.p->mainThread, ( ULONG_PTR ) NULL ); } break; default: dlog( kDebugLevelNotice, DEBUG_NAME "ServiceControlHandler: event (0x%08X)\n", inControl ); break; } if( setStatus && gServiceStatusHandle ) { ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); check_translated_errno( ok, GetLastError(), kUnknownErr ); } return NO_ERROR; } //=========================================================================================================================== // ServiceRun //=========================================================================================================================== static OSStatus ServiceRun( int argc, LPTSTR argv[] ) { OSStatus err; BOOL initialized; BOOL ok; DEBUG_UNUSED( argc ); DEBUG_UNUSED( argv ); initialized = FALSE; // Make the service as running before we call ServiceSpecificInitialize. We've // had reports that some machines with McAfee firewall installed cause a problem with iTunes installation. // We think that the firewall product is interferring with code in ServiceSpecificInitialize. So as a // simple workaround, we'll mark us as running *before* we call ServiceSpecificInitialize. This will unblock // any installers that are waiting for our state to change. gServiceStatus.dwCurrentState = SERVICE_RUNNING; ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); check_translated_errno( ok, GetLastError(), kParamErr ); // Initialize the service-specific stuff err = ServiceSpecificInitialize( argc, argv ); require_noerr( err, exit ); initialized = TRUE; err = CheckFirewall(); check_noerr( err ); if ( err ) { gRetryFirewall = TRUE; } // Run the service-specific stuff. This does not return until the service quits or is stopped. ReportStatus( EVENTLOG_INFORMATION_TYPE, "Service started\n" ); err = ServiceSpecificRun( argc, argv ); ReportStatus( EVENTLOG_INFORMATION_TYPE, "Service stopped (%d)\n", err ); require_noerr( err, exit ); // Service stopped. Clean up and we're done. exit: if( initialized ) { ServiceSpecificFinalize( argc, argv ); } return( err ); } //=========================================================================================================================== // ServiceStop //=========================================================================================================================== static void ServiceStop( void ) { BOOL ok; OSStatus err; // Signal the event to cause the service to exit. if( gServiceStatusHandle ) { gServiceStatus.dwCurrentState = SERVICE_STOP_PENDING; ok = SetServiceStatus( gServiceStatusHandle, &gServiceStatus ); check_translated_errno( ok, GetLastError(), kParamErr ); } err = ServiceSpecificStop(); check_noerr( err ); } #if 0 #pragma mark - #pragma mark == Service Specific == #endif //=========================================================================================================================== // ServiceSpecificInitialize //=========================================================================================================================== static OSStatus ServiceSpecificInitialize( int argc, LPTSTR argv[] ) { OSVERSIONINFO osInfo; OSStatus err; BOOL ok; DEBUG_UNUSED( argc ); DEBUG_UNUSED( argv ); mDNSPlatformMemZero( &gMDNSRecord, sizeof gMDNSRecord); mDNSPlatformMemZero( &gPlatformStorage, sizeof gPlatformStorage); gPlatformStorage.registerWaitableEventFunc = RegisterWaitableEvent; gPlatformStorage.unregisterWaitableEventFunc = UnregisterWaitableEvent; gPlatformStorage.reportStatusFunc = ReportStatus; err = mDNS_Init( &gMDNSRecord, &gPlatformStorage, gRRCache, RR_CACHE_SIZE, mDNS_Init_AdvertiseLocalAddresses, CoreCallback, mDNS_Init_NoInitCallbackContext); require_noerr( err, exit); err = SetupNotifications(); check_noerr( err ); err = udsserver_init(mDNSNULL, 0); require_noerr( err, exit); // // Get the version of Windows that we're running on // osInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); ok = GetVersionEx( &osInfo ); err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); gOSMajorVersion = osInfo.dwMajorVersion; gOSMinorVersion = osInfo.dwMinorVersion; SetLLRoute( &gMDNSRecord ); exit: if( err != kNoErr ) { ServiceSpecificFinalize( argc, argv ); } return( err ); } //=========================================================================================================================== // ServiceSpecificRun //=========================================================================================================================== static OSStatus ServiceSpecificRun( int argc, LPTSTR argv[] ) { HANDLE * waitList; int waitListCount; DWORD timeout; DWORD result; BOOL done; mStatus err; DEBUG_UNUSED( argc ); DEBUG_UNUSED( argv ); timeout = ( gRetryFirewall ) ? kRetryFirewallPeriod : INFINITE; err = SetupInterfaceList( &gMDNSRecord ); check( !err ); err = uDNS_SetupDNSConfig( &gMDNSRecord ); check( !err ); done = FALSE; // Main event loop. while( !done ) { waitList = NULL; waitListCount = 0; err = SetupWaitList( &gMDNSRecord, &waitList, &waitListCount ); require_noerr( err, exit ); gEventSourceListChanged = FALSE; while ( !gEventSourceListChanged ) { static mDNSs32 RepeatedBusy = 0; mDNSs32 nextTimerEvent; // Give the mDNS core a chance to do its work and determine next event time. nextTimerEvent = udsserver_idle( mDNS_Execute( &gMDNSRecord ) - mDNS_TimeNow( &gMDNSRecord ) ); if ( nextTimerEvent < 0) nextTimerEvent = 0; else if ( nextTimerEvent > (0x7FFFFFFF / 1000)) nextTimerEvent = 0x7FFFFFFF / mDNSPlatformOneSecond; else nextTimerEvent = ( nextTimerEvent * 1000) / mDNSPlatformOneSecond; // Debugging sanity check, to guard against CPU spins if ( nextTimerEvent > 0 ) { RepeatedBusy = 0; } else { nextTimerEvent = 1; if ( ++RepeatedBusy >= mDNSPlatformOneSecond ) { ShowTaskSchedulingError( &gMDNSRecord ); RepeatedBusy = 0; } } if ( gMDNSRecord.ShutdownTime ) { mDNSs32 now = mDNS_TimeNow( &gMDNSRecord ); if ( mDNS_ExitNow( &gMDNSRecord, now ) ) { mDNS_FinalExit( &gMDNSRecord ); done = TRUE; break; } if ( nextTimerEvent - gMDNSRecord.ShutdownTime >= 0 ) { nextTimerEvent = gMDNSRecord.ShutdownTime; } } // Wait until something occurs (e.g. cancel, incoming packet, or timeout). // // Note: There seems to be a bug in WinSock with respect to Alertable I/O. According // to MSDN , Alertable I/O // callbacks will only be invoked during the following calls (when the caller sets // the appropriate flag): // // - SleepEx // - WaitForSingleObjectEx // - WaitForMultipleObjectsEx // - SignalObjectAndWait // - MsgWaitForMultipleObjectsEx // // However, we have seen callbacks be invoked during calls to bind() (and maybe others). If there // weren't a bug, then socket events would only be queued during the call to WaitForMultipleObjects() and // we'd only have to check them once afterwards. However since that doesn't seem to be the case, we'll // check the queue both before we call WaitForMultipleObjects() and after. DispatchSocketEvents( &gMDNSRecord ); result = WaitForMultipleObjectsEx( ( DWORD ) waitListCount, waitList, FALSE, (DWORD) nextTimerEvent, TRUE ); check( result != WAIT_FAILED ); DispatchSocketEvents( &gMDNSRecord ); if ( result != WAIT_FAILED ) { if ( result == WAIT_TIMEOUT ) { // Next task timeout occurred. Loop back up to give mDNS core a chance to work. dlog( kDebugLevelChatty - 1, DEBUG_NAME "timeout\n" ); continue; } else if ( result == WAIT_IO_COMPLETION ) { dlog( kDebugLevelChatty - 1, DEBUG_NAME "i/o completion\n" ); continue; } else if ( result == kWaitListStopEvent ) { // Stop event. Set the done flag and break to exit. dlog( kDebugLevelVerbose, DEBUG_NAME "stopping...\n" ); udsserver_exit(); mDNS_StartExit( &gMDNSRecord ); break; } else if( result == kWaitListInterfaceListChangedEvent ) { int inBuffer; int outBuffer; DWORD outSize; // It would be nice to come up with a more elegant solution to this, but it seems that // GetAdaptersAddresses doesn't always stay in sync after network changed events. So as // as a simple workaround, we'll pause for a couple of seconds before processing the change. // We arrived at 2 secs by trial and error. We could reproduce the problem after sleeping // for 500 msec and 750 msec, but couldn't after sleeping for 1 sec. We added another // second on top of that to account for machine load or some other exigency. Sleep( 2000 ); // Interface list changed event. Break out of the inner loop to re-setup the wait list. InterfaceListDidChange( &gMDNSRecord ); // reset the event handler inBuffer = 0; outBuffer = 0; err = WSAIoctl( gInterfaceListChangedSocket, SIO_ADDRESS_LIST_CHANGE, &inBuffer, 0, &outBuffer, 0, &outSize, NULL, NULL ); if( err < 0 ) { check( errno_compat() == WSAEWOULDBLOCK ); } } else if ( result == kWaitListComputerDescriptionEvent ) { // The computer description might have changed ComputerDescriptionDidChange( &gMDNSRecord ); udsserver_handle_configchange( &gMDNSRecord ); // and reset the event handler if ( ( gDescKey != NULL ) && ( gDescChangedEvent != NULL ) ) { err = RegNotifyChangeKeyValue( gDescKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, gDescChangedEvent, TRUE); check_noerr( err ); } } else if ( result == kWaitListTCPIPEvent ) { // The TCP/IP might have changed TCPIPConfigDidChange( &gMDNSRecord ); udsserver_handle_configchange( &gMDNSRecord ); // and reset the event handler if ( ( gTcpipKey != NULL ) && ( gTcpipChangedEvent ) ) { err = RegNotifyChangeKeyValue( gTcpipKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gTcpipChangedEvent, TRUE ); check_noerr( err ); } } else if ( result == kWaitListDynDNSEvent ) { // The DynDNS config might have changed DynDNSConfigDidChange( &gMDNSRecord ); udsserver_handle_configchange( &gMDNSRecord ); // and reset the event handler if ((gDdnsKey != NULL) && (gDdnsChangedEvent)) { err = RegNotifyChangeKeyValue(gDdnsKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gDdnsChangedEvent, TRUE); check_noerr( err ); } } else if ( result == kWaitListFileShareEvent ) { // File sharing changed FileSharingDidChange( &gMDNSRecord ); // and reset the event handler if ((gFileSharingKey != NULL) && (gFileSharingChangedEvent)) { err = RegNotifyChangeKeyValue(gFileSharingKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFileSharingChangedEvent, TRUE); check_noerr( err ); } } else if ( result == kWaitListFirewallEvent ) { // Firewall configuration changed FirewallDidChange( &gMDNSRecord ); // and reset the event handler if ((gFirewallKey != NULL) && (gFirewallChangedEvent)) { err = RegNotifyChangeKeyValue(gFirewallKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFirewallChangedEvent, TRUE); check_noerr( err ); } } else if ( result == kWaitListAdvertisedServicesEvent ) { // Ultimately we'll want to manage multiple services, but right now the only service // we'll be managing is SMB. FileSharingDidChange( &gMDNSRecord ); // and reset the event handler if ( ( gAdvertisedServicesKey != NULL ) && ( gAdvertisedServicesChangedEvent ) ) { err = RegNotifyChangeKeyValue(gAdvertisedServicesKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gAdvertisedServicesChangedEvent, TRUE); check_noerr( err ); } } else if ( result == kWaitListSPSWakeupEvent ) { LARGE_INTEGER timeout; ReportStatus( EVENTLOG_INFORMATION_TYPE, "Maintenance wake" ); timeout.QuadPart = kSPSMaintenanceWakePeriod; timeout.QuadPart *= kSecondsTo100NSUnits; SetWaitableTimer( gSPSSleepEvent, &timeout, 0, NULL, NULL, TRUE ); } else if ( result == kWaitListSPSSleepEvent ) { ReportStatus( EVENTLOG_INFORMATION_TYPE, "Returning to sleep after maintenance wake" ); // Calling SetSuspendState() doesn't invoke our sleep handlers, so we'll // call HandlePowerSuspend() explicity. This will reset the // maintenance wake timers. HandlePowerSuspend( NULL ); SetSuspendState( FALSE, FALSE, FALSE ); } else { int waitItemIndex; waitItemIndex = (int)( ( (int) result ) - WAIT_OBJECT_0 ); dlog( kDebugLevelChatty, DEBUG_NAME "waitable event on %d\n", waitItemIndex ); check( ( waitItemIndex >= 0 ) && ( waitItemIndex < waitListCount ) ); if ( ( waitItemIndex >= 0 ) && ( waitItemIndex < waitListCount ) ) { HANDLE signaledEvent; int n = 0; signaledEvent = waitList[ waitItemIndex ]; // If gCurrentSource is not NULL, then this routine has been called // re-entrantly which should never happen. check( !gCurrentSource ); for ( gCurrentSource = gEventSourceList; gCurrentSource; ) { EventSource * current = gCurrentSource; if ( gCurrentSource->event == signaledEvent ) { gCurrentSource->handler( &gMDNSRecord, gCurrentSource->event, gCurrentSource->context ); ++n; break; } // If the current node was removed as a result of calling // the handler, then gCurrentSource was already incremented to // the next node. If it wasn't removed, then increment it // ourselves if ( gCurrentSource == current ) { gCurrentSource = gCurrentSource->next; } } gCurrentSource = NULL; check( n > 0 ); } else { dlog( kDebugLevelWarning, DEBUG_NAME "%s: unexpected wait result (result=0x%08X)\n", __ROUTINE__, result ); } } } else { Sleep( 3 * 1000 ); err = SetupInterfaceList( &gMDNSRecord ); check( !err ); err = uDNS_SetupDNSConfig( &gMDNSRecord ); check( !err ); break; } } if ( waitList ) { free( waitList ); waitList = NULL; waitListCount = 0; } } exit: return( 0 ); } //=========================================================================================================================== // ServiceSpecificStop //=========================================================================================================================== static OSStatus ServiceSpecificStop( void ) { OSStatus err; BOOL ok; ok = SetEvent(gStopEvent); err = translate_errno( ok, (OSStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); exit: return( err ); } //=========================================================================================================================== // ServiceSpecificFinalize //=========================================================================================================================== static void ServiceSpecificFinalize( int argc, LPTSTR argv[] ) { DEBUG_UNUSED( argc ); DEBUG_UNUSED( argv ); // // clean up any open sessions // while ( gEventSourceList ) { UnregisterWaitableEvent( &gMDNSRecord, gEventSourceList->event ); } // // clean up the notifications // TearDownNotifications(); // // clean up loaded library // if( gIPHelperLibraryInstance ) { gGetIpInterfaceEntryFunctionPtr = NULL; FreeLibrary( gIPHelperLibraryInstance ); gIPHelperLibraryInstance = NULL; } } //=========================================================================================================================== // SetupNotifications //=========================================================================================================================== mDNSlocal mStatus SetupNotifications() { mStatus err; SocketRef sock; unsigned long param; int inBuffer; int outBuffer; DWORD outSize; gStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL); err = translate_errno( gStopEvent, errno_compat(), kNoResourcesErr ); require_noerr( err, exit ); // Register to listen for address list changes. gInterfaceListChangedEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); err = translate_errno( gInterfaceListChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); err = translate_errno( IsValidSocket( sock ), errno_compat(), kUnknownErr ); require_noerr( err, exit ); gInterfaceListChangedSocket = sock; // Make the socket non-blocking so the WSAIoctl returns immediately with WSAEWOULDBLOCK. It will set the event // when a change to the interface list is detected. param = 1; err = ioctlsocket( sock, FIONBIO, ¶m ); err = translate_errno( err == 0, errno_compat(), kUnknownErr ); require_noerr( err, exit ); inBuffer = 0; outBuffer = 0; err = WSAIoctl( sock, SIO_ADDRESS_LIST_CHANGE, &inBuffer, 0, &outBuffer, 0, &outSize, NULL, NULL ); if( err < 0 ) { check( errno_compat() == WSAEWOULDBLOCK ); } err = WSAEventSelect( sock, gInterfaceListChangedEvent, FD_ADDRESS_LIST_CHANGE ); err = translate_errno( err == 0, errno_compat(), kUnknownErr ); require_noerr( err, exit ); gDescChangedEvent = CreateEvent(NULL, TRUE, FALSE, NULL); err = translate_errno( gDescChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = RegOpenKeyEx( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\parameters"), 0, KEY_READ, &gDescKey); check_translated_errno( err == 0, errno_compat(), kNameErr ); if ( gDescKey != NULL ) { err = RegNotifyChangeKeyValue( gDescKey, TRUE, REG_NOTIFY_CHANGE_LAST_SET, gDescChangedEvent, TRUE); require_noerr( err, exit ); } // This will catch all changes to tcp/ip networking, including changes to the domain search list gTcpipChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); err = translate_errno( gTcpipChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters"), &gTcpipKey ); require_noerr( err, exit ); err = RegNotifyChangeKeyValue( gTcpipKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gTcpipChangedEvent, TRUE); require_noerr( err, exit ); // This will catch all changes to ddns configuration gDdnsChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); err = translate_errno( gDdnsChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode TEXT("\\DynDNS\\Setup"), &gDdnsKey ); require_noerr( err, exit ); err = RegNotifyChangeKeyValue( gDdnsKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gDdnsChangedEvent, TRUE); require_noerr( err, exit ); // This will catch all changes to file sharing gFileSharingChangedEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); err = translate_errno( gFileSharingChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\Shares"), &gFileSharingKey ); // Just to make sure that initialization doesn't fail on some old OS // that doesn't have this key, we'll only add the notification if // the key exists. if ( !err ) { err = RegNotifyChangeKeyValue( gFileSharingKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFileSharingChangedEvent, TRUE); require_noerr( err, exit ); } else { err = mStatus_NoError; } // This will catch changes to the Windows firewall gFirewallChangedEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); err = translate_errno( gFirewallChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); // Just to make sure that initialization doesn't fail on some old OS // that doesn't have this key, we'll only add the notification if // the key exists. err = RegCreateKey( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Services\\SharedAccess\\Parameters\\FirewallPolicy\\FirewallRules"), &gFirewallKey ); if ( !err ) { err = RegNotifyChangeKeyValue( gFirewallKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gFirewallChangedEvent, TRUE); require_noerr( err, exit ); } else { err = mStatus_NoError; } // This will catch all changes to advertised services configuration gAdvertisedServicesChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL); err = translate_errno( gAdvertisedServicesChangedEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode TEXT("\\Services"), &gAdvertisedServicesKey ); require_noerr( err, exit ); err = RegNotifyChangeKeyValue( gAdvertisedServicesKey, TRUE, REG_NOTIFY_CHANGE_NAME|REG_NOTIFY_CHANGE_LAST_SET, gAdvertisedServicesChangedEvent, TRUE); require_noerr( err, exit ); gSPSWakeupEvent = CreateWaitableTimer( NULL, FALSE, NULL ); err = translate_errno( gSPSWakeupEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); gSPSSleepEvent = CreateWaitableTimer( NULL, FALSE, NULL ); err = translate_errno( gSPSSleepEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); gUDSEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); err = translate_errno( gUDSEvent, ( mStatus ) GetLastError(), kUnknownErr ); require_noerr( err, exit ); exit: if( err ) { TearDownNotifications(); } return( err ); } //=========================================================================================================================== // TearDownNotifications //=========================================================================================================================== mDNSlocal mStatus TearDownNotifications() { if ( gStopEvent ) { CloseHandle( gStopEvent ); gStopEvent = NULL; } if( IsValidSocket( gInterfaceListChangedSocket ) ) { close_compat( gInterfaceListChangedSocket ); gInterfaceListChangedSocket = kInvalidSocketRef; } if( gInterfaceListChangedEvent ) { CloseHandle( gInterfaceListChangedEvent ); gInterfaceListChangedEvent = 0; } if ( gDescChangedEvent != NULL ) { CloseHandle( gDescChangedEvent ); gDescChangedEvent = NULL; } if ( gDescKey != NULL ) { RegCloseKey( gDescKey ); gDescKey = NULL; } if ( gTcpipChangedEvent != NULL ) { CloseHandle( gTcpipChangedEvent ); gTcpipChangedEvent = NULL; } if ( gDdnsChangedEvent != NULL ) { CloseHandle( gDdnsChangedEvent ); gDdnsChangedEvent = NULL; } if ( gDdnsKey != NULL ) { RegCloseKey( gDdnsKey ); gDdnsKey = NULL; } if ( gFileSharingChangedEvent != NULL ) { CloseHandle( gFileSharingChangedEvent ); gFileSharingChangedEvent = NULL; } if ( gFileSharingKey != NULL ) { RegCloseKey( gFileSharingKey ); gFileSharingKey = NULL; } if ( gFirewallChangedEvent != NULL ) { CloseHandle( gFirewallChangedEvent ); gFirewallChangedEvent = NULL; } if ( gFirewallKey != NULL ) { RegCloseKey( gFirewallKey ); gFirewallKey = NULL; } if ( gAdvertisedServicesChangedEvent != NULL ) { CloseHandle( gAdvertisedServicesChangedEvent ); gAdvertisedServicesChangedEvent = NULL; } if ( gAdvertisedServicesKey != NULL ) { RegCloseKey( gAdvertisedServicesKey ); gAdvertisedServicesKey = NULL; } if ( gSPSWakeupEvent ) { CloseHandle( gSPSWakeupEvent ); gSPSWakeupEvent = NULL; } if ( gSPSSleepEvent ) { CloseHandle( gSPSSleepEvent ); gSPSSleepEvent = NULL; } return( mStatus_NoError ); } //=========================================================================================================================== // RegisterWaitableEvent //=========================================================================================================================== static mStatus RegisterWaitableEvent( mDNS * const inMDNS, HANDLE event, void * context, RegisterWaitableEventHandler handler ) { EventSource * source; mStatus err = mStatus_NoError; ( void ) inMDNS; check( event ); check( handler ); source = ( EventSource* ) malloc( sizeof( EventSource ) ); require_action( source, exit, err = mStatus_NoMemoryErr ); mDNSPlatformMemZero( source, sizeof( EventSource ) ); source->event = event; source->context = context; source->handler = handler; source->next = gEventSourceList; gEventSourceList = source; gEventSourceListChanged = TRUE; gEventSources++; exit: return err; } //=========================================================================================================================== // UnregisterWaitableEvent //=========================================================================================================================== static void UnregisterWaitableEvent( mDNS * const inMDNS, HANDLE event ) { EventSource * current = gEventSourceList; EventSource * last = NULL; ( void ) inMDNS; check( event ); while ( current ) { if ( current->event == event ) { if ( last == NULL ) { gEventSourceList = current->next; } else { last->next = current->next; } gEventSourceListChanged = TRUE; // Protect against removing the node that we happen // to be looking at as we iterate through the event // source list in ServiceSpecificRun() if ( current == gCurrentSource ) { gCurrentSource = current->next; } gEventSources--; free( current ); break; } last = current; current = current->next; } } //=========================================================================================================================== // SetupWaitList //=========================================================================================================================== mDNSlocal mStatus SetupWaitList( mDNS * const inMDNS, HANDLE **outWaitList, int *outWaitListCount ) { int waitListCount; HANDLE * waitList; HANDLE * waitItemPtr; EventSource * source; mStatus err; dlog( kDebugLevelTrace, DEBUG_NAME "setting up wait list\n" ); ( void ) inMDNS; check( inMDNS->p ); check( outWaitList ); check( outWaitListCount ); // Allocate an array to hold all the objects to wait on. waitListCount = kWaitListFixedItemCount + gEventSources; waitList = ( HANDLE* ) malloc( waitListCount * sizeof( *waitList ) ); require_action( waitList, exit, err = mStatus_NoMemoryErr ); waitItemPtr = waitList; // Add the fixed wait items to the beginning of the list. *waitItemPtr++ = gStopEvent; *waitItemPtr++ = gInterfaceListChangedEvent; *waitItemPtr++ = gDescChangedEvent; *waitItemPtr++ = gTcpipChangedEvent; *waitItemPtr++ = gDdnsChangedEvent; *waitItemPtr++ = gFileSharingChangedEvent; *waitItemPtr++ = gFirewallChangedEvent; *waitItemPtr++ = gAdvertisedServicesChangedEvent; *waitItemPtr++ = gSPSWakeupEvent; *waitItemPtr++ = gSPSSleepEvent; for ( source = gEventSourceList; source; source = source->next ) { *waitItemPtr++ = source->event; } check( ( int )( waitItemPtr - waitList ) == waitListCount ); *outWaitList = waitList; *outWaitListCount = waitListCount; waitList = NULL; err = mStatus_NoError; exit: if( waitList ) { free( waitList ); } dlog( kDebugLevelTrace, DEBUG_NAME "setting up wait list done (err=%d %m)\n", err, err ); return( err ); } //=========================================================================================================================== // CoreCallback //=========================================================================================================================== static void CoreCallback(mDNS * const inMDNS, mStatus status) { if (status == mStatus_ConfigChanged) { SetLLRoute( inMDNS ); } } //=========================================================================================================================== // UDSCanAccept //=========================================================================================================================== mDNSlocal void UDSCanAccept( mDNS * const inMDNS, HANDLE event, void * context ) { ( void ) inMDNS; ( void ) event; if ( gUDSCallback ) { gUDSCallback( ( int ) gUDSSocket, 0, context ); } } //=========================================================================================================================== // UDSCanRead //=========================================================================================================================== mDNSlocal void UDSCanRead( TCPSocket * sock ) { udsEventCallback callback = ( udsEventCallback ) sock->userCallback; if ( callback ) { callback( (int) sock->fd, 0, sock->userContext ); } } //=========================================================================================================================== // udsSupportAddFDToEventLoop //=========================================================================================================================== mStatus udsSupportAddFDToEventLoop( SocketRef fd, udsEventCallback callback, void *context, void **platform_data) { mStatus err = mStatus_NoError; // We are using some knowledge of what is being passed to us here. If the fd is a listen socket, // then the "callback" parameter is NULL. If it is an actual read/write socket, then the "callback" // parameter is not null. This is important because we use waitable events for the listen socket // and alertable I/O for the read/write sockets. if ( context ) { TCPSocket * sock; sock = malloc( sizeof( TCPSocket ) ); require_action( sock, exit, err = mStatus_NoMemoryErr ); mDNSPlatformMemZero( sock, sizeof( TCPSocket ) ); sock->fd = (SOCKET) fd; sock->readEventHandler = UDSCanRead; sock->userCallback = callback; sock->userContext = context; sock->m = &gMDNSRecord; err = TCPAddSocket( sock->m, sock ); require_noerr( err, exit ); *platform_data = sock; } else { gUDSSocket = fd; gUDSCallback = callback; gUDSEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); err = translate_errno( gUDSEvent, (mStatus) GetLastError(), kUnknownErr ); require_noerr( err, exit ); err = WSAEventSelect( fd, gUDSEvent, FD_ACCEPT | FD_CLOSE ); err = translate_errno( err == 0, WSAGetLastError(), kNoResourcesErr ); require_noerr( err, exit ); err = RegisterWaitableEvent( &gMDNSRecord, gUDSEvent, context, UDSCanAccept ); require_noerr( err, exit ); } exit: return err; } int udsSupportReadFD( SocketRef fd, char *buf, int len, int flags, void *platform_data ) { TCPSocket * sock; mDNSBool closed; int ret; ( void ) flags; sock = ( TCPSocket* ) platform_data; require_action( sock, exit, ret = -1 ); require_action( sock->fd == fd, exit, ret = -1 ); ret = mDNSPlatformReadTCP( sock, buf, len, &closed ); if ( closed ) { ret = 0; } exit: return ret; } mStatus udsSupportRemoveFDFromEventLoop( SocketRef fd, void *platform_data) // Note: This also CLOSES the socket { mStatus err = kNoErr; if ( platform_data != NULL ) { TCPSocket * sock; dlog( kDebugLevelInfo, DEBUG_NAME "session closed\n" ); sock = ( TCPSocket* ) platform_data; check( sock->fd == fd ); mDNSPlatformTCPCloseConnection( sock ); } else if ( gUDSEvent != NULL ) { UnregisterWaitableEvent( &gMDNSRecord, gUDSEvent ); WSAEventSelect( fd, gUDSEvent, 0 ); CloseHandle( gUDSEvent ); gUDSEvent = NULL; } return err; } mDNSexport void RecordUpdatedNiceLabel(mDNS *const m, mDNSs32 delay) { (void)m; (void)delay; // No-op, for now } //=========================================================================================================================== // SystemWakeForNetworkAccess //=========================================================================================================================== mDNSu8 SystemWakeForNetworkAccess( LARGE_INTEGER * timeout ) { HKEY key = NULL; DWORD dwSize; DWORD enabled; mDNSu8 ok; SYSTEM_POWER_STATUS powerStatus; time_t startTime; time_t nextWakeupTime; int delta; DWORD err; dlog( kDebugLevelInfo, DEBUG_NAME "SystemWakeForNetworkAccess\n" ); // Make sure we have a timer require_action( gSPSWakeupEvent != NULL, exit, ok = FALSE ); require_action( gSPSSleepEvent != NULL, exit, ok = FALSE ); // Make sure the user enabled bonjour sleep proxy client err = RegCreateKey( HKEY_LOCAL_MACHINE, kServiceParametersNode L"\\Power Management", &key ); require_action( !err, exit, ok = FALSE ); dwSize = sizeof( DWORD ); err = RegQueryValueEx( key, L"Enabled", NULL, NULL, (LPBYTE) &enabled, &dwSize ); require_action( !err, exit, ok = FALSE ); require_action( enabled, exit, ok = FALSE ); // Make sure machine is on AC power ok = ( mDNSu8 ) GetSystemPowerStatus( &powerStatus ); require_action( ok, exit, ok = FALSE ); require_action( powerStatus.ACLineStatus == AC_LINE_ONLINE, exit, ok = FALSE ); // Now make sure we have a network interface that does wake-on-lan ok = ( mDNSu8 ) IsWOMPEnabled( &gMDNSRecord ); require_action( ok, exit, ok = FALSE ); // Now make sure we have advertised services. Doesn't make sense to // enable sleep proxy if we have no multicast services that could // potentially wake us up. ok = ( mDNSu8 ) mDNSCoreHaveAdvertisedMulticastServices( &gMDNSRecord ); require_action( ok, exit, ok = FALSE ); // Calculate next wake up time startTime = time( NULL ); // Seconds since midnight January 1, 1970 nextWakeupTime = startTime + ( 120 * 60 ); // 2 hours later if ( gMDNSRecord.p->nextDHCPLeaseExpires < nextWakeupTime ) { nextWakeupTime = gMDNSRecord.p->nextDHCPLeaseExpires; } // Finally calculate the next relative wakeup time delta = ( int )( ( ( double )( nextWakeupTime - startTime ) ) * 0.9 ); ReportStatus( EVENTLOG_INFORMATION_TYPE, "enabling sleep proxy client with next maintenance wake in %d seconds", delta ); // Convert seconds to 100 nanosecond units expected by SetWaitableTimer timeout->QuadPart = -delta; timeout->QuadPart *= kSecondsTo100NSUnits; ok = TRUE; exit: if ( key ) { RegCloseKey( key ); } return ok; } //=========================================================================================================================== // HaveRoute //=========================================================================================================================== static bool HaveRoute( PMIB_IPFORWARDROW rowExtant, unsigned long addr, unsigned long metric ) { PMIB_IPFORWARDTABLE pIpForwardTable = NULL; DWORD dwSize = 0; BOOL bOrder = FALSE; OSStatus err; bool found = false; unsigned long int i; // // Find out how big our buffer needs to be. // err = GetIpForwardTable(NULL, &dwSize, bOrder); require_action( err == ERROR_INSUFFICIENT_BUFFER, exit, err = kUnknownErr ); // // Allocate the memory for the table // pIpForwardTable = (PMIB_IPFORWARDTABLE) malloc( dwSize ); require_action( pIpForwardTable, exit, err = kNoMemoryErr ); // // Now get the table. // err = GetIpForwardTable(pIpForwardTable, &dwSize, bOrder); require_noerr( err, exit ); // // Search for the row in the table we want. // for ( i = 0; i < pIpForwardTable->dwNumEntries; i++) { if ( ( pIpForwardTable->table[i].dwForwardDest == addr ) && ( !metric || ( pIpForwardTable->table[i].dwForwardMetric1 == metric ) ) ) { memcpy( rowExtant, &(pIpForwardTable->table[i]), sizeof(*rowExtant) ); found = true; break; } } exit: if ( pIpForwardTable != NULL ) { free(pIpForwardTable); } return found; } //=========================================================================================================================== // IsValidAddress //=========================================================================================================================== static bool IsValidAddress( const char * addr ) { return ( addr && ( strcmp( addr, "0.0.0.0" ) != 0 ) ) ? true : false; } //=========================================================================================================================== // GetAdditionalMetric //=========================================================================================================================== static ULONG GetAdditionalMetric( DWORD ifIndex ) { ULONG metric = 0; if( !gIPHelperLibraryInstance ) { gIPHelperLibraryInstance = LoadLibrary( TEXT( "Iphlpapi" ) ); gGetIpInterfaceEntryFunctionPtr = (GetIpInterfaceEntryFunctionPtr) GetProcAddress( gIPHelperLibraryInstance, "GetIpInterfaceEntry" ); if( !gGetIpInterfaceEntryFunctionPtr ) { BOOL ok; ok = FreeLibrary( gIPHelperLibraryInstance ); check_translated_errno( ok, GetLastError(), kUnknownErr ); gIPHelperLibraryInstance = NULL; } } if ( gGetIpInterfaceEntryFunctionPtr ) { MIB_IPINTERFACE_ROW row; DWORD err; ZeroMemory( &row, sizeof( MIB_IPINTERFACE_ROW ) ); row.Family = AF_INET; row.InterfaceIndex = ifIndex; err = gGetIpInterfaceEntryFunctionPtr( &row ); require_noerr( err, exit ); metric = row.Metric + 256; } exit: return metric; } //=========================================================================================================================== // SetLLRoute //=========================================================================================================================== static OSStatus SetLLRoute( mDNS * const inMDNS ) { OSStatus err = kNoErr; DEBUG_UNUSED( inMDNS ); // // Don't call SetLLRoute on loopback // Default route on Windows 7 breaks network connectivity // // Don't mess w/ the routing table on Vista and later OSes, as // they have a permanent route to link-local addresses. Otherwise, // set a route to link local addresses (169.254.0.0) // if ( ( gOSMajorVersion < 6 ) && gServiceManageLLRouting && !gPlatformStorage.registeredLoopback4 ) { DWORD ifIndex; MIB_IPFORWARDROW rowExtant; bool addRoute; MIB_IPFORWARDROW row; ZeroMemory(&row, sizeof(row)); err = GetRouteDestination(&ifIndex, &row.dwForwardNextHop); require_noerr( err, exit ); row.dwForwardDest = inet_addr(kLLNetworkAddr); row.dwForwardIfIndex = ifIndex; row.dwForwardMask = inet_addr(kLLNetworkAddrMask); row.dwForwardType = 3; row.dwForwardProto = MIB_IPPROTO_NETMGMT; row.dwForwardAge = 0; row.dwForwardPolicy = 0; row.dwForwardMetric1 = 20 + GetAdditionalMetric( ifIndex ); row.dwForwardMetric2 = (DWORD) - 1; row.dwForwardMetric3 = (DWORD) - 1; row.dwForwardMetric4 = (DWORD) - 1; row.dwForwardMetric5 = (DWORD) - 1; addRoute = true; // // check to make sure we don't already have a route // if ( HaveRoute( &rowExtant, inet_addr( kLLNetworkAddr ), 0 ) ) { // // set the age to 0 so that we can do a memcmp. // rowExtant.dwForwardAge = 0; // // check to see if this route is the same as our route // if (memcmp(&row, &rowExtant, sizeof(row)) != 0) { // // if it isn't then delete this entry // DeleteIpForwardEntry(&rowExtant); } else { // // else it is, so we don't want to create another route // addRoute = false; } } if (addRoute && row.dwForwardNextHop) { err = CreateIpForwardEntry(&row); check_noerr( err ); } } exit: return ( err ); } //=========================================================================================================================== // GetRouteDestination //=========================================================================================================================== static OSStatus GetRouteDestination(DWORD * ifIndex, DWORD * address) { struct in_addr ia; IP_ADAPTER_INFO * pAdapterInfo = NULL; IP_ADAPTER_INFO * pAdapter = NULL; ULONG bufLen; mDNSBool done = mDNSfalse; OSStatus err; // // GetBestInterface will fail if there is no default gateway // configured. If that happens, we will just take the first // interface in the list. MSDN support says there is no surefire // way to manually determine what the best interface might // be for a particular network address. // ia.s_addr = inet_addr(kLLNetworkAddr); err = GetBestInterface(*(IPAddr*) &ia, ifIndex); if (err) { *ifIndex = 0; } // // Make an initial call to GetAdaptersInfo to get // the necessary size into the bufLen variable // err = GetAdaptersInfo( NULL, &bufLen); require_action( err == ERROR_BUFFER_OVERFLOW, exit, err = kUnknownErr ); pAdapterInfo = (IP_ADAPTER_INFO*) malloc( bufLen ); require_action( pAdapterInfo, exit, err = kNoMemoryErr ); err = GetAdaptersInfo( pAdapterInfo, &bufLen); require_noerr( err, exit ); pAdapter = pAdapterInfo; err = kUnknownErr; // // // // Look for the Nortel VPN virtual interface, along with Juniper virtual interface. // // If these interfaces are active (i.e., has a non-zero IP Address), // then we want to disable routing table modifications. while (pAdapter) { if ( ( IsNortelVPN( pAdapter ) || IsJuniperVPN( pAdapter ) || IsCiscoVPN( pAdapter ) ) && ( inet_addr( pAdapter->IpAddressList.IpAddress.String ) != 0 ) ) { dlog( kDebugLevelTrace, DEBUG_NAME "disabling routing table management due to VPN incompatibility" ); goto exit; } pAdapter = pAdapter->Next; } while ( !done ) { pAdapter = pAdapterInfo; err = kUnknownErr; while (pAdapter) { // If we don't have an interface selected, choose the first one that is of type ethernet and // has a valid IP Address if ((pAdapter->Type == MIB_IF_TYPE_ETHERNET) && ( IsValidAddress( pAdapter->IpAddressList.IpAddress.String ) ) && (!(*ifIndex) || (pAdapter->Index == (*ifIndex)))) { *address = inet_addr( pAdapter->IpAddressList.IpAddress.String ); *ifIndex = pAdapter->Index; err = kNoErr; break; } pAdapter = pAdapter->Next; } // If we found the right interface, or we weren't trying to find a specific interface then we're done if ( !err || !( *ifIndex) ) { done = mDNStrue; } // Otherwise, try again by wildcarding the interface else { *ifIndex = 0; } } exit: if ( pAdapterInfo != NULL ) { free( pAdapterInfo ); } return( err ); } static bool IsNortelVPN( IP_ADAPTER_INFO * pAdapter ) { return ((pAdapter->Type == MIB_IF_TYPE_ETHERNET) && (pAdapter->AddressLength == 6) && (pAdapter->Address[0] == 0x44) && (pAdapter->Address[1] == 0x45) && (pAdapter->Address[2] == 0x53) && (pAdapter->Address[3] == 0x54) && (pAdapter->Address[4] == 0x42) && (pAdapter->Address[5] == 0x00)) ? true : false; } static bool IsJuniperVPN( IP_ADAPTER_INFO * pAdapter ) { return ( strnistr( pAdapter->Description, "Juniper", sizeof( pAdapter->Description ) ) != NULL ) ? true : false; } static bool IsCiscoVPN( IP_ADAPTER_INFO * pAdapter ) { return ((pAdapter->Type == MIB_IF_TYPE_ETHERNET) && (pAdapter->AddressLength == 6) && (pAdapter->Address[0] == 0x00) && (pAdapter->Address[1] == 0x05) && (pAdapter->Address[2] == 0x9a) && (pAdapter->Address[3] == 0x3c) && (pAdapter->Address[4] == 0x7a) && (pAdapter->Address[5] == 0x00)) ? true : false; } static const char * strnistr( const char * string, const char * subString, size_t max ) { size_t subStringLen; size_t offset; size_t maxOffset; size_t stringLen; const char * pPos; if ( ( string == NULL ) || ( subString == NULL ) ) { return string; } stringLen = ( max > strlen( string ) ) ? strlen( string ) : max; if ( stringLen == 0 ) { return NULL; } subStringLen = strlen( subString ); if ( subStringLen == 0 ) { return string; } if ( subStringLen > stringLen ) { return NULL; } maxOffset = stringLen - subStringLen; pPos = string; for ( offset = 0; offset <= maxOffset; offset++ ) { if ( _strnicmp( pPos, subString, subStringLen ) == 0 ) { return pPos; } pPos++; } return NULL; }