---

PServer.cpp

Go to the documentation of this file.

// PServer.cpp: implementation of the PServer class.


#include "stdafx.h"
#include "PServer.h"
#include "errorCodes.h"

// Construction/Destruction

PServer::PServer(const TString &name, const bool isOut, const DWORD bufferSize)
: Pipe( name, isOut )
{
    hConnectThread = NULL;
    connected = false;

    if( isOutbound ){
        in = 0;
        out = bufferSize;
    } else {
        in = bufferSize;
        out = 0;
    }
}

PServer::~PServer()
{
    disconnect();
    if(hConnectThread != NULL)
        CloseHandle(hConnectThread);
}

// Member Functions

void PServer::disconnect()
{
    if( getAttemptConnectResult() == PS_WAITING ) {
        TerminateThread(hConnectThread, PS_CANCELLED);  
        connected = false;
    }
    
    connected = false;
    DisconnectNamedPipe(hPipe);
    CloseHandle(hPipe);
    
    ResetEvent(clientStayConnected);
}

bool PServer::serve()
{
    if( PServer::isConnected() ){
        return true;
    }

    if( WaitForSingleObject(serverStayConnected, 0) == WAIT_OBJECT_0 ){
        return false; // Client yet to process disconnect request
    }

    hPipe = CreateNamedPipe(
        pipeName,           // pipe name
        isOutbound ? PIPE_ACCESS_OUTBOUND : PIPE_ACCESS_INBOUND,    // pipe open mode
        0,                  // Byte mode, blocking operations
        1,                  // Maximum pipe Instances
        out,                // output buffer size
        in,                 // input buffer size
        NMPWAIT_WAIT_FOREVER,   // default time-out interval
        NULL);              // Default Security, non inheritable

    if( GetLastError() == ERROR_ALREADY_EXISTS ) {
        CloseHandle(hPipe);  // Close duplicated handle
        hPipe = INVALID_HANDLE_VALUE;
    }
    if ( hPipe == INVALID_HANDLE_VALUE ) {
        return false;
    }
    
    if(hConnectThread != NULL)
        CloseHandle(hConnectThread);

    hConnectThread = chBEGINTHREADEX(
        NULL,           // Default Security, non inheritable
        0,              // use default stack size  
        &waitForClient, // thread function
        this,           // thread argument
        0,              // use default creation flags 
        NULL);          // don't need thread identifier

    if(hConnectThread == NULL){
        CloseHandle(hPipe);
        return false;
    }

    return true;
}

DWORD WINAPI PServer::waitForClient(LPVOID param)
{
    PServer* server = (PServer*) param;

    // Wait for the client to connect; if it succeeds, 
    // the function returns a nonzero value. If the function returns 
    // zero, GetLastError returns ERROR_PIPE_CONNECTED.
    server->connected = ConnectNamedPipe(server->hPipe, NULL) ? 
        true : (GetLastError() == ERROR_PIPE_CONNECTED);

    if( server->connected ){
        return PS_CONNECTED;
    } else {
        return PS_FAILED;
    }

}

HANDLE PServer::getConnectedEventHandle()
{
    HANDLE rtrn;

    // The thread handle can be used as an event object.
    // becomes signalled when the thread stops running

    DuplicateHandle(
        GetCurrentProcess(),
        hConnectThread,     // handle to duplicate
        GetCurrentProcess(),
        &rtrn,              // duplicate handle
        SYNCHRONIZE,        // handle can only be used to wait on
        false,              // non inheritable
        0);                 // no extra options

    return rtrn;
}

DWORD PServer::getAttemptConnectResult() const
{
    DWORD exitCode;
    GetExitCodeThread(hConnectThread, &exitCode);

    return exitCode;
}

bool PServer::isConnected()
{
    if( WaitForSingleObject(clientStayConnected, 0) == WAIT_OBJECT_0 ){
        this->disconnect();
    }

    return connected;
}

---