namedpipe.cpp File Reference

Server and Client communication over NamedPipes. More...

#include "pch.h"

Functions
HANDLE	NamedPipeServerCreatePipe (LPCSTR PipeName, UINT32 OutputBufferSize, UINT32 InputBufferSize)
	Create a named pipe server.
BOOLEAN	NamedPipeServerWaitForClientConntection (HANDLE PipeHandle)
	wait for client connection
UINT32	NamedPipeServerReadClientMessage (HANDLE PipeHandle, char *BufferToSave, int MaximumReadBufferLength)
	read client message from the named pipe
BOOLEAN	NamedPipeServerSendMessageToClient (HANDLE PipeHandle, char *BufferToSend, int BufferSize)
VOID	NamedPipeServerCloseHandle (HANDLE PipeHandle)
	Close handle of server's named pipe.
HANDLE	NamedPipeClientCreatePipe (LPCSTR PipeName)
	Create a client named pipe.
HANDLE	NamedPipeClientCreatePipeOverlappedIo (LPCSTR PipeName)
	Create a client named pipe through overlapped I/O.
BOOLEAN	NamedPipeClientSendMessage (HANDLE PipeHandle, char *BufferToSend, int BufferSize)
	send client message over named pipe
UINT32	NamedPipeClientReadMessage (HANDLE PipeHandle, char *BufferToRead, int MaximumSizeOfBuffer)
VOID	NamedPipeClientClosePipe (HANDLE PipeHandle)
	close named pipe handle of client
int	NamedPipeServerExample ()
	and example of how to use named pipe as a server
int	NamedPipeClientExample ()
	and example of how to use named pipe as a client

Variables
OVERLAPPED	g_OverlappedIoStructureForReadDebugger
	This is an OVERLAPPED structure for managing simultaneous read and writes for debugger (in current design debuggee is not needed to write simultaneously but it's needed for write)
OVERLAPPED	g_OverlappedIoStructureForWriteDebugger

Detailed Description

Server and Client communication over NamedPipes.

Author

Sina Karvandi (sina@.nosp@m.hype.nosp@m.rdbg..nosp@m.org)

Version

0.1

Date

2020-07-15

Copyright

This project is released under the GNU Public License v3.

Function Documentation

NamedPipeClientClosePipe()

VOID NamedPipeClientClosePipe

(

HANDLE

PipeHandle

)

close named pipe handle of client

Parameters

PipeHandle

Returns

VOID

{
    CloseHandle(PipeHandle);
}

NamedPipeClientCreatePipe()

HANDLE NamedPipeClientCreatePipe

(

LPCSTR

PipeName

)

Create a client named pipe.

Pipe name format - \servername\pipe\pipename This pipe is for server on the same computer, however, pipes can be used to connect to a remote server

Parameters

PipeName

Returns

HANDLE

{
    HANDLE hPipe;
 
    //
    // Connect to the server pipe using CreateFile()
    //
    hPipe = CreateFileA(PipeName,      // pipe name
                        GENERIC_READ | // read and write access
                            GENERIC_WRITE,
                        0,             // no sharing
                        NULL,          // default security attributes
                        OPEN_EXISTING, // opens existing pipe
                        0,             // default attributes
                        NULL);         // no template file
 
    if (INVALID_HANDLE_VALUE == hPipe)
    {
        ShowMessages("err, occurred while connecting to the server (%x)\n",
                     GetLastError());
        //
        // One might want to check whether the server pipe is busy
        // This sample will error out if the server pipe is busy
        // Read on ERROR_PIPE_BUSY and WaitNamedPipe() for that
        //
 
        //
        // Error
        //
        return NULL;
    }
    else
    {
        return hPipe;
    }
}

NamedPipeClientCreatePipeOverlappedIo()

HANDLE NamedPipeClientCreatePipeOverlappedIo

(

LPCSTR

PipeName

)

Create a client named pipe through overlapped I/O.

Pipe name format - \servername\pipe\pipename This pipe is for server on the same computer, however, pipes can be used to connect to a remote server

Parameters

PipeName

Returns

HANDLE

{
    HANDLE hPipe;
 
    //
    // Connect to the server pipe using CreateFile()
    //
    hPipe = CreateFileA(PipeName,      // pipe name
                        GENERIC_READ | // read and write access
                            GENERIC_WRITE,
                        0,                    // no sharing
                        NULL,                 // default security attributes
                        OPEN_EXISTING,        // opens existing pipe
                        FILE_FLAG_OVERLAPPED, // Overlapped I/O
                        NULL);                // no template file
 
    if (INVALID_HANDLE_VALUE == hPipe)
    {
        ShowMessages("err, occurred while connecting to the server (%x)\n",
                     GetLastError());
        //
        // One might want to check whether the server pipe is busy
        // This sample will error out if the server pipe is busy
        // Read on ERROR_PIPE_BUSY and WaitNamedPipe() for that
        //
 
        //
        // Error
        //
        return NULL;
    }
    else
    {
        //
        // Create event for overlapped I/O (Read)
        //
        g_OverlappedIoStructureForReadDebugger.hEvent =
            CreateEvent(NULL, TRUE, FALSE, NULL);
 
        //
        // Create event for overlapped I/O (Write)
        //
        g_OverlappedIoStructureForWriteDebugger.hEvent =
            CreateEvent(NULL, TRUE, FALSE, NULL);
 
        return hPipe;
    }
}

NamedPipeClientExample()

int NamedPipeClientExample

(

)

and example of how to use named pipe as a client

Returns

int

{
    HANDLE    PipeHandle;
    BOOLEAN   SentMessageResult;
    UINT32    ReadBytes;
    const int BufferSize         = 1024;
    char      Buffer[BufferSize] = "test message to send from client !!!";
 
    PipeHandle = NamedPipeClientCreatePipe("\\\\.\\Pipe\\HyperDbgTests");
 
    if (!PipeHandle)
    {
        //
        // Unable to create handle
        //
        return 1;
    }
 
    SentMessageResult =
        NamedPipeClientSendMessage(PipeHandle, Buffer, (UINT32)strlen(Buffer) + 1);
 
    if (!SentMessageResult)
    {
        //
        // Sending error
        //
        return 1;
    }
 
    ReadBytes = NamedPipeClientReadMessage(PipeHandle, Buffer, BufferSize);
 
    if (!ReadBytes)
    {
        //
        // Nothing to read
        //
        return 1;
    }
 
    ShowMessages("server sent the following message: %s\n", Buffer);
 
    NamedPipeClientClosePipe(PipeHandle);
 
    return 0;
}

NamedPipeClientReadMessage()

UINT32 NamedPipeClientReadMessage	(	HANDLE	PipeHandle,
		char *	BufferToRead,
		int	MaximumSizeOfBuffer )

{
    DWORD cbBytes;
 
    //
    // Read server response
    //
    BOOL bResult = ReadFile(PipeHandle,          // handle to pipe
                            BufferToRead,        // buffer to receive data
                            MaximumSizeOfBuffer, // size of buffer
                            &cbBytes,            // number of bytes read
                            NULL);               // not overlapped I/O
 
    if ((!bResult) || (0 == cbBytes))
    {
        ShowMessages("err, occurred while reading from the server (%x)\n",
                     GetLastError());
        CloseHandle(PipeHandle);
        return NULL; // Error
    }
 
    //
    // Success
    //
    return cbBytes;
}

NamedPipeClientSendMessage()

BOOLEAN NamedPipeClientSendMessage	(	HANDLE	PipeHandle,
		char *	BufferToSend,
		int	BufferSize )

send client message over named pipe

Parameters

PipeHandle
BufferToSend
BufferSize

Returns

BOOLEAN

{
    //
    // We are done connecting to the server pipe,
    // we can start communicating with
    // the server using ReadFile()/WriteFile()
    // on handle - hPipe
    //
 
    DWORD cbBytes;
 
    //
    // Send the message to server
    //
    BOOL bResult =
        WriteFile(PipeHandle,   // handle to pipe
                  BufferToSend, // buffer to write from
                  BufferSize,   // number of bytes to write, include the NULL
                  &cbBytes,     // number of bytes written
                  NULL);        // not overlapped I/O
 
    if ((!bResult) || (BufferSize != cbBytes))
    {
        ShowMessages("err, occurred while writing to the server (%x)\n",
                     GetLastError());
        CloseHandle(PipeHandle);
 
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

NamedPipeServerCloseHandle()

VOID NamedPipeServerCloseHandle

(

HANDLE

PipeHandle

)

Close handle of server's named pipe.

Parameters

PipeHandle

Returns

VOID

{
    CloseHandle(PipeHandle);
}

NamedPipeServerCreatePipe()

HANDLE NamedPipeServerCreatePipe	(	LPCSTR	PipeName,
		UINT32	OutputBufferSize,
		UINT32	InputBufferSize )

Create a named pipe server.

Parameters

PipeName
OutputBufferSize
InputBufferSize

Returns

HANDLE

{
    HANDLE hPipe;
 
    hPipe = CreateNamedPipeA(PipeName,                   // pipe name
                             PIPE_ACCESS_DUPLEX,         // read/write access
                             PIPE_TYPE_MESSAGE |         // message type pipe
                                 PIPE_READMODE_MESSAGE | // message-read mode
                                 PIPE_WAIT,              // blocking mode
                             PIPE_UNLIMITED_INSTANCES,   // max. instances
                             OutputBufferSize,           // output buffer size
                             InputBufferSize,            // input buffer size
                             NMPWAIT_USE_DEFAULT_WAIT,   // client time-out
                             NULL);                      // default security attribute
 
    if (INVALID_HANDLE_VALUE == hPipe)
    {
        ShowMessages("err, rror occurred while creating the pipe (%x)\n",
                     GetLastError());
        return NULL;
    }
    return hPipe;
}

NamedPipeServerExample()

int NamedPipeServerExample

(

)

and example of how to use named pipe as a server

Returns

int

{
    HANDLE    PipeHandle;
    BOOLEAN   SentMessageResult;
    UINT32    ReadBytes;
    const int BufferSize               = 1024;
    char      BufferToRead[BufferSize] = {0};
    char      BufferToSend[BufferSize] = "test message to send from server !!!";
 
    PipeHandle = NamedPipeServerCreatePipe("\\\\.\\Pipe\\HyperDbgTests",
                                           BufferSize,
                                           BufferSize);
    if (!PipeHandle)
    {
        //
        // Error in creating handle
        //
        return 1;
    }
 
    if (!NamedPipeServerWaitForClientConntection(PipeHandle))
    {
        //
        // Error in connection
        //
        return 1;
    }
 
    ReadBytes =
        NamedPipeServerReadClientMessage(PipeHandle, BufferToRead, BufferSize);
 
    if (!ReadBytes)
    {
        //
        // Nothing to read
        //
        return 1;
    }
 
    ShowMessages("message from client : %s\n", BufferToRead);
 
    SentMessageResult = NamedPipeServerSendMessageToClient(
        PipeHandle,
        BufferToSend,
        (UINT32)strlen(BufferToSend) + 1);
 
    if (!SentMessageResult)
    {
        //
        // error in sending
        //
        return 1;
    }
 
    NamedPipeServerCloseHandle(PipeHandle);
 
    return 0;
}

NamedPipeServerReadClientMessage()

UINT32 NamedPipeServerReadClientMessage	(	HANDLE	PipeHandle,
		char *	BufferToSave,
		int	MaximumReadBufferLength )

read client message from the named pipe

Parameters

PipeHandle
BufferToSave
MaximumReadBufferLength

Returns

UINT32

{
    DWORD cbBytes;
 
    //
    // We are connected to the client.
    // To communicate with the client
    // we will use ReadFile()/WriteFile()
    // on the pipe handle - hPipe
    //
 
    //
    // Read client message
    //
    BOOL bResult = ReadFile(PipeHandle,              // handle to pipe
                            BufferToSave,            // buffer to receive data
                            MaximumReadBufferLength, // size of buffer
                            &cbBytes,                // number of bytes read
                            NULL);                   // not overlapped I/O
 
    if ((!bResult) || (0 == cbBytes))
    {
        ShowMessages("err, occurred while reading from the client (%x)\n",
                     GetLastError());
        CloseHandle(PipeHandle);
        return 0;
    }
 
    //
    // Number of bytes that the client sends to us
    //
    return cbBytes;
}

NamedPipeServerSendMessageToClient()

BOOLEAN NamedPipeServerSendMessageToClient	(	HANDLE	PipeHandle,
		char *	BufferToSend,
		int	BufferSize )

{
    DWORD cbBytes;
 
    //
    // Reply to client
    //
    BOOLEAN bResult =
        WriteFile(PipeHandle,   // handle to pipe
                  BufferToSend, // buffer to write from
                  BufferSize,   // number of bytes to write, include the NULL
                  &cbBytes,     // number of bytes written
                  NULL);        // not overlapped I/O
 
    if ((!bResult) || (BufferSize != cbBytes))
    {
        ShowMessages("err, occurred while writing to the client (%x)\n",
                     GetLastError());
        CloseHandle(PipeHandle);
        return FALSE;
    }
    return TRUE;
}

NamedPipeServerWaitForClientConntection()

BOOLEAN NamedPipeServerWaitForClientConntection

(

HANDLE

PipeHandle

)

wait for client connection

Parameters

PipeHandle

Returns

BOOLEAN

{
    //
    // Wait for the client to connect
    //
    BOOL ClientConnected = ConnectNamedPipe(PipeHandle, NULL);
 
    if (FALSE == ClientConnected)
    {
        ShowMessages("err, occurred while connecting to the client (%x)\n",
                     GetLastError());
        CloseHandle(PipeHandle);
        return FALSE;
    }
 
    //
    // Client connected
    //
    return TRUE;
}

Variable Documentation

g_OverlappedIoStructureForReadDebugger

OVERLAPPED g_OverlappedIoStructureForReadDebugger

extern

This is an OVERLAPPED structure for managing simultaneous read and writes for debugger (in current design debuggee is not needed to write simultaneously but it's needed for write)

{0};

g_OverlappedIoStructureForWriteDebugger

OVERLAPPED g_OverlappedIoStructureForWriteDebugger

extern

{0};