pipetunnel.cpp File Reference

#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <errno.h>

Include dependency graph for pipetunnel.cpp:

Go to the source code of this file.

Classes
struct	WriterThread

Macros
#define	WIN32_LEAN_AND_MEAN
#define	FILE_FLAG_FIRST_PIPE_INSTANCE   0x00080000

Functions
static void	print_error (DWORD win32_error)
SOCKET	open_tcp_connect ()
LONG	read_pipe (HANDLE hPipe, SOCKET sock)
int	main (int argc, char **argv)

Variables
static SOCKET	s_srv_socket = (SOCKET)-1

Macro Definition Documentation

FILE_FLAG_FIRST_PIPE_INSTANCE

#define FILE_FLAG_FIRST_PIPE_INSTANCE   0x00080000

Definition at line 31 of file pipetunnel.cpp.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 16 of file pipetunnel.cpp.

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

Definition at line 234 of file pipetunnel.cpp.

{
    char path[MAX_PATH];
    const char* pipe_name;
 
    if (argc > 1)
        pipe_name = *++argv;
    else
        pipe_name = "com_2";
 
    sprintf(path, "\\\\.\\pipe\\%s", pipe_name);
 
 
    // initialize winsock
    WSADATA wsa_data;
 
    if (WSAStartup(MAKEWORD(2,2), &wsa_data)) {
        fprintf(stderr, "WSAStartup() failed\n");
        return 0;
    }
 
 
    // increment priority to be faster than the cpu eating VMWare process
    SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
 
 
    HANDLE hPipe = INVALID_HANDLE_VALUE;
 
    for(;;) {
        DWORD read;
 
        if (hPipe == INVALID_HANDLE_VALUE) {
            hPipe = CreateNamedPipe(path, PIPE_ACCESS_DUPLEX|FILE_FLAG_FIRST_PIPE_INSTANCE|FILE_FLAG_OVERLAPPED, PIPE_WAIT|PIPE_TYPE_BYTE, 1, 4096, 4096, 30000, NULL);
 
            if (hPipe == INVALID_HANDLE_VALUE) {
                print_error(GetLastError());
                return 1;
            }
        }
 
        // wait for the client side of the pipe
        while(!ReadFile(hPipe, NULL, 0, &read, NULL) &&
              GetLastError()==ERROR_PIPE_LISTENING)
            Sleep(1000);
 
        puts("\nnamed pipe connected, now waiting for TCP connection...");
 
        SOCKET sock = open_tcp_connect();
        if (sock == (SOCKET)-1)
            break;
 
        puts("TCP connection established.");
 
        // launch writer thread
        new WriterThread(sock, hPipe);
 
        // launch reader loop
        LONG error = read_pipe(hPipe, sock);
 
 
        // close TCP connectiom
        closesocket(sock);
        sock = (SOCKET)-1;
 
        // close named pipe
        CloseHandle(hPipe);
        hPipe = INVALID_HANDLE_VALUE;
 
 
        if (error == ERROR_BROKEN_PIPE)
            puts("\nconnection closed.");   // normal connection termination
        else {
            print_error(GetLastError());
            break;
        }
    }
 
    if (hPipe != INVALID_HANDLE_VALUE)
        if (!CloseHandle(hPipe))
            print_error(GetLastError());
 
    return 0;
}

open_tcp_connect()

SOCKET open_tcp_connect

(

)

Definition at line 92 of file pipetunnel.cpp.

{
    if (s_srv_socket == (SOCKET)-1) {
        SOCKADDR_IN srv_addr = {0};
 
        srv_addr.sin_family = AF_INET;
        srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        srv_addr.sin_port = htons(9999);
 
        s_srv_socket = socket(PF_INET, SOCK_STREAM, 0);
        if (s_srv_socket == (SOCKET)-1) {
            perror("socket()");
            return 0;
        }
 
        if (bind(s_srv_socket, (struct sockaddr*) &srv_addr, sizeof(srv_addr)) == -1) {
            perror("bind()");
            return 0;
        }
 
        if (listen(s_srv_socket, 4) == -1) {
            perror("listen()");
            return 0;
        }
    }
 
    SOCKADDR_IN rem_addr;
    int rem_len = sizeof(rem_addr);
 
    for(;;) {
        SOCKET sock = accept(s_srv_socket, (struct sockaddr*)&rem_addr, &rem_len);
 
        if (sock < 0) {
            if (errno == EINTR)
                continue;
 
            perror("accept()");
            return 0;
        }
 
        return sock;
    }
}

Referenced by main().

print_error()

static void print_error ( DWORD  win32_error )

static

Definition at line 35 of file pipetunnel.cpp.

{
    fprintf(stderr, "WIN32 error %lu\n", win32_error);
}

Referenced by main().

read_pipe()

LONG read_pipe	(	HANDLE	hPipe,
		SOCKET	sock
	)

Definition at line 202 of file pipetunnel.cpp.

{
    for(;;) {
        DWORD read;
        char buffer[1024];
 
        // wait for input data
        WaitForSingleObject(hPipe, INFINITE);
 
        if (!ReadFile(hPipe, buffer, sizeof(buffer), &read, NULL)) {
            DWORD error = GetLastError();
 
            if (error == ERROR_PIPE_LISTENING)
                Sleep(1000);
            else
                return error;
        }
 
        if (read) {
#ifdef _DEBUG
            dbg_trace('>', buffer, read);
#endif
 
            if (!send(sock, buffer, read, 0)) {
                perror("send()");
                return GetLastError();
            }
        }
    }
}

Referenced by _wpopen(), CreatePipe(), and main().

Variable Documentation

s_srv_socket

SOCKET s_srv_socket = (SOCKET)-1

static

Definition at line 90 of file pipetunnel.cpp.

Referenced by open_tcp_connect().