react-native-zeroconf 0.13.7 → 0.14.0

package/android/src/main/jni/mdnsresponder/mDNSWindows/SystemService/Service.c

@@ -0,0 +1,2669 @@
+/* -*- 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	<stdio.h>
+#include	<stdlib.h>
+#include	<crtdbg.h>
+#include	<stdarg.h>
+#include	<stddef.h>
+
+
+#include	"CommonServices.h"
+#include	"DebugServices.h"
+#include	"RegNames.h"
+
+#include	"uds_daemon.h"
+#include	"GenLinkedList.h"
+#include	"Service.h"
+#include	"mDNSWindows/SystemService/EventLog.h"
+
+#include	"Resource.h"
+
+#include	"mDNSEmbeddedAPI.h"
+#include	"uDNS.h"
+#include	"mDNSWin32.h"
+
+#include	"Firewall.h"
+
+#if( !TARGET_OS_WINDOWS_CE )
+	#include	<mswsock.h>
+	#include	<process.h>
+	#include	<ipExport.h>
+	#include	<ws2def.h>
+	#include	<ws2ipdef.h>
+	#include	<iphlpapi.h>
+	#include	<netioapi.h>
+	#include	<iptypes.h>
+	#include	<powrprof.h>
+#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, "    <no args>    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;
+	
+	// <rdar://problem/5727548> 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 <http://msdn.microsoft.com/en-us/library/aa363772(VS.85).aspx>, 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, &param );
+	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 );
+
+	//
+	// <rdar://problem/4096464> Don't call SetLLRoute on loopback
+	// <rdar://problem/6885843> 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;
+			
+	// <rdar://problem/3718122>
+	// <rdar://problem/5652098>
+	//
+	// 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;
+}
+