MFC程序逆向消息篇(上)+(下) 11楼

标题： MFC程序逆向消息篇(上)+(下) 11楼
作者：szdbg
时间：2007-10-31 06:26
链接：http://bbs.pediy.com/showthread.php?t=54150

前言：
记得前一段时间，我刚接触软件破解和逆向这一行时，对于一些软件不知从何处跟踪按钮消息，试了好多方法，就是断不下来，在系统模块中经常转得晕头转向，而一无所获。

MFC程序是一种常见类型的程序，我静下心来，潜心研究了一下MFC消息流程。弄清原委之后，一切豁然开朗，发现跟踪MFC程序和消息处理原来是如此。。。，跟踪按钮事件处理也由此变得特别简单。

于是，我将这些研究整理成文，以备后忘。并希望对和我一样的菜鸟有所帮助，有误之处，请高手指正。

本文目的就是以一个MFC的标准对话框程序为例,同时从源码和反汇编代码两方面来研究MFC消息的流程走向，弄清MFC消息路径的所有站点，这样就可以任意定位MFC的所有消息事件，可以从任一站点切入，进行跟踪分析MFC的处理过程。甚至可以从PumpMessage大本营出发，一直全程跟踪，做到心中有数，不慌不乱。

关于对话框的启动过程，其过程很简单，程序进入WinMain函数之后，会调用对话框的DoModal函数，然后就进入RunModalLoop函数，消息循环在这里就开始了，限于篇幅，本文不作多说，有兴趣者可看看MFC源码。本篇重点在于分析MFC的消息分发处理的过程。
先看一下RunModalLoop函数部分源码：

int CWnd::RunModalLoop(DWORD dwFlags)
{  ...
  for (;;)
  {  ...
    do
    {  if (!AfxGetThread()->PumpMessage())    // pump message, but quit on WM_QUIT
      {
        AfxPostQuitMessage(0);
        return -1;
}
      ...
    } while (::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE));
  }
  ...
}

这里，AfxGetThread()->PumpMessage()是MFC消息处理的大本营，MFC程序的所有消息就是从这里开始，经过重重路径转换，翻山越岭,中途直达Windows系统内核，再返回到MFC地界，又途经不少周折，才找到最终目的地  消息函数地址。可谓是山重水复疑无路，柳暗花明又一村。

一个按钮点击事件的过程如下：
CWinThread::PumpMessage -> CWnd::PretranslateMessage -> CWnd::WWalkPreTranslateMessate -> CD1Dlg::PreTranslateMessage -> CDialog::PreTranslateMessage -> CWnd::PreTranslateInput  -> CWnd::IsDialogMessageA -> USER32内核 -> AfxWndProcBase -> AfxWndProc -> AfxCallWndProc -> CWnd::WindowProc -> CWnd::OnWndMsg -> CWnd::OnCommand -> CDialog::OnCmdMsg -> CCmdTarget::OnCmdMsg -> _AfxDispatchCmdMsg -> CD1Dlg::OnButton1()

VC下，可以随手写一个标准的对话框程序，上面放一个按钮，点击按钮后，弹出一个消息框。我们现在就从PumpMessage()开始，来分析这中间的消息流程：

1. CWinThread::PumpMessage函数 (消息泵)
BOOL CWinThread::PumpMessage()
{     //GetMessage 当消息为WM_QUIT时，返回0,其它消息时，返回TRUE，有错误时，返回-1
　　　if (!::GetMessage(&m_msgCur, NULL, NULL, NULL))  return FALSE;
　　　if (m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCur))
{
　　　　::TranslateMessage(&m_msgCur);
　　　　::DispatchMessage(&m_msgCur);　
}
　　　return TRUE;
}
PumpMessage只有在接收到WM_QUIT消息时，才返回FALSE，其它情况，返回TRUE。由于CWinThread::PumpMessage()函数负责从消息队列中获取消息、翻译消息以及分发消息等，因此习惯将此函数称之为“消息泵”。
在PumpMessage函数中，PreTranslateMessage函数至关重要，正是有了这个PreTranslateMessage()，才使得MFC能够灵活的控制消息的分发模式，可以说，PreTranslateMessage()就是MFC的实现消息分发模式的工具。

PumpMessage函数反汇编代码：
73D31194 >  56                    PUSH ESI
...
73D311A1    FF15 B0B6DC73         CALL DWORD PTR DS:[<&USER32.GetMessageA>]
73D311A7    85C0                  TEST EAX,EAX
73D311A9    74 26                 JE SHORT MFC42.73D311D1    ;收到WM_QUIT，退出程序
73D311AB    817E 38 6A030000      CMP DWORD PTR DS:[ESI+38],36A
73D311B2    74 1A                 JE SHORT MFC42.73D311CE
73D311B4    8B06                  MOV EAX,DWORD PTR DS:[ESI]
73D311B6    57                    PUSH EDI
73D311B7    8BCE                  MOV ECX,ESI
73D311B9    FF50 60               CALL DWORD PTR DS:[EAX+60]    ; PreTranslateMessage (消息预处理)
73D311BC    85C0                  TEST EAX,EAX
73D311BE    75 0E                 JNZ SHORT MFC42.73D311CE
73D311C0    57                    PUSH EDI          ;消息预处理返回FALSE
73D311C1    FF15 ACB6DC73         CALL DWORD PTR DS:[<&USER32.TranslateMessage>]
73D311C7    57                    PUSH EDI
73D311C8    FF15 30B6DC73         CALL DWORD PTR DS:[<&USER32.DispatchMessageA>]
;
73D311CE    6A 01                 PUSH 1            ;返回TRUE
73D311D0    58                    POP EAX
73D311D1    5F                    POP EDI
73D311D2    5E                    POP ESI
73D311D3    C3                    RETN

提示：
a. OD加载程序后，调出MFC42.dll模块，定位到PumpMessage代码入口处。
b. 在CALL DWORD PTR DS:[EAX+60]这一条语句上设置条件断点[[esp]+4]==202,即可设置鼠标左键释放断点。
   说明：call [eax+60]是调用PreTranslateMessage函数，入口参数为：MSG* pMsg,所以：
   [esp]就是pMsg，而[[esp]]就是pMsg->hWnd  , [[esp]+4]就是pMsg->Message
c. [[esp]]==002407B4 && [[esp]+4]==202 可以为指定按钮设置点击断点。这里002407B4是目标按钮的句柄.

2. CWinThread::PreTranslateMessage函数
BOOL CWinThread::PreTranslateMessage(MSG* pMsg)
{  // if this is a thread-message, short-circuit this function
  if (pMsg->hwnd == NULL && DispatchThreadMessageEx(pMsg))    return TRUE;
  CWnd* pMainWnd = AfxGetMainWnd();
  // 通过WalkPreTranslateTree 进行消息分发
  if (CWnd::WalkPreTranslateTree(pMainWnd->GetSafeHwnd(), pMsg))  return TRUE;  // 消息分发处理关键
  if (pMainWnd != NULL)
  {
     CWnd* pWnd = CWnd::FromHandle(pMsg->hwnd);
     if (pWnd->GetTopLevelParent() != pMainWnd)
      return pMainWnd->PreTranslateMessage(pMsg);  //程序主框架处理消息
  }
  return FALSE;   // no special processing
}

PreTranslateMessage函数反汇编部分代码
73D313D0 >   PUSH ESI
73D313D1     PUSH EDI
73D313D2     MOV EDI,DWORD PTR SS:[ESP+C]
73D313D6     CMP DWORD PTR DS:[EDI],0
73D313D9     JE MFC42.73D8E9A1
73D313DF     CALL MFC42.#6575_?AfxGetMainWnd@@YGPAVCW>
73D313E4     MOV ESI,EAX
73D313E6     TEST ESI,ESI
73D313E8     JE SHORT MFC42.73D313ED
73D313EA     MOV EAX,DWORD PTR DS:[ESI+20]
73D313ED     PUSH EDI
73D313EE     PUSH EAX
73D313EF     CALL MFC42.#6367_?WalkPreTranslateTree@C>
73D313F4     TEST EAX,EAX
73D313F6     JNZ SHORT MFC42.73D31415
73D313F8 >   TEST ESI,ESI
73D313FA     JE SHORT MFC42.73D3140E
73D313FC     PUSH DWORD PTR DS:[EDI]
73D313FE     CALL MFC42.#2864_?FromHandle@CWnd@@SGPAV>
73D31403     MOV ECX,EAX
73D31405     CALL MFC42.#3815_?GetTopLevelParent@CWnd>
73D3140A     CMP EAX,ESI
73D3140C     JNZ SHORT MFC42.73D3141A
73D3140E     XOR EAX,EAX
73D31410     POP EDI
73D31411     POP ESI
73D31412     RETN 4
提示：
a. OD加载程序后，调出MFC42.dll模块，定位到PreTranslateMessage代码入口处。
b. 在函数入口处设置条件断点[[esp+4]+4]==202,即可设置鼠标左键释放断点。
   说明：此函数的入口参数为：MSG* pMsg,在入口处时，[esp]是函数返回地址，所以：
   [esp+4]就是pMsg，而[[esp+4]]就是pMsg->hWnd  , [[esp+4]+4]就是pMsg->Message
c. [[esp+4]]==002407B4 && [[esp+4]+4]==202 可以为指定按钮设置点击断点。这里002407B4是目标按钮的句柄.

3. CWnd::WalkPreTranslateTree函数
CWnd::WalkPreTranslateTree()的所使用的策略很简单，拥有该消息窗口最先获得该消息的处理权，如果它不想对该消息进行处理（该窗口对象的PreTranslateMessage()函数返回FALSE），就将处理权交给它的父亲窗口，如此向树的根部遍历，直到遇到hWndStop（在CWinThread::PreTranslateMessage()中，hWndStop表示的是线程主窗口的句柄）。
记住这个消息处理权的传递方向，是由树的某个一般节点或叶子节点向树的根部传递！

BOOL PASCAL CWnd::WalkPreTranslateTree(HWND hWndStop, MSG* pMsg)
{  for (HWND hWnd = pMsg->hwnd; hWnd != NULL; hWnd = ::GetParent(hWnd))  //从当前窗口到父窗口，逐层往上
  {  CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
    if (pWnd != NULL)
    {  // target window is a C++ window
      if (pWnd->PreTranslateMessage(pMsg))  return TRUE;　　//消息被某一窗口处理了，返回
    }
    if (hWnd == hWndStop)  break;    // got to hWndStop window without interest
  }
  return FALSE;       // no special processing
}
正是这个if (pWnd->PreTranslateMessage(pMsg))  return TRUE;　才实现了MFC灵活的消息分发处理机制。MFC程序各个窗口类中重载的PreTranslateMessage虚函数，都是从这里进来的。
MFC从当前消息窗口类逐级向上搜索执行各个类的PreTranslateMessage函数，只要有一个PreTranslateMessage函数
返回TRUE，WalkPreTranslateTree就中止搜索，并返回TRUE，否则返回FALSE。
   在PumpMessage函数中最终就是根据WalkPreTranslateTree函数的返回值决定是否要由Windows系统进行消息处理与分发。

WalkPreTranslateTree函数反汇编代码如下：
73D31389  MOV EDI,EDI                                        ;  D1.0040308C
73D3138B  PUSH ESI
73D3138C  PUSH EDI
73D3138D  MOV EDI,DWORD PTR SS:[ESP+10]
73D31391  MOV ESI,DWORD PTR DS:[EDI]
73D31393  JMP SHORT MFC42.73D313BD
73D31395  /PUSH ESI
73D31396  |CALL MFC42.#2867_?FromHandlePermanent@CWnd@@SGPAV>        ;取得CWnd 指针值
73D3139B  |TEST EAX,EAX              ;CWnd * 值不为NULL时，则调用CWnd::PreTranslateMessage()
73D3139D  |JE SHORT MFC42.73D313AE
73D3139F  |MOV EDX,DWORD PTR DS:[EAX]
73D313A1  |PUSH EDI
73D313A2  |MOV ECX,EAX
73D313A4  |CALL DWORD PTR DS:[EDX+98]  ;<JMP.&MFC42.#5280_?PreTranslateMessage > ;通过虚函数方式调用
73D313AA  |TEST EAX,EAX
73D313AC  |JNZ SHORT MFC42.73D313C8        ;消息被处理了，返回TRUE
73D313AE  |CMP ESI,DWORD PTR SS:[ESP+C]
73D313B2  |JE SHORT MFC42.73D313C1
73D313B4  |PUSH ESI                                          ; /hWnd
73D313B5  |CALL DWORD PTR DS:[<&USER32.GetParent>]           ; \GetParent
73D313BB  |MOV ESI,EAX
73D313BD   TEST ESI,ESI
73D313BF  \JNZ SHORT MFC42.73D31395
73D313C1  XOR EAX,EAX              ;返回FALSE
73D313C3  POP EDI
73D313C4  POP ESI
73D313C5  RETN 8
73D313C8  XOR EAX,EAX
73D313CA  INC EAX                ;返回 TRUE
73D313CB  JMP SHORT MFC42.73D313C3
跟踪说明：
在上面一句73D313A4  CALL DWORD PTR DS:[EDX+98] 设置按钮点击条件断点： [[esp]]==002407B4 && [[esp]+4]==202
可以发现：当点击按钮后，按钮点击事件函数代码就会在这条语句后执行，当按钮事件函数代码执行完毕后，CALL才会返回TRUE。

4. CD1Dlg::PreTranslateMessage函数
BOOL CDialog::PreTranslateMessage(MSG* pMsg)
{    ...
  return CDialog::PreTranslateMessage(pMsg);
}
若接收消息的窗口类重载了PreTranslateMessage函数，则此时会调用它，否则就进入第5步。实际应用中，这里很有可能是消息流程的一个分水岭，可能走向两条不同的道路。这完全取决于应用程序新增的代码，若应用程序在这里返回TRUE，消息流程就返回去了。否则，就会继续往下执行。
    在跟踪按钮消息时，此处应作为一个注意点，而设置断点的最佳位置是在上一步WalkPreTranslateTree函数中所说的位置，跟踪下来，注意消息流程的走向。

5. CDialog::PreTranslateMessage函数
BOOL CDialog::PreTranslateMessage(MSG* pMsg)
{
  if (CWnd::PreTranslateMessage(pMsg)) return TRUE;
  CFrameWnd* pFrameWnd = GetTopLevelFrame();
  if (pFrameWnd != NULL && pFrameWnd->m_bHelpMode) return FALSE;
  if (pMsg->message == WM_KEYDOWN && (pMsg->wParam == VK_ESCAPE || pMsg->wParam == VK_CANCEL) &&
     (::GetWindowLong(pMsg->hwnd, GWL_STYLE) & ES_MULTILINE) &&_AfxCompareClassName(pMsg->hwnd, _T("Edit")))
  {
    HWND hItem = ::GetDlgItem(m_hWnd, IDCANCEL);
    if (hItem == NULL || ::IsWindowEnabled(hItem))
    {
      SendMessage(WM_COMMAND, IDCANCEL, 0);
      return TRUE;
    }
  }
  return PreTranslateInput(pMsg);      // 消息流入此处
}

CDialog::PreTranslateMessage()反汇编代码如下：
73D468A4 >  PUSH ESI
73D468A5    PUSH EDI
73D468A6    MOV EDI,DWORD PTR SS:[ESP+C]
73D468AA    MOV ESI,ECX
73D468AC    PUSH EDI
73D468AD    CALL MFC42.#5290_?PreTranslateMessage@CWnd@@UAEHPAUtagMSG@>
73D468B2    TEST EAX,EAX
73D468B4    JNZ MFC42.73D8D490
73D468BA    MOV ECX,ESI
73D468BC    CALL MFC42.#3813_?GetTopLevelFrame@CWnd@@QBEPAVCFrameWnd@@>
73D468C1    TEST EAX,EAX
73D468C3    JNZ MFC42.73D8D429
73D468C9    CMP DWORD PTR DS:[EDI+4],100
73D468D0    JE SHORT MFC42.73D468DF
73D468D2    PUSH EDI
73D468D3    MOV ECX,ESI
73D468D5    CALL MFC42.#5278_?PreTranslateInput@CWnd@@QAEHPAUtagMSG@@@>     ;消息从流入此处
73D468DA    POP EDI
73D468DB    POP ESI
73D468DC    RETN 4

6. CWnd::PreTranslateInput函数
BOOL CWnd::PreTranslateInput(LPMSG lpMsg)
{
  if ((lpMsg->message < WM_KEYFIRST || lpMsg->message > WM_KEYLAST) &&
    (lpMsg->message < WM_MOUSEFIRST || lpMsg->message > WM_MOUSELAST))  // 过滤消息
    return FALSE;
  return IsDialogMessage(lpMsg);
}
从源码中可以看出，这个函数是对消息进行过滤，对于按键消息和鼠标消息，直接返回FALSE,然后再返回到PumpMessge函数中，调用TranslageMessage()和DispatchMessage()函数，进行消息转换和分发，再进入MFC。对于其它消息，则调用CWnd::IsDialogMessage()函数进行下一步处理。
CWnd::PreTranslateInput()函数反汇编代码如下：
73D34009 >  MOV EDX,DWORD PTR SS:[ESP+4]
73D3400D    MOV EAX,DWORD PTR DS:[EDX+4]
73D34010    CMP EAX,100
73D34015    JNB SHORT MFC42.73D34023
73D34017    CMP EAX,200
73D3401C    JNB SHORT MFC42.73D34032
73D3401E    XOR EAX,EAX
73D34020    RETN 4
73D34023    CMP EAX,108
73D34028  ^ JA SHORT MFC42.73D34017
73D3402A    PUSH EDX
73D3402B    CALL MFC42.#4047_?IsDialogMessageA@CWnd@@QAEHPAUtagMSG@@@Z
73D34030  ^ JMP SHORT MFC42.73D34020
73D34032    CMP EAX,209
73D34037  ^ JBE SHORT MFC42.73D3402A
73D34039  ^ JMP SHORT MFC42.73D3401E
7. CWnd::IsDialogMessageA函数
BOOL CWnd::IsDialogMessage(LPMSG lpMsg)
{
  if (m_nFlags & WF_OLECTLCONTAINER)
    return afxOccManager->IsDialogMessage(this, lpMsg);
  else
    return ::IsDialogMessage(m_hWnd, lpMsg);
}
这里会转进User32.IsDialogMessageA函数，从而转入系统内核，由Windows系统再来负责将消息的分发传送到各个目标窗口。
注：User32.IsDialogMessage并不是象它的名字那样用来检查对话框消息的，而是用来解释或转换消息的。更贴切的名字应该是TranslateDialogMessage。CWnd::IsDialogMessage实际上是一个以LPMSG作为参数，再加上内部的m_hWnd参数来调用User32.IsDialogMessage的打包函数。这样，MFC中每一个对话框都会解释自己的输入。所以，若同时运行五个对话框，每一个对话框的PreTranslateMessage都会自动调用User32.IsDialogMessage，而且运转良好，完全可以不用我们编程处理，MFC真是太牛了。

CWnd::IsDialogMessageA函数反汇编代码：
73D468F5 > PUSH ESI
73D468F6   MOV ESI,ECX
73D468F8   TEST BYTE PTR DS:[ESI+29],1
73D468FC   JNZ MFC42.73D8E273
73D46902   PUSH DWORD PTR SS:[ESP+8]
73D46906   PUSH DWORD PTR DS:[ESI+20]
73D46909   CALL DWORD PTR DS:[<&USER32.IsDialogMessageA>]      ;进入系统内核
73D4690F   POP ESI
73D46910   RETN 4
提示：
1 . OD中设断： bp IsDialogMessageA MSG==202 , 则当鼠标左键释放时，会中断在User32.IsDialogMessageA函数入口上。
2.  若已知按钮的句柄，且要求当点击该按钮时，程序中断在IsDialogMessageA上，则可以作如下设断：
bp IsDialogMessageA [[esp+8]]==00060350 && MSG==202.
  3. 中断后，可以通过堆栈返回到CWnd::IsDialogMessageA函数代码处。
=========================================================================================================
8. User32 内核处理，不分析
这里面的过程，我们就当作一个黑匣子吧，不管它，一般情况下，也无需管它。因为我们百分之百相信它。
=========================================================================================================
当消息到达此处时，又进入了MFC地界 .第8步之前，可以说是经常峰回路转，山重水复。第8步之后，是柳暗花明，可以一路高歌，直奔目的地了。

欲知后事如何，且听下回分解！

标题：MFC程序逆向消息篇(下)
作者：szdbg
时间：2007-11-01 19:40

上篇里嗦地说了一大堆，其实所说的消息都是PostMessage方式的。MFC中还有另外一种很常见的消息发送方式，就是SendMessage函数。这个消息起始路径和上篇所讲的完全不一样。这种方式下，前面的7个站点均不执行，而是直接进入第8站点:User32内核，从第8站点出来后，这两种消息方式走上了同一条道路，进入第9个站点或第10个站点了，真是殊道同归。
对于MFC窗口程序，所有窗口都使用同一窗口过程： AfxWndProcBase(第9个站点)或AfxWndProc(第10个站点)。如果程序是动态链接到MFC DLL(定义了_AFXDLL)，则AfxWndProcBase被用作窗口过程，否则AfxWndProc被用作窗口过程。而在AfxWndProcBase中，最终也是调用AfxWndProc函数。
所以，可以说，第10个站点：AfxWndProc函数是MFC的所有消息必经之点。
可以作如下测试：在Button1事件代码中加入:  SendMessage(WM_COMMAND,IDC_BUTTON2,0);  这是往Button2发送点击消息，当点击Button1时，跟进Button1的事件代码流程，再跟进SendMessage函数的内部代码，可以发现，和上面所讲是完全一样的。

各位可能有疑问了，消息从User32内核出来之后，应该是由Windows系统自动发往各个窗口的消息处理函数，但这里怎么会全部进入了AfxWndProc()函数呢？这涉及到了钩子函数，有兴趣者，请看本文附录，正文不作多说。现在继续进入消息之旅：

请看以下源码：
9. AfxWndProcBase函数
LRESULT CALLBACK AfxWndProcBase(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
  AFX_MANAGE_STATE(_afxBaseModuleState.GetData());
  return AfxWndProc(hWnd, nMsg, wParam, lParam);
}
AfxWndProcBase首先使用宏AFX_MANAGE_STATE设置正确的模块状态，然后调用AfxWndProc。
说明：如果程序是动态链接到MFC DLL(定义了_AFXDLL)，则AfxWndProcBase被用作窗口过程，否则AfxWndProc被用作窗口过程。从源码可以知道，在AfxWndProcBase中，最终也是调用AfxWndProc函数。

AfxWndProcBase反汇编代码：
73D31B81 >  MOV EAX,MFC42.73DC2CFE
73D31B86    CALL MFC42.__EH_prolog                                     ; JMP 到 MSVCRT._EH_prolog
73D31B8B    PUSH ECX
73D31B8C    PUSH ECX
73D31B8D    PUSH MFC42.#2188_?CreateObject@?$CProcessLocal@V_AFX_BASE_>
73D31B92    MOV ECX,OFFSET MFC42._afxBaseModuleState
73D31B97    CALL MFC42.#3028_?GetData@CProcessLocalObject@@QAEPAVCNoTr>
73D31B9C    PUSH EAX
73D31B9D    LEA ECX,DWORD PTR SS:[EBP-14]
73D31BA0    CALL MFC42.#6467_??0AFX_MAINTAIN_STATE2@@QAE@PAVAFX_MODULE>
73D31BA5    PUSH DWORD PTR SS:[EBP+14]
73D31BA8    AND DWORD PTR SS:[EBP-4],0
73D31BAC    PUSH DWORD PTR SS:[EBP+10]
73D31BAF    PUSH DWORD PTR SS:[EBP+C]
73D31BB2    PUSH DWORD PTR SS:[EBP+8]
73D31BB5    CALL MFC42.#1578_?AfxWndProc@@YGJPAUHWND__@@IIJ@Z
73D31BBA    MOV ECX,DWORD PTR SS:[EBP-10]
73D31BBD    MOV EDX,DWORD PTR SS:[EBP-14]
73D31BC0    MOV DWORD PTR DS:[ECX+4],EDX
73D31BC3    MOV ECX,DWORD PTR SS:[EBP-C]
73D31BC6    MOV DWORD PTR FS:[0],ECX
73D31BCD    LEAVE
73D31BCE    RETN 10

10. AfxWndProc函数 - 是所有的CWnd类及其派生类的WndProc
LRESULT CALLBACK AfxWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
  if (nMsg == WM_QUERYAFXWNDPROC)  return 1;
  CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
  return AfxCallWndProc(pWnd, hWnd, nMsg, wParam, lParam);
}
AfxWndProc()要做的第一件事是找到目标窗口的CWnd对象。一旦找到CWnd对象，就会立刻调用AfxCallWndProc()。
这样，AfxWndProc就成为CWnd或其派生类的窗口过程。不论队列消息，还是非队列消息，都送到AfxWndProc窗口过程来处理（如果使用MFC DLL，则AfxWndProcBase被调用，然后是AfxWndProc）。
Windows消息送给AfxWndProc窗口过程之后，AfxWndProc得到HWND窗口对应的MFC窗口对象，然后，调用AfxCallWndProc函数进行下一步处理。
AfxWndProc函数反汇编代码:
73D31BD1 >  PUSH EBP
73D31BD2    MOV EBP,ESP
73D31BD4    CMP DWORD PTR SS:[EBP+C],360
73D31BDB    JE MFC42.73D8BF8A
73D31BE1    PUSH DWORD PTR SS:[EBP+8]
73D31BE4    CALL MFC42.#2867_?FromHandlePermanent@CWnd@@SGPAV1@PAUHWND>
73D31BE9    PUSH DWORD PTR SS:[EBP+14]
73D31BEC    PUSH DWORD PTR SS:[EBP+10]
73D31BEF    PUSH DWORD PTR SS:[EBP+C]
73D31BF2    PUSH DWORD PTR SS:[EBP+8]
73D31BF5    PUSH EAX
73D31BF6    CALL MFC42.#1109_?AfxCallWndProc@@YGJPAVCWnd@@PAUHWND__@@I>
73D31BFB    POP EBP
73D31BFC    RETN 10
提示：
    a. OD加载程序后，调出MFC42.dll模块，定位到AfxWndProc代码入口处。
b. 在入口PUSH EBP处设置条件断点[esp+8]==111,即可设置按钮点击事件断点。
c. [esp+4]==002407B4 && [esp+8]==202 可以为指定按钮设置点击断点(002407B4是按钮的句柄值)。
说明：此时设置条件断点就更方便了，[esp]是返回地址，[esp+4]是接收消息的窗口句柄，[esp+8]就是消息代码值

11. AfxCallWndProc函数
LRESULT AFXAPI AfxCallWndProc(CWnd* pWnd, HWND hWnd, UINT nMsg,WPARAM wParam = 0, LPARAM lParam = 0)
{     _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
     //存储标志符和参数，因为MFC内部需要这些参数和信息，但用户不需关心
     MSG oldState = pThreadState->m_lastSentMsg;
     pThreadState->m_lastSentMsg.hwnd = hWnd;
     pThreadState->m_lastSentMsg.message = nMsg;
     pThreadState->m_lastSentMsg.wParam = wParam;
     pThreadState->m_lastSentMsg.lParam = lParam;
     …
     //委派到窗口的WindowProc
     lResult = pWnd->WindowProc(nMsg, wParam, lParam);
     …
     return lResult;
}
AfxCallWndProc函数把消息送给CWnd类或其派生类的对象。该函数主要是把消息和消息参数(nMsg、wParam、lParam)传递给MFC窗口对象的成员函数WindowProc（pWnd->WindowProc）作进一步处理。如果是WM_INITDIALOG消息，则在调用WindowProc前后要作一些处理。

AfxCallWndProc 函数反汇编代码：
73D31BFF >  MOV EAX,MFC42.73DC2D82
73D31C04    CALL MFC42.__EH_prolog                                   ; JMP 到 MSVCRT._EH_prolog
73D31C09    SUB ESP,34
73D31C0C    PUSH EBX
73D31C0D    PUSH ESI
73D31C0E    PUSH EDI
73D31C0F    MOV ECX,OFFSET MFC42._afxThreadState
73D31C14    MOV DWORD PTR SS:[EBP-10],ESP
73D31C17    PUSH MFC42.#2202_?CreateObject@?$CThreadLocal@V_AFX_THREAD>
73D31C1C    CALL MFC42.#3030_?GetData@CThreadLocalObject@@QAEPAVCNoTra>
...
73D31C62    PUSH DWORD PTR SS:[EBP+18]
73D31C65    MOV EAX,DWORD PTR DS:[EDI]
73D31C67    MOV ECX,EDI
73D31C69    PUSH DWORD PTR SS:[EBP+14]
73D31C6C    PUSH ESI
73D31C6D    CALL DWORD PTR DS:[EAX+A0]    <D1.?WindowProc@CWnd@@MAEJIIJ  mfc42:MFC42.DLL>
...
73D31C9A    C2 1400         RETN 14

12. CWnd::WindowProc函数
AfxWndProc和 AfxCallWndProc都是AFX的API函数。而WindowProc已经是CWnd的一个方法。所以可以注意到在WindowProc中已经没有关于句柄或者是CWnd的参数了。至此，消息已经正式登堂入室，步入MFC的大厅了。真是辛苦啊！
其源码如下：
LRESULT CWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
  LRESULT lResult = 0;
  if (!OnWndMsg(message, wParam, lParam, &lResult))    // OnWndMsg做了大部分工作
    lResult = DefWindowProc(message, wParam, lParam);
  return lResult;
}
CWnd::WindowProc先发送消息到OnWndMsg()函数，它试图在类中为该消息寻找一个处理函数；如果未被处理，则调用DefWindowProc()函数。DefWindowProc()是缺省的窗口过程，所有不能或者没有被OnWndMsg处理的函数都将交由它处理。
CWnd::WindowProc是一个虚拟函数，程序员可以在CWnd的派生类中覆盖它，改变MFC分发消息的方式。例如，MFC的CControlBar就覆盖了WindowProc，对某些消息作了自己的特别处理，其他消息处理由基类的WindowProc函数完成。

CWnd::WindowProc()函数反汇编代码：
73D31CC8 >  PUSH EBP
73D31CC9    MOV EBP,ESP
73D31CCB    PUSH ECX
73D31CCC    PUSH ESI
73D31CCD    MOV ESI,ECX
73D31CCF    LEA ECX,DWORD PTR SS:[EBP-4]
73D31CD2    AND DWORD PTR SS:[EBP-4],0
73D31CD6    MOV EAX,DWORD PTR DS:[ESI]
73D31CD8    PUSH ECX
73D31CD9    PUSH DWORD PTR SS:[EBP+10]
73D31CDC    MOV ECX,ESI
73D31CDE    PUSH DWORD PTR SS:[EBP+C]
73D31CE1    PUSH DWORD PTR SS:[EBP+8]
73D31CE4    CALL DWORD PTR DS:[EAX+A4]  ;<D1.?OnWndMsg@CWnd@@   mfc42:MFC42.DLL>
73D31CEA    TEST EAX,EAX
73D31CEC    JNZ SHORT MFC42.73D31D04
73D31CEE    PUSH DWORD PTR SS:[EBP+10]
73D31CF1    MOV EAX,DWORD PTR DS:[ESI]
73D31CF3    MOV ECX,ESI
73D31CF5    PUSH DWORD PTR SS:[EBP+C]
73D31CF8    PUSH DWORD PTR SS:[EBP+8]
73D31CFB    CALL DWORD PTR DS:[EAX+A8]   ; <D1.?DefWindowProcA@CWnd@@   mfc42:MFC42.DLL>
73D31CFB    CALL DWORD PTR DS:[EAX+A8]
73D31D01    MOV DWORD PTR SS:[EBP-4],EAX
73D31D04    MOV EAX,DWORD PTR SS:[EBP-4]
73D31D07    POP ESI
73D31D08    LEAVE
73D31D09    RETN 0C
提示：
    a. OD加载程序后，调出MFC42.dll模块，定位到WindowProc代码入口处。
b. 在入口PUSH EBP处设置条件断点[esp+4]==111,即可设置按钮点击事件断点。
说明：  1. 此时[esp]是返回地址，[esp+4]是消息代码值。
        2. 由于，此时的接收消息窗口的句柄被CWnd类隐藏起来了，所以此时要设定指定按钮断点不太方便。

13. CWnd::OnWndMsg函数 (这个函数很长，此处仅选一部分)
BOOL CWnd::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{  LRESULT lResult = 0;
  if (message == WM_COMMAND)
  {  if (OnCommand(wParam, lParam))    // 命令消息从此处流进
    {  lResult = 1;
      goto LReturnTrue;    }
    return FALSE;  }
  if (message == WM_NOTIFY)
  {  NMHDR* pNMHDR = (NMHDR*)lParam;
    if (pNMHDR->hwndFrom != NULL && OnNotify(wParam, lParam, &lResult))  goto LReturnTrue;
    return FALSE;  }
  if (message == WM_ACTIVATE)  _AfxHandleActivate(this, wParam, CWnd::FromHandle((HWND)lParam));
  ...
}
CWnd::OnWndMsg()函数的功能首先按字节对消息进行排序，对于WM_COMMAND消息，调用OnCommand()消息响应函数，对于WM_NOTIFY消息调用OnNotify()消息响应函数。任何被遗漏的消息将是一个窗口消息。OnWndMsg()函数搜索类的消息映像，以找到一个能处理任何窗口消息的处理函数。
如果OnWndMsg()函数不能找到这样的处理函数的话，则把消息返回到WindowProc()函数，由它将消息发送给DefWindowProc()函数。

CWnd::OnWndMsg 部分反汇编代码:
73D31D0C >  MOV EAX,MFC42.73DC2E0A
73D31D11    CALL MFC42.__EH_prolog        ; JMP 到 MSVCRT._EH_prolog
...
73D31D1E    MOV EBX,DWORD PTR SS:[EBP+8]  ;取出message参数
...
73D31D23    CMP EBX,111          ;是否为WM_COMMAND消息
73D31D29    MOV EDI,ECX
73D31D2B    JE MFC42.73D31DBE
...
73D31DBE    PUSH DWORD PTR SS:[EBP+10]
73D31DC1    MOV EAX,DWORD PTR DS:[EDI]
73D31DC3    PUSH DWORD PTR SS:[EBP+C]
73D31DC6    CALL DWORD PTR DS:[EAX+80] ; <D1.?OnCommand@CWnd@@  mfc42:MFC42.DLL>
...
提示：
73D31DC6    CALL DWORD PTR DS:[EAX+80]，也是对点击按钮之类的WM_COMMAND消息设置断点较好的切入点，这里可以直接F2设置断点，更为方便，因为，只有在WM_COMMAND消息下，才有可能执行这条语句。

14. CWnd::OnCommand函数
BOOL CWnd::OnCommand(WPARAM wParam, LPARAM lParam)
{
  UINT nID = LOWORD(wParam);
  HWND hWndCtrl = (HWND)lParam;
  int nCode = HIWORD(wParam);
  ...
  return OnCmdMsg(nID, nCode, NULL, NULL);  //通过虚函数调用，直接进入了重载的的CD2Dlg::OnCmdMsg函数
}
该函数查看这是不是一个控件通知(lParam参数不为NULL，如果lParam参数为空的话，说明该消息不是控件通知)，如果它是，OnCommand()函数会试图将消息映射到制造通知的控件；如果他不是一个控件通知(或者如果控件拒绝映射的消息)OnCommand()就会调用OnCmdMsg()函数

CWnd::OnCommand()函数部分反汇编代码:
73D3291C >  PUSH EBP
73D3291D    MOV EBP,ESP
73D3291F    SUB ESP,2C
73D32922    MOV EAX,DWORD PTR SS:[EBP+8]
…
73D3296B    PUSH EBX
73D3296C    PUSH EBX
73D3296D    MOV ECX,ESI
73D3296F    PUSH DWORD PTR SS:[EBP+8]
73D32972    PUSH EDI
73D32973    CALL DWORD PTR DS:[EAX+14]    ;<D1.?OnCmdMsg@CDialog@@   mfc42:MFC42.DLL>
73D32976    POP EDI
73D32977    POP ESI
73D32978    POP EBX
73D32979    LEAVE
73D3297A    RETN 8
提示：
在函数入口处，同样可以F2直接设置断点，定位WM_COMMAND消息。

15. CD2Dlg::OnCmdMsg函数(如果重载了的话)
BOOL CD2Dlg::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{   ...
  return CDialog::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}

16. CDialog::OnCmdMsg()函数：
BOOL CDialog::OnCmdMsg(UINT nID, int nCode, void* pExtra,AFX_CMDHANDLERINFO* pHandlerInfo)
{
  if (CWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))  //从这里直接进入了CCmdTarget::OnCmdMsg()
    return TRUE;
  ...
}
CDialog::OnCmdMsg()函数部分反汇编代码:
73D38FAA >  PUSH EBP
73D38FAB    MOV EBP,ESP
…
73D38FBB    PUSH DWORD PTR SS:[EBP+10]
73D38FBE    PUSH EDI
73D38FBF    PUSH EBX
73D38FC0    CALL MFC42.#4424_?OnCmdMsg@CCmdTarget@@UAEHIHPAXPAUAFX_CMD>    ; CCmdTarget::OnCmdMsg()
73D38FC5    TEST EAX,EAX
73D38FC7    JNZ SHORT MFC42.73D38FE6
…
73D38FD8    RETN 10
对话框的OnCmdMsg其实也是重载了CCmdTarget::OnCmdMsg()函数。

17. CCmdTarget::OnCmdMsg()函数
BOOL CCmdTarget::OnCmdMsg(UINT nID, int nCode, void* pExtra,AFX_CMDHANDLERINFO* pHandlerInfo)
{  const AFX_MSGMAP* pMessageMap;
  const AFX_MSGMAP_ENTRY* lpEntry;
  UINT nMsg = 0;
  nMsg = HIWORD(nCode);
  nCode = LOWORD(nCode);
  if (nMsg == 0)  nMsg = WM_COMMAND;
  //查看消息映射是否自己所需
for (pMessageMap = GetMessageMap(); pMessageMap != NULL;pMessageMap = (*pMessageMap->pfnGetBaseMap)())
  {  lpEntry = AfxFindMessageEntry(pMessageMap->lpEntries, nMsg, nCode, nID);
    if (lpEntry != NULL)
    {   //有匹配的消息映射时，会进行如下调用:
      return _AfxDispatchCmdMsg(this, nID, nCode,lpEntry->pfn, pExtra, lpEntry->nSig, pHandlerInfo);
    }  }
  return FALSE; }
根据接收消息的类，OnCmdMsg()函数将在一个称为命令传递(Command Routing)的过程中潜在的传递命令消息和控件通知。例如：如果拥有该窗口的类是一个框架类，则命令和通知消息也被传递到视图和文档类，并为该类寻找一个消息处理函数。
CCmdTarget是MFC消息映射体系结构的基类。正是通过这个体系结构，才将命令或者消息映射到开发人员所写的命令处理函数或者消息响应函数。
OnCmdMsg()实际上是CCmdTarget的成员函数，而不是CWnd的成员函数。认实这一点很重要，因为它允许任何从CCmdTarget派生的类接收一个命令消息，即使那些没有一个窗口的类也可以。如，当你跟踪MFC的SDI或MDI程序消息流程时，会发现没有窗口的文档类处理消息时，也会重载OnCmdMsg()函数，使它能为文档模板类提供命令消息。

73D3223C >  PUSH EBP
73D3223D    MOV EBP,ESP
…
73D32267    CALL DWORD PTR DS:[EAX+30]  ; GetMessageMap 得到消息映射表地址
…
73D3227A    CALL MFC42.#1145_?AfxFindMessageEntry@@YGPBUAFX_MSGMAP_ENT>   ;寻找消息函数
73D3227F    TEST EAX,EAX
73D32281    JNZ SHORT MFC42.73D32296      ; 找到，则转
…
73D32296    PUSH DWORD PTR SS:[EBP+14]
73D32299    PUSH DWORD PTR DS:[EAX+10]
73D3229C    PUSH DWORD PTR SS:[EBP+10]
73D3229F    PUSH DWORD PTR DS:[EAX+14]    ;这个[EAX+14]就是消息函数的地址
73D322A2    PUSH DWORD PTR SS:[EBP+C]
73D322A5    PUSH DWORD PTR SS:[EBP+8]
73D322A8    PUSH EDI
73D322A9    CALL MFC42.73D3233C        ;调用_AfxDispatchCmdMsg这个函数
…
这里GetMessageMap() 和 AfxFindMessageEntry() 两个函数就是搜索查寻消息函数在消息映射表中的位置，从而找出消息函数的地址。关于这个两个函数代码分析，及消息映射表的结构，本文就不分析了(分析起来，又要里嗦地说了一大堆)。有兴趣者可自行参考相关资料，网上很多(看雪论坛精华集上也有很多这方面的资料，而且写得很不错)。

提示：
个人认为，对于对话框程序，在这个函数函数入口处设置断点最好(请记住这个函数：CCmdTarget::OnCmdMsg())，因为：
一、不用设置条件断点，只有在发生WM_COMMAND消息后，才运行到此。
二、而且再继续往下运行到73D3229F    PUSH DWORD PTR DS:[EAX+14]，就得到了消息函数的地址。
或者，也可以往下到 73D322A9    CALL MFC42.73D3233C语句时F7跟进，再往下执行几条语句，就很容易来到WM_COMMAND消息函数代码处。见下面说明。

跟进73D3233C,执行几条语句，经过几次跳转后，很快就定位到了按钮事件代码处：
73D3233C    PUSH EBP
73D3233D    MOV EBP,ESP
...
73D3234E    CMP EAX,28
73D32351    JBE SHORT MFC42.73D32390
73D32353    SUB EAX,29
73D32356    JE MFC42.73D8E55B
73D3235C    SUB EAX,3
73D3235F    JNZ MFC42.73D8E52F
…
73D3239E    SUB EAX,0A
73D323A1 >  JE SHORT MFC42.73D323D2
73D323A3    DEC EAX
73D323A4    JE MFC42.73D8E4FD
73D323AA    SUB EAX,16
73D323AD    JE SHORT MFC42.73D323C8
73D323AF    SUB EAX,3
73D323B2    JNZ MFC42.73D8E4E7
…
73D323D2    MOV ECX,DWORD PTR SS:[EBP+8]  ; Case C of Switch XXXXXXXX
73D323D5    CALL DWORD PTR SS:[EBP+14]    ; D1.?OnButton1@CD1Dlg@@IAEXXZ D1Dlg.obj  进入按钮函数代码
73D323D8  ^ JMP SHORT MFC42.73D3237B
其实上面一段代码就是_AfxDispatchCmdMsg函数。

18. _AfxDispatchCmdMsg()函数(反汇编代码见上), 找到按钮消息函数处
AFX_STATIC BOOL AFXAPI _AfxDispatchCmdMsg(CCmdTarget* pTarget, UINT nID, int nCode,
  AFX_PMSG pfn, void* pExtra, UINT nSig, AFX_CMDHANDLERINFO* pHandlerInfo)
{  union MessageMapFunctions mmf;
  mmf.pfn = pfn;
  BOOL bResult = TRUE;
  switch (nSig)
  {
  case AfxSig_vv:
    // normal command or control notification
    ASSERT(CN_COMMAND == 0);        // CN_COMMAND same as BN_CLICKED
    ASSERT(pExtra == NULL);
    (pTarget->*mmf.pfn_COMMAND)();  //从这里执行下面的CD2Dlg::OnButton1()函数
    break;
  case AfxSig_bv:
    ...
  ...
}
这里，通过调用全局函数_AfxDispatchCmdMsg，来调用具体的消息处理函数。这样便完成了从产生消息到调用消息响应函数的全过程。其参数分别介绍如下。
pTarget：该参数是指向处理消息的对象。
nID：该参数是命令ID。
nCode：该参数是通知消息等，对于一个命令消息，该变量将赋值为CN_COMMAND(相当于0)。
pfn：该参数是消息处理函数地址。
pExtra：该参数用于存放一些有用的信息，它取决于当前正被处理的消息类型。如果是控件通知WM_NOTIFY，则是指向NMHDR的AFX_NOTIFY结构的指针；如果是菜单项和工具栏更新，则它是指向CCmdUI派生类的指针；如果是其他类型，则为空。
nSig：该参数定义消息处理函数的调用变量。在AFXMSG_.H中，为nSig预定义了60多个值，例如，nSig值为iww，则在调用消息处理函数前，使OnWndMsg()格式化wParam和lParam为两个UINT变量，返回值为整型。
pHandlerInfo：该参数是一个指针，指向AFX_CMDHANDLERINFO结构。
前6个参数（除了pExtra以外）都是输入参数，而参数pExtra和pHandlerInfo既可以用作输出参数，也可以用作输入参数。
该函数主要完成的任务是：首先，它检查参数pHandlerInfo是否空，如果不空，则用pTarget和pfn填充它所指向的结构，并且返回TRUE；其次，如果pHandlerInfo空，则进行消息处理函数的调用。它根据参数nSig的值，把参数pfn的类型转换为要调用的消息处理函数的类型。
如果在视图中没有找到相应的消息处理函数，则将会交由文档类来进行处理。

19. 执行我们的按钮消息函数
void CD1Dlg::OnButton1() {  AfxMessageBox("OK");  }

注：
    MFC另外两种常见的框架程序，SDI和MDI程序，其消息流程分析同此类似，其间过程大同小异，我就不再分析了。有兴趣者，可自行分析，这里只是提一下注意之点：
1.  对于SDI/MDI程序，最好在CWnd::OnCommand()函数入口处，设置断点，然后跟进CCmdTarget::OnCmdMsg()函数，就很快找到消息函数地址了。
2.  若要在CCmdTarget::OnCmdMsg()函数入口处设置断点。必须设置条件断点，如[esp+4]==3e8, 这里3e8是按钮的ID值。由于在SDI和MDI程序正常运行时，经常有文档类，框架类消息从此流过，设置条件断点后，会引起OD运行特别慢。所以，如果确实要在此处设置断点，注意：在需要设置断点时再设置断点，OD中断后，马上取消断点！

附录：MFC对Windows消息的截获过程

MFC在调用对话框的DoModal函数之时,在PreModal内部调用了AfxHookWindowCreate()函数(对于SDI/MDI程序，是在调用CWnd::CreateEx()函数里面),这是一个安装WH_CBT类型钩子的函数。安装WH_CBT类型的钩子过程后，系统在下列情况下将会首先调用此函数：激活窗口，创建或销毁窗口，最大化或最小化窗口，移动或缩放窗口，完成一个系统命令，从系统的消息队列里移除一个鼠标或者键盘事件，设置键盘，设置输入焦点或者同步系统消息队列事件等。安装钩子后，窗口的消息走向就要发生变化。
安装构子函数AfxHookWindowCreate()源码如下：
void AFXAPI AfxHookWindowCreate(CWnd* pWnd)
{
  _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
  if (pThreadState->m_pWndInit == pWnd)  return;
  if (pThreadState->m_hHookOldCbtFilter == NULL)
  {
    pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT,  _AfxCbtFilterHook, NULL, ::GetCurrentThreadId());
    if (pThreadState->m_hHookOldCbtFilter == NULL) AfxThrowMemoryException();
  }
  pThreadState->m_pWndInit = pWnd;
}

继续观察其中钩子过程的地址_AfxCbtFilterHook的源码，部分源码如下：
LRESULT CALLBACK _AfxCbtFilterHook(int code, WPARAM wParam, LPARAM lParam)
{   _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
    if (code != HCBT_CREATEWND)
    {      // 等待HCBT_CREATEWND通过其他的钩子
           return CallNextHookEx(pThreadState->m_hHookOldCbtFilter, code, wParam, lParam);
    }
    …
    if (!afxData.bWin4 && !bContextIsDLL && (pCtl3dState = _afxCtl3dState.GetDataNA()) != NULL &&  pCtl3dState->
m_pfnSubclassDlgEx != NULL &&   (dwFlags = AfxCallWndProc(pWndInit, hWnd, WM_QUERY3DCONTROLS)) != 0)
    {       // 窗口类注册是用AfxWndProc进行的吗?
            WNDPROC afxWndProc = AfxGetAfxWndProc();
            BOOL bAfxWndProc = ((WNDPROC)GetWindowLong(hWnd, GWL_WNDPROC) == afxWndProc);
            pCtl3dState->m_pfnSubclassDlgEx(hWnd, dwFlags);
            if (!bAfxWndProc)    //如果还没有编排到AfxWndProc则用AfxWndProc子类化窗口
            {                 //用标准的AfxWndProc子类化窗口
                   oldWndProc = (WNDPROC)SetWindowLong(hWnd, GWL_WNDPROC,
                        (DWORD)afxWndProc);
                   *pOldWndProc = oldWndProc;     //保存原窗口过程
            }
    }
    …
}
从钩子函数中可以看到，如果它检测到注册窗口类时，使用的窗口过程不是AfxWndProc函数，则它将用此函数替代，并且通过这个设置，在调用::CreateWindowEx后，将原窗口过程保存在窗口类的成员变量m_pfnSuper中，这样就形成了一个窗口过程链。在需要的时候，原窗口过程地址可以通过窗口类成员函数GetSuperWndProcAddr获得。

这样，AfxWndProc就成为CWnd或其派生类的窗口过程。不论队列消息还是非队列消息，都将首先送到AfxWndProc窗口过程进行处理。经过消息分发之后仍没有被处理的消息，将送给原窗口过程处理。

注册时所使用的窗口过程果真不是AfxWndProc，而是DefWindowProc，因此钩子函数将完成这一替换任务。而调用函数AfxGetAfxWndProc所返回的结果正是函数AfxWndProc的地址，从其定义便可知这一事实：

WNDPROC AFXAPI  AfxGetAfxWndProc()
{
#ifdef _AFXDLL
      return AfxGetModuleState()->m_pfnAfxWndProc;
#else
      return &AfxWndProc;
#endif
}

至此，相信各位能够明白DispatchMessage最终将消息发到了AfxWndProc函数里，而非DefWindowProc里。AfxWndProc的作用是截获所有发送给窗口的消息（包括队列消息和非队列消息），所以实质上它是一个窗口消息分发器。
==============================================================================================

结束语：
我们的消息之旅到此结束了。相信各位仔细看完之后，不会再MFC的消息流程感到迷惑。MFC的消息就是沿着固定的路线，中间可能有分支，沿途经过一二十个站点，就能到达目的地 -- 消息函数地址处了。
各位看完之后，若有不明白或疑问之处，我很乐意同大家进行探讨！
这篇文章中我没有进行公式性条款归纳，因为我觉得没有这个必要，只要理解了MFC的这种消息处理机制，比任何归纳都重要。就可以从任意一个MFC函数切入，随意跟踪MFC程序，以不变应万变，任你程序消息函数处理如何隐藏，如何变化多端。我们都可以揪出来。
最后，本文肯定仅在很多不当和失误之处，若能得到各位高手指点一二，我的这份辛苦也不算白费了。

作者：szdbg
E-mail：szdbg@sina.com
【版权声明】本文原创于看雪论坛，纯属技术交流, 转载请注明作者并保持文章的完整, 谢谢!
2007-11-1