Thread.h

#pragma once

#include "../../Config.h"
#include "../../Include/Winheaders.h"
#include "../../Include/NativeStructures.h"
#include "../../Include/Types.h"

#include <memory>

namespace blackbone
{

#define DEFAULT_ACCESS_T  THREAD_SUSPEND_RESUME    | \
                          THREAD_GET_CONTEXT       | \
                          THREAD_SET_CONTEXT       | \
                          THREAD_QUERY_INFORMATION | \
                          THREAD_TERMINATE         | \
                          SYNCHRONIZE

#define MAXULONG64_2 ((uint64_t)~((uint64_t)0))
#define MAXULONG32_2 ((uint32_t)~((uint32_t)0))


// Breakpoint type
enum HWBPType
{
    hwbp_access  = 3,   // Read or write
    hwbp_write   = 1,   // Write only
    hwbp_execute = 0,   // Execute only
};

enum HWBPLength
{
    hwbp_1 = 0,         // 1 byte
    hwbp_2 = 1,         // 2 bytes
    hwbp_4 = 3,         // 4 bytes
    hwbp_8 = 2,         // 8 bytes
};


class Thread
{
public:
    BLACKBONE_API Thread( DWORD id, class ProcessCore* hProcess, DWORD access = DEFAULT_ACCESS_T );
    BLACKBONE_API Thread( HANDLE handle, class ProcessCore* hProcess );
    BLACKBONE_API Thread( const Thread& other );
    BLACKBONE_API ~Thread();

    BLACKBONE_API inline DWORD id() const { return _id; }

    BLACKBONE_API inline HANDLE handle() const { return _handle; }

    BLACKBONE_API inline bool valid() const { return (_handle != NULL && ExitCode() == STILL_ACTIVE); }

    BLACKBONE_API ptr_t teb( _TEB32* pteb = nullptr ) const;
   
    BLACKBONE_API ptr_t teb( _TEB64* pteb = nullptr ) const;

    BLACKBONE_API inline ptr_t teb() const { return teb( (TEB_T*)nullptr ); }

    BLACKBONE_API uint64_t startTime();

    BLACKBONE_API uint64_t execTime();

    BLACKBONE_API bool Suspend();

    BLACKBONE_API bool Resume();

    BLACKBONE_API bool GetContext( _CONTEXT32& ctx, DWORD flags = CONTEXT_ALL, bool dontSuspend = false );

    BLACKBONE_API bool GetContext( _CONTEXT64& ctx, DWORD flags = CONTEXT64_ALL, bool dontSuspend = false );

    BLACKBONE_API bool SetContext( _CONTEXT32& ctx, bool dontSuspend = false );

    BLACKBONE_API bool SetContext( _CONTEXT64& ctx, bool dontSuspend = false );

    BLACKBONE_API bool Terminate( DWORD code = 0 );

    BLACKBONE_API bool Join( int timeout = INFINITE );

    BLACKBONE_API DWORD ExitCode() const;

    int BLACKBONE_API AddHWBP( ptr_t addr, HWBPType type, HWBPLength length );

    BLACKBONE_API bool RemoveHWBP( int idx );

    BLACKBONE_API bool RemoveHWBP( ptr_t ptr );

    BLACKBONE_API void Close();

    BLACKBONE_API inline bool operator ==(const Thread& other) { return (_id == other._id); }

    BLACKBONE_API Thread& operator =(const Thread& other)
    {
        _id = other._id;
        _core = other._core;
        _handle = other._handle;

        // Transfer handle ownership
        other.ReleaseHandle();

        return *this;
    }

private:

    inline void ReleaseHandle() const { _handle = NULL; }

private:
    class ProcessCore* _core;           // Core routines

    DWORD _id = 0;                      // Thread ID
    mutable HANDLE _handle = NULL;      // Thread handle
};

}