You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
881 lines
25 KiB
881 lines
25 KiB
/********************************************************************/
|
|
/** Copyright(c) 1995 Microsoft Corporation. **/
|
|
/********************************************************************/
|
|
|
|
//***
|
|
//
|
|
// Filename: svchand.c
|
|
//
|
|
// Description: This module contains procedures to handle DDM service state
|
|
// changes and startup initialization.
|
|
//
|
|
// History: May 11,1995 NarenG Created original version.
|
|
//
|
|
|
|
#define _ALLOCATE_DDM_GLOBALS_
|
|
#include "ddm.h"
|
|
#include "objects.h"
|
|
#include "handlers.h"
|
|
#include "rasmanif.h"
|
|
#include "util.h"
|
|
#include <ddmif.h>
|
|
#include <ddmparms.h>
|
|
#include "timer.h"
|
|
#include "rassrvr.h"
|
|
|
|
DWORD
|
|
EventDispatcher(
|
|
IN LPVOID arg
|
|
);
|
|
|
|
//***
|
|
//
|
|
// Function: DDMServiceStopComplete
|
|
//
|
|
// Descr: called by each device which has closed. Checks if all devices
|
|
// are closed and if true signals the event dispatcher to
|
|
// exit the "forever" loop and return.
|
|
//
|
|
//***
|
|
|
|
VOID
|
|
DDMServiceStopComplete(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// check if all devices have been stopped
|
|
//
|
|
|
|
if ( DeviceObjIterator( DeviceObjIsClosed, TRUE, NULL ) != NO_ERROR )
|
|
{
|
|
DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM,
|
|
"ServiceStopComplete:there are device pending close");
|
|
|
|
//
|
|
// there are still unclosed devices
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
//*** All Devices Are Closed at the Supervisor Level ***
|
|
//
|
|
|
|
DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM,
|
|
"ServiceStopComplete: ALL devices closed");
|
|
|
|
//
|
|
// Notify connections that the service has stopped.
|
|
//
|
|
{
|
|
RASEVENT RasEvent;
|
|
|
|
ZeroMemory((PBYTE) &RasEvent, sizeof(RASEVENT));
|
|
|
|
RasEvent.Type = SERVICE_EVENT;
|
|
RasEvent.Event = RAS_SERVICE_STOPPED;
|
|
RasEvent.Service = REMOTEACCESS;
|
|
|
|
(void) RasSendNotification(&RasEvent);
|
|
}
|
|
|
|
//
|
|
// notify the DIM that DDM has terminated. This will also cause the
|
|
// event dispatcher and timer threads to die.
|
|
//
|
|
|
|
SetEvent( gblSupervisorEvents[DDM_EVENT_SVC_TERMINATED] );
|
|
}
|
|
|
|
//***
|
|
//
|
|
// Function: DDMServiceTerminate
|
|
//
|
|
// Descr: deallocates all resources and closes all dialin devices
|
|
//
|
|
//***
|
|
|
|
VOID
|
|
DDMServiceTerminate(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// Disconnect all connected DDM interfaces
|
|
//
|
|
|
|
IfObjectDisconnectInterfaces();
|
|
|
|
//
|
|
// Wait for all disconenct notificaions to be processed
|
|
//
|
|
|
|
Sleep( 2000L );
|
|
|
|
DeviceObjIterator( DeviceObjStartClosing, FALSE, NULL );
|
|
|
|
//
|
|
// UnRegister the notifier form rasman
|
|
//
|
|
(void) RasRegisterPnPHandler( (PAPCFUNC) DdmDevicePnpHandler,
|
|
NULL,
|
|
FALSE);
|
|
|
|
//
|
|
// check if all devices are closed and terminate if true
|
|
//
|
|
|
|
DDMServiceStopComplete();
|
|
}
|
|
|
|
//***
|
|
//
|
|
// Function: DDMServicePause
|
|
//
|
|
// Descr: disables listening on any active listenning ports. Sets
|
|
// service global state to RAS_SERVICE_PAUSED. No new listen
|
|
// will be posted when a client terminates.
|
|
//
|
|
//***
|
|
|
|
VOID
|
|
DDMServicePause(
|
|
VOID
|
|
)
|
|
{
|
|
WORD i;
|
|
PDEVICE_OBJECT pDeviceObj;
|
|
|
|
DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM,"SvServicePause: Entered");
|
|
|
|
//
|
|
// Close all active listenning ports
|
|
//
|
|
|
|
DeviceObjIterator( DeviceObjCloseListening, FALSE, NULL );
|
|
|
|
//
|
|
// Notify all interfaces that they are not reachable
|
|
//
|
|
|
|
IfObjectNotifyAllOfReachabilityChange( FALSE, INTERFACE_SERVICE_IS_PAUSED );
|
|
}
|
|
|
|
//***
|
|
//
|
|
// Function: DDMServiceResume
|
|
//
|
|
// Descr: resumes listening on all ports.
|
|
//
|
|
//***
|
|
VOID
|
|
DDMServiceResume(
|
|
VOID
|
|
)
|
|
{
|
|
WORD i;
|
|
PDEVICE_OBJECT pDeviceObj;
|
|
|
|
DDM_PRINT(gblDDMConfigInfo.dwTraceId,TRACE_FSM,"SvServiceResume: Entered");
|
|
|
|
//
|
|
// resume listening on all closed devices
|
|
//
|
|
|
|
DeviceObjIterator( DeviceObjResumeListening, FALSE, NULL );
|
|
|
|
//
|
|
// Notify all interfaces that they are reachable now.
|
|
//
|
|
|
|
IfObjectNotifyAllOfReachabilityChange( TRUE, INTERFACE_SERVICE_IS_PAUSED );
|
|
}
|
|
|
|
//***
|
|
//
|
|
// Function: DDMServiceInitialize
|
|
//
|
|
// Descrption: It does init work as follows:
|
|
// Loads the configuration parameters
|
|
// Loads the security module if there is one.
|
|
// Creates the event flags
|
|
// Initializes the message DLL
|
|
// Opens all dialin devices
|
|
// Initializes the DCBs
|
|
// Initializes the authentication DLL
|
|
// Posts listen on all opened dialin devices
|
|
//
|
|
// NOTE: Also changing the working set size for this process
|
|
// will change it for all the services in this process.
|
|
// Is this OK?
|
|
// What do we do about the security check call?
|
|
//
|
|
// Returns: NO_ERROR - Sucess
|
|
// non-zero - Failure
|
|
//
|
|
//***
|
|
DWORD
|
|
DDMServiceInitialize(
|
|
IN DIM_INFO * DimInfo
|
|
)
|
|
{
|
|
DWORD dwIndex;
|
|
DWORD ThreadId;
|
|
QUOTA_LIMITS ql;
|
|
NTSTATUS ntStatus = STATUS_SUCCESS;
|
|
DWORD dwRetCode = NO_ERROR;
|
|
HANDLE hEventDispatcher = NULL;
|
|
DEVICE_OBJECT * pDeviceObj = NULL;
|
|
HPORT * phPorts = NULL;
|
|
BOOL fIpAllowed = FALSE;
|
|
LPVOID lpfnRasAuthProviderFreeAttributes = NULL;
|
|
LPVOID lpfnRasAuthProviderAuthenticateUser = NULL;
|
|
LPVOID lpfnRasAuthConfigChangeNotification = NULL;
|
|
LPVOID lpfnRasAcctProviderStartAccounting = NULL;
|
|
LPVOID lpfnRasAcctProviderInterimAccounting = NULL;
|
|
LPVOID lpfnRasAcctProviderStopAccounting = NULL;
|
|
LPVOID lpfnRasAcctProviderFreeAttributes = NULL;
|
|
LPVOID lpfnRasAcctConfigChangeNotification = NULL;
|
|
DWORD dwLocalIpAddress = 0;
|
|
DWORD dwCSFlags = 0;
|
|
|
|
#define TIMERQCS_INITIALIZED 0x00000001
|
|
#define DEVICETABLECS_INITIALIZED 0x00000002
|
|
#define ACCOUNTINGSESSIONCS_INITIALIZED 0x00000004
|
|
#define MEDIATABLECS_INITIALIZED 0x00000008
|
|
|
|
|
|
ZeroMemory( &gblDDMConfigInfo, sizeof( gblDDMConfigInfo ) );
|
|
gblDDMConfigInfo.fRasSrvrInitialized = FALSE;
|
|
gblDDMConfigInfo.hIpHlpApi = NULL;
|
|
gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack = NULL;
|
|
gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack = NULL;
|
|
gblDDMConfigInfo.dwNumRouterManagers = DimInfo->dwNumRouterManagers;
|
|
gblRouterManagers = DimInfo->pRouterManagers;
|
|
gblpInterfaceTable = DimInfo->pInterfaceTable;
|
|
gblDDMConfigInfo.pServiceStatus = DimInfo->pServiceStatus;
|
|
gblDDMConfigInfo.dwTraceId = DimInfo->dwTraceId;
|
|
gblDDMConfigInfo.hLogEvents = DimInfo->hLogEvents;
|
|
gblphEventDDMServiceState = DimInfo->phEventDDMServiceState;
|
|
gblphEventDDMTerminated = DimInfo->phEventDDMTerminated;
|
|
gblDDMConfigInfo.lpdwNumThreadsRunning = DimInfo->lpdwNumThreadsRunning;
|
|
gblDDMConfigInfo.lpfnIfObjectRemove = DimInfo->lpfnIfObjectRemove;
|
|
gblDDMConfigInfo.lpfnIfObjectGetPointer = DimInfo->lpfnIfObjectGetPointer;
|
|
gblDDMConfigInfo.lpfnIfObjectInsertInTable =
|
|
DimInfo->lpfnIfObjectInsertInTable;
|
|
gblDDMConfigInfo.lpfnIfObjectAllocateAndInit =
|
|
DimInfo->lpfnIfObjectAllocateAndInit;
|
|
gblDDMConfigInfo.lpfnIfObjectGetPointerByName =
|
|
DimInfo->lpfnIfObjectGetPointerByName;
|
|
gblDDMConfigInfo.lpfnIfObjectWANDeviceInstalled =
|
|
DimInfo->lpfnIfObjectWANDeviceInstalled;
|
|
gblDDMConfigInfo.lpfnRouterIdentityObjectUpdate =
|
|
DimInfo->lpfnRouterIdentityObjectUpdate;
|
|
|
|
gblDDMConfigInfo.fRasmanReferenced = FALSE;
|
|
|
|
DimInfo->fWANDeviceInstalled = FALSE;
|
|
|
|
try
|
|
{
|
|
(VOID) TimerQInitialize();
|
|
dwCSFlags |= TIMERQCS_INITIALIZED;
|
|
|
|
InitializeCriticalSection(
|
|
&(gblDeviceTable.CriticalSection) );
|
|
dwCSFlags |= DEVICETABLECS_INITIALIZED;
|
|
|
|
InitializeCriticalSection( &(gblMediaTable.CriticalSection) );
|
|
dwCSFlags |= MEDIATABLECS_INITIALIZED;
|
|
|
|
InitializeCriticalSection(
|
|
&(gblDDMConfigInfo.CSAccountingSessionId) );
|
|
dwCSFlags |= ACCOUNTINGSESSIONCS_INITIALIZED;
|
|
|
|
}
|
|
except (EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
dwRetCode = GetExceptionCode();
|
|
|
|
if(dwCSFlags & TIMERQCS_INITIALIZED)
|
|
{
|
|
TimerQDelete();
|
|
}
|
|
|
|
if(dwCSFlags & DEVICETABLECS_INITIALIZED)
|
|
{
|
|
DeleteCriticalSection(
|
|
&gblDeviceTable.CriticalSection);
|
|
}
|
|
|
|
if(dwCSFlags & MEDIATABLECS_INITIALIZED)
|
|
{
|
|
DeleteCriticalSection(
|
|
&gblMediaTable.CriticalSection);
|
|
}
|
|
|
|
return dwRetCode;
|
|
}
|
|
|
|
do
|
|
{
|
|
//
|
|
// Create DDM private heap
|
|
//
|
|
|
|
gblDDMConfigInfo.hHeap = HeapCreate( 0, DDM_HEAP_INITIAL_SIZE,
|
|
DDM_HEAP_MAX_SIZE );
|
|
|
|
if ( gblDDMConfigInfo.hHeap == NULL )
|
|
{
|
|
dwRetCode = GetLastError();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Allocate and initialize the media object table.
|
|
//
|
|
|
|
if ( ( dwRetCode = MediaObjInitializeTable() ) != NO_ERROR )
|
|
{
|
|
DDMLogError(ROUTERLOG_NOT_ENOUGH_MEMORY, 0, NULL, dwRetCode );
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// initialize the rasman module
|
|
//
|
|
|
|
if ( ( dwRetCode = RasInitialize() ) != NO_ERROR )
|
|
{
|
|
//
|
|
// can't start rasman
|
|
//
|
|
|
|
DDMLogErrorString( ROUTERLOG_RASMAN_NOT_AVAILABLE,
|
|
0, NULL, dwRetCode, 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Increase rasman's reference count since we are in the same process
|
|
// this does not happen automatically
|
|
//
|
|
|
|
if ( dwRetCode = RasReferenceRasman( TRUE ) )
|
|
{
|
|
//
|
|
// can't start rasman
|
|
//
|
|
|
|
DDMLogErrorString( ROUTERLOG_RASMAN_NOT_AVAILABLE,
|
|
0, NULL, dwRetCode, 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
gblDDMConfigInfo.fRasmanReferenced = TRUE;
|
|
|
|
//
|
|
// Check if there is any security agent on the network. If there is,
|
|
// we check with it if we can start up or not.
|
|
//
|
|
|
|
/*
|
|
if ( SecurityCheck() )
|
|
{
|
|
dwRetCode = ERROR_SERVICE_DISABLED;
|
|
break;
|
|
}
|
|
*/
|
|
|
|
if ( ( dwRetCode = GetRouterPhoneBook() ) != NO_ERROR )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( ( dwRetCode = LoadStrings() ) != NO_ERROR )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// get handle to the supervisor parameters key
|
|
//
|
|
|
|
if ( dwRetCode = RegOpenKey( HKEY_LOCAL_MACHINE,
|
|
DDM_PARAMETERS_KEY_PATH,
|
|
&(gblDDMConfigInfo.hkeyParameters) ))
|
|
{
|
|
WCHAR * pwChar = DDM_PARAMETERS_KEY_PATH;
|
|
|
|
DDMLogError( ROUTERLOG_CANT_OPEN_REGKEY, 1, &pwChar, dwRetCode);
|
|
|
|
break;
|
|
}
|
|
|
|
if ( dwRetCode = RegOpenKey( HKEY_LOCAL_MACHINE,
|
|
DDM_ACCOUNTING_KEY_PATH,
|
|
&(gblDDMConfigInfo.hkeyAccounting) ))
|
|
{
|
|
WCHAR * pwChar = DDM_ACCOUNTING_KEY_PATH;
|
|
|
|
DDMLogError( ROUTERLOG_CANT_OPEN_REGKEY, 1, &pwChar, dwRetCode);
|
|
|
|
break;
|
|
}
|
|
|
|
if ( dwRetCode = RegOpenKey( HKEY_LOCAL_MACHINE,
|
|
DDM_AUTHENTICATION_KEY_PATH,
|
|
&(gblDDMConfigInfo.hkeyAuthentication) ))
|
|
{
|
|
WCHAR * pwChar = DDM_AUTHENTICATION_KEY_PATH;
|
|
|
|
DDMLogError( ROUTERLOG_CANT_OPEN_REGKEY, 1, &pwChar, dwRetCode);
|
|
|
|
break;
|
|
}
|
|
|
|
if ( ( dwRetCode = LoadDDMParameters( gblDDMConfigInfo.hkeyParameters,
|
|
&fIpAllowed) )
|
|
!= NO_ERROR )
|
|
{
|
|
//
|
|
// error loading parameters
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Load the secuirity module if there is one.
|
|
//
|
|
|
|
if ( ( dwRetCode = LoadSecurityModule() ) != NO_ERROR )
|
|
{
|
|
//
|
|
// error loading security dll
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Load the third party admin module if there is one
|
|
//
|
|
|
|
if ( ( dwRetCode = LoadAdminModule() ) != NO_ERROR )
|
|
{
|
|
//
|
|
// error loading admin module dll
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// This call allocates memory for all enumed devices with dialin
|
|
// capability, opens each device and updates the port handle and
|
|
// the port name in the DCB.
|
|
//
|
|
|
|
if ((dwRetCode = RmInit(&(DimInfo->fWANDeviceInstalled))) != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Allocate the supervisor events array, 2 per device bucket since there
|
|
// are 2 rasman events per device, state change and frame received.
|
|
//
|
|
|
|
gblSupervisorEvents = (HANDLE *)LOCAL_ALLOC( LPTR,
|
|
(NUM_DDM_EVENTS + (gblDeviceTable.NumDeviceBuckets * 3))
|
|
* sizeof( HANDLE ) );
|
|
|
|
if ( gblSupervisorEvents == (HANDLE *)NULL )
|
|
{
|
|
dwRetCode = GetLastError();
|
|
|
|
DDMLogError(ROUTERLOG_NOT_ENOUGH_MEMORY, 0, NULL, dwRetCode );
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Create the DDM Events
|
|
//
|
|
|
|
for ( dwIndex = 0;
|
|
dwIndex < (NUM_DDM_EVENTS+(gblDeviceTable.NumDeviceBuckets * 3));
|
|
dwIndex ++ )
|
|
{
|
|
switch( dwIndex )
|
|
{
|
|
case DDM_EVENT_SVC:
|
|
|
|
gblSupervisorEvents[dwIndex]=*gblphEventDDMServiceState;
|
|
gblEventHandlerTable[dwIndex].EventHandler = SvcEventHandler;
|
|
break;
|
|
|
|
case DDM_EVENT_SVC_TERMINATED:
|
|
|
|
gblSupervisorEvents[dwIndex]=*gblphEventDDMTerminated;
|
|
break;
|
|
|
|
case DDM_EVENT_TIMER:
|
|
|
|
gblSupervisorEvents[dwIndex]=CreateWaitableTimer( NULL,
|
|
FALSE,
|
|
NULL );
|
|
gblEventHandlerTable[dwIndex].EventHandler = TimerHandler;
|
|
break;
|
|
|
|
case DDM_EVENT_SECURITY_DLL:
|
|
|
|
gblSupervisorEvents[dwIndex]=CreateEvent(NULL,FALSE,FALSE,NULL);
|
|
gblEventHandlerTable[dwIndex].EventHandler =
|
|
SecurityDllEventHandler;
|
|
break;
|
|
|
|
case DDM_EVENT_PPP:
|
|
|
|
gblSupervisorEvents[dwIndex]=CreateEvent(NULL,FALSE,FALSE,NULL);
|
|
gblEventHandlerTable[dwIndex].EventHandler = PppEventHandler;
|
|
break;
|
|
|
|
case DDM_EVENT_CHANGE_NOTIFICATION:
|
|
case DDM_EVENT_CHANGE_NOTIFICATION1:
|
|
case DDM_EVENT_CHANGE_NOTIFICATION2:
|
|
|
|
gblSupervisorEvents[dwIndex]=CreateEvent(NULL,FALSE,FALSE,NULL);
|
|
gblEventHandlerTable[dwIndex].EventHandler =
|
|
ChangeNotificationEventHandler;
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// RasMan events
|
|
//
|
|
|
|
gblSupervisorEvents[dwIndex]=CreateEvent(NULL,FALSE,FALSE,NULL);
|
|
break;
|
|
}
|
|
|
|
if ( gblSupervisorEvents[dwIndex] == NULL )
|
|
{
|
|
dwRetCode = GetLastError();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Initialize the Message Mechanism
|
|
//
|
|
|
|
InitializeMessageQs( gblSupervisorEvents[DDM_EVENT_SECURITY_DLL],
|
|
gblSupervisorEvents[DDM_EVENT_PPP] );
|
|
|
|
//
|
|
// Register the device hEvents with RasMan
|
|
//
|
|
|
|
dwRetCode = DeviceObjIterator(DeviceObjRequestNotification,TRUE,NULL);
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( fIpAllowed )
|
|
{
|
|
//
|
|
// GetLocalNASIpAddress tries to load iphlpapi.dll. iphlpapi.dll
|
|
// tries to load dhcpcsvc.dll. The latter fails unless TCP/IP is
|
|
// installed and a popup appears.
|
|
//
|
|
|
|
dwLocalIpAddress = GetLocalNASIpAddress();
|
|
}
|
|
|
|
//
|
|
// Load the configured authentication provider
|
|
//
|
|
|
|
dwRetCode = LoadAndInitAuthOrAcctProvider(
|
|
TRUE,
|
|
dwLocalIpAddress,
|
|
NULL,
|
|
&lpfnRasAuthProviderAuthenticateUser,
|
|
&lpfnRasAuthProviderFreeAttributes,
|
|
&lpfnRasAuthConfigChangeNotification,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL );
|
|
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
DDMLogErrorString( ROUTERLOG_AUTHPROVIDER_FAILED_INIT,
|
|
0, NULL, dwRetCode, 0);
|
|
break;
|
|
}
|
|
|
|
gblDDMConfigInfo.lpfnRasAuthConfigChangeNotification = (DWORD(*)(DWORD))
|
|
lpfnRasAuthConfigChangeNotification;
|
|
|
|
//
|
|
// Load the configured accounting provider
|
|
//
|
|
|
|
dwRetCode = LoadAndInitAuthOrAcctProvider(
|
|
FALSE,
|
|
dwLocalIpAddress,
|
|
&(gblDDMConfigInfo.dwAccountingSessionId),
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&lpfnRasAcctProviderStartAccounting,
|
|
&lpfnRasAcctProviderInterimAccounting,
|
|
&lpfnRasAcctProviderStopAccounting,
|
|
&lpfnRasAcctProviderFreeAttributes,
|
|
&lpfnRasAcctConfigChangeNotification );
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
DDMLogErrorString( ROUTERLOG_ACCTPROVIDER_FAILED_INIT,
|
|
0, NULL, dwRetCode, 0);
|
|
break;
|
|
}
|
|
|
|
gblDDMConfigInfo.lpfnRasAcctConfigChangeNotification = (DWORD(*)(DWORD))
|
|
lpfnRasAcctConfigChangeNotification;
|
|
|
|
|
|
//
|
|
// Initialize PPP RASIPHLP DLL
|
|
//
|
|
|
|
if ( fIpAllowed )
|
|
{
|
|
DWORD i;
|
|
BOOL bCalled = FALSE;
|
|
|
|
for (i=0; i<gblDDMConfigInfo.NumAdminDlls; i++)
|
|
{
|
|
PADMIN_DLL_CALLBACKS AdminDllCallbacks = &gblDDMConfigInfo.AdminDllCallbacks[i];
|
|
if (AdminDllCallbacks[i].lpfnMprAdminGetIpAddressForUser!=NULL)
|
|
{
|
|
dwRetCode = RasSrvrInitialize(
|
|
AdminDllCallbacks[i].lpfnMprAdminGetIpAddressForUser,
|
|
AdminDllCallbacks[i].lpfnMprAdminReleaseIpAddress );
|
|
|
|
bCalled = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!bCalled)
|
|
{
|
|
dwRetCode = RasSrvrInitialize(NULL, NULL);
|
|
}
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
DDMLogErrorString( ROUTERLOG_CANT_INITIALIZE_IP_SERVER,
|
|
0, NULL, dwRetCode, 0 );
|
|
|
|
break;
|
|
}
|
|
|
|
gblDDMConfigInfo.fRasSrvrInitialized = TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// Start the timer
|
|
//
|
|
|
|
{
|
|
LARGE_INTEGER DueTime;
|
|
|
|
DueTime.QuadPart = Int32x32To64((LONG)1000, -10000);
|
|
|
|
if ( !SetWaitableTimer( gblSupervisorEvents[DDM_EVENT_TIMER],
|
|
&DueTime, 1000, NULL, NULL, FALSE) )
|
|
{
|
|
dwRetCode = GetLastError();
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Initialize PPP engine DLL
|
|
//
|
|
|
|
dwRetCode = PppDdmInit(
|
|
SendPppMessageToDDM,
|
|
gblDDMConfigInfo.dwServerFlags,
|
|
gblDDMConfigInfo.dwLoggingLevel,
|
|
dwLocalIpAddress,
|
|
gblDDMConfigInfo.fFlags&DDM_USING_RADIUS_AUTHENTICATION,
|
|
lpfnRasAuthProviderAuthenticateUser,
|
|
lpfnRasAuthProviderFreeAttributes,
|
|
lpfnRasAcctProviderStartAccounting,
|
|
lpfnRasAcctProviderInterimAccounting,
|
|
lpfnRasAcctProviderStopAccounting,
|
|
lpfnRasAcctProviderFreeAttributes,
|
|
(LPVOID)GetNextAccountingSessionId );
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
DDMLogErrorString(ROUTERLOG_PPP_INIT_FAILED, 0, NULL, dwRetCode, 0);
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Create the Event dispatcher thread
|
|
//
|
|
|
|
if ( ( hEventDispatcher = CreateThread( NULL, 0, EventDispatcher,
|
|
NULL, 0, &ThreadId)) == 0 )
|
|
{
|
|
//
|
|
// cannot create event dispatcher thread
|
|
//
|
|
|
|
dwRetCode = GetLastError();
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Register for plug and play notifications with RASMAN
|
|
//
|
|
|
|
dwRetCode = RasRegisterPnPHandler( (PAPCFUNC) DdmDevicePnpHandler,
|
|
hEventDispatcher,
|
|
TRUE);
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize notification event list
|
|
//
|
|
|
|
InitializeListHead( &(gblDDMConfigInfo.NotificationEventListHead) );
|
|
|
|
//
|
|
// Initialize the array of Analog/Digital Ip Addresses.
|
|
//
|
|
dwRetCode = AddressPoolInit();
|
|
|
|
if( dwRetCode != NO_ERROR )
|
|
{
|
|
break;
|
|
}
|
|
|
|
gblDDMConfigInfo.dwIndex = 0;
|
|
|
|
/*
|
|
TimerQInsert( NULL,
|
|
gblDDMConfigInfo.dwAnnouncePresenceTimer,
|
|
AnnouncePresenceHandler );
|
|
*/
|
|
|
|
//
|
|
// Send notification to the connections folder that ddm
|
|
// has started.
|
|
//
|
|
{
|
|
RASEVENT RasEvent;
|
|
|
|
ZeroMemory((PBYTE) &RasEvent, sizeof(RASEVENT));
|
|
|
|
RasEvent.Type = SERVICE_EVENT;
|
|
RasEvent.Event = RAS_SERVICE_STARTED;
|
|
RasEvent.Service = REMOTEACCESS;
|
|
|
|
(void) RasSendNotification(&RasEvent);
|
|
}
|
|
|
|
return( NO_ERROR );
|
|
|
|
} while ( FALSE );
|
|
|
|
|
|
//
|
|
// We call DDMCleanUp before setting the gblphEventDDMTerminated because
|
|
// otherwise the DIM dll will be unloaded while DDMCleanUp is being
|
|
// executed
|
|
//
|
|
|
|
DDMCleanUp();
|
|
|
|
//
|
|
// Will terminate the event dispatcher thread if it started
|
|
// and will notify DIM that the service is terminated.
|
|
//
|
|
if(NULL != gblphEventDDMTerminated)
|
|
{
|
|
SetEvent( *gblphEventDDMTerminated );
|
|
}
|
|
|
|
gblphEventDDMTerminated = NULL;
|
|
|
|
return( dwRetCode );
|
|
}
|
|
|
|
//***
|
|
//
|
|
// Function: SvcEventHandler
|
|
//
|
|
// Descrption: Invoked following the event signaled by the handler registered
|
|
// with the service controller. Replaces old service state with
|
|
// the new state and calls the appropriate handler.
|
|
//
|
|
//***
|
|
VOID
|
|
SvcEventHandler(
|
|
VOID
|
|
)
|
|
{
|
|
EnterCriticalSection( &(gblDeviceTable.CriticalSection) );
|
|
|
|
switch ( gblDDMConfigInfo.pServiceStatus->dwCurrentState )
|
|
{
|
|
case SERVICE_RUNNING:
|
|
DDMServiceResume();
|
|
break;
|
|
|
|
case SERVICE_PAUSED:
|
|
DDMServicePause();
|
|
break;
|
|
|
|
case SERVICE_STOP_PENDING:
|
|
DDMServiceTerminate();
|
|
break;
|
|
|
|
default:
|
|
RTASSERT(FALSE);
|
|
}
|
|
|
|
LeaveCriticalSection( &(gblDeviceTable.CriticalSection) );
|
|
|
|
}
|
|
|
|
|
|
|