reactos/sdk/tools/pipetools/pipetunnel.cpp

//
// pipetunnel.cpp
//
// Martin Fuchs, 30.11.2003
//

//
// Invoke as:   "pipetunnel [pipe_name]",
// for example: "pipetunnel com_2"
//
// Then start up RectOS in VMWare, wait for the serial connect.
// After that you can connect GDB using the command "target remote :9999".
//


#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include <winsock.h>

#ifdef _MSC_VER
#pragma comment(lib, "wsock32")
#endif

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


 // This definition currently missing in MinGW.
#ifndef FILE_FLAG_FIRST_PIPE_INSTANCE
#define FILE_FLAG_FIRST_PIPE_INSTANCE 0x00080000
#endif


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


#ifdef _DEBUG

 // critical section wrapper
struct CritSect : public CRITICAL_SECTION
{
    CritSect()
    {
        InitializeCriticalSection(this);
    }

    ~CritSect()
    {
        DeleteCriticalSection(this);
    }
};

static void dbg_trace(char mode, const char* buffer, int l)
{
    static char s_mode = '\0';
    static CritSect crit_sect;

    EnterCriticalSection(&crit_sect);

    if (l) {
        for(const char*p=buffer; l--; ++p) {
            if (mode != s_mode) {
                putchar('\n');
                putchar(mode);
                putchar(' ');

                s_mode = mode;
            }

            if (*p=='\n' || !*p /*|| *p=='#'*/) {
                /*if (*p == '#')
                    putchar(*p);*/

                s_mode = '\0';
            } else
                putchar(*p);
        }
    }

    LeaveCriticalSection(&crit_sect);
}

#endif


static SOCKET s_srv_socket = (SOCKET)-1;

SOCKET open_tcp_connect()
{
    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;
    }
}



struct WriterThread
{
    WriterThread(SOCKET sock, HANDLE hPipe)
        : _sock(sock),
          _hPipe(hPipe)
    {
        DWORD tid;

        HANDLE hThread = CreateThread(NULL, 0, WriterThreadRoutine, this, 0, &tid);

        if (hThread) {
            SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST);

            CloseHandle(hThread);
        } else
            delete this;
    }

protected:
    SOCKET  _sock;
    HANDLE  _hPipe;

    static DWORD WINAPI WriterThreadRoutine(LPVOID param)
    {
        WriterThread* pThis = (WriterThread*) param;

        DWORD ret = pThis->Run();

        delete pThis;

        return ret;
    }

    DWORD Run()
    {
        char buffer[1024];

        for(;;) {
            int r = recv(_sock, buffer, sizeof(buffer), 0);

            if (r == -1) {
                perror("recv()");
                fprintf(stderr, "debugger connection broken\n");
                _sock = (SOCKET)-1;
                return 1;
            }

            if (r) {
                DWORD wrote;

                if (!WriteFile(_hPipe, buffer, r, &wrote, NULL))
                    break;

#ifdef _DEBUG
                dbg_trace('<', buffer, r);
#endif
            }
        }

        return 0;
    }
};


LONG read_pipe(HANDLE hPipe, SOCKET sock)
{
    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();
            }
        }
    }
}


int main(int argc, char** argv)
{
    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;
}