//根据用户输入创建一个临时内存断点

 stuPointInfo tempPointInfo;
 stuPointInfo* pResultPointInfo = NULL;
 memset(&tempPointInfo, 0, sizeof(stuPointInfo));
 tempPointInfo.lpPointAddr = lpAddr;
 tempPointInfo.ptType = MEM_POINT;
 tempPointInfo.isOnlyOne = FALSE;
 
 if (stricmp("access", pCmd->chParam2) == 0)
 {
     tempPointInfo.ptAccess = ACCESS;
 } 
 else if (stricmp("write", pCmd->chParam2) == 0)
 {
     tempPointInfo.ptAccess = WRITE;
 }
 else
 {
     printf("Void access!\r\n");
     return FALSE;
 }
 
 int nLen = (int)HexStringToHex(pCmd->chParam3, TRUE);
 
 if (nLen == 0 )
 {
     printf("Point length can not set Zero!\r\n");
     return FALSE;
 }
 
 tempPointInfo.dwPointLen = nLen;
 tempPointInfo.nPtNum = m_nOrdPtFlag;
 m_nOrdPtFlag++;
 
 //查找该内存断点在断点链表中是否已经存在
 if (FindPointInList(tempPointInfo, &pResultPointInfo, FALSE))
 {
     if (pResultPointInfo->dwPointLen >= nLen)//存在同样类型且长度大于要设置断点的断点
     {
         printf("The Memory breakpoint is already exist!\r\n");
         return FALSE;
     } 
     else//查找到的断点长度小于要设置的断点长度，则删除掉找到的断点，重新设置
         //此时只需要删除断点-分页表项 和 断点表项
     {
         DeletePointInList(pResultPointInfo->nPtNum, FALSE);
     }
 }
 
 // 根据 tempPointInfo 设置内存断点
 // 添加断点链表项，添加内存断点-分页表中记录，添加分页信息表记录
 // 首先根据 tempPointInfo 中的地址和长度获得所跨越的全部分页
 
 LPVOID lpAddress = (LPVOID)((int)tempPointInfo.lpPointAddr & 0xfffff000);
 DWORD OutAddr = (DWORD)tempPointInfo.lpPointAddr + 
         tempPointInfo.dwPointLen;
 
 MEMORY_BASIC_INFORMATION mbi = {0};
 
 while ( TRUE )
 {
     if ( sizeof(mbi) != VirtualQueryEx(m_hProcess, lpAddress, &mbi, sizeof(mbi)) )
     {
         break;
     }
 
     if ((DWORD)mbi.BaseAddress >= OutAddr)
     {
         break;            
     }
 
     if ( mbi.State == MEM_COMMIT )
     {
         //将内存分页信息添加到分页表中
         AddRecordInPageList(mbi.BaseAddress, 
                             mbi.RegionSize, 
                             mbi.AllocationProtect);
         //将断点-分页信息添加到断点-分页表中
         DWORD dwPageAddr = (DWORD)mbi.BaseAddress;
         while (dwPageAddr < OutAddr)
         {
             stuPointPage *pPointPage = new stuPointPage;
             pPointPage->dwPageAddr = dwPageAddr;
             pPointPage->nPtNum = tempPointInfo.nPtNum;
             g_PointPageList.push_back(pPointPage);
             //设置该内存页为不可访问
             DWORD dwTempProtect;
             VirtualProtectEx(m_hProcess, (LPVOID)dwPageAddr,
                 1, PAGE_NOACCESS, &dwTempProtect);
 
             dwPageAddr += 0x1000;
         }
 
     }
     lpAddress = (LPVOID)((DWORD)mbi.BaseAddress + mbi.RegionSize);
     if ((DWORD)lpAddress >= OutAddr)
     {
         break;
     }
 }
 
 //断点添加到断点信息表中
 stuPointInfo *pPoint = new stuPointInfo;
 memcpy(pPoint, &tempPointInfo, sizeof(stuPointInfo));
 g_ptList.push_back(pPoint);
printf("***Set Memory breakpoint success!***\r\n");
 

//处理访问异常部分

BOOL CDoException::DoAccessException()
{
BOOL bRet;
DWORD dwAccessAddr; //读写地址
DWORD dwAccessFlag; //读写标志
BOOL isExceptionFromMemPoint = FALSE; //异常是否由内存断点设置引起，默认为否
stuPointInfo* pPointInfo = NULL; //命中的断点
BOOL isHitMemPoint = FALSE; //是否精确命中断点
 
dwAccessFlag = m_DbgInfo.ExceptionRecord.ExceptionInformation[0];
dwAccessAddr = m_DbgInfo.ExceptionRecord.ExceptionInformation[1];
//根据 访问地址 到“断点-分页表”中去查找
//同一个内存分页可能有多个断点
//如果没有在“断点-分页表”中查找到，则说明这个异常不是断点引起的
list<stuPointPage*>::iterator it = g_PointPageList.begin();
int nSize = g_PointPageList.size();
 
//遍历链表中每个节点，将每个匹配的“断点-分页记录”都添加到g_ResetMemBp链表（需要重设的断点的内存分页信息链表）中
for ( int i = 0; i < nSize; i++ )
{
stuPointPage* pPointPage = *it;
//如果在“断点-分页表”中查找到
//再根据断点表中信息判断是否符合用户所下断点信息
if (pPointPage->dwPageAddr == (dwAccessAddr & 0xfffff000))
{
stuResetMemBp *p = new stuResetMemBp;
p->dwAddr = pPointPage->dwPageAddr;
p->nID = pPointPage->nPtNum; 
g_ResetMemBp.push_back(p);
 
//暂时恢复内存页原来的属性
BOOL bDoOnce = FALSE;
if (!bDoOnce)
{
//这些操作只需要执行一次
bDoOnce = TRUE;
isExceptionFromMemPoint = TRUE;
//暂时恢复内存页原来属性的函数
TempResumePageProp(pPointPage->dwPageAddr);
//设置单步，在单步中将断点设回
UpdateContextFromThread();
m_Context.EFlags |= TF;
UpdateContextToThread();
}
 
//先找到断点序号对应的断点
list<stuPointInfo*>::iterator it2 = g_ptList.begin();
for ( int j = 0; j < g_ptList.size(); j++ )
{
pPointInfo = *it2;
if (pPointInfo->nPtNum == pPointPage->nPtNum)
{
break;
}
it2++;
}
 
//再判断是否符合用户所下断点信息（断点类型和断点范围是否均相符）
if (isHitMemPoint == FALSE)
{
if (dwAccessAddr >= (DWORD)pPointInfo->lpPointAddr && 
dwAccessAddr < (DWORD)pPointInfo->lpPointAddr +
pPointInfo->dwPointLen)
{
if ( pPointInfo->ptAccess == ACCESS || 
(pPointInfo->ptAccess == WRITE && dwAccessFlag == 1) )
{
isHitMemPoint = TRUE;
}
}
}
}
it++;
}
 
//如果异常不是由内存断点设置引起，则调试器不处理
if (isExceptionFromMemPoint == FALSE)
{
return FALSE;
}
 
//如果命中内存断点，则暂停，显示相关信息并等待用户输入
if (isHitMemPoint)
{
ShowBreakPointInfo(pPointInfo);
//显示反汇编代码
m_lpDisAsmAddr = m_DbgInfo.ExceptionRecord.ExceptionAddress;
ShowAsmCode();
//显示寄存器值
ShowRegValue(NULL);
 
//等待用户输入
bRet = FALSE;
while (bRet == FALSE)
{
bRet = WaitForUserInput();
}
}
return TRUE;
}

//处理单步异常
BOOL CDoException::DoStepException()
{
   BOOL                    bRet;
   DWORD                  dwDr6 = 0;                //硬件调试寄存器Dr6的值
   DWORD                 dwDr6Low = 0;    //硬件调试寄存器Dr6低4位的值
   stuPointInfo               tempPointInfo;
   stuPointInfo*              pResultPointInfo = NULL;
   char                     CodeBuf[24] = {0};
 
   UpdateContextFromThread();
 
   //是否需要重设INT3断点
   if (m_isNeedResetPoint == TRUE)
   {
       m_isNeedResetPoint = FALSE;
       char chCC = (char)0xcc;
       bRet = WriteProcessMemory(m_hProcess, m_pFindPoint->lpPointAddr, 
                                 &chCC, 1, NULL);
       if (bRet == FALSE)
       {
           printf("WriteProcessMemory error!\r\n");
           return FALSE;
       }
   }
 
   //是否需要重设硬件断点
   if (m_isNeedResetHardPoint == TRUE)
   {
       m_Context.Dr7 |= (int)pow(4, m_nNeedResetHardPoint);
       UpdateContextToThread();
       m_isNeedResetHardPoint = FALSE;
   }
 
   dwDr6 = m_Context.Dr6;
   dwDr6Low = dwDr6 & 0xf; //取低4位
 
   //如果是由硬件断点触发的单步，需要用户输入才能继续
   //另外，如果是硬件执行断点，则需要先暂时取消断点，设置单步，下次再恢复断点
   if (dwDr6Low != 0)
   {
       ShowHardwareBreakpoint(dwDr6Low);
       m_nNeedResetHardPoint = log(dwDr6Low)/log(2)+0.5;//加0.5是为了四舍五入
       //判断由 dwDr6Low 指定的DRX寄存器，是否是执行断点
       if((m_Context.Dr7 << (14 - (m_nNeedResetHardPoint * 2))) >> 30 == 0)
       {
           switch (m_nNeedResetHardPoint)
           {
           case 0:
               m_Context.Dr7 &= 0xfffffffe;
               break;
           case 1:
               m_Context.Dr7 &= 0xfffffffb;
               break;
           case 2:
               m_Context.Dr7 &= 0xffffffef;
               break;
           case 3:
               m_Context.Dr7 &= 0xffffffbf;
               break;
           default:
               printf("Error!\r\n");
           }
           m_Context.EFlags |= TF;
           UpdateContextToThread();
           m_isNeedResetHardPoint = TRUE;
       }
 
       m_isUserInputStep = TRUE; //这个设置只是为了能够等待用户输入
   }
 
   if (m_isUserInputStep == FALSE)
   {
       //重设内存断点
       ResetMemBp();
       return TRUE;
   }
 
   //以下代码在用户输入为 "T" 命令、或硬件断点触发时执行
   //如果此处有INT3断点，则需要先暂时删除INT3断点
   //这样做是为了在用户输入“T”命令、或硬件断点触发时忽略掉INT3断点
   //以免在一个地方停下两次
   memset(&tempPointInfo, 0, sizeof(stuPointInfo));
   tempPointInfo.lpPointAddr = m_DbgInfo.ExceptionRecord.ExceptionAddress;
   tempPointInfo.ptType = ORD_POINT;
 
   if (FindPointInList(tempPointInfo, &pResultPointInfo, TRUE))
   {
       //非一次性断点，才需要重设断点
       if (pResultPointInfo->isOnlyOne == FALSE)
       {
           m_Context.EFlags |= TF;
           UpdateContextToThread();
           m_isNeedResetPoint = TRUE;
       }
       else//一次性断点，从链表里面删除
       {
           delete[] m_pFindPoint;
           g_ptList.erase(m_itFind);
       }
       WriteProcessMemory(m_hProcess, m_pFindPoint->lpPointAddr, 
           &(m_pFindPoint->u.chOldByte), 1, NULL);
       if (bRet == FALSE)
       {
           printf("WriteProcessMemory error!\r\n");
           return FALSE;
       }
}
 
   m_lpDisAsmAddr = m_DbgInfo.ExceptionRecord.ExceptionAddress;
   m_isUserInputStep = FALSE;
 
   //更新m_Context为现在的环境值
   UpdateContextFromThread();
 
   //显示汇编代码和寄存器信息
   ShowAsmCode();
   ShowRegValue(NULL);
 
   //重设内存断点
   ResetMemBp();
 
//等待用户输入
   bRet = FALSE;
   while (bRet == FALSE)
   {
       bRet = WaitForUserInput();
   }
   return TRUE;
}