pipespy.cpp File Reference

#include <process.h>
#include <windows.h>
#include <stdio.h>

Include dependency graph for pipespy.cpp:

Go to the source code of this file.

Classes
struct	_READ_OVERLAPPED

Typedefs
typedef struct _READ_OVERLAPPED	READ_OVERLAPPED

Enumerations
enum	{ PIPEBUF_INITIAL_SIZE = 4096 , PIPEBUF_MAX_SIZE = 16384 }

Functions
void	dumphex (const char *buf, int len, int pos)
VOID WINAPI	WritePipeCompletion (DWORD dwErrorCode, DWORD dwNumberOfBytesTransferred, LPOVERLAPPED lpOverlapped)
VOID WINAPI	ReadPipeCompletion (DWORD dwErrorCode, DWORD dwNumberOfBytesTransferred, LPOVERLAPPED lpOverlapped)
void __cdecl	pipeserver (void *param)
int	main (int ac, char **av)

Variables
HANDLE	g_DebugServerPipe
HANDLE	g_DebugClientPipe
CRITICAL_SECTION	g_OutputLock

Typedef Documentation

READ_OVERLAPPED

typedef struct _READ_OVERLAPPED READ_OVERLAPPED

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
PIPEBUF_INITIAL_SIZE
PIPEBUF_MAX_SIZE

Definition at line 52 of file pipespy.cpp.

     {
    PIPEBUF_INITIAL_SIZE    = 4096,
    PIPEBUF_MAX_SIZE        = 16384
};

Function Documentation

dumphex()

void dumphex	(	const char *	buf,
		int	len,
		int	pos
	)

Definition at line 32 of file pipespy.cpp.

{
    int i, j;
    for(j = 0; j < len; j += 16) {
        for(i = 0; i < 16; i++) {
            if(i + j < len)
                printf("%02x%c", (unsigned char)buf[i + j], j + i + 1 == pos ? '*' : ' ');
            else
                printf("   ");
        }
        for(i = 0; i < 16; i++) {
            if(i + j < len)
                printf("%c", buf[i + j] >= ' ' ? buf[i + j] : '.');
            else
                printf(" ");
        }
        printf("\n");
    }
}

Referenced by ReadPipeCompletion().

main()

int main	(	int	ac,
		char **	av
	)

Definition at line 152 of file pipespy.cpp.

{
    if(ac != 3) {
        printf("syntax: pipespy serverpipe clientpipe\n");
        return 0;
    }
 
    g_DebugServerPipe = CreateNamedPipe(av[1], PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
        1, 4096, 4096, NMPWAIT_WAIT_FOREVER, 0);
 
    if(g_DebugServerPipe == INVALID_HANDLE_VALUE) {
        printf("Error %u creating server pipe\n", GetLastError());
        return 0;
    }
 
    g_DebugClientPipe = CreateNamedPipe(av[2], PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
                                        1, 4096, 4096, NMPWAIT_WAIT_FOREVER, 0);
 
    if(g_DebugClientPipe == INVALID_HANDLE_VALUE) {
        printf("Error %u creating client pipe\n", GetLastError());
        CloseHandle(g_DebugServerPipe);
        return 0;
    }
 
    InitializeCriticalSection(&g_OutputLock);
    _beginthread(pipeserver, 0, (void*)g_DebugServerPipe);
    pipeserver((void*)g_DebugClientPipe);
    DeleteCriticalSection(&g_OutputLock);
    return 0;
}

pipeserver()

void __cdecl pipeserver

(

void *

param

)

Definition at line 116 of file pipespy.cpp.

{
    READ_OVERLAPPED ReadOverlapped;
 
    ReadOverlapped.Pipe = (HANDLE)param, ReadOverlapped.OtherPipe = ReadOverlapped.Pipe == g_DebugServerPipe ? g_DebugClientPipe : g_DebugServerPipe;
    ReadOverlapped.Server = ReadOverlapped.Pipe == g_DebugServerPipe;
    ReadOverlapped.Buffer = (char*)malloc(PIPEBUF_INITIAL_SIZE);
 
    for(;;) {
        if(!ConnectNamedPipe(ReadOverlapped.Pipe, 0) && GetLastError() != ERROR_PIPE_CONNECTED) {
            printf(ReadOverlapped.Server ? "Server> Error %u accepting pipe connection\n" : "Client> Error %u accepting pipe connection\n",
                   GetLastError());
            break;
        }
 
        ReadOverlapped.Connected = true;
        printf(ReadOverlapped.Server ? "Server> Connected\n" : "Client> Connected\n");
 
        ZeroMemory(&ReadOverlapped.ReadOverlapped, sizeof(OVERLAPPED));
        ReadFileEx(ReadOverlapped.Pipe, ReadOverlapped.Buffer, PIPEBUF_INITIAL_SIZE, &ReadOverlapped.ReadOverlapped, ReadPipeCompletion);
 
        do {
            SleepEx(INFINITE, TRUE);
        } while(ReadOverlapped.Connected) ;
 
        DisconnectNamedPipe(ReadOverlapped.Pipe);
        printf(ReadOverlapped.Server ? "Server> Disconnected\n" : "Client> Disconnected\n");
    }
 
    printf(ReadOverlapped.Server ? "Server> Shutting down\n" : "Client> Shutting down\n");
 
    free(ReadOverlapped.Buffer);
    CloseHandle(ReadOverlapped.Pipe);
    SleepEx(0, TRUE);
}

Referenced by main().

ReadPipeCompletion()

VOID WINAPI ReadPipeCompletion	(	DWORD	dwErrorCode,
		DWORD	dwNumberOfBytesTransferred,
		LPOVERLAPPED	lpOverlapped
	)

Definition at line 76 of file pipespy.cpp.

{
    READ_OVERLAPPED* ReadOverlapped = (READ_OVERLAPPED*)lpOverlapped;
    LPOVERLAPPED WriteOverlapped;
 
    EnterCriticalSection(&g_OutputLock);
 
    if(dwErrorCode) {
        printf(ReadOverlapped->Server ? "Server> Error %u reading from pipe\n" : "Client> Error %u reading from pipe\n", dwErrorCode);
        ReadOverlapped->Connected = false;
    } else {
        SYSTEMTIME SystemTime;
 
        GetLocalTime(&SystemTime);
        printf(ReadOverlapped->Server ? "Server> [%02u:%02u:%02u.%03u] Received %u byte message:\n" : "Client> [%02u:%02u:%02u.%03u] Received %u byte message:\n",
            SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMilliseconds, dwNumberOfBytesTransferred);
        dumphex(ReadOverlapped->Buffer, (int)dwNumberOfBytesTransferred, -1);
        printf("\n");
    }
 
    LeaveCriticalSection(&g_OutputLock);
 
    WriteOverlapped = (LPOVERLAPPED)malloc(sizeof(OVERLAPPED)+dwNumberOfBytesTransferred);
 
    if(!WriteOverlapped)
        printf(ReadOverlapped->Server ? "Server> Out of memory\n" : "Client> Out of memory\n");
    else {
        ZeroMemory(WriteOverlapped, sizeof(OVERLAPPED));
        WriteOverlapped->hEvent = (HANDLE)ReadOverlapped->Server;
        memcpy(((char*)WriteOverlapped)+sizeof(OVERLAPPED), ReadOverlapped->Buffer, dwNumberOfBytesTransferred);
        WriteFileEx(ReadOverlapped->OtherPipe, ((char*)WriteOverlapped)+sizeof(OVERLAPPED), dwNumberOfBytesTransferred, WriteOverlapped,
                    WritePipeCompletion);
    }
 
    if(!dwErrorCode) {
        ZeroMemory(ReadOverlapped, sizeof(OVERLAPPED));
        ReadFileEx(ReadOverlapped->Pipe, ReadOverlapped->Buffer, PIPEBUF_INITIAL_SIZE, &ReadOverlapped->ReadOverlapped, ReadPipeCompletion);
    }
}

Referenced by pipeserver(), and ReadPipeCompletion().

WritePipeCompletion()

VOID WINAPI WritePipeCompletion	(	DWORD	dwErrorCode,
		DWORD	dwNumberOfBytesTransferred,
		LPOVERLAPPED	lpOverlapped
	)

Definition at line 65 of file pipespy.cpp.

{
    if(dwErrorCode) {
        EnterCriticalSection(&g_OutputLock);
        printf(lpOverlapped->hEvent ? "Server> Error %u writing to client pipe\n" : "Client> Error %u writing to server pipe\n", dwErrorCode);
        LeaveCriticalSection(&g_OutputLock);
    }
 
    free((void*)lpOverlapped);
}

Referenced by ReadPipeCompletion().

Variable Documentation

g_DebugClientPipe

HANDLE g_DebugClientPipe

Definition at line 29 of file pipespy.cpp.

Referenced by main(), and pipeserver().

g_DebugServerPipe

HANDLE g_DebugServerPipe

Definition at line 29 of file pipespy.cpp.

Referenced by main(), and pipeserver().

g_OutputLock

CRITICAL_SECTION g_OutputLock

Definition at line 30 of file pipespy.cpp.

Referenced by main(), ReadPipeCompletion(), and WritePipeCompletion().