mirror of
https://github.com/reactos/reactos.git
synced 2024-11-09 16:20:37 +00:00
298 lines
9.2 KiB
C++
298 lines
9.2 KiB
C++
/* $Id: gdb2.cpp,v 1.1 2001/04/15 23:42:07 narnaoud Exp $
|
|
*
|
|
* gdb2 - gdb output splitter
|
|
*
|
|
* Copyright (C) 2000,2001 Nedko Arnaoudov <nedkohome@atia.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "ph.h"
|
|
|
|
#define GDB_INITIAL_COMMAND "gdb.exe"
|
|
#define PARAMS_SEPARATOR " "
|
|
#define PARAMS_SEPARATOR_LEN strlen(PARAMS_SEPARATOR);
|
|
|
|
void DisplayError(char *pszAPI);
|
|
void ReadAndHandleOutput(HANDLE hPipeRead);
|
|
void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,
|
|
HANDLE hChildStdIn,
|
|
HANDLE hChildStdErr,
|
|
char *pchCommandLine);
|
|
|
|
DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam);
|
|
HANDLE hChildProcess = NULL;
|
|
HANDLE hStdIn = NULL; // Handle to parents std input.
|
|
BOOL bRunThread = TRUE;
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
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
|
|
// Sets up STARTUPINFO structure, and launches redirected child.
|
|
///////////////////////////////////////////////////////////////////////
|
|
void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,
|
|
HANDLE hChildStdIn,
|
|
HANDLE hChildStdErr,
|
|
char *pchCommandLine)
|
|
{
|
|
PROCESS_INFORMATION pi;
|
|
STARTUPINFO si;
|
|
|
|
// 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 = "debugged program console";
|
|
// 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");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// ReadAndHandleOutput
|
|
// Monitors handle for input. Exits when child exits or pipe breaks.
|
|
///////////////////////////////////////////////////////////////////////
|
|
void ReadAndHandleOutput(HANDLE hPipeRead)
|
|
{
|
|
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");
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// GetAndSendInputThread
|
|
// Thread procedure that monitors the console for input and sends input
|
|
// to the child process through the input pipe.
|
|
// This thread ends when the child application exits.
|
|
///////////////////////////////////////////////////////////////////////
|
|
DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam)
|
|
{
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// DisplayError
|
|
// Displays the error number and corresponding message.
|
|
///////////////////////////////////////////////////////////////////////
|
|
void DisplayError(char *pszAPI)
|
|
{
|
|
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());
|
|
}
|