|
|
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name :
igateway.cxx
Abstract: This module defines the functions for Internet Services related gateway processing ( spawning process and thread for i/o).
Author:
Murali R. Krishnan ( MuraliK ) 25-Jan-1995
Environment:
User Mode - Win32 Project:
Internet Services Common DLL
Functions Exported:
BOOL TsProcessGatewayRequest( IN LPVOID pClientContext, IN PIGATEWAY_REQUEST pigRequest, IN PFN_GATEWAY_READ_CALLBACK pfnReadCallBack);
Revision History:
--*/
/*++
A service may require gateway call to process special requests received from the clients. Such requests are processed by spawning a special process and communicating with the special process. The process takes the client supplied data as input and sends its output to be sent to the client. Since the service module is aware of the details of input and output, a special thread is created in the service process to deal with the input and output. A two-way pipe is established b/w the spawned process and the service thread. Once the "special gateway process" completes processing the input and terminates, the thread doing I/O proceeds to munging. During munging state, the thread calls upon a callback function for munging and data transfer. The call-back function is responsible for altering the data if need be and sending the data to client. After this the service thread terminates its work.
--*/
/************************************************************
* Include Headers ************************************************************/
# include <tcpdllp.hxx>
# include "igateway.hxx"
# define MAX_CB_DATA_FROM_GATEWAY ( 4096)
/************************************************************
* Type Definitions ************************************************************/
class IGATEWAY_PROCESSOR {
public: inline IGATEWAY_PROCESSOR( IN LPVOID pClientContext, IN PFN_IGATEWAY_READ_CALLBACK pfnReadCallBack, IN LPBYTE pbDataToGateway = NULL, IN DWORD cbDataToGateway = 0 ) : m_pClientContext ( pClientContext), m_pfnReadCallBack ( pfnReadCallBack), m_pbDataToGateway ( pbDataToGateway), m_cbDataToGateway ( cbDataToGateway), m_hStdIn ( INVALID_HANDLE_VALUE), m_hStdOut ( INVALID_HANDLE_VALUE) { m_fCompleted = 0; m_fValid = ( m_pfnReadCallBack != NULL); } inline virtual ~IGATEWAY_PROCESSOR( VOID); BOOL IsValid( VOID) const { return ( m_fValid); }
VOID SetProcessingCompleted( IN BOOL fValue = TRUE) { m_fCompleted = ( fValue) ? 1 : 0; }
BOOL IsProcessingCompleted( VOID) const { return ( m_fCompleted == 1); }
HANDLE QueryStdInHandle( VOID) const { return ( m_hStdIn); } HANDLE QueryStdOutHandle( VOID) const { return ( m_hStdOut); }
BOOL StartGatewayProcess( IN LPCTSTR pszCmdLine, IN LPCTSTR pszWorkingDir, IN LPVOID lpvEnvironment, IN HANDLE hUserToken);
//
// the worker thread for gateway request processing
//
DWORD GatewayIOWorker( VOID);
# if DBG
VOID Print( VOID) const;
# endif // DBG
private:
DWORD m_fValid : 1; DWORD m_fCompleted : 1;
PVOID m_pClientContext; // client context information
PFN_IGATEWAY_READ_CALLBACK m_pfnReadCallBack; HANDLE m_hStdIn; HANDLE m_hStdOut;
LPBYTE m_pbDataToGateway; DWORD m_cbDataToGateway;
BOOL SetupChildPipes( IN STARTUPINFO * pStartupInfo);
}; // class IGATEWAY_PROCESSOR
typedef IGATEWAY_PROCESSOR * PIGATEWAY_PROCESSOR;
inline IGATEWAY_PROCESSOR::~IGATEWAY_PROCESSOR( VOID){ DBG_ASSERT( IsProcessingCompleted()); if ( m_hStdIn != INVALID_HANDLE_VALUE && !CloseHandle( m_hStdIn)) { IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, "IGATEWAY_PROCESSOR:CloseHandle( StdIn %08x) failed." " Error = %d.\n", m_hStdIn, GetLastError())); } } if ( m_hStdOut != INVALID_HANDLE_VALUE && !CloseHandle( m_hStdOut)) { IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, "IGATEWAY_PROCESSOR:CloseHandle( StdOut %08x) failed." " Error = %d.\n", m_hStdOut, GetLastError())); } }
} // IGATEWAY_PROCESSOR::~IGATEWAY_PROCESSOR()
# if DBG
static inline VOIDPrintStartupInfo( IN const STARTUPINFO * pStartInfo){
IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, " Startup Info = %08x. cb = %d." " hStdInput = %08x. hStdOutput = %08x." " hStdError = %08x.\n", pStartInfo, pStartInfo->cb, pStartInfo->hStdInput, pStartInfo->hStdOutput, pStartInfo->hStdError)); }
} // PrintStartupInfo()
static inline VOIDPrintProcessInfo( IN const PROCESS_INFORMATION * pProcInfo){ IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, " ProcessInfo = %08x." " hProcess = %08x. hThread = %08x." " dwProcessId = %08x. dwThreadId = %08x", pProcInfo, pProcInfo->hProcess, pProcInfo->hThread, pProcInfo->dwProcessId, pProcInfo->dwThreadId)); }
} // PrintProcessInfo()
# endif // DBG
/************************************************************
* Functions ************************************************************/
static DWORDWINAPIGatewayRequestIOThreadFunction( IN LPVOID pThreadParam)/*++
The function is called when the thread for Gateway request I/O is created. This function calls the GatewayIOWorker member function to process I/O from the gateway process.
In addition this function also deletes the IGATEWAY_PROCESSOR object, at the end. Memory deallocation is done here, since this thread will die at the end of this procedure and no other thread has knowledge about this object to perform cleanup.
Arguments: pThreadParam pointer to thread parameter. This function is called with the parameter as the pointer to IGATEWAY_PROCESSOR object.
Returns: Win32 error code resulting from gateway I/O processing. --*/{ PIGATEWAY_PROCESSOR pigProcessor = (PIGATEWAY_PROCESSOR ) pThreadParam; DWORD dwError; DBG_ASSERT( pigProcessor != NULL);
dwError = pigProcessor->GatewayIOWorker();
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, "Freeing the IGATEWAY_PROCESSOR object ( %08x)\n", pigProcessor)); }
delete pigProcessor;
return ( dwError);} // GatewayRequestIOThreadFunction()
dllexp BOOLTsProcessGatewayRequest( IN LPVOID pClientContext, IN PIGATEWAY_REQUEST pigRequest, IN PFN_IGATEWAY_READ_CALLBACK pfnReadCallBack)/*++
Description: This function creates a gateway processor object responsible for processing gateway requests. It extracts the parameters required from input request package ( IGATEWAY_REQUEST structure). It creates a separate process for gateway request and a separate thread for handling I/O for the gateway request. The thread uses buffers supplied for i/o in pigRequest. On a completion of read, the thread calls the callback function for processing the data retrieved. If the call back function returns any error further procecssing in the thread is halted and the thread dies. The process also will eventually die, since the pipes are broken.
Arguments: pClientContext context information supplied by client pigRequest pointer to IGATEWAY_REQUEST object. pfnReadCallBack pointer to callback function for read completions.
Returns: TRUE on success and FALSE if there is any failure. Use GetLastError() to retrieve Win32 error code.--*/{ BOOL fReturn = FALSE; PIGATEWAY_PROCESSOR pigProcessor = NULL;
DBG_ASSERT( pigRequest != NULL && pfnReadCallBack != NULL);
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, "TsProcessGatewayRequest() called. pigRequest = %08x.\n", pigRequest)); }
//
// create a new gateway processor object for handling the gateway request.
//
pigProcessor = new IGATEWAY_PROCESSOR( pClientContext, pfnReadCallBack, pigRequest->pbDataToGateway, pigRequest->cbDataToGateway); fReturn = ( pigProcessor != NULL) && pigProcessor->IsValid();
if ( fReturn) { IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, " Created a new IGATEWAY_PROCESSOR object.\n")); DBG_CODE( pigProcessor->Print()); DBGPRINTF( ( DBG_CONTEXT, " Starting a process for the gateway command\n")); }
fReturn = pigProcessor->StartGatewayProcess( pigRequest->pszCmdLine, pigRequest->pszWorkingDir, pigRequest->lpvEnvironment, pigRequest->hUserToken); if ( fReturn) {
HANDLE hThread; DWORD dwThreadId;
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, " Creating a new thread to handle gateway I/O\n")); }
//
// Create a new thread to handle I/O with the process spawned.
//
hThread = CreateThread( NULL, // lpSecurityAttributes,
0, // stack size in Bytes,
GatewayRequestIOThreadFunction, (LPVOID )pigProcessor, // params
0, // Creation flags
&dwThreadId); if ( ( fReturn = ( hThread != NULL))) { IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, " Created Gateway I/O thread. Hdl=%d. Id=%d\n", hThread, dwThreadId)); }
//
// Close thread handle, since we are not bothered about its
// termination and there is no special cleanup required.
//
DBG_REQUIRE( CloseHandle( hThread)); } else {
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, "Creation of gateway I/O thread failed." " Error = %d\n", GetLastError())); } } // creation of IO thread
} // successful start of process for gateway.
} // creation of pigProcessor
if ( !fReturn) {
IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, " Failure to set up gateway request processiong." " Deleting the IGATEWAY_PROCESSOR object( %08x)." " Error = %d.\n", pigProcessor, GetLastError())); }
if ( pigProcessor != NULL) {
DBG_ASSERT( !pigProcessor->IsValid()); delete pigProcessor; } }
return ( fReturn);} // TsProcessGatewayRequest()
/************************************************************
* IGATEWAY_PROCESSOR member functions ************************************************************/
BOOLIGATEWAY_PROCESSOR::StartGatewayProcess( IN LPCTSTR pszCmdLine, IN LPCTSTR pszWorkingDir, IN LPVOID lpvEnvironment, // optional
IN HANDLE hUserToken)/*++
Description: This function sets up pipes for communication with gateway and starts a process for gateway application.
Arguments: pszCmdLine pointer to null-terminated string containing the command line for the gateway call. The first word ( seq of chars) in pszCmdLine, specifies the gateway application to be used.
pszWorkingDir pointer to working directory for the gateway call. hUserToken handle for the user accessing gateway for secure access. lpvEnvironment pointer to Environment Block for CreateProcess to pass environment information to the gateway application. Returns: TRUE on success; and FALSE if there is any failure. Use GetLastError() for Win32 error code.--*/{ BOOL fReturn; STARTUPINFO startInfo; PROCESS_INFORMATION procInfo;
DBG_ASSERT( pszCmdLine != NULL && pszWorkingDir != NULL); DBG_ASSERT( hUserToken != INVALID_HANDLE_VALUE);
memset( (PVOID ) &procInfo, 0, sizeof( procInfo)); memset( (PVOID ) &startInfo, 0, sizeof( startInfo)); startInfo.cb = sizeof( startInfo);
if ( ( fReturn = SetupChildPipes( &startInfo))) {
//
// Successfully setup the child pipes. Proceed to create the process.
//
fReturn = CreateProcessAsUser( hUserToken, NULL, // pszImageName
(TCHAR *) pszCmdLine, // pszCommandLine
NULL, // process security
NULL, // thread security
TRUE, // inherit handles,
DETACHED_PROCESS, lpvEnvironment, pszWorkingDir, &startInfo, &procInfo);
DBG_CODE( PrintStartupInfo( &startInfo)); DBG_CODE( PrintProcessInfo( &procInfo));
//
// Had already set up the stderror to be same as stdoutput
// in SetupChildPipes(). Verify the same.
//
if ( fReturn) {
DBG_REQUIRE( startInfo.hStdError == startInfo.hStdOutput);
DBG_REQUIRE( CloseHandle( startInfo.hStdOutput)); DBG_REQUIRE( CloseHandle( startInfo.hStdInput)); DBG_REQUIRE( CloseHandle( procInfo.hProcess)); DBG_REQUIRE( CloseHandle( procInfo.hThread)); } IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, "StartGatewayProcess: CreateProcessAsUser( %s)" " returns %d. Error = %d.\n", pszCmdLine, fReturn, GetLastError())); } } else {
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, "StartGatewayProcess(). Unable to setup child Pipes." " Error = %d\n", GetLastError())); } }
return ( fReturn);} // IGATEWAY_PROCESSOR::StartGatewayProcess()
BOOLIGATEWAY_PROCESSOR::SetupChildPipes( IN LPSTARTUPINFO lpStartupInfo)/*++
Description: Creates pipe and duplicates handles for redirecting stdin and stdout to child process.
Arguments: pStartupInfo pointer to startup information structure used by CreateProcess(). This receives the child stdin and stdout.
Returns: TRUE on success and FALSE if there is any error.--*/{ BOOL fReturn; SECURITY_ATTRIBUTES securityAttributes;
DBG_ASSERT( lpStartupInfo != NULL);
securityAttributes.nLength = sizeof( securityAttributes); securityAttributes.bInheritHandle = TRUE; securityAttributes.lpSecurityDescriptor = NULL;
m_hStdIn = m_hStdOut = NULL; lpStartupInfo->dwFlags = STARTF_USESTDHANDLES; //
// create pipes for communication and duplicate handles.
// mark the duplicates handles as non-inherited to avoid handle leaks
//
fReturn = ( CreatePipe( &m_hStdIn, // parent read pipe
&lpStartupInfo->hStdOutput,// child write pipe
&securityAttributes, 0) && // nSize
DuplicateHandle( GetCurrentProcess(), // hSourceProcess
m_hStdIn, // hSourceHandle
GetCurrentProcess(), // hTargetProcess
&m_hStdIn, // lphTargetHandle
0, // desired access
FALSE, // bInheritHandle
DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE) && CreatePipe( &lpStartupInfo->hStdInput, // parent read pipe
&m_hStdOut, // child write pipe
&securityAttributes, 0) && // nSize
DuplicateHandle( GetCurrentProcess(), // hSourceProcess
m_hStdOut, // hSourceHandle
GetCurrentProcess(), // hTargetProcess
&m_hStdOut, // lphTargetHandle
0, // desired access
FALSE, // bInheritHandle
DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE) );
//
// stdout and stderr share the same handle. In the worst case
// clients close stderr before closing stdout, then we need to duplicate
// stderr too. For now dont duplicate stdout.
//
lpStartupInfo->hStdError = lpStartupInfo->hStdOutput;
IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, "Handles. ChildProcess. In= %08x. Out= %08x. Err= %08x.\n", lpStartupInfo->hStdInput, lpStartupInfo->hStdOutput, lpStartupInfo->hStdError));
DBGPRINTF( ( DBG_CONTEXT, " IO Thread. In= %08x. Out= %08x.\n", m_hStdIn, m_hStdOut)); }
if ( !fReturn) {
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, " SetupChildPipes failed. Error = %d.\n", GetLastError())); }
//
// Free up the handles if any allocated.
//
if ( m_hStdIn != NULL) { DBG_REQUIRE( CloseHandle( m_hStdIn)); m_hStdIn = INVALID_HANDLE_VALUE; }
if ( m_hStdOut != NULL) { DBG_REQUIRE( CloseHandle( m_hStdOut)); m_hStdOut = INVALID_HANDLE_VALUE; } }
return ( fReturn);} // IGATEWAY_PROCESSOR::SetupChildPipes()
DWORDIGATEWAY_PROCESSOR::GatewayIOWorker( VOID)/*++
Description: This is the core function that performs the I/O with the gateway process. I/O is performed using the pipes created by cross-linking the stdout and stdin of gateway process to duplicated handles in the I/O thread.
First, this function writes any data to be sent to the gateway process on the read pipe of the process ( to m_hStdOut of the IGATEWAY_PROCESSOR object). Subsequently it loops receiving data from the gateway process and passing it onto the client ( meaning service that requested gateway processing). It uses the read callback function to make the client perform necessary work. At the least the client should copy the data returned during in callback. ( Otherwise, there is a danger of the data getting lost in subsequent read from the gateway process.)
Arguments: None
Returns: Win32 error code.--*/{ DWORD dwError = NO_ERROR; BOOL fDoneWaitingForGateway; BYTE pbDataFromGateway[ MAX_CB_DATA_FROM_GATEWAY]; DWORD cbRead = 0; IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, " Entering IGATEWAY_PROCESSOR( %08x)::GatewayIOWorker()\n", this)); }
//
// 1. Write any data to the gateway process's stdin
//
if ( m_cbDataToGateway != 0) {
DWORD cbWritten; BOOL fWritten;
DBG_ASSERT( m_pbDataToGateway != NULL);
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, "GatewayIOWorker( %08x)." " Writing %u bytes to gateway ( child) process's" " stdin ( %08x)\n", this, m_cbDataToGateway, m_hStdOut)); }
fWritten = WriteFile( m_hStdOut, m_pbDataToGateway, m_cbDataToGateway, &cbWritten, NULL);
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, "GatewayIOWorker( %08x). WriteFile() returns %d." " written %u bytes of %u bytes. Error = %d.\n", this, fWritten, cbWritten, m_cbDataToGateway, GetLastError())); }
//
// The error if any during WriteFile() is ignored.
//
} // data written to gateway process
//
// 2. Loop for data from gateway.
//
DBG_ASSERT( m_pfnReadCallBack != NULL); for( fDoneWaitingForGateway = FALSE; !fDoneWaitingForGateway; ) {
BOOL fCallBack; //
// 3. Wait for data from gateway process.
//
dwError = WaitForSingleObject( m_hStdIn, INFINITE);
//
// 4. Depending on return code, either read data or get error code
//
switch( dwError) {
case WAIT_OBJECT_0: { BOOL fRead; //
// 4.a Got something to read. Read the data into buffer.
//
fRead = ReadFile( m_hStdIn, pbDataFromGateway, MAX_CB_DATA_FROM_GATEWAY, &cbRead, NULL); dwError = ( fRead) ? NO_ERROR: GetLastError(); IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, " GatewayIOWorker( %08x). ReadDataFromGateway" " returns %d. Read %d bytes. Error = %d.\n", this, fRead, cbRead, dwError)); } if ( dwError == ERROR_BROKEN_PIPE) {
fDoneWaitingForGateway = TRUE; } break; } // case WAIT_OBJECT_0
case WAIT_FAILED: default: { //
// Unknown error.
//
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, " GatewayIOWorker(). WaitForReading Gateway" " data failed. Error = %d\n", dwError)); }
fDoneWaitingForGateway = TRUE; break; } } // switch
//
// 5. send data or error code back to the callback function.
//
fCallBack = ( *m_pfnReadCallBack)( m_pClientContext, dwError, pbDataFromGateway, cbRead);
if ( !fCallBack) {
dwError = GetLastError();
IF_DEBUG( GATEWAY) { DBGPRINTF( ( DBG_CONTEXT, " GatewayIOWorker( %08x). ReadCallback failed." " Exiting the gateway processing. Error = %d\n", dwError)); }
fDoneWaitingForGateway = TRUE; } } // for
IF_DEBUG( GATEWAY) {
DBGPRINTF( ( DBG_CONTEXT, " GatewayIOWorker( %08x). Exiting the IO thread." " Error = %d.\n", this, dwError)); } SetProcessingCompleted( TRUE);
return ( dwError);} // IGATEWAY_PROCESSOR::GatewayIOWorker()
# if DBG
VOIDIGATEWAY_PROCESSOR::Print( VOID) const{ DBGPRINTF( ( DBG_CONTEXT, " Printing IGATEWAY_PROCESSOR object ( %08x)\n", this)); DBGPRINTF( ( DBG_CONTEXT, "IsValid = %d. IsIOCompleted = %d.\n", m_fValid, m_fCompleted));
DBGPRINTF( ( DBG_CONTEXT, " Client Context = %08x\tIO call back function = %08x\n", m_pClientContext, m_pfnReadCallBack)); DBGPRINTF( ( DBG_CONTEXT, " Child StdIn handle = %08x\t Child StdOut handle = %08x\n", m_hStdIn, m_hStdOut)); DBGPRINTF( ( DBG_CONTEXT, " Buffer for Data to Gateway = %08x, %u bytes\n", m_pbDataToGateway, m_cbDataToGateway)); return;} // IGATEWAY_PROCESSOR::Print()
dllexp VOIDPrintIGatewayRequest( IN const IGATEWAY_REQUEST * pigRequest){ DBGPRINTF( ( DBG_CONTEXT, " Printing IGATEWAY_REQUEST object ( %08x)\n", pigRequest)); if ( pigRequest != NULL) {
DBGPRINTF( ( DBG_CONTEXT, " CommandLine = %s.\n WorkingDir = %s\n", pigRequest->pszCmdLine, pigRequest->pszWorkingDir)); DBGPRINTF( ( DBG_CONTEXT, " UserHandle = %08x. lpvEnvironment = %08x\n", pigRequest->hUserToken, pigRequest->lpvEnvironment));
DBGPRINTF( ( DBG_CONTEXT, " pbDataToGateway = %08x. cbDataToGateway = %u.\n", pigRequest->pbDataToGateway, pigRequest->cbDataToGateway)); }
return;} // PrintIGatewayRequest()
# endif // DBG
/************************ End of File ***********************/
|
