690 lines
18 KiB
C
690 lines
18 KiB
C
/*++
|
||
|
||
Copyright (c) 1991-1992 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
xsinit.c
|
||
|
||
Abstract:
|
||
|
||
This module contains the initialization and termination code for
|
||
the XACTSRV component of the server service.
|
||
|
||
Author:
|
||
|
||
David Treadwell (davidtr) 05-Jan-1991
|
||
Shanku Niyogi (w-shanku)
|
||
|
||
Revision History:
|
||
|
||
Chuck Lenzmeier (chuckl) 17-Jun-1992
|
||
Merged xactsrv.c into xsinit.c and moved from xssvc to
|
||
srvsvc\server
|
||
|
||
--*/
|
||
|
||
//
|
||
// Includes.
|
||
//
|
||
|
||
#include "srvsvcp.h"
|
||
#include "xsdata.h"
|
||
|
||
#include <windows.h> // from sdk\inc
|
||
#include <xactsrv2.h> // from private\inc
|
||
#include <srvfsctl.h>
|
||
|
||
#include <xsconst.h> // from xactsrv
|
||
|
||
#undef DEBUG
|
||
#undef DEBUG_API_ERRORS
|
||
#include <xsdebug.h>
|
||
|
||
extern CRITICAL_SECTION SpoolerMutex;
|
||
|
||
BOOLEAN
|
||
XsUnloadPrintSpoolerFunctions(
|
||
);
|
||
|
||
|
||
DWORD
|
||
XsStartXactsrv (
|
||
VOID
|
||
)
|
||
{
|
||
NTSTATUS status;
|
||
DWORD error;
|
||
DWORD i;
|
||
HANDLE threadHandle;
|
||
DWORD threadId;
|
||
HANDLE eventHandle;
|
||
HANDLE serverHandle;
|
||
ANSI_STRING ansiName;
|
||
UNICODE_STRING unicodeName;
|
||
IO_STATUS_BLOCK ioStatusBlock;
|
||
OBJECT_ATTRIBUTES objectAttributes;
|
||
PORT_MESSAGE connectionRequest;
|
||
REMOTE_PORT_VIEW clientView;
|
||
BOOL waitForEvent;
|
||
|
||
//
|
||
// Set up variables so that we'll know how to shut down in case of
|
||
// an error.
|
||
//
|
||
|
||
serverHandle = NULL;
|
||
eventHandle = NULL;
|
||
waitForEvent = FALSE;
|
||
|
||
try {
|
||
RtlInitializeResource( &SsData.LibraryResource );
|
||
InitializeCriticalSection( &SpoolerMutex );
|
||
} except( EXCEPTION_EXECUTE_HANDLER ) {
|
||
return RtlNtStatusToDosError( GetExceptionCode() );
|
||
}
|
||
SsData.LibraryResourceInitialized = TRUE;
|
||
|
||
//
|
||
// Create a event that will be set by the last thread to exit.
|
||
//
|
||
|
||
IF_DEBUG(INIT) {
|
||
SS_PRINT(( "XsStartXactsrv: Creating termination event.\n" ));
|
||
}
|
||
SS_ASSERT( SsData.XsAllThreadsTerminatedEvent == NULL );
|
||
|
||
status = NtCreateEvent(
|
||
&SsData.XsAllThreadsTerminatedEvent,
|
||
EVENT_ALL_ACCESS,
|
||
NULL,
|
||
NotificationEvent,
|
||
FALSE
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtCreateEvent failed: %X\n",
|
||
status ));
|
||
}
|
||
|
||
SsData.XsAllThreadsTerminatedEvent = NULL;
|
||
goto exit;
|
||
}
|
||
|
||
//
|
||
// Open the server device. Note that we need this handle because
|
||
// the handle used by the main server service is synchronous. We
|
||
// need to to do the XACTSRV_CONNECT FSCTL asynchronously.
|
||
//
|
||
|
||
RtlInitUnicodeString( &unicodeName, XS_SERVER_DEVICE_NAME_W );
|
||
|
||
InitializeObjectAttributes(
|
||
&objectAttributes,
|
||
&unicodeName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
status = NtOpenFile(
|
||
&serverHandle,
|
||
FILE_READ_DATA, // DesiredAccess
|
||
&objectAttributes,
|
||
&ioStatusBlock,
|
||
0L, // ShareAccess
|
||
0L // OpenOptions
|
||
);
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
status = ioStatusBlock.Status;
|
||
}
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtOpenFile (server device object) "
|
||
"failed: %X\n", status ));
|
||
}
|
||
goto exit;
|
||
}
|
||
|
||
//
|
||
// Create the LPC port.
|
||
//
|
||
// !!! Right now this only tries a single port name. If, for some
|
||
// bizarre reason, somebody already has a port by this name,
|
||
// then this will fail. It might make sense to try different
|
||
// names if this fails.
|
||
//
|
||
// !!! We might want to make the port name somewhat random for
|
||
// slightly enhanced security.
|
||
|
||
RtlInitUnicodeString( &unicodeName, XS_PORT_NAME_W );
|
||
RtlInitAnsiString( &ansiName, XS_PORT_NAME_A );
|
||
|
||
InitializeObjectAttributes(
|
||
&objectAttributes,
|
||
&unicodeName,
|
||
0,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
IF_DEBUG(LPC) {
|
||
SS_PRINT(( "XsInitialize: creating port %Z\n", &ansiName ));
|
||
}
|
||
|
||
SS_ASSERT( SsData.XsConnectionPortHandle == NULL );
|
||
|
||
status = NtCreatePort(
|
||
&SsData.XsConnectionPortHandle,
|
||
&objectAttributes,
|
||
0,
|
||
XS_PORT_MAX_MESSAGE_LENGTH,
|
||
XS_PORT_MAX_MESSAGE_LENGTH * 32
|
||
);
|
||
|
||
if ( ! NT_SUCCESS(status) ) {
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
if ( status == STATUS_OBJECT_NAME_COLLISION ) {
|
||
SS_PRINT(( "XsStartXactsrv: The XACTSRV port already "
|
||
"exists\n"));
|
||
|
||
} else {
|
||
SS_PRINT(( "XsStartXactsrv: Failed to create port %Z: %X\n",
|
||
&ansiName, status ));
|
||
}
|
||
}
|
||
|
||
SsData.XsConnectionPortHandle = NULL;
|
||
goto exit;
|
||
}
|
||
|
||
//
|
||
// Set up an event so that we'll know when IO completes, then send
|
||
// the FSCTL to the server indicating that it should now connect to
|
||
// us. We'll set up the port while the IO is outstanding, then wait
|
||
// on the event when the port setup is complete.
|
||
//
|
||
|
||
status = NtCreateEvent(
|
||
&eventHandle,
|
||
EVENT_ALL_ACCESS,
|
||
NULL, // ObjectAttributes
|
||
NotificationEvent,
|
||
FALSE
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtCreateEvent failed: %X\n",
|
||
status ));
|
||
}
|
||
goto exit;
|
||
}
|
||
|
||
IF_DEBUG(LPC) {
|
||
SS_PRINT(( "XsStartXactsrv: sending FSCTL_SRV_XACTSRV_CONNECT.\n" ));
|
||
}
|
||
|
||
status = NtFsControlFile(
|
||
serverHandle,
|
||
eventHandle,
|
||
NULL, // ApcRoutine
|
||
NULL, // ApcContext
|
||
&ioStatusBlock,
|
||
FSCTL_SRV_XACTSRV_CONNECT,
|
||
ansiName.Buffer,
|
||
ansiName.Length,
|
||
NULL, // OutputBuffer
|
||
0L // OutputBufferLength
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtFsControlFile failed: %X\n",
|
||
status ));
|
||
}
|
||
goto exit;
|
||
}
|
||
|
||
waitForEvent = TRUE;
|
||
|
||
//
|
||
// Start listening for the server's connection to the port. Note
|
||
// that it is OK if the server happens to call NtConnectPort
|
||
// first--it will simply block until this call to NtListenPort
|
||
// occurs.
|
||
//
|
||
|
||
IF_DEBUG(LPC) {
|
||
SS_PRINT(( "XsStartXactsrv: listening to port.\n" ));
|
||
}
|
||
|
||
connectionRequest.u1.s1.TotalLength = sizeof(connectionRequest);
|
||
connectionRequest.u1.s1.DataLength = (CSHORT)0;
|
||
status = NtListenPort(
|
||
SsData.XsConnectionPortHandle,
|
||
&connectionRequest
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtListenPort failed: %X\n", status ));
|
||
}
|
||
goto exit;
|
||
}
|
||
|
||
//
|
||
// The server has initiated the connection. Accept the connection.
|
||
//
|
||
// !!! We probably need some security check here.
|
||
//
|
||
|
||
clientView.Length = sizeof(clientView);
|
||
clientView.ViewSize = 0;
|
||
clientView.ViewBase = 0;
|
||
|
||
IF_DEBUG(LPC) {
|
||
SS_PRINT(( "XsStartXactsrv: Accepting connection to port.\n" ));
|
||
}
|
||
|
||
SS_ASSERT( SsData.XsCommunicationPortHandle == NULL );
|
||
|
||
status = NtAcceptConnectPort(
|
||
&SsData.XsCommunicationPortHandle,
|
||
NULL, // PortContext
|
||
&connectionRequest,
|
||
TRUE, // AcceptConnection
|
||
NULL, // ServerView
|
||
&clientView
|
||
);
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtAcceptConnectPort failed: %X\n",
|
||
status ));
|
||
}
|
||
|
||
SsData.XsCommunicationPortHandle = NULL;
|
||
goto exit;
|
||
}
|
||
|
||
IF_DEBUG(LPC) {
|
||
SS_PRINT(( "XsStartXactsrv: client view size: %ld, base: %lx\n",
|
||
clientView.ViewSize, clientView.ViewBase ));
|
||
}
|
||
|
||
//
|
||
// Complete the connection to the port, thereby releasing the server
|
||
// thread waiting in NtConnectPort.
|
||
//
|
||
|
||
IF_DEBUG(LPC) {
|
||
SS_PRINT(( "XsStartXactsrv: Completing connection to port.\n" ));
|
||
}
|
||
|
||
status = NtCompleteConnectPort( SsData.XsCommunicationPortHandle );
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtCompleteConnectPort failed: %X\n",
|
||
status ));
|
||
}
|
||
goto exit;
|
||
}
|
||
|
||
|
||
status = STATUS_SUCCESS;
|
||
|
||
exit:
|
||
|
||
//
|
||
// Wait for the IO to complete, then close the event handle.
|
||
//
|
||
|
||
if ( waitForEvent ) {
|
||
|
||
NTSTATUS waitStatus;
|
||
|
||
SS_ASSERT( eventHandle != NULL );
|
||
|
||
waitStatus = NtWaitForSingleObject( eventHandle, FALSE, NULL );
|
||
|
||
if ( !NT_SUCCESS(waitStatus) ) {
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: NtWaitForSingleObject failed: "
|
||
"%X\n", waitStatus ));
|
||
}
|
||
|
||
//
|
||
// If another error has already occurred, don't report this
|
||
// one.
|
||
//
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
status = waitStatus;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Check the status in the IO status block. If it is bad, then
|
||
// there was some problem on the server side of the port setup.
|
||
//
|
||
|
||
if ( !NT_SUCCESS(ioStatusBlock.Status) ) {
|
||
IF_DEBUG(ERRORS) {
|
||
SS_PRINT(( "XsStartXactsrv: bad status in IO status block: "
|
||
"%X\n", ioStatusBlock.Status ));
|
||
}
|
||
|
||
//
|
||
// If another error has already occurred, don't report this
|
||
// one.
|
||
//
|
||
|
||
if ( NT_SUCCESS(status) ) {
|
||
status = ioStatusBlock.Status;
|
||
}
|
||
|
||
}
|
||
|
||
CloseHandle( eventHandle );
|
||
|
||
}
|
||
|
||
//
|
||
// Close the handle to the server.
|
||
//
|
||
|
||
if ( serverHandle != NULL ) {
|
||
CloseHandle( serverHandle );
|
||
}
|
||
|
||
//
|
||
// If the above failed, return to caller now.
|
||
//
|
||
|
||
if ( !NT_SUCCESS(status) ) {
|
||
return RtlNtStatusToDosError( status );
|
||
}
|
||
|
||
//
|
||
// Start one API processing thread. It will spawn others if needed
|
||
//
|
||
threadHandle = CreateThread(
|
||
NULL,
|
||
0,
|
||
(LPTHREAD_START_ROUTINE)XsProcessApisWrapper,
|
||
0,
|
||
0,
|
||
&threadId
|
||
);
|
||
|
||
if ( threadHandle != 0 ) {
|
||
|
||
IF_DEBUG(THREADS) {
|
||
SS_PRINT(( "XsStartXactsrv: Created thread %ld for "
|
||
"processing APIs\n", SsData.XsThreads ));
|
||
}
|
||
|
||
CloseHandle( threadHandle );
|
||
SsData.ApiThreadsStarted = TRUE;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Thread creation failed. Return an error to the caller.
|
||
// It is the responsibility of the caller to call
|
||
// XsStopXactsrv to clean up.
|
||
//
|
||
|
||
error = GetLastError( );
|
||
return error;
|
||
|
||
}
|
||
|
||
|
||
//
|
||
// Initialization succeeded.
|
||
//
|
||
|
||
return NO_ERROR;
|
||
|
||
} // XsStartXactsrv
|
||
|
||
|
||
/*
|
||
* This routine is called to stop the transaction processor once the
|
||
* server driver has terminated.
|
||
*/
|
||
VOID
|
||
XsStopXactsrv (
|
||
VOID
|
||
)
|
||
{
|
||
NTSTATUS status;
|
||
static XACTSRV_REQUEST_MESSAGE requestMessage;
|
||
LONG i;
|
||
BOOL ok;
|
||
|
||
//
|
||
// Stop all the xs worker threads, and release resources
|
||
//
|
||
|
||
if ( SsData.XsConnectionPortHandle != NULL ) {
|
||
|
||
//
|
||
// Indicate that XACTSRV is terminating.
|
||
//
|
||
SsData.XsTerminating = TRUE;
|
||
|
||
IF_DEBUG(TERMINATION) {
|
||
SS_PRINT(("XsStopXactsrv: queueing termination messages\n"));
|
||
}
|
||
|
||
if( SsData.ApiThreadsStarted == TRUE ) {
|
||
|
||
//
|
||
// Queue a message to kill off the worker thereads
|
||
//
|
||
RtlZeroMemory( &requestMessage, sizeof( requestMessage ));
|
||
requestMessage.PortMessage.u1.s1.DataLength =
|
||
(USHORT)( sizeof(requestMessage) - sizeof(PORT_MESSAGE) );
|
||
requestMessage.PortMessage.u1.s1.TotalLength = sizeof(requestMessage);
|
||
requestMessage.MessageType = XACTSRV_MESSAGE_WAKEUP;
|
||
|
||
status = NtRequestPort(
|
||
SsData.XsConnectionPortHandle,
|
||
(PPORT_MESSAGE)&requestMessage
|
||
);
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
if ( !NT_SUCCESS(status) ) {
|
||
SS_PRINT(( "SrvXsDisconnect: NtRequestPort failed: %X\n",
|
||
status ));
|
||
}
|
||
}
|
||
|
||
//
|
||
// The above will cause all worker threads to wake up then die.
|
||
//
|
||
|
||
ok = WaitForSingleObject( SsData.XsAllThreadsTerminatedEvent, (DWORD)-1 );
|
||
|
||
IF_DEBUG(ERRORS) {
|
||
if ( !ok ) {
|
||
SS_PRINT(( "XsStopXactsrv: WaitForSingleObject failed: "
|
||
"%ld\n", GetLastError() ));
|
||
}
|
||
}
|
||
|
||
SsData.ApiThreadsStarted = FALSE;
|
||
}
|
||
|
||
CloseHandle( SsData.XsConnectionPortHandle );
|
||
}
|
||
|
||
if( SsData.XsCommunicationPortHandle != NULL ) {
|
||
CloseHandle( SsData.XsCommunicationPortHandle );
|
||
SsData.XsCommunicationPortHandle = NULL;
|
||
}
|
||
|
||
//
|
||
// Unload the xactsrv libaray
|
||
//
|
||
if( SsData.XsXactsrvLibrary != NULL ) {
|
||
PXS_API_TABLE_ENTRY entry = XsApiTable;
|
||
|
||
//
|
||
// Null out all of the entry points
|
||
//
|
||
for( entry = XsApiTable;
|
||
entry < &XsApiTable[ XS_SIZE_OF_API_TABLE ];
|
||
entry++ ) {
|
||
|
||
entry->Handler = NULL;
|
||
}
|
||
|
||
XsSetParameters = NULL;
|
||
XsCaptureParameters = NULL;
|
||
XsCheckSmbDescriptor = NULL;
|
||
|
||
FreeLibrary( SsData.XsXactsrvLibrary );
|
||
SsData.XsXactsrvLibrary = NULL;
|
||
}
|
||
|
||
//
|
||
// Unload the license library
|
||
//
|
||
if( SsData.XsLicenseLibrary != NULL ) {
|
||
SsData.SsLicenseRequest = NULL;
|
||
SsData.SsFreeLicense = NULL;
|
||
FreeLibrary( SsData.XsLicenseLibrary );
|
||
SsData.XsLicenseLibrary = NULL;
|
||
}
|
||
|
||
if( SsData.LibraryResourceInitialized == TRUE ) {
|
||
// Unload the spooler library if necessary
|
||
XsUnloadPrintSpoolerFunctions();
|
||
DeleteCriticalSection( &SpoolerMutex );
|
||
|
||
// Delete the library resource
|
||
RtlDeleteResource( &SsData.LibraryResource );
|
||
SsData.LibraryResourceInitialized = FALSE;
|
||
}
|
||
|
||
//
|
||
// Close the termination event.
|
||
//
|
||
|
||
if ( SsData.XsAllThreadsTerminatedEvent != NULL ) {
|
||
CloseHandle( SsData.XsAllThreadsTerminatedEvent );
|
||
SsData.XsAllThreadsTerminatedEvent = NULL;
|
||
}
|
||
|
||
return;
|
||
|
||
} // XsStopXactsrv
|
||
|
||
/*
|
||
* This routine is called to dynamically load the transaction library for
|
||
* downlevel clients. It fills in the entry points for the library
|
||
*/
|
||
BOOLEAN
|
||
XsLoadXactLibrary( WORD FunctionNumber )
|
||
{
|
||
PXS_API_TABLE_ENTRY entry = &XsApiTable[ FunctionNumber ];
|
||
|
||
if( SsData.XsXactsrvLibrary == NULL ) {
|
||
|
||
RtlAcquireResourceExclusive( &SsData.LibraryResource, TRUE );
|
||
|
||
if( SsData.XsXactsrvLibrary == NULL ) {
|
||
SsData.XsXactsrvLibrary = LoadLibrary( L"xactsrv.dll" );
|
||
}
|
||
|
||
RtlReleaseResource( &SsData.LibraryResource );
|
||
|
||
if( SsData.XsXactsrvLibrary == NULL ) {
|
||
|
||
DbgPrint( "SRVSVC: Unable to load xactsrv.dll, error %u\n",
|
||
GetLastError() );
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if( XsSetParameters == NULL &&
|
||
(XsSetParameters = (XS_SET_PARAMETERS_FUNCTION)GetProcAddress(
|
||
SsData.XsXactsrvLibrary, "XsSetParameters" )) == NULL ) {
|
||
|
||
DbgPrint( "SRVSVC: XsSetParameters entry missing from xactsrv.dll, err %u\n",
|
||
GetLastError() );
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
if( XsCaptureParameters == NULL &&
|
||
(XsCaptureParameters = (XS_CAPTURE_PARAMETERS_FUNCTION)GetProcAddress(
|
||
SsData.XsXactsrvLibrary, "XsCaptureParameters" )) == NULL ) {
|
||
|
||
DbgPrint( "SRVSVC: XsCaptureParameters entry missing from xactsrv.dll, err %u\n",
|
||
GetLastError() );
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
if( XsCheckSmbDescriptor == NULL &&
|
||
(XsCheckSmbDescriptor = (XS_CHECK_SMB_DESCRIPTOR_FUNCTION)GetProcAddress(
|
||
SsData.XsXactsrvLibrary, "XsCheckSmbDescriptor" )) == NULL ) {
|
||
|
||
DbgPrint( "SRVSVC: XsCheckSmbDescriptor entry missing from xactsrv.dll, err %u\n",
|
||
GetLastError() );
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Fetch the requested entry point
|
||
//
|
||
entry->Handler =
|
||
(PXACTSRV_API_HANDLER)GetProcAddress( SsData.XsXactsrvLibrary, entry->HandlerName );
|
||
|
||
if( entry->Handler == NULL ) {
|
||
|
||
DbgPrint( "SRVSVC: %s entry missing from xactsrv.dll, err %u\n",
|
||
entry->HandlerName, GetLastError() );
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOLEAN
|
||
SsLoadLicenseLibrary()
|
||
{
|
||
if( SsData.XsLicenseLibrary == NULL ) {
|
||
|
||
RtlAcquireResourceExclusive( &SsData.LibraryResource, TRUE );
|
||
|
||
if( SsData.XsLicenseLibrary == NULL ) {
|
||
SsData.XsLicenseLibrary = LoadLibrary( L"ntlsapi.dll" );
|
||
}
|
||
|
||
RtlReleaseResource( &SsData.LibraryResource );
|
||
|
||
if( SsData.XsLicenseLibrary == NULL ) {
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
SsData.SsLicenseRequest = (PNT_LICENSE_REQUEST_W)GetProcAddress( SsData.XsLicenseLibrary, "NtLicenseRequestW" );
|
||
SsData.SsFreeLicense = (PNT_LS_FREE_HANDLE)GetProcAddress( SsData.XsLicenseLibrary, "NtLSFreeHandle" );
|
||
|
||
return( SsData.SsLicenseRequest != NULL && SsData.SsFreeLicense != NULL );
|
||
}
|