516 lines
13 KiB
C
516 lines
13 KiB
C
//*************************************************************
|
|
//
|
|
// File name: TSrv.c
|
|
//
|
|
// Description: Contains routines to support remote
|
|
// terminals
|
|
//
|
|
// Microsoft Confidential
|
|
// Copyright (c) Microsoft Corporation 1991-1997
|
|
// All rights reserved
|
|
//
|
|
//*************************************************************
|
|
|
|
#include <regapi.h>
|
|
#include <TSrv.h>
|
|
#include <TSrvTerm.h>
|
|
#include <TSrvCom.h>
|
|
#include <TSrvInfo.h>
|
|
#include <TSrvVC.h>
|
|
#include <McsLib.h>
|
|
|
|
#include "stdio.h"
|
|
|
|
#include "_tsrvinfo.h"
|
|
#include <tlsapi.h>
|
|
|
|
// Data declarations
|
|
|
|
HINSTANCE g_hDllInstance = NULL; // DLL instance
|
|
HANDLE g_hMainThread = NULL; // Main work thread
|
|
HANDLE g_hReadyEvent = NULL; // Ready event
|
|
BOOL g_fShutdown = FALSE; // TSrvShare shutdown flag
|
|
HANDLE g_hIcaTrace; // system wide trace handle
|
|
HANDLE g_MainThreadExitEvent = NULL;
|
|
|
|
extern HANDLE g_hVCAddinChangeEvent;
|
|
extern HKEY g_hAddinRegKey; // handle to Addins reg subkey
|
|
|
|
#define CERTIFICATE_INSTALLATION_INTERVAL 900000
|
|
|
|
LICENSE_STATUS GetServerCertificate(CERT_TYPE CertType,
|
|
LPBYTE * ppbCertificate,
|
|
LPDWORD pcbCertificate );
|
|
|
|
//*************************************************************
|
|
//
|
|
// DllMain()
|
|
//
|
|
// Purpose: Dll entry point.
|
|
//
|
|
// Parameters: IN [hInstance] -- Dll hInstance.
|
|
// IN [dwReason] -- Call reason
|
|
// IN [lpReserved] -- Reserved.
|
|
//
|
|
// Return: TRUE if successful
|
|
// FALSE if not
|
|
//
|
|
// History: 07-17-97 BrianTa Created
|
|
//
|
|
//*************************************************************
|
|
BOOL WINAPI _CRT_INIT(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved);
|
|
|
|
BOOL
|
|
WINAPI
|
|
TShareDLLEntry(
|
|
IN HINSTANCE hInstance,
|
|
IN DWORD dwReason,
|
|
IN LPVOID lpReserved)
|
|
{
|
|
BOOL fSuccess;
|
|
|
|
// DbgBreakPoint();
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: DllMain entry\n"));
|
|
|
|
TRACE((DEBUG_TSHRSRV_DEBUG,
|
|
"TShrSRV: hInstance 0x%x, dwReason 0x%x\n",
|
|
hInstance, dwReason));
|
|
|
|
fSuccess = TRUE;
|
|
|
|
switch (dwReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
if (!_CRT_INIT(hInstance, dwReason, lpReserved))
|
|
return(FALSE);
|
|
|
|
TRACE((DEBUG_TSHRSRV_NORMAL,
|
|
"TShrSRV: DLL attach\n"));
|
|
|
|
// Disable thread library calls and save off
|
|
// the DLL instance handle
|
|
|
|
DisableThreadLibraryCalls(hInstance);
|
|
|
|
g_hDllInstance = hInstance;
|
|
|
|
TSRNG_Initialize();
|
|
|
|
//
|
|
// init TShare util library.
|
|
//
|
|
|
|
if (TSUtilInit() != ERROR_SUCCESS)
|
|
{
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// invoke mcsmux library first.
|
|
//
|
|
|
|
if (!MCSDLLInit())
|
|
{
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Invoke TShareSRV initialization
|
|
//
|
|
|
|
if (!TSRVStartup())
|
|
{
|
|
fSuccess = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// additional init routines go here.
|
|
//
|
|
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
|
|
TRACE((DEBUG_TSHRSRV_NORMAL,
|
|
"TShrSRV: DLL deattach\n"));
|
|
|
|
//
|
|
// Invoke TShareSRV shutdown
|
|
//
|
|
|
|
TSRVShutdown();
|
|
|
|
//
|
|
// invoke mcsmux cleanup routine.
|
|
//
|
|
|
|
MCSDllCleanup();
|
|
|
|
TSUtilCleanup();
|
|
|
|
TSRNG_Shutdown();
|
|
|
|
if (!_CRT_INIT(hInstance, dwReason, lpReserved))
|
|
return(FALSE);
|
|
|
|
break;
|
|
|
|
default:
|
|
TRACE((DEBUG_TSHRSRV_DEBUG,
|
|
"TShrSRV: Unknown reason code\n"));
|
|
break;
|
|
}
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: DllMain exit - 0x%x\n",
|
|
fSuccess));
|
|
|
|
return (fSuccess);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// TSRVStartup()
|
|
//
|
|
// Purpose: Performs startup processing.
|
|
//
|
|
// Parameters: void
|
|
//
|
|
// Return: TRUE if successful
|
|
// FALSE if not
|
|
//
|
|
// Notes: This routine is called by DLLMain to perform the
|
|
// most basic initialization
|
|
//
|
|
// History: 07-17-97 BrianTa Created
|
|
//
|
|
//*************************************************************
|
|
|
|
BOOL
|
|
TSRVStartup(void)
|
|
{
|
|
DWORD err;
|
|
LONG rc;
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSRVStartup entry\n"));
|
|
|
|
g_hMainThread = NULL;
|
|
|
|
g_MainThreadExitEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
|
|
|
|
if( NULL == g_MainThreadExitEvent )
|
|
{
|
|
err = GetLastError();
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSRVStartup exit - 0x%x\n",
|
|
err));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
TSRV_VC_KEY,
|
|
0,
|
|
KEY_READ,
|
|
&g_hAddinRegKey);
|
|
|
|
if (rc == ERROR_SUCCESS)
|
|
{
|
|
g_hVCAddinChangeEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
|
|
|
|
if( NULL == g_hVCAddinChangeEvent )
|
|
{
|
|
//
|
|
// This is not catastrophic, so we just trace and continue.
|
|
//
|
|
err = GetLastError();
|
|
TRACE((DEBUG_TSHRSRV_ERROR,
|
|
"TShrSRV: Failed to create VC Addin Change event - 0x%x\n",
|
|
err));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// This is not catastrophic either.
|
|
TRACE((DEBUG_TSHRSRV_ERROR,
|
|
"TShrSRV: Failed to open key %S, rc %d\n",
|
|
TSRV_VC_KEY, rc));
|
|
}
|
|
|
|
g_hReadyEvent = CreateEvent(NULL, // security attributes
|
|
FALSE, // manual-reset event
|
|
FALSE, // initial state
|
|
NULL); // event-object name
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSRVStartup exit - 0x%x\n",
|
|
g_hReadyEvent ? TRUE : FALSE));
|
|
|
|
return (g_hReadyEvent ? TRUE : FALSE);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// TSRVShutdown()
|
|
//
|
|
// Purpose: Performs shutdown processing.
|
|
//
|
|
// Parameters: void
|
|
//
|
|
// Return: void
|
|
//
|
|
// History: 07-17-97 BrianTa Created
|
|
//
|
|
//*************************************************************
|
|
|
|
void
|
|
TSRVShutdown(void)
|
|
{
|
|
DWORD dwWaitStatus;
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSRVShutdown entry\n"));
|
|
|
|
// Denote that we are no longer ready to service any
|
|
// new requests
|
|
|
|
TSrvReady(FALSE);
|
|
|
|
// If we were able to launch our main worker thread, then
|
|
// we may need to terminate conferences, etc.
|
|
|
|
if (g_hMainThread)
|
|
{
|
|
// Tell the system that we are terminating. This will cause
|
|
// TSrvMainThread to exit once it has finished servicing all
|
|
// outstanding posted work items.
|
|
|
|
TSrvTerminating(TRUE);
|
|
|
|
// Wait for TSrvMainThread to exit
|
|
|
|
TRACE((DEBUG_TSHRSRV_NORMAL,
|
|
"TShrSRV: Waiting for TSrvMainThread to exit\n"));
|
|
|
|
SetEvent( g_MainThreadExitEvent );
|
|
|
|
dwWaitStatus = WaitForSingleObject(g_hMainThread, 600000);
|
|
|
|
if( WAIT_OBJECT_0 != dwWaitStatus )
|
|
{
|
|
//
|
|
// The thread did not terminate within allowable time
|
|
//
|
|
|
|
TRACE((DEBUG_TSHRSRV_DEBUG,
|
|
"TShrSRV: TSrvMainThread refused to exit, killing\n"));
|
|
|
|
TerminateThread( g_hMainThread, 0 );
|
|
}
|
|
|
|
CloseHandle( g_hMainThread );
|
|
g_hMainThread = NULL;
|
|
|
|
CloseHandle( g_MainThreadExitEvent );
|
|
g_MainThreadExitEvent = NULL;
|
|
|
|
CloseHandle( g_hVCAddinChangeEvent );
|
|
g_hVCAddinChangeEvent = NULL;
|
|
|
|
if (g_hAddinRegKey)
|
|
{
|
|
RegCloseKey(g_hAddinRegKey);
|
|
g_hAddinRegKey = NULL;
|
|
}
|
|
|
|
// Get the VC code to free its stuff
|
|
TSrvTermVC();
|
|
|
|
TLSShutdown();
|
|
}
|
|
else
|
|
{
|
|
TSrvTerminating(TRUE);
|
|
}
|
|
|
|
// Inform GCC we no longer want to be a Node Controller
|
|
|
|
TSrvUnregisterNC();
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSRVShutdown exit\n"));
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// TSrvMainThread()
|
|
//
|
|
// Purpose: Main worker thread for TShareSRV.
|
|
//
|
|
// Parameters: void
|
|
//
|
|
// Return: 0
|
|
//
|
|
// Notes: This thread is spawned by DLLMain. It performs
|
|
// the vast majority of TShareSRV initialization
|
|
// and then waits for work items to be posted to it.
|
|
//
|
|
// History: 07-17-97 BrianTa Created
|
|
//
|
|
//*************************************************************
|
|
|
|
DWORD
|
|
WINAPI
|
|
TSrvMainThread(LPVOID pvContext)
|
|
{
|
|
LPBYTE pX509Cert;
|
|
DWORD dwX509CertLen;
|
|
DWORD dwWaitStatus;
|
|
LICENSE_STATUS Status;
|
|
LARGE_INTEGER DueTime = {0,0};
|
|
HANDLE rghWait[4] = {0};
|
|
DWORD dwCount = 0;
|
|
DWORD dwWaitExit = 0xFFFFFFFF;
|
|
DWORD dwWaitVCAddin = 0xFFFFFFFF;
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSrvMainThread entry\n"));
|
|
|
|
if (TSrvInitialize())
|
|
{
|
|
TSrvReady(TRUE);
|
|
|
|
TRACE((DEBUG_TSHRSRV_NORMAL,
|
|
"TShrSRV: Entering TSrvMainThread worker loop\n"));
|
|
|
|
if (g_MainThreadExitEvent)
|
|
{
|
|
dwWaitExit = WAIT_OBJECT_0 + dwCount;
|
|
rghWait[dwCount] = g_MainThreadExitEvent;
|
|
dwCount++;
|
|
TRACE((DEBUG_TSHRSRV_DEBUG, "TShrSRV: Added exit event\n"));
|
|
}
|
|
|
|
if (g_hVCAddinChangeEvent)
|
|
{
|
|
//
|
|
// The addin change notification was set up earlier, when we read
|
|
// the addins information from the registry.
|
|
//
|
|
dwWaitVCAddin = WAIT_OBJECT_0 + dwCount;
|
|
rghWait[dwCount] = g_hVCAddinChangeEvent;
|
|
dwCount++;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
dwWaitStatus = WaitForMultipleObjects(dwCount,
|
|
rghWait,
|
|
FALSE,
|
|
INFINITE);
|
|
|
|
if( dwWaitExit == dwWaitStatus )
|
|
{
|
|
//
|
|
// time to exit the thread
|
|
//
|
|
|
|
TRACE((DEBUG_TSHRSRV_NORMAL,
|
|
"TShrSRV: TSrvMainThread got EXIT event\n"));
|
|
break;
|
|
}
|
|
else if (dwWaitVCAddin == dwWaitStatus)
|
|
{
|
|
//
|
|
// The Virtual Channel Addins registry key has changed.
|
|
// We need to kick off a refresh of our data.
|
|
//
|
|
TRACE((DEBUG_TSHRSRV_WARN,
|
|
"TShrSRV: TSrvMainThread got VC ADDINS CHANGED event\n"));
|
|
TSrvGotAddinChangedEvent();
|
|
}
|
|
else
|
|
{
|
|
TS_ASSERT(dwWaitStatus == WAIT_FAILED);
|
|
TRACE((DEBUG_TSHRSRV_DEBUG,
|
|
"TShrSRV: Wait failed, so we'll just exit\n"));
|
|
|
|
//
|
|
// Wait failed, just bail
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
|
|
TSrvReady(FALSE);
|
|
}
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSrvMainThread exit - 0x%x\n",
|
|
0));
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// TSrvInitialize()
|
|
//
|
|
// Purpose: Main routine for TSrvShare initialization
|
|
//
|
|
// Parameters: void
|
|
//
|
|
// Return: TRUE if successful
|
|
// FALSE if not
|
|
//
|
|
// History: 07-17-97 BrianTa Created
|
|
//
|
|
//*************************************************************
|
|
|
|
BOOL
|
|
TSrvInitialize(void)
|
|
{
|
|
BOOL fSuccess;
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSrvInitialize entry\n"));
|
|
|
|
fSuccess = FALSE;
|
|
|
|
// Initialize TSrvInfo data structs
|
|
|
|
if (TSrvInitGlobalData())
|
|
{
|
|
if (TSrvInitVC())
|
|
{
|
|
// Register TShareSRV as GCC node controller
|
|
|
|
if (TSrvRegisterNC())
|
|
{
|
|
if (ERROR_SUCCESS == TLSInit())
|
|
{
|
|
fSuccess = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACE((DEBUG_TSHRSRV_FLOW,
|
|
"TShrSRV: TSrvInitialize exit - 0x%x\n", fSuccess));
|
|
|
|
return (fSuccess);
|
|
}
|
|
|