mirror of
https://github.com/reactos/reactos.git
synced 2026-06-08 00:46:10 +08:00
gdb2\Makefile
svn path=/trunk/; revision=1792
This commit is contained in:
Nedko Arnaudov
298
rosapps/devutils/gdb2/gdb2.cpp
Normal file
298
rosapps/devutils/gdb2/gdb2.cpp
Normal file
@@ -0,0 +1,298 @@
|
||||
/* $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());
|
||||
}
|
||||
Reference in New Issue
Block a user