也说说Thunk

面向对象是个好东西，用接近世界的方式抽象程序世界，直观。

全局函数（或许我应该特指Windows　API）也是好东西，要什么调什么，毫不含糊.

那么，当他们走到一起，矛盾就产生

类时刻保护着自己的成员，以至于为每一个方法加入一个指向自己的指针.

比如有以下类

 

class TestClass()
{
    void Func();
};

 

则Func被编译器安插了this以针，以便Func内部可以访问类TestClass的成员变量,即Func变为如下样子

 

void Func(TestClass* this);

 

在实际的开发中，使用API时常常会要求我们提供回调函数，比如SetTimer，我们需要设置向这个API提供一个如下类型的函数指针：

 

typedef VOID (CALLBACK* TIMERPROC)(HWND, UINT, UINT_PTR, DWORD);

 

假如我们有如下类

class TestClass()
{
    void OnTimeProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime )
    {
        //do something
    }
}; 

 

 

并希望将成员函数

 

void OnTimeProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );

设为API：

 

UINT_PTR
WINAPI
SetTimer(
    __in_opt HWND hWnd,
    __in UINT_PTR nIDEvent,
    __in UINT uElapse,
    __in_opt TIMERPROC lpTimerFunc); 

 

的第四个参数，以便定时器的时间到时，我们的类成员函数TestFunc:OnTimerProc被调用。

根据最前面对Func的分析,在编译时，OnTimerProc会被安插this指针,变成如下形式:

 

void OnTimeProc(TestClass *this, HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );

 

很显然,我们无法直接设置。

那我们应该怎么做呢，在完成这个任务之前，让我们先看一下一个稍简单一点的例子，用以说明Thunk原理。

Thunk的原理其实说起来很简单：巧妙的将数据段的几个字节的数据设为特殊的值，然后告诉系统，这几个字节的数据是代码（即将一个函数指针指向这几个字节的第一个字节），让系统来执行。

这样说起来就很简单.

相信对于后一个操作:将一个函数指针指向这几个字节的第一个字节我们都应该会：

比如有结构体:

 

typedef struct thunk
{
    DWORD    dwMovEsp;
    DWORD    dwThis;
    BYTE    bJmp;
    DWORD    dwRealProc; 

}THUNK; 

 

函数指针:

 

typedef void (*FUNC)(DWORD dwThis); 

 

则如下代码将一个thunk的结构体强转为FUNC型的函数指针:

 

THUNK testThunk; 

FUNC fun = (FUNC)&testThunk; 

fun(NULL);//先设为NULL 

 

这样，系统便会把testThunk所指向的内存加载到缓冲中。

现在的总是是将这个结构体设为多少比较好？

在x86 指令集中，我们可以查到:

汇编指令JMP为0xe9

所以，我们写下如下函数用于设置这个结构体的值:

 

void Init(DWORD proc,void* pThis)
    {
        dwMovEsp = 0x042444C7;  //C7 44 24 04
        dwThis = (DWORD)pThis;
        bJmp = 0xe9;
        dwRealProc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(thunk)));
        FlushInstructionCache(GetCurrentProcess(),this,sizeof(thunk));
    }

 

前两行用于将pThis指针压栈，接下来的两句用于设置跳转的相对地址。最后一个是更新缓存（说实话，我个人觉得这句在这种情况下是可有可无的,但也可能是我认识不够深，望指教）。

整个代码如下:

 1#include "stdafx.h"
 2#include "wtypes.h" 
 3
 4#include <iostream>
 5using namespace std; 
 6
 7typedef void (*FUNC)(DWORD dwThis);
 8void JmpedFun(DWORD dwThis); 
 9
#pragma pack(push,1)
typedef struct tagTHUNK
{
    DWORD    dwMovEsp;
    DWORD    dwThis;
    BYTE    bJmp;
    DWORD    dwRealProc; 

    void Init(DWORD proc,void* pThis)
    {
        dwMovEsp = 0x042444C7;  //C7 44 24 04
        dwThis = (DWORD)pThis;
        bJmp = 0xe9;
        dwRealProc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(THUNK)));
        FlushInstructionCache(GetCurrentProcess(),this,sizeof(THUNK));
    }
}THUNK;
#pragma pack(pop) 

class Test
{
public:
    THUNK m_thunk;
    int      m_nTest; 

    //构造函数中初始化为3，仅为测试，以便查看外面的方法JmpedTest是否可以正确取得这个值
    Test() : m_nTest(3)
    {} 

    void TestThunk()
    {
        m_thunk.Init((DWORD)JmpedFun,this);
        FUNC f = (FUNC)&m_thunk;
        f(1); 

        cout << "Test::fun()" << endl;
    } 

    int GetTestValue()
    {
        return m_nTest;
    }
}; 

void JmpedFun(DWORD dwThis)
{
    cout << "JmpFun access the Test class's data member:" << ((Test*)dwThis)->GetTestValue() << endl;
} 

int _tmain(int argc, _TCHAR* argv[])
{
    Test t;
    t.TestThunk();
    system("pause");
    return 0;
} 

 

测试成功，接下来是将thunk技术应用到实际中,就是一开始提出的问题。

首先，要使用定时器的功能，肯定要调用API：SetTimer,而调用这个API需要一个如下签名的函数指针:typedef VOID (CALLBACK* TIMERPROC)(HWND, UINT, UINT_PTR, DWORD);因此，我们要做的，就是利用Thunk技术，让这个回调函数调用我们的类的成员方法。

我们可以用一个代理类来完成这一系列的工作，然后我们的真正的业务逻辑类就继承自这个代理类。

现在想想这个代理类要完成这个任务需要那些数据？

首先，他要知道当他被API回调时，他应该调用哪一个类的成员方法，类的面员方法的函数指针时需要指定类类型。如下所示:

 

void (Base:: *  )( HWND , UINT , UINT , DWORD ); 

 

看到这里，相信任何一个初级的刚入门的c++程序员都可以快速的写下以下类:

 

 1class SimpleTest;
 2class SimpleTimerAdapter
 3{
 4public:
 5    CALLBACKThunk thunk;
 6    typedef void (SimpleTest::*func)(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );
 7    typedef func MemberCallBackType;
 8    MemberCallBackType mTimerProc; 
 9
    void Init(TIMERPROC proc, void* pThis,int nPos = 0)
    {
        assert(pThis != NULL);
        if(pThis)
        {
            thunk.m_mov = 0x042444C7; //C7 44 24 04, here 04 is first param ,08 is second
            thunk.m_this = (DWORD)pThis;
            thunk.m_jmp = 0xe9;
            thunk.m_relproc = (int)proc - ((int)this + sizeof(CALLBACKThunk));
        }
    } 

    TIMERPROC MakeCallback(MemberCallBackType lpfn,void* pThis, int nPos = 0)
    {
        assert(pThis);
        if (pThis)
        {
            Init(DefaultCallBackProc, pThis ,nPos);
            mTimerProc = lpfn;
            return (TIMERPROC)&thunk;
        }
        return NULL;
    } 

    UINT_PTR SetTimer(UINT uElapse, MemberCallBackType lpTimerFunc)
    {
        return ::SetTimer(NULL, 0, uElapse, MakeCallback(lpTimerFunc,this));
    } 

    BOOL KillTimer(UINT_PTR uIDEvent)
    {
        return ::KillTimer(NULL, uIDEvent);
    } 

    static void CALLBACK DefaultCallBackProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime )
    {
        (BaseType(hwnd)->*MemberFuncType(hwnd))(0, uMsg, idEvent, dwTime);
    } 

    static SimpleTest* BaseType(void* pThis)
    {
        return reinterpret_cast<SimpleTest*>(pThis);
    } 

    template <class T>
    static MemberCallBackType MemberFuncType(T pThis)
    {
        return reinterpret_cast<SimpleTest*>(pThis)->mTimerProc;
    }
}; 

  

  

class SimpleTest : public SimpleTimerAdapter
{
public:
    bool mQuit; 

    void TimerProc2(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime )
    {
        mQuit = true;
        KillTimer( idEvent);
        printf("good! %d\n", idEvent);
    }
}; 


 

 

然后在MAIN中写下测试代码:

 

 1int main(void)
 2{
 3    SimpleTest a;
 4    a.mQuit = false;
 5    SetTimer(NULL, 0, 1000, a.MakeCallback(&SimpleTest::TimerProc2,&a)); 
 6
 7    MSG msg;
 8    while(!a.mQuit && GetMessage(&msg, 0, 0, 0) )
 9    {
        printf("before dispatch!\n");
        DispatchMessage(&msg);
    } 

    system("pause");
    return 0;
} 

 

以上方法确实可以完成任务，但仅限于完成这一个任务而已，

甚至，在一个类中SimpleTimeAdapter中写出了这样的代码：

 

typedef void (SimpleTest::*func)(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );

 

我写出这段代码只是为了更清楚的显示代理类是如何工作的，除此之外，以上代码,没有任何作用，为真正的纯垃圾代码

为了抽象出一个中间代理类，我们需要用到模板，对于上面提到的定义问题，用模板可以很轻松的解决。同时，把最基本的内容从代理类中抽象出来。于是得以以下三个类:

 

 

 1/**//*
 2* class Base,最终的功能类，目地的要跳转到Base的成员函数中去
 3* class Impl,中间类，界于Adapt与Base之间
 4* MemberCallBackType Base的成员函数
 5* CallBackType,我们给API的回调函数
 6*/
 7template <class Base, class Impl, class MemberCallBackType, class CallBackType>
 8class CallBackAdapter
 9{
protected:
    typedef CallBackAdapter<Base, Impl, MemberCallBackType, CallBackType> SelfType;
    typedef MemberCallBackType BaseMemberCallBackType; 

    CALLBACKThunk thunk; 

    void Init(CallBackType proc, SelfType* pThis,int nPos = 0)
    {
        thunk.m_mov = 0x042444C7; //C7 44 24 04, here 04 is first param ,08 is second
        thunk.m_this = (DWORD)pThis;
        thunk.m_jmp = 0xe9;
        thunk.m_relproc = (int)proc - ((int)this + sizeof(CALLBACKThunk));
    } 

    CallBackType _CallBackProcAddress(void){
        return (CallBackType)&thunk;
    }
public:
    template <class T>
    static Base* BaseType(T pThis){
        return reinterpret_cast<Base*>(pThis);
    } 

    template <class T>
    static MemberCallBackType MemberFuncType(T pThis){
        return reinterpret_cast<SelfType*>(pThis)->mTimerProc;
    } 

    MemberCallBackType mTimerProc; 

    operator CallBackType(){ 

        Init(&Impl::DefaultCallBackProc, this);
        mTimerProc = &Base::TimerProc;
        return (CallBackType)&thunk;
    }
    CallBackType MakeCallback(MemberCallBackType lpfn,int nPos = 0){ 

        Init(&Impl::DefaultCallBackProc, this,nPos);
        mTimerProc = lpfn;
        return (CallBackType)&thunk;
    }
}; 

 

 

 

template <class Base>
class TimerAdapter : public CallBackAdapter<
                            Base,
                            TimerAdapter<Base>,
                            void (Base:: *  )( HWND , UINT , UINT , DWORD ),
                            void (CALLBACK *)( HWND , UINT , UINT , DWORD )>
{
public:
    typedef typename TimerAdapter<Base>::BaseMemberCallBackType MemCallBackType; 

    UINT_PTR SetTimer(UINT uElapse, MemCallBackType lpTimerFunc)
    {
        return ::SetTimer(NULL, 0, uElapse, MakeCallBackProc(lpTimerFunc));
    } 

    BOOL KillTimer(UINT_PTR uIDEvent)
    {
        return ::KillTimer(NULL, uIDEvent);
    } 

    static void CALLBACK DefaultCallBackProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime )
    {
        (BaseType(hwnd)->*MemberFuncType(hwnd))(0, uMsg, idEvent, dwTime);
        //(Base*)(hwnd)->*(reinterpret_cast<Base*>(hwnd)->mTimerProc)(0, uMsg, idEvent, dwTime);
    } 

}; 

测试代码如下:

 

 1int main(void)
 2{
 3    Test a;
 4    printf("timer id is %d", a.SetTimer(100, &Test::TimerProc2));
 5    a.mQuit = false;
 6    SetTimer(NULL, 0, 100, a.MakeCallback(&Test::TimerProc2)); 
 7
 8    //SimpleTest a;
 9    //a.mQuit = false;
    //SetTimer(NULL, 0, 1000, a.MakeCallback(&SimpleTest::TimerProc2,&a)); 

    MSG msg;
    while(!a.mQuit && GetMessage(&msg, 0, 0, 0) )
    {
        printf("before dispatch!\n");
        DispatchMessage(&msg);
    } 

    system("pause");
    return 0;
}

 

参考:

ATL Under the HOOK Part 5 : http://www.codeproject.com/KB/atl/atl_underthehood_5.aspx

还有一篇也是CodeProject上的，但由于看文章的时间太久了，今天再去找时没有找到。