gdb2.cpp File Reference

#include "ph.h"

Include dependency graph for gdb2.cpp:

Go to the source code of this file.

Macros
#define	GDB_INITIAL_COMMAND   "gdb.exe"
#define	PARAMS_SEPARATOR   " "
#define	PARAMS_SEPARATOR_LEN   strlen(PARAMS_SEPARATOR);

Functions
void	DisplayError (const char *pszAPI)
void	ReadAndHandleOutput (HANDLE hPipeRead)
void	PrepAndLaunchRedirectedChild (HANDLE hChildStdOut, HANDLE hChildStdIn, HANDLE hChildStdErr, char *pchCommandLine)
DWORD WINAPI	GetAndSendInputThread (LPVOID lpvThreadParam)
int	main (int argc, char *argv[])

Variables
HANDLE	hChildProcess = NULL
HANDLE	hStdIn = NULL
BOOL	bRunThread = TRUE

Macro Definition Documentation

GDB_INITIAL_COMMAND

#define GDB_INITIAL_COMMAND   "gdb.exe"

Definition at line 24 of file gdb2.cpp.

PARAMS_SEPARATOR

#define PARAMS_SEPARATOR   " "

Definition at line 25 of file gdb2.cpp.

PARAMS_SEPARATOR_LEN

#define PARAMS_SEPARATOR_LEN   strlen(PARAMS_SEPARATOR);

Definition at line 26 of file gdb2.cpp.

Function Documentation

DisplayError()

void DisplayError

(

const char *

pszAPI

)

Definition at line 277 of file gdb2.cpp.

{
    LPVOID lpvMessageBuffer;
    CHAR szPrintBuffer[512];
    DWORD nCharsWritten;
 
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
        NULL, GetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR)&lpvMessageBuffer, 0, NULL);
 
    wsprintf(szPrintBuffer,
        "ERROR: API    = %s.\n   error code = %d.\n   message    = %s.\n",
        pszAPI, GetLastError(), (char *)lpvMessageBuffer);
 
    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),szPrintBuffer,
        lstrlen(szPrintBuffer),&nCharsWritten,NULL);
 
    LocalFree(lpvMessageBuffer);
    ExitProcess(GetLastError());
}

Referenced by GetAndSendInputThread(), main(), PrepAndLaunchRedirectedChild(), and ReadAndHandleOutput().

GetAndSendInputThread()

DWORD WINAPI GetAndSendInputThread

(

LPVOID

lpvThreadParam

)

Definition at line 247 of file gdb2.cpp.

{
    CHAR read_buff[256];
    DWORD nBytesRead,nBytesWrote;
    HANDLE hPipeWrite = (HANDLE)lpvThreadParam;
 
    // Get input from our console and send it to child through the pipe.
    while (bRunThread)
    {
        if(!ReadConsole(hStdIn,read_buff,1,&nBytesRead,NULL))
            DisplayError("ReadConsole");
 
        read_buff[nBytesRead] = '\0'; // Follow input with a NULL.
 
        if (!WriteFile(hPipeWrite,read_buff,nBytesRead,&nBytesWrote,NULL))
        {
            if (GetLastError() == ERROR_NO_DATA)
                break; // Pipe was closed (normal exit path).
            else
                DisplayError("WriteFile");
        }
    }
 
    return 1;
}

Referenced by main().

main()

int main	(	int argc	,
		char *	argv[]
	)

Definition at line 40 of file gdb2.cpp.

{
    HANDLE hOutputReadTmp,hOutputRead,hOutputWrite;
    HANDLE hInputWriteTmp,hInputRead,hInputWrite;
    HANDLE hErrorWrite;
    HANDLE hThread;
    DWORD ThreadId;
    SECURITY_ATTRIBUTES sa;
 
    // Set up the security attributes struct.
    sa.nLength= sizeof(SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;
 
 
    // Create the child output pipe.
    if (!CreatePipe(&hOutputReadTmp,&hOutputWrite,&sa,0))
        DisplayError("CreatePipe");
 
 
    // Create a duplicate of the output write handle for the std error
    // write handle. This is necessary in case the child application
    // closes one of its std output handles.
    if (!DuplicateHandle(GetCurrentProcess(),hOutputWrite,
        GetCurrentProcess(),&hErrorWrite,0,
        TRUE,DUPLICATE_SAME_ACCESS))
        DisplayError("DuplicateHandle");
 
 
    // Create the child input pipe.
    if (!CreatePipe(&hInputRead,&hInputWriteTmp,&sa,0))
        DisplayError("CreatePipe");
 
 
    // Create new output read handle and the input write handles. Set
    // the Properties to FALSE. Otherwise, the child inherits the
    // properties and, as a result, non-closeable handles to the pipes
    // are created.
    if (!DuplicateHandle(GetCurrentProcess(),hOutputReadTmp,
        GetCurrentProcess(),
        &hOutputRead, // Address of new handle.
        0,FALSE, // Make it uninheritable.
        DUPLICATE_SAME_ACCESS))
        DisplayError("DupliateHandle");
 
    if (!DuplicateHandle(GetCurrentProcess(),hInputWriteTmp,
        GetCurrentProcess(),
        &hInputWrite, // Address of new handle.
        0,FALSE, // Make it uninheritable.
        DUPLICATE_SAME_ACCESS))
        DisplayError("DupliateHandle");
 
 
    // Close inheritable copies of the handles you do not want to be
    // inherited.
    if (!CloseHandle(hOutputReadTmp)) DisplayError("CloseHandle");
    if (!CloseHandle(hInputWriteTmp)) DisplayError("CloseHandle");
 
 
    // Get std input handle so you can close it and force the ReadFile to
    // fail when you want the input thread to exit.
    if ( (hStdIn = GetStdHandle(STD_INPUT_HANDLE)) ==
        INVALID_HANDLE_VALUE )
        DisplayError("GetStdHandle");
 
    SetConsoleTitle("gdb control console");
 
    size_t size = strlen(GDB_INITIAL_COMMAND)+PARAMS_SEPARATOR_LEN;
 
    // get parameters length
    for (int i = 1 ; i < argc ; i++)
        size += strlen(argv[i])+PARAMS_SEPARATOR_LEN;
 
    size++; // terminating null
 
    char *pszCommandLine = new char [size];
    if (!pszCommandLine)
    {
        printf("out of memory.\n");
        return -1;
    }
 
    strcpy(pszCommandLine,GDB_INITIAL_COMMAND);
    for (int i = 1 ; i < argc ; i++)
    {
        strcat(pszCommandLine,PARAMS_SEPARATOR);
        strcat(pszCommandLine,argv[i]);
    }
 
    PrepAndLaunchRedirectedChild(hOutputWrite,hInputRead,hErrorWrite,pszCommandLine);
 
 
    // Close pipe handles (do not continue to modify the parent).
    // You need to make sure that no handles to the write end of the
    // output pipe are maintained in this process or else the pipe will
    // not close when the child process exits and the ReadFile will hang.
    if (!CloseHandle(hOutputWrite)) DisplayError("CloseHandle");
    if (!CloseHandle(hInputRead )) DisplayError("CloseHandle");
    if (!CloseHandle(hErrorWrite)) DisplayError("CloseHandle");
 
 
    // Launch the thread that gets the input and sends it to the child.
    hThread = CreateThread(NULL,0,GetAndSendInputThread,
        (LPVOID)hInputWrite,0,&ThreadId);
    if (hThread == NULL) DisplayError("CreateThread");
 
 
    // Read the child's output.
    ReadAndHandleOutput(hOutputRead);
    // Redirection is complete
 
 
    // Force the read on the input to return by closing the stdin handle.
    if (!CloseHandle(hStdIn)) DisplayError("CloseHandle");
 
 
    // Tell the thread to exit and wait for thread to die.
    bRunThread = FALSE;
 
    if (WaitForSingleObject(hThread,INFINITE) == WAIT_FAILED)
        DisplayError("WaitForSingleObject");
 
    if (!CloseHandle(hOutputRead)) DisplayError("CloseHandle");
    if (!CloseHandle(hInputWrite)) DisplayError("CloseHandle");
 
    return 0;
}

PrepAndLaunchRedirectedChild()

void PrepAndLaunchRedirectedChild	(	HANDLE	hChildStdOut,
		HANDLE	hChildStdIn,
		HANDLE	hChildStdErr,
		char *	pchCommandLine
	)

Definition at line 172 of file gdb2.cpp.

{
    PROCESS_INFORMATION pi;
    STARTUPINFO si;
    static CHAR Title[] = "debugged program console";
 
    // Set up the start up info struct.
    ZeroMemory(&si,sizeof(STARTUPINFO));
    si.cb = sizeof(STARTUPINFO);
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdOutput = hChildStdOut;
    si.hStdInput  = hChildStdIn;
    si.hStdError  = hChildStdErr;
    si.lpTitle = Title;
    // Use this if you want to hide the child:
    //     si.wShowWindow = SW_HIDE;
    // Note that dwFlags must include STARTF_USESHOWWINDOW if you want to
    // use the wShowWindow flags.
 
 
    // Launch the process that you want to redirect (in this case,
    // Child.exe). Make sure Child.exe is in the same directory as
    // redirect.c launch redirect from a command line to prevent location
    // confusion.
    if (!CreateProcess(NULL,pchCommandLine,NULL,NULL,TRUE,
        CREATE_NEW_CONSOLE,NULL,NULL,&si,&pi))
        DisplayError("CreateProcess");
 
 
    // Set global child process handle to cause threads to exit.
    hChildProcess = pi.hProcess;
 
 
    // Close any unnecessary handles.
    if (!CloseHandle(pi.hThread)) DisplayError("CloseHandle");
}

Referenced by main().

ReadAndHandleOutput()

void ReadAndHandleOutput

(

HANDLE

hPipeRead

)

Definition at line 216 of file gdb2.cpp.

{
    CHAR lpBuffer[256];
    DWORD nBytesRead;
    DWORD nCharsWritten;
 
    while(TRUE)
    {
        if (!ReadFile(hPipeRead,lpBuffer,sizeof(lpBuffer),
            &nBytesRead,NULL) || !nBytesRead)
        {
            if (GetLastError() == ERROR_BROKEN_PIPE)
                break; // pipe done - normal exit path.
            else
                DisplayError("ReadFile"); // Something bad happened.
        }
 
        // Display the character read on the screen.
        if (!WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),lpBuffer,
            nBytesRead,&nCharsWritten,NULL))
            DisplayError("WriteConsole");
    }
}

Referenced by main().

Variable Documentation

bRunThread

BOOL bRunThread = TRUE

Definition at line 38 of file gdb2.cpp.

Referenced by GetAndSendInputThread(), and main().

hChildProcess

HANDLE hChildProcess = NULL

Definition at line 36 of file gdb2.cpp.

Referenced by PrepAndLaunchRedirectedChild().

hStdIn

HANDLE hStdIn = NULL

Definition at line 37 of file gdb2.cpp.

Referenced by GetAndSendInputThread(), and main().