zjgcjy/pykd
1
0
Fork 0
mirror of https://github.com/ivellioscolin/pykd.git synced 2025-04-21 12:53:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

ready for release

Browse Source 
git-svn-id: https://pykd.svn.codeplex.com/svn@52944 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp 2010-07-26 10:55:12 +00:00
parent 5b7de9d7f8
commit 5f7636ac4b
21 changed files with 424 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
pykd/dbgcmd.cpp
View File

@ -1,7 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include "dbgext.h"
#include "dbgcmd.h" #include "dbgcmd.h"
#include "dbgexcept.h" #include "dbgexcept.h"
@ -104,9 +103,9 @@ dbgCommand( const std::string &command )
try { try {
OutputReader outReader( g_Ext->m_Client ); OutputReader outReader( dbgExt->client );
hres = g_Ext->m_Control->Execute( DEBUG_OUTCTL_THIS_CLIENT, command.c_str(), 0 ); hres = dbgExt->control->Execute( DEBUG_OUTCTL_THIS_CLIENT, command.c_str(), 0 );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugControl::Execute failed" ); throw DbgException( "IDebugControl::Execute failed" );
@ -114,11 +113,11 @@ dbgCommand( const std::string &command )
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return "error"; return "error";

2
pykd/dbgcmd.h
View File

@ -10,7 +10,5 @@
std::string std::string
dbgCommand( const std::string &command ); dbgCommand( const std::string &command );
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////

63
pykd/dbgdump.cpp Normal file
View File

@ -0,0 +1,63 @@
#include "stdafx.h"
#include "dbgext.h"
#include "dbgdump.h"
#include "dbgexcept.h"
#include "dbgsession.h"
#include "dbgsystem.h"
/////////////////////////////////////////////////////////////////////////////////
std::string
dbgLoadDump( const std::string &fileName )
{
HRESULT hres;
wchar_t *fileNameW = NULL;
try {
fileNameW = new wchar_t [ fileName.size()+ 1 ];
MultiByteToWideChar(
CP_ACP,
0,
fileName.c_str(),
fileName.size() + 1,
fileNameW,
fileName.size() + 1 );
hres = dbgExt->client4->OpenDumpFileWide( fileNameW, NULL );
if ( FAILED( hres ) )
throw DbgException( "IDebugClient4::OpenDumpFileWide failed" );
hres = dbgExt->control->WaitForEvent(DEBUG_WAIT_DEFAULT, INFINITE);
if ( FAILED( hres ) )
throw DbgException( "IDebugControl::WaitForEvent failed" );
dbgSessionStarted = true;
if ( fileNameW )
delete[] fileNameW;
return "loaded ok";
}
catch( std::exception& )
{
//g_Ext->Out( "pykd error: %s\n", e.what() );
}
catch(...)
{
//g_Ext->Out( "pykd unexpected error\n" );
}
std::string result = "failed to open dump ";
result += fileName;
if ( fileNameW )
delete[] fileNameW;
return result;
}
/////////////////////////////////////////////////////////////////////////////////

10
pykd/dbgdump.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include <string>
/////////////////////////////////////////////////////////////////////////////////
std::string
dbgLoadDump( const std::string &dumpName );
/////////////////////////////////////////////////////////////////////////////////

115
pykd/dbgext.cpp
View File

@ -1,12 +1,13 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include <wdbgexts.h>
#include <boost/python.hpp> #include <boost/python.hpp>
#include <boost/python/class.hpp> #include <boost/python/class.hpp>
#include <boost/python/module.hpp> #include <boost/python/module.hpp>
#include <boost/python/def.hpp> #include <boost/python/def.hpp>
#include "dbgext.h"
#include "dbgprint.h" #include "dbgprint.h"
#include "dbgreg.h" #include "dbgreg.h"
#include "dbgtype.h" #include "dbgtype.h"
@ -15,13 +16,24 @@
#include "dbgmem.h" #include "dbgmem.h"
#include "dbgsystem.h" #include "dbgsystem.h"
#include "dbgcmd.h" #include "dbgcmd.h"
#include "dbgdump.h"
#include "dbgexcept.h"
#include "dbgsession.h"
/////////////////////////////////////////////////////////////////////////////////
DbgExt *dbgExt = NULL;
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
BOOST_PYTHON_MODULE( pykd ) BOOST_PYTHON_MODULE( pykd )
{ {
boost::python::def( "createSession", &dbgCreateSession );
boost::python::def( "isSessionStart", &dbgIsSessionStart );
boost::python::def( "symbolsPath", &dbgSymPath );
boost::python::def( "dprint", &DbgPrint::dprint ); boost::python::def( "dprint", &DbgPrint::dprint );
boost::python::def( "dprintln", &DbgPrint::dprintln ); boost::python::def( "dprintln", &DbgPrint::dprintln );
boost::python::def( "loadDump", &dbgLoadDump );
boost::python::def( "dbgCommand", &dbgCommand ); boost::python::def( "dbgCommand", &dbgCommand );
boost::python::def( "is64bitSystem", is64bitSystem ); boost::python::def( "is64bitSystem", is64bitSystem );
boost::python::def( "reg", &loadRegister ); boost::python::def( "reg", &loadRegister );
@ -36,67 +48,73 @@ BOOST_PYTHON_MODULE( pykd )
boost::python::class_<typedVarClass>( "typedVarClass" ) boost::python::class_<typedVarClass>( "typedVarClass" )
.def("getAddress", &typedVarClass::getAddress ); .def("getAddress", &typedVarClass::getAddress );
boost::python::class_<dbgModuleClass>( "dbgModuleClass" ) boost::python::class_<dbgModuleClass>( "dbgModuleClass" )
.add_property("begin", &dbgModuleClass::getBegin ) .def("begin", &dbgModuleClass::getBegin )
.add_property("end", &dbgModuleClass::getEnd ) .def("end", &dbgModuleClass::getEnd )
.def("name", &dbgModuleClass::getName )
.def("contain", &dbgModuleClass::contain ); .def("contain", &dbgModuleClass::contain );
} }
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
class EXT_CLASS : public ExtExtension HRESULT
CALLBACK
DebugExtensionInitialize(
OUT PULONG Version,
OUT PULONG Flags )
{ {
public: *Version = DEBUG_EXTENSION_VERSION( 1, 0 );
*Flags = 0;
virtual HRESULT Initialize(void) { PyImport_AppendInittab("pykd", initpykd );
HRESULT hr = ExtExtension::Initialize(); Py_Initialize();
if ( FAILED( hr ) )
return hr;
Py_Initialize(); dbgSessionStarted = true;
PyImport_AppendInittab("pykd",initpykd ); return S_OK;
}
return hr;
}
virtual void Uninitialize(void) {
Py_Finalize();
}
public: VOID
EXT_COMMAND_METHOD( info ); CALLBACK
EXT_COMMAND_METHOD( exec ); DebugExtensionUninitialize()
};
EXT_DECLARE_GLOBALS();
/////////////////////////////////////////////////////////////////////////////////
EXT_COMMAND(
info,
"Python Info",
"" )
{ {
Out( "Python Info" ); Py_Finalize();
}
void
SetupDebugEngine( IDebugClient4 *client, DbgExt *dbgExt )
{
client->QueryInterface( __uuidof(IDebugClient), (void **)&dbgExt->client );
client->QueryInterface( __uuidof(IDebugClient4), (void **)&dbgExt->client4 );
client->QueryInterface( __uuidof(IDebugControl), (void **)&dbgExt->control );
client->QueryInterface( __uuidof(IDebugRegisters), (void **)&dbgExt->registers );
client->QueryInterface( __uuidof(IDebugSymbols), (void ** )&dbgExt->symbols );
client->QueryInterface( __uuidof(IDebugSymbols2), (void ** )&dbgExt->symbols2 );
client->QueryInterface( __uuidof(IDebugSymbols3), (void ** )&dbgExt->symbols3 );
client->QueryInterface( __uuidof(IDebugDataSpaces), (void **)&dbgExt->dataSpaces );
} }
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
EXT_COMMAND( HRESULT
exec, CALLBACK
"Execute python code", py( PDEBUG_CLIENT4 client, PCSTR args)
"{f;b;;quite mode}{;x}" )
{ {
bool fromFile = false;
if ( HasArg( "f" ) )
fromFile = true;
try { try {
DbgExt ext = { 0 };
SetupDebugEngine( client, &ext );
dbgExt = &ext;
boost::python::object main = boost::python::import("__main__"); boost::python::object main = boost::python::import("__main__");
@ -104,14 +122,8 @@ EXT_COMMAND(
boost::python::object result; boost::python::object result;
if ( fromFile ) result = boost::python::exec_file( args, global, global );
{
result = boost::python::exec_file( GetUnnamedArgStr( 0 ), global, global );
}
else
{
result = boost::python::exec( GetUnnamedArgStr( 0 ), global, global );
}
} }
catch( boost::python::error_already_set const & ) catch( boost::python::error_already_set const & )
{ {
@ -137,7 +149,8 @@ EXT_COMMAND(
{ {
} }
return S_OK;
} }
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////

27
pykd/dbgext.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include <dbgeng.h>
struct DbgExt {
IDebugClient *client;
IDebugClient4 *client4;
IDebugControl *control;
IDebugRegisters *registers;
IDebugSymbols *symbols;
IDebugSymbols2 *symbols2;
IDebugSymbols3 *symbols3;
IDebugDataSpaces *dataSpaces;
};
extern DbgExt *dbgExt;
void
SetupDebugEngine( IDebugClient4 *client, DbgExt *dbgExt );

17
pykd/dbgmem.cpp
View File

@ -1,7 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include "dbgext.h"
#include "dbgexcept.h" #include "dbgexcept.h"
#include "dbgmem.h" #include "dbgmem.h"
@ -16,7 +15,7 @@ loadMemory( ULONG64 address, PVOID dest, ULONG length )
try { try {
HRESULT hres = g_Ext->m_Data->ReadVirtual( address, dest, length, NULL ); HRESULT hres = dbgExt->dataSpaces->ReadVirtual( address, dest, length, NULL );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugDataSpace::ReadVirtual failed" ); throw DbgException( "IDebugDataSpace::ReadVirtual failed" );
@ -25,11 +24,11 @@ loadMemory( ULONG64 address, PVOID dest, ULONG length )
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "Kd2Lua unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return false; return false;
@ -62,11 +61,11 @@ compareMemory( ULONG64 addr1, ULONG64 addr2, ULONG length )
try { try {
hres = g_Ext->m_Data->ReadVirtual( addr1, m1, length, NULL ); hres = dbgExt->dataSpaces->ReadVirtual( addr1, m1, length, NULL );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugDataSpace::ReadVirtual failed" ); throw DbgException( "IDebugDataSpace::ReadVirtual failed" );
hres = g_Ext->m_Data->ReadVirtual( addr2, m2, length, NULL ); hres = dbgExt->dataSpaces->ReadVirtual( addr2, m2, length, NULL );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugDataSpace::ReadVirtual failed" ); throw DbgException( "IDebugDataSpace::ReadVirtual failed" );
@ -75,11 +74,11 @@ compareMemory( ULONG64 addr1, ULONG64 addr2, ULONG length )
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "Kd2Lua unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
delete[] m1; delete[] m1;

69
pykd/dbgmodule.cpp
View File

@ -1,7 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include "dbgext.h"
#include "dbgmodule.h" #include "dbgmodule.h"
#include "dbgexcept.h" #include "dbgexcept.h"
#include "dbgmem.h" #include "dbgmem.h"
@ -15,26 +14,26 @@ loadModule( const std::string &moduleName )
try { try {
ULONG64 moduleBase; ULONG64 moduleBase;
hres = g_Ext->m_Symbols->GetModuleByModuleName( moduleName.c_str(), 0, NULL, &moduleBase ); hres = dbgExt->symbols->GetModuleByModuleName( moduleName.c_str(), 0, NULL, &moduleBase );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetModuleByModuleName failed" ); throw DbgException( "IDebugSymbol::GetModuleByModuleName failed" );
DEBUG_MODULE_PARAMETERS moduleParam = { 0 }; DEBUG_MODULE_PARAMETERS moduleParam = { 0 };
hres = g_Ext->m_Symbols->GetModuleParameters( 1, &moduleBase, 0, &moduleParam ); hres = dbgExt->symbols->GetModuleParameters( 1, &moduleBase, 0, &moduleParam );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetModuleParameters failed" ); throw DbgException( "IDebugSymbol::GetModuleParameters failed" );
return boost::python::object( dbgModuleClass( moduleBase, moduleParam.Size ) ); return boost::python::object( dbgModuleClass( moduleName, moduleBase, moduleParam.Size ) );
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return boost::python::object(); return boost::python::object();
@ -53,7 +52,7 @@ findModule( ULONG64 addr )
ULONG moduleIndex; ULONG moduleIndex;
ULONG64 moduleBase; ULONG64 moduleBase;
hres = g_Ext->m_Symbols->GetModuleByOffset( addr, 0, &moduleIndex, &moduleBase ); hres = dbgExt->symbols->GetModuleByOffset( addr, 0, &moduleIndex, &moduleBase );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
{ {
@ -61,24 +60,70 @@ findModule( ULONG64 addr )
} }
DEBUG_MODULE_PARAMETERS moduleParam = { 0 }; DEBUG_MODULE_PARAMETERS moduleParam = { 0 };
hres = g_Ext->m_Symbols->GetModuleParameters( 1, &moduleBase, 0, &moduleParam ); hres = dbgExt->symbols->GetModuleParameters( 1, &moduleBase, 0, &moduleParam );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetModuleParameters failed" ); throw DbgException( "IDebugSymbol::GetModuleParameters failed" );
char moduleName[0x100];
return boost::python::object( dbgModuleClass( moduleBase, moduleParam.Size ) ); hres =
dbgExt->symbols->GetModuleNames(
moduleIndex,
0,
NULL,
0,
NULL,
moduleName,
sizeof( moduleName ),
NULL,
NULL,
0,
NULL );
if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetModuleNames failed" );
return boost::python::object( dbgModuleClass( moduleName, moduleBase, moduleParam.Size ) );
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return boost::python::object(); return boost::python::object();
} }
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
void
dbgModuleClass::reloadSymbols()
{
HRESULT hres;
try {
std::string reloadParam = "/f "; //"/f /s ";
reloadParam += m_name;
hres = dbgExt->symbols->Reload( reloadParam.c_str() );
if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::Reload failed" );
}
catch( std::exception &e )
{
dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
}
catch(...)
{
dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
}
}
/////////////////////////////////////////////////////////////////////////////////

17
pykd/dbgmodule.h
View File

@ -16,7 +16,8 @@ public:
m_end( 0 ) m_end( 0 )
{} {}
dbgModuleClass( ULONG64 base, ULONG size ) : dbgModuleClass( const std::string &name, ULONG64 base, ULONG size ) :
m_name( name ),
m_base( base ), m_base( base ),
m_end( base + size ) m_end( base + size )
{} {}
@ -39,11 +40,21 @@ public:
return m_base <= addr && addr <= m_end; return m_base <= addr && addr <= m_end;
} }
std::string
getName() const {
return m_name;
}
void
reloadSymbols();
private: private:
ULONG64 m_base; ULONG64 m_base;
ULONG64 m_end;
ULONG64 m_end;
std::string m_name;
}; };
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////

14
pykd/dbgprint.cpp
View File

@ -1,16 +1,22 @@
#include "stdafx.h" #include "stdafx.h"
#include <iostream>
#include "dbgprint.h" #include "dbgprint.h"
#include <engextcpp.hpp> #include "dbgext.h"
using namespace std; using namespace std;
void DbgPrint::dprint( const string& str ) void DbgPrint::dprint( const string& str )
{ {
g_Ext->Dml( str.c_str() ); HRESULT hres = dbgExt->control->ControlledOutput( DEBUG_OUTCTL_AMBIENT_DML, DEBUG_OUTPUT_NORMAL, str.c_str() );
if ( FAILED( hres ) )
std::cout << str;
} }
void DbgPrint::dprintln( const std::string& str ) void DbgPrint::dprintln( const std::string& str )
{ {
g_Ext->Dml( str.c_str() ); DbgPrint::dprint( str );
g_Ext->Dml( "\r\n" ); DbgPrint::dprint( "\r\n" );
} }

1
pykd/dbgprint.h
View File

@ -11,5 +11,6 @@ public:
static void dprint( const std::string& str ); static void dprint( const std::string& str );
static void dprintln( const std::string& str ); static void dprintln( const std::string& str );
}; };

12
pykd/dbgreg.cpp
View File

@ -1,7 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include "dbgext.h"
#include "dbgreg.h" #include "dbgreg.h"
#include "dbgexcept.h" #include "dbgexcept.h"
@ -14,17 +13,16 @@ loadRegister( const std::string &registerName )
{ {
HRESULT hres; HRESULT hres;
try { try {
ULONG registerIndex = 0; ULONG registerIndex = 0;
hres = g_Ext->m_Registers->GetIndexByName( registerName.c_str(), &registerIndex ); hres = dbgExt->registers->GetIndexByName( registerName.c_str(), &registerIndex );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugRegister::GetIndexByName failed" ); throw DbgException( "IDebugRegister::GetIndexByName failed" );
DEBUG_VALUE debugValue; DEBUG_VALUE debugValue;
hres = g_Ext->m_Registers->GetValue( registerIndex, &debugValue ); hres = dbgExt->registers->GetValue( registerIndex, &debugValue );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugRegister::GetValue failed" ); throw DbgException( "IDebugRegister::GetValue failed" );
@ -49,11 +47,11 @@ loadRegister( const std::string &registerName )
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return boost::python::str( "REG_ERR" ); return boost::python::str( "REG_ERR" );

24
pykd/dbgsession.cpp Normal file
View File

@ -0,0 +1,24 @@
#include "stdafx.h"
#include "dbgsession.h"
#include "dbgext.h"
DbgExt dbgGlobalSession = { 0 };
bool dbgSessionStarted = false;
void
dbgCreateSession()
{
IDebugClient4 *client = NULL;
DebugCreate( __uuidof(IDebugClient4), (void **)&client );
SetupDebugEngine( client, &dbgGlobalSession );
dbgExt = &dbgGlobalSession;
}
bool
dbgIsSessionStart()
{
return dbgSessionStarted;
}

11
pykd/dbgsession.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
void
dbgCreateSession();
extern
bool dbgSessionStarted;
bool
dbgIsSessionStart();

22
pykd/dbgsym.cpp
View File

@ -1,9 +1,9 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include "dbgext.h"
#include "dbgsym.h" #include "dbgsym.h"
#include "dbgexcept.h" #include "dbgexcept.h"
#include "dbgprint.h"
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
@ -22,7 +22,7 @@ findSymbolForAddress( ULONG64 addr )
ULONG moduleIndex; ULONG moduleIndex;
ULONG64 moduleBase; ULONG64 moduleBase;
hres = g_Ext->m_Symbols->GetModuleByOffset( addr, 0, &moduleIndex, &moduleBase ); hres = dbgExt->symbols->GetModuleByOffset( addr, 0, &moduleIndex, &moduleBase );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
{ {
@ -30,14 +30,14 @@ findSymbolForAddress( ULONG64 addr )
} }
char moduleName[0x100]; char moduleName[0x100];
hres = g_Ext->m_Symbols2->GetModuleNameString( DEBUG_MODNAME_MODULE, moduleIndex, moduleBase, hres = dbgExt->symbols2->GetModuleNameString( DEBUG_MODNAME_MODULE, moduleIndex, moduleBase,
moduleName, sizeof( moduleName ), NULL ); moduleName, sizeof( moduleName ), NULL );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol2::GetModuleNameString failed" ); throw DbgException( "IDebugSymbol2::GetModuleNameString failed" );
ULONG entries = 0; ULONG entries = 0;
hres = g_Ext->m_Symbols3->GetSymbolEntriesByOffset( addr, 0, &debugId, &displace, 1, &entries ); hres = dbgExt->symbols3->GetSymbolEntriesByOffset( addr, 0, &debugId, &displace, 1, &entries );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol3::GetSymbolEntriesByOffset failed" ); throw DbgException( "IDebugSymbol3::GetSymbolEntriesByOffset failed" );
@ -50,7 +50,7 @@ findSymbolForAddress( ULONG64 addr )
} }
char symbolName[0x100]; char symbolName[0x100];
hres = g_Ext->m_Symbols3->GetSymbolEntryString( &debugId, 0, symbolName, sizeof(symbolName ), NULL ); hres = dbgExt->symbols3->GetSymbolEntryString( &debugId, 0, symbolName, sizeof(symbolName ), NULL );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol3::GetSymbolEntryString failed" ); throw DbgException( "IDebugSymbol3::GetSymbolEntryString failed" );
@ -60,11 +60,11 @@ findSymbolForAddress( ULONG64 addr )
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return boost::python::object( addr ); return boost::python::object( addr );
@ -84,7 +84,7 @@ findAddressForSymbol( const std::string &moduleName, const std::string &symbol
ModuleSymName += symbolName; ModuleSymName += symbolName;
ULONG64 offset = 0ULL; ULONG64 offset = 0ULL;
hres = g_Ext->m_Symbols->GetOffsetByName( ModuleSymName.c_str(), &offset ); hres = dbgExt->symbols->GetOffsetByName( ModuleSymName.c_str(), &offset );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetOffsetByName failed" ); throw DbgException( "IDebugSymbol::GetOffsetByName failed" );
@ -92,11 +92,11 @@ findAddressForSymbol( const std::string &moduleName, const std::string &symbol
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return (ULONG64)~0; return (ULONG64)~0;

53
pykd/dbgsystem.cpp
View File

@ -1,11 +1,11 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp>
#include <exception> #include <exception>
#include "dbgext.h"
#include "dbgexcept.h"
#include "dbgsystem.h" #include "dbgsystem.h"
///////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
bool bool
is64bitSystem() is64bitSystem()
@ -13,21 +13,60 @@ is64bitSystem()
HRESULT hres; HRESULT hres;
try { try {
hres = g_Ext->m_Control->IsPointer64Bit();
hres = dbgExt->control->IsPointer64Bit();
return hres == S_OK; return hres == S_OK;
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return false; return false;
} }
///////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
std::string
dbgSymPath()
{
HRESULT hres;
char *path = NULL;
std::string pathStr;
try {
ULONG size;
dbgExt->symbols->GetSymbolPath( NULL, 0, &size );
path = new char[ size ];
hres = dbgExt->symbols->GetSymbolPath( path, size, NULL );
if ( FAILED( hres ) )
throw DbgException( "IDebugSymbols::GetSymbolPath failed" );
pathStr = path;
}
catch( std::exception &e )
{
dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
}
catch(...)
{
dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
}
if ( path )
delete[] path;
return pathStr;
}
///////////////////////////////////////////////////////////////////////////////////

6
pykd/dbgsystem.h
View File

@ -1,5 +1,7 @@
#pragma once #pragma once
#include <string>
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
bool bool
@ -11,4 +13,8 @@ ptrSize() {
return is64bitSystem() ? 8 : 4; return is64bitSystem() ? 8 : 4;
} }
std::string
dbgSymPath();
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////

29
pykd/dbgtype.cpp
View File

@ -1,7 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include <engextcpp.hpp> #include "dbgext.h"
#include "dbgtype.h" #include "dbgtype.h"
#include "dbgexcept.h" #include "dbgexcept.h"
#include "dbgmem.h" #include "dbgmem.h"
@ -76,12 +75,12 @@ loadTypedVar( const std::string &moduleName, const std::string &typeName, ULONG6
return valueLoader<void*>( address, ptrSize() ); return valueLoader<void*>( address, ptrSize() );
} }
hres = g_Ext->m_Symbols->GetModuleByModuleName( moduleName.c_str(), 0, NULL, &moduleBase ); hres = dbgExt->symbols->GetModuleByModuleName( moduleName.c_str(), 0, NULL, &moduleBase );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetModuleByModuleName failed" ); throw DbgException( "IDebugSymbol::GetModuleByModuleName failed" );
ULONG typeId; ULONG typeId;
hres = g_Ext->m_Symbols->GetTypeId( moduleBase, typeName.c_str(), &typeId ); hres = dbgExt->symbols->GetTypeId( moduleBase, typeName.c_str(), &typeId );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetTypeId failed" ); throw DbgException( "IDebugSymbol::GetTypeId failed" );
@ -91,23 +90,23 @@ loadTypedVar( const std::string &moduleName, const std::string &typeName, ULONG6
for ( ULONG i = 0; ; ++i ) for ( ULONG i = 0; ; ++i )
{ {
char fieldName[100]; char fieldName[100];
hres = g_Ext->m_Symbols2->GetFieldName( moduleBase, typeId, i, fieldName, sizeof(fieldName), NULL ); hres = dbgExt->symbols2->GetFieldName( moduleBase, typeId, i, fieldName, sizeof(fieldName), NULL );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
break; break;
ULONG fieldTypeId; ULONG fieldTypeId;
ULONG fieldOffset; ULONG fieldOffset;
hres = g_Ext->m_Symbols3->GetFieldTypeAndOffset( moduleBase, typeId, fieldName, &fieldTypeId, &fieldOffset ); hres = dbgExt->symbols3->GetFieldTypeAndOffset( moduleBase, typeId, fieldName, &fieldTypeId, &fieldOffset );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol3::GetFieldTypeAndOffset failed" ); throw DbgException( "IDebugSymbol3::GetFieldTypeAndOffset failed" );
char fieldTypeName[100]; char fieldTypeName[100];
hres = g_Ext->m_Symbols->GetTypeName( moduleBase, fieldTypeId, fieldTypeName, sizeof(fieldTypeName), NULL ); hres = dbgExt->symbols->GetTypeName( moduleBase, fieldTypeId, fieldTypeName, sizeof(fieldTypeName), NULL );
ULONG fieldSize; ULONG fieldSize;
hres = g_Ext->m_Symbols->GetTypeSize( moduleBase, fieldTypeId, &fieldSize ); hres = dbgExt->symbols->GetTypeSize( moduleBase, fieldTypeId, &fieldSize );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetTypeName failed" ); throw DbgException( "IDebugSymbol::GetTypeName failed" );
@ -127,11 +126,11 @@ loadTypedVar( const std::string &moduleName, const std::string &typeName, ULONG6
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return boost::python::str( "VAR_ERR" ); return boost::python::str( "VAR_ERR" );
@ -148,29 +147,29 @@ containingRecord( ULONG64 address, const std::string &moduleName, const std::str
ULONG64 moduleBase; ULONG64 moduleBase;
hres = g_Ext->m_Symbols->GetModuleByModuleName( moduleName.c_str(), 0, NULL, &moduleBase ); hres = dbgExt->symbols->GetModuleByModuleName( moduleName.c_str(), 0, NULL, &moduleBase );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetModuleByModuleName failed" ); throw DbgException( "IDebugSymbol::GetModuleByModuleName failed" );
ULONG typeId; ULONG typeId;
hres = g_Ext->m_Symbols->GetTypeId( moduleBase, typeName.c_str(), &typeId ); hres = dbgExt->symbols->GetTypeId( moduleBase, typeName.c_str(), &typeId );
if ( FAILED( hres ) ) if ( FAILED( hres ) )
throw DbgException( "IDebugSymbol::GetTypeId failed" ); throw DbgException( "IDebugSymbol::GetTypeId failed" );
ULONG fieldTypeId; ULONG fieldTypeId;
ULONG fieldOffset; ULONG fieldOffset;
hres = g_Ext->m_Symbols3->GetFieldTypeAndOffset( moduleBase, typeId, fieldName.c_str(), &fieldTypeId, &fieldOffset ); hres = dbgExt->symbols3->GetFieldTypeAndOffset( moduleBase, typeId, fieldName.c_str(), &fieldTypeId, &fieldOffset );
return loadTypedVar( moduleName, typeName, address - fieldOffset ); return loadTypedVar( moduleName, typeName, address - fieldOffset );
} }
catch( std::exception &e ) catch( std::exception &e )
{ {
g_Ext->Out( "pykd error: %s\n", e.what() ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd error: %s\n", e.what() );
} }
catch(...) catch(...)
{ {
g_Ext->Out( "pykd unexpected error\n" ); dbgExt->control->Output( DEBUG_OUTPUT_ERROR, "pykd unexpected error\n" );
} }
return boost::python::str( "VAR_ERR" ); return boost::python::str( "VAR_ERR" );

2
pykd/pykd.def
View File

@ -3,4 +3,4 @@ EXPORTS
DebugExtensionUninitialize DebugExtensionUninitialize
info info
exec py

30
pykd/pykd.vcproj
View File

@ -66,7 +66,8 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="dbgeng.lib engextcpp.lib" AdditionalDependencies="dbgeng.lib "
OutputFile="$(OutDir)\$(ProjectName).pyd"
LinkIncremental="2" LinkIncremental="2"
AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\i386&quot;;&quot;$(PYTHON_ROOT)\x86\libs&quot;;&quot;$(BOOST_ROOT)\stage\lib&quot;" AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\i386&quot;;&quot;$(PYTHON_ROOT)\x86\libs&quot;;&quot;$(BOOST_ROOT)\stage\lib&quot;"
ModuleDefinitionFile="pykd.def" ModuleDefinitionFile="pykd.def"
@ -149,6 +150,7 @@
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="dbgeng.lib engextcpp.lib" AdditionalDependencies="dbgeng.lib engextcpp.lib"
OutputFile="$(OutDir)\$(ProjectName).pyd"
LinkIncremental="2" LinkIncremental="2"
AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\amd64&quot;;&quot;$(PYTHON_ROOT)\x64\libs&quot;;&quot;$(BOOST_ROOT)\stage64\lib&quot;" AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\amd64&quot;;&quot;$(PYTHON_ROOT)\x64\libs&quot;;&quot;$(BOOST_ROOT)\stage64\lib&quot;"
ModuleDefinitionFile="pykd.def" ModuleDefinitionFile="pykd.def"
@ -225,7 +227,8 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="dbgeng.lib engextcpp.lib" AdditionalDependencies="dbgeng.lib"
OutputFile="$(OutDir)\$(ProjectName).pyd"
LinkIncremental="1" LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\i386&quot;;&quot;$(PYTHON_ROOT)\x86\libs&quot;;&quot;$(BOOST_ROOT)\stage\lib&quot;" AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\i386&quot;;&quot;$(PYTHON_ROOT)\x86\libs&quot;;&quot;$(BOOST_ROOT)\stage\lib&quot;"
ModuleDefinitionFile="pykd.def" ModuleDefinitionFile="pykd.def"
@ -305,7 +308,8 @@
/> />
<Tool <Tool
Name="VCLinkerTool" Name="VCLinkerTool"
AdditionalDependencies="dbgeng.lib engextcpp.lib" AdditionalDependencies="dbgeng.lib"
OutputFile="$(OutDir)\$(ProjectName).pyd"
LinkIncremental="1" LinkIncremental="1"
AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\amd64&quot;;&quot;$(PYTHON_ROOT)\x64\libs&quot;;&quot;$(BOOST_ROOT)\stage64\lib&quot;" AdditionalLibraryDirectories="&quot;$(DBG_SDK_ROOT)\lib\amd64&quot;;&quot;$(PYTHON_ROOT)\x64\libs&quot;;&quot;$(BOOST_ROOT)\stage64\lib&quot;"
ModuleDefinitionFile="pykd.def" ModuleDefinitionFile="pykd.def"
@ -353,6 +357,10 @@
RelativePath=".\dbgcmd.cpp" RelativePath=".\dbgcmd.cpp"
> >
</File> </File>
<File
RelativePath=".\dbgdump.cpp"
>
</File>
<File <File
RelativePath=".\dbgext.cpp" RelativePath=".\dbgext.cpp"
> >
@ -373,6 +381,10 @@
RelativePath=".\dbgreg.cpp" RelativePath=".\dbgreg.cpp"
> >
</File> </File>
<File
RelativePath=".\dbgsession.cpp"
>
</File>
<File <File
RelativePath=".\dbgsym.cpp" RelativePath=".\dbgsym.cpp"
> >
@ -435,10 +447,18 @@
RelativePath=".\dbgcmd.h" RelativePath=".\dbgcmd.h"
> >
</File> </File>
<File
RelativePath=".\dbgdump.h"
>
</File>
<File <File
RelativePath=".\dbgexcept.h" RelativePath=".\dbgexcept.h"
> >
</File> </File>
<File
RelativePath=".\dbgext.h"
>
</File>
<File <File
RelativePath=".\dbgmem.h" RelativePath=".\dbgmem.h"
> >
@ -455,6 +475,10 @@
RelativePath=".\dbgreg.h" RelativePath=".\dbgreg.h"
> >
</File> </File>
<File
RelativePath=".\dbgsession.h"
>
</File>
<File <File
RelativePath=".\dbgsym.h" RelativePath=".\dbgsym.h"
> >

5
pykd/stdafx.h
View File

@ -25,8 +25,13 @@
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files: // Windows Header Files:
#include <tchar.h>
#include <windows.h> #include <windows.h>
#define __field_ecount_opt(x) #define __field_ecount_opt(x)