root/trunk/ElephantDebugApi/debugger_concrete.h

#ifndef DEBUGER_CONTRETE_H
#define DEBUGER_CONTRETE_H
#include <windows.h>

#include "edbgfunctions.h"
#include "helper_functions.h"
#include "debugger_interfaces.h" 


// VERY IMPORTANT!!!
// you must run this as a thread, or the pause and resume will pause your program , see bottom

class Win32Debugger : IWin32Debugger {
private:
    IDebugDispatcher * dispatch;
    bool firstChanceException;
    string path;
    CONTEXT context; // machine specific data, whats in the registers etc
    DEBUG_EVENT dbg; // debug structure
    STARTUPINFOA startup; // proccess info, used in CreateProccess
    PROCESS_INFORMATION output;     //proccess information
    bool paused;
    bool stop;

public:

    Win32Debugger (IDebugDispatcher * disp ) : dispatch(disp) {
        firstChanceException = true;
    }

    ~Win32Debugger ( ) {
        delete dispatch;
    }

    virtual bool Run( ) {
        paused = false;
        stop = false;
        startup.cb=sizeof(startup);
        ZeroMemory(&startup, sizeof(startup) );
        char* lpszPath = strdup(path.c_str() );
        int result = CreateProcess  (lpszPath, NULL , NULL, NULL, false,  DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, NULL, NULL, &startup, &output);
        
        if ( result == 0 ) {
            //PrintError();
            return false;
        }
        MainLoop();
        return true;
    
    }
    virtual bool Load(const string& _path ) {
        path = _path;
        return false;
    }


    virtual void MainLoop () { 
        uint continueStatus = DBG_CONTINUE;
        
        bool firstRun = true;

        while ( true )
        {
            while ( paused ) Sleep(1);
            if ( stop ) return;

            WaitForDebugEvent(&dbg, INFINITE);
            switch ( dbg.dwDebugEventCode )
            {

            case EXCEPTION_DEBUG_EVENT  :
            {
                dispatch->OnOutput(get_exception_name(dbg.u.Exception.ExceptionRecord.ExceptionCode));
                if ( !HandleDebugException(dbg.u.Exception.ExceptionRecord.ExceptionCode) )
                {

                    if ( firstChanceException )
                    {
                        firstChanceException  =false;
/*
                    }
                    else
                    {
*/
//                      CV4FileListing listing = GetListingForException(dbg.u.Exception.ExceptionRecord,output.hProcess,(char*)path.substr(0,path.find_last_of("\\") ) .c_str());

                        //::MessageBox(0,listing.filePath.c_str() ,0,0);
                        vector<BackTraceItem> bt;

                        BackTrace(bt);
                        dispatch->OnException(ExceptionData(get_exception_name(dbg.u.Exception.ExceptionRecord.ExceptionCode), "FilePath" ,-1, bt ));

                        continueStatus = DBG_EXCEPTION_NOT_HANDLED;

                    }
                }

                else
                {


                    if (firstRun && dbg.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT)
                    { 
                        firstRun = false;
                    }
                    else
                    { 
//                      AfxMessageBox("here");
                        vector<BackTraceItem> bt;
                        BackTrace(bt);
//                          sendData(get_exception_name(dbg.u.Exception.ExceptionRecord.ExceptionCode) );
                        for ( int i = 0; i < bt.size();i++) { ::MessageBox(0,bt[i].symName.c_str() ,"HERESS",0 ); }
                        RegisterDumpData r = DumpRegisters();
                        ThreadData t; //TODO needed?
                        string filePath = "Unkown";
                        int lineNumber = -1;
                        if ( bt.size() > 1 ) {
                            filePath = bt[1].fileName;
                            lineNumber = bt[1].lineNumber;
                        }

                        ExceptionData e(get_exception_name(dbg.u.Exception.ExceptionRecord. ExceptionCode), filePath, lineNumber,bt  );
                        ProcessData p; //TODO needed?
                        dispatch->OnBreakPoint(BreakData(e, t, r, p) );                     

                    }
                        
                }

                break;
            }

            case CREATE_THREAD_DEBUG_EVENT  :
            {
                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
//                  sendData(get_event_name(dbg.dwDebugEventCode ) );
//                  onCreateThread.notify(ThreadData.create());
                break;
            }

            case CREATE_PROCESS_DEBUG_EVENT :
            {

                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
//                  sendData(get_event_name(dbg.dwDebugEventCode ) );
//                  onCreateProccess.notify(ProcessData.create());
                break;
            }

            case EXIT_THREAD_DEBUG_EVENT    :
            {
                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );

//                  sendData("\n" ~ get_event_name(dbg.dwDebugEventCode ) );
//                  ci.sendDirect("Exiting");
//                  onExitThread.notify();
//                  running = false;
//                  paused = false;
                vector<BackTraceItem> bt;
                BackTrace(bt);
//                          sendData(get_exception_name(dbg.u.Exception.ExceptionRecord.ExceptionCode) );
                RegisterDumpData r = DumpRegisters();
                ThreadData t; //TODO needed?
                string filePath = "Unkown";
                int lineNumber = -1;
                if ( bt.size() > 1 ) {
                    filePath = bt[1].fileName;
                    lineNumber = bt[1].lineNumber;
                }

                ExceptionData e(get_exception_name(dbg.u.Exception.ExceptionRecord. ExceptionCode), filePath, lineNumber,bt  );
                ProcessData p; //TODO needed?
                dispatch->OnEnd(BreakData(e, t, r, p) );                        

                return ;

                break;
            }

            case EXIT_PROCESS_DEBUG_EVENT   : {

                
                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
                vector<BackTraceItem> bt;
                BackTrace(bt);
//                          sendData(get_exception_name(dbg.u.Exception.ExceptionRecord.ExceptionCode) );
                RegisterDumpData r = DumpRegisters();
                ThreadData t; //TODO needed?
                string filePath = "Unkown";
                int lineNumber = -1;
                if ( bt.size() > 1 ) {
                    filePath = bt[1].fileName;
                    lineNumber = bt[1].lineNumber;
                }

                ExceptionData e(get_exception_name(dbg.u.Exception.ExceptionRecord. ExceptionCode), filePath, lineNumber,bt  );
                ProcessData p; //TODO needed?
                dispatch->OnEnd(BreakData(e, t, r, p) );                        

                
                return ;
                break;
            }

            case LOAD_DLL_DEBUG_EVENT   :
            {
                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
                dispatch->OnDllLoad(DLLData(dbg.u.LoadDll, GetDLLName(output.hProcess, dbg))) ;
                break;
            }

            case UNLOAD_DLL_DEBUG_EVENT :
            {
                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
//                  unloadDLL(findDLL(dbg.u.UnloadDll.lpBaseOfDll));
                break;
            }

            case OUTPUT_DEBUG_STRING_EVENT  :
            {

                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
                char * read_str = new char[dbg.u.DebugString.nDebugStringLength];
                ReadDebugString( output.hProcess, dbg.u.DebugString ,read_str ) ;
                string  str (read_str);
                delete read_str;
                dispatch->OnTrace(str);
                break;
            }

            case RIP_EVENT:
            {
                dispatch->OnOutput(get_event_name(dbg.dwDebugEventCode ) );
//                  sendData(get_event_name(dbg.dwDebugEventCode ) );
//                  onEnd.notify(get_event_name(dbg.dwDebugEventCode ));
                break;
            }

            default :

//              dispatch->OnEnd(DumpRegisters() );
//              paused = false;
//              running = false;
                return ;
            }
        

            ContinueDebugEvent(output.dwProcessId, output.dwThreadId, continueStatus);

        }

//      paused = false;
//      running = false;
        

        

    }
    virtual bool End () { return true; }
    
    void Pause() { paused = true; }

    void Resume() { paused = false; }

    void Stop() { stop = true; }


    string GetDLLName(HANDLE process, DEBUG_EVENT de )
    {

        char *buffer = new char [MAX_PATH+1];
        GetModuleFileNameFromHeader(
            process,
            de.u.LoadDll.hFile,
            (DWORD) de.u.LoadDll.lpBaseOfDll,
            buffer, MAX_PATH+1);
        string ret(buffer);
        delete buffer;
        return ret;
    }



    bool HandleDebugException(uint code)
    {
        switch ( code )
        {

        case EXCEPTION_BREAKPOINT :
            return true;

        default :
            return false;
        }

        return false;
    }

    

    RegisterDumpData DumpRegisters()
    {
        SuspendThread(output.hThread );
        context.ContextFlags = CONTEXT_FULL |
            CONTEXT_FLOATING_POINT |
            CONTEXT_DEBUG_REGISTERS;
        GetThreadContext(output.hThread, &context);
        RegisterDumpData d(context) ;
        ResumeThread(output.hThread );
        return d;

    }

    void BackTrace(vector<BackTraceItem>  & bt)
    {
        SuspendThread(output.hThread );
        context.ContextFlags = CONTEXT_FULL |
            CONTEXT_FLOATING_POINT |
            CONTEXT_DEBUG_REGISTERS;
        GetThreadContext(output.hThread, &context);
//      StackBackTrace(output.hProcess, output.hThread, &context,bt);
//      ::MessageBox(0,ITOA(bt.size()).c_str(),0,0 );

        ResumeThread(output.hThread );


    }

};

#endif


// #ifndef DEBUG_THREAD_H
// #define DEBUG_THREAD_H

// class Win32Debugger;

// struct DebugThreadData {
//  Win32Debugger* debugger;
//  string path;

//  ~DebugThreadData() {
//      delete debugger;
//  }
// };

// UINT StartDebuggerThread(LPVOID);

// #endif


// #include "stdafx.h"
// #include "d2debugger.h"
// #include "debugging_threads.h"
// #include "debugger_concrete.h"

// UINT StartDebuggerThread(LPVOID x) {
//  DebugThreadData* data = (DebugThreadData*)x;
//  theApp.m_pMainFrame->debugHandle = GetCurrentThread();
//  Win32Debugger *debug = (Win32Debugger*)data->debugger;
//  debug->Load(data->path);
//  debug->Run();
//  delete data;
//  theApp.m_pMainFrame->debugger = NULL;
//  return 0;
// }