iocp_class.cpp

一个完成端口的框架程序

                 MB_OK|MB_ICONERROR|MB_APPLMODAL|MB_SETFOREGROUND|MB_TOPMOST);
      return false;
   }

   //监听
   if(listen(sock,64)==SOCKET_ERROR)
   {
      char Msg[MAX_PATH];
      memset(Msg,0,MAX_PATH);
      sprintf(Msg,
              "Listen Error[Address:%s,Port:%d]\r\nwith Error Code (WSA:%d,Error:%d)!",
              (strlen(FBindAddress)>0?FBindAddress:"Inaddr_Any"),
              FPort,
              BufferSize,
              WSAGetLastError(),
              GetLastError());
      closesocket(sock);
      MessageBox(GetActiveWindow(),
                 Msg,
                 "Socket Error",
                 MB_OK|MB_ICONERROR|MB_APPLMODAL|MB_SETFOREGROUND|MB_TOPMOST);
      return false;
   }
   FListenSock=sock;
   return true;
}

//Create Listen Socket to do accept loop
//创建监听线程
bool __fastcall TtcpIOCP::CreateListenThread(void)
{
   unsigned long Result;
   unsigned  ThreadID;
   if(NULL!=FListenThread)
      return false;
   FListenThread=(HANDLE)_beginthreadex(NULL,
                                        0,
                                        ListenerThread,
                                        this,
                                        CREATE_SUSPENDED,
                                        &ThreadID);
   if(NULL==FListenThread)
   {
      char Msg[MAX_PATH];
      memset(Msg,0,MAX_PATH);
      sprintf(Msg,
              "Can not complete with create thread!(Error:%d)\r\nThread terminate later...",
              GetLastError());
      MessageBox(GetActiveWindow(),
                 Msg,
                 "Thread Error",
                 MB_OK|MB_ICONERROR|MB_APPLMODAL|MB_SETFOREGROUND|MB_TOPMOST);
      ExitThread(-1);
      return false;
   }
   Result=ResumeThread(FListenThread);
   if(Result==0xFFFFFFFF)
   {
      TerminateThread(FListenThread,1);
      CloseHandle(FListenThread);
      char Msg[MAX_PATH];
      memset(Msg,0,MAX_PATH);
      sprintf(Msg,
              "Can not resume thread(%d)!(Error:%d)\r\nThread terminate later...",
              ThreadID,
              GetLastError());
      MessageBox(GetActiveWindow(),
                 Msg,
                 "Thread Error",
                 MB_OK|MB_ICONERROR|MB_APPLMODAL|MB_SETFOREGROUND|MB_TOPMOST);
      ExitThread(-1);
      FListenThread=NULL;
      return false;
   }
   return true;
}
//set the Listen thread to sleep,
//but no affect other communications
bool __fastcall TtcpIOCP::PauseListen(void)
{
   if(FListenSock==INVALID_SOCKET)
      return false;
   if(NULL==FListenThread)
      return false;
   if(LS_WORK!=RunningState)
      return false;
   FTuningListenState=LS_PAUSE;
   //发送空连接以使accept返回
   TempConnect(FBindAddress,Port);
   if(RunningState==FTuningListenState)
   {
      DWORD Result=SuspendThread(FListenThread);
      if(Result==0xFFFFFFFF)
      {
         DWORD ExitCode;
         if(GetExitCodeThread(FListenThread,&ExitCode))
            if(GetLastError()==STILL_ACTIVE)
               return false;
         CloseHandle(FListenThread);
         FListenThread=NULL;
         return false;
      }
   }
   return RunningState==FTuningListenState;
}
//set the listen thread work on,
//no effect with the listen thread wasn't sleeping
//恢复暂停的监听线程
bool __fastcall TtcpIOCP::ResumeListen(void)
{
   if(FListenSock==INVALID_SOCKET)
      return false;
   if(NULL==FListenThread)
      return false;
   if(LS_PAUSE!=RunningState)
      return false;
   FTuningListenState=LS_WORK;
   ResumeThread(FListenThread);
   return RunningState==FTuningListenState;
}

//close the listen thread
//关闭监听线程
void __fastcall TtcpIOCP::DestroyListenThread(void)
{
   if(NULL==FListenThread)
      return;
   FTuningListenState=LS_SHUTDN;
   if((LS_WORK==RunningState)&&(FListenSock!=INVALID_SOCKET))
   {
     //发送空连接以使accept返回
     TempConnect(FBindAddress,Port);
   }
   DWORD ExitCode;
   GetExitCodeThread(FListenThread,&ExitCode);
   if(ExitCode==STILL_ACTIVE)
   {
      //TerminateThread(FListenThread,0);
      WaitForSingleObject(FListenThread,INFINITE);
   }
   CloseHandle(FListenThread);
   FListenThread=NULL;
}

//close the listen socket
//关闭监听Socket
void __fastcall TtcpIOCP::DestroyListenSock(void)
{
   if(FListenSock==INVALID_SOCKET)
      return;
   /*关闭Socket前，先关闭监听线程*/
   if(NULL!=FListenThread)
   {
      DestroyListenThread();
   }
   ForceCloseSocket(FListenSock,true);
   FListenSock=INVALID_SOCKET;
   FTuningListenState=LS_CLOSED;
   FRunningState=LS_CLOSED;
}

/*For Purifier Thread*/
//Create the Purifier Thread loop
//运行时脉线程
bool __fastcall TtcpIOCP::CreatePurifierTimer(void)
{
   if(!FIOCPInvalid)
      return false;
   if(NULL!=FPurifierTimer)
      return true;
   if(TIMERR_NOERROR!=timeBeginPeriod(100))
      return false;
   UINT fuEvent=TIME_PERIODIC;
   if(WinVersion>=0x501)//WinXP or Later
      fuEvent|=TIME_KILL_SYNCHRONOUS;
   FPurifierTimer=timeSetEvent(1000,
                               100,
                               PurifierTimerProc,
                               (DWORD_PTR)this,
                               fuEvent);
   if(NULL==FPurifierTimer)
   {
      timeEndPeriod(1);
      return false;
   }
   return true;
}

//Terminate the Purifier Thread loop
//删除时脉线程
void __fastcall TtcpIOCP::DestroyPurifierTimer(void)
{
   if(NULL==FPurifierTimer)
      return;
   timeKillEvent(FPurifierTimer);
   timeEndPeriod(1);
   FPurifierTimer=NULL;
}

//总连接数，包括未清理的坏连接
unsigned int __fastcall TtcpIOCP::GetCount(void)
{
   return FConnectionList.size()+
		  FrecycleConnectionList.size();
}
//有效连接数
UINT __fastcall TtcpIOCP::GetValidCount(void)
{
   return FConnectionList.size();
}

//工作线程数
UINT  __fastcall TtcpIOCP::GetThreadCount(void)
{
   return FThreadList.size();
}

/*For Server Thread*/
//tune the service state to vState Value
//调节服务状态
//所有状态由此调度，线程数量的调节除外
bool __fastcall TtcpIOCP::SetRunningState(const TEnumListenState vState)
{
   if(RunningState!=TuningListenState)
      return false;
   if(RunningState==vState)
      return true;
   switch(RunningState)
   {
      case LS_CLOSED: /*关闭状态*/
           if(LS_WORK!=vState)
              return false;
           break;
      case LS_SHUTDN: /*预关闭态*/
           if(LS_CLOSED!=vState)
              return false;
           break;
      case LS_PAUSE:  /*暂停状态*/
           break;
      case LS_WORK:   /*工作状态*/
           break;
   }
   FTuningListenState=vState;
   switch(FTuningListenState)
   {
      case LS_WORK:
           if(INVALID_SOCKET==ListenSock)
           {
              if(!CreateListenSock())
              {
                 FTuningListenState=RunningState;
                 return false;
              }
           }
           if(NULL==FListenThread)
           {
              if(!CreateListenThread())
              {
                 FTuningListenState=RunningState;
                 return false;
              }
           }
           if(LS_PAUSE==RunningState)
           {
              if(!ResumeListen())
                 return false;
           }
           SetExpectThread(ExpectThreadCount);
           break;
      case LS_PAUSE:
           if(!PauseListen())
              return false;
   }
   return true;
}

//Set Port value as vPort
//if it is listening,no effect,
//an false value will be returned
//设置服务端口
bool __fastcall TtcpIOCP::SetServicePort(const int vPort)
{
   if(LS_CLOSED!=RunningState)
      return false;
   FPort=vPort;
   return true;
}

//设置最大连接数，限制1~2147483647
void __fastcall TtcpIOCP::SetMaxConnections(const UINT Count)
{
   if(Count<1||Count>2147483647)
	  return;
   FMaxConnections=Count;
}

//Set Bind Address Value,
//any valid local address by default
//设置绑定地址
//暂不支持多地址绑定
bool __fastcall TtcpIOCP::SetBindAddress(const char vBindAddress[])
{
   char InternalAddress[MAX_PATH];
   if(LS_CLOSED!=RunningState)
      return false;
   int iLen=strlen(vBindAddress);
   if(iLen>MAX_PATH)
      return false;
   memset(InternalAddress,0,MAX_PATH);
   if(!ResolveHost(vBindAddress,InternalAddress))
      return false;
   iLen=strlen(InternalAddress);
   memcpy(FBindAddress,InternalAddress,iLen);
   FBindAddress[iLen]='\0';
   return true;
}

//Getting binding address
//取得绑定的IP地址
//
//参数:
//vBuffer:接收字符串缓冲区，当BufferLenth为0时，只返回地址实际长度
//BufferLength:接收字符串缓冲区大小,如果缓冲区过小，可能无法接受完全地址，最好提供16Bytes
//返回值:返回实际绑定地址的长度。0表示使用所有本地地址
unsigned int __fastcall TtcpIOCP::GetBindAddress(char *vBuffer,const unsigned int BufferLength)
{
   UINT Result=strlen(FBindAddress);
   if(0==Result||0==BufferLength)
      return Result;
   if(BufferLength<Result)
      Result=BufferLength;
   memcpy(vBuffer,FBindAddress,Result);
   if(Result<BufferLength)
      vBuffer[Result]='\0';
   return Result;
}

/*要对一个Connection并保存Connection的有效性，就必须要进行Lock*/
//进入临界区并增加Lock计数
UINT __fastcall TtcpIOCP::Lock()
{
   EnterCriticalSection(&conn_CriticalSection);
   FLocks++;   
   return FLocks;
}
//退出临界区并减少Lock计数
UINT __fastcall TtcpIOCP::Unlock()
{
   if(0==LockCount)
      return 0;
   FLocks--;
   LeaveCriticalSection(&conn_CriticalSection);
   return FLocks;
}