cHookJump.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cHookJump_H
#define _INC_cHookJump_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cThreadLock.h"
#include "cUnitTestDecl.h"
 
namespace Gray
{
        class GRAYCORE_LINK cHookJump
        {
 
        public:
                static const BYTE k_I_NULL = 0x00;
#if USE_INTEL
                static const BYTE k_I_JUMP = 0xe9;              // X86
#endif
                static const int k_LEN_J = 1;   
 
                static const int k_LEN_P = 4;   
#ifdef USE_64BIT
                static const int k_LEN_A = 16;  
#else
                static const int k_LEN_A = 8;   
#endif
                static const int k_LEN_D = k_LEN_J + k_LEN_P;   
 
                friend class cHookSwapLock;
                friend class cHookSwapChain;
 
        protected:
                FARPROC m_pFuncOrig;                    
                BYTE m_OldCode[k_LEN_D];                
                BYTE m_Jump[k_LEN_D];                   
                cThreadLockFast m_Lock;                 
 
        protected:
                bool SwapOld() noexcept
                {
                        if (!isHookValid())
                                return false;
                        cMem::Copy((void*)m_pFuncOrig, m_OldCode, sizeof(m_OldCode));
                        return true;
                }
                void SwapReset() noexcept
                {
                        if (!isHookInstalled() || m_pFuncOrig == nullptr)       // hook has since been destroyed!
                                return;
                        cMem::Copy((void*)m_pFuncOrig, m_Jump, sizeof(m_Jump));
                }
 
        public:
                cHookJump() noexcept
                        : m_pFuncOrig(nullptr)
                {
                        m_OldCode[0] = k_I_NULL;
                        m_Jump[0] = k_I_NULL;
                }
                ~cHookJump()
                {
                        RemoveHook();
                }
 
                bool isHookInstalled() const noexcept
                {
                        return m_Jump[0] == k_I_JUMP;
                }
                bool isHookValid() const noexcept
                {
                        if (!isHookInstalled() || m_pFuncOrig == nullptr)
                                return false;
                        if (::memcmp((const void*)m_pFuncOrig, m_Jump, sizeof(m_Jump)))
                                return false;   // NOT set !!
                        return true;
                }
 
                bool isChainable() const noexcept
                {
                        // The jump i inserted is just on top of another jump? 
                        // I don't need to lock and swap to call the old code. I can just chain to it
                        return m_OldCode[0] == k_I_JUMP;        // the old code was just a jump as well.
                }
 
                FARPROC GetChainFunc() const;
 
                bool InstallHook(FARPROC pFuncOrig, FARPROC pFuncNew);
                void RemoveHook();
 
                UNITTEST_FRIEND(cHookJump);
        };
 
        class GRAYCORE_LINK cHookSwapLock : public cThreadGuardFast
        {
        public:
                cHookJump& m_rJump;     
                bool m_bSwapOld;        // has Old. Must be locked.
 
        public:
                cHookSwapLock(cHookJump& rJump, bool swap = true)
                        : cThreadGuardFast(rJump.m_Lock)        // MUST lock while we do this. single thread.
                        , m_rJump(rJump)
                {
                        m_bSwapOld = swap ? m_rJump.SwapOld() : false;
                }
                ~cHookSwapLock() noexcept
                {
                        if (m_bSwapOld)
                        {
                                m_rJump.SwapReset();
                        }
                }
        };
 
        class GRAYCORE_LINK cHookSwapChain : public cHookSwapLock
        {
        public:
                FARPROC m_pFuncChain;   // chained version of m_pFuncOrig. or fallback to m_pFuncOrig.
        public:
                cHookSwapChain(cHookJump& rJump)
                        : cHookSwapLock(rJump, !rJump.isChainable())
                {
                        m_pFuncChain = rJump.GetChainFunc();
                }
        };
}
 
#endif // _INC_cHookJump_H