network_utility.cpp

一个完成端口的框架程序

//---------------------------------------------------------------------------


#pragma hdrstop

#include "NetWork_Utility.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)
//---------------------------------------------------------------------------
/*Create new I/O Completion Port*/
//
//[in]dwNumberOfConcurrentThreads:
// Maximum number of threads
// that the operating system can allow
// to concurrently process I/O completion packets
// for the I/O completion port.
//
//Return Value:a new I/O Completion Port Handle
//创建完成端口句柄
HANDLE CreateNewIoCompletionPort(DWORD dwNumberOfConcurrentThreads)
{
   return CreateIoCompletionPort(INVALID_HANDLE_VALUE,
                                 NULL,
                                 0,
                                 dwNumberOfConcurrentThreads);
}

/*Associate Device(socket) with I/O Completion Port*/
//[in] hComPort:
//Handle to I/O Completion Port
//将一个I/O句柄与完成端口例程绑定
bool AssociateWithIoCompletionPort(HANDLE hComPort,
                                   HANDLE hDevice,
                                   DWORD dwCompKey)
{
   return (CreateIoCompletionPort(hDevice,
                                  hComPort,
                                  dwCompKey,
                                  0)==hComPort);
}
//---------------------------------------------------------------------------
//Test if AHost is a valid IP address string
//检查一个串是否为合法的IP地址串
 bool __fastcall IsIP(const char *AHost)
{
   int iLen=strlen(AHost);
   if(iLen<7||iLen>15)
      return false;
   char TestIP[17];
   memcpy(TestIP,AHost,iLen);
   int DotCount=0;
   TestIP[iLen]='.';
   int TestDigit=0;
   for(int i=0;i<=iLen;i++)
   {
      if((TestIP[i]<'0'||TestIP[i]>'9')&&
         (TestIP[i]!='.'||i==0))
         return false;
      if(TestIP[i]=='.')
      {
         if(TestDigit>255||TestDigit<0)
            return false;
         if(TestIP[i-1]=='.')
            return false;
         TestDigit=0;
         DotCount++;
      }
      else
      {
         TestDigit=TestDigit*10+(TestIP[i]-48);
      }
   }
   return DotCount==4;
}
 bool __fastcall IsIP2(const char *AHost)
{
   int iLen=strlen(AHost);
   if(iLen<7||iLen>15)
      return false;
   char TestIP[17];
   memset(TestIP,0,17);
   int IP[4]={256,256,256,256};
   sscanf(AHost,"%d.%d.%d.%d%s",&IP[0],&IP[1],&IP[2],&IP[3],TestIP);
   return IP[0]<256
        &&IP[1]<256
        &&IP[2]<256
        &&IP[3]<256
        &&(strlen(TestIP)==0);
}
//Resolvehost from AHost to IP Address stored to DestIP String
//地址解析
bool __fastcall GetHostByName(const char AHost[],char *DestIP)
{
   WSADATA WSADat;
   struct hostent* Host;
   if(WSAStartup(WINSOCK_VERSION,&WSADat)!=0)
      return false;
   try
   {
      Host=gethostbyname(AHost);
      sprintf(DestIP,
              "%d.%d.%d.%d\0",
              (unsigned char)(Host->h_addr_list[0][0]),
              (unsigned char)(Host->h_addr_list[0][1]),
              (unsigned char)(Host->h_addr_list[0][2]),
              (unsigned char)(Host->h_addr_list[0][3]));
   }
   __finally
   {
      WSACleanup;
   }
   return IsIP(DestIP);
}

//Resolvehost from AHost to IP Address stored to DestIP String
//test It is Local Address
//地址解析,析出本地地址
bool __fastcall ResolveHost(const char AHost[],char *DestIP)
{
   bool Result=true;
   if(0==stricmp(AHost, "LOCALHOST")) // this Computer
      strcpy(DestIP,"127.0.0.1");
   else
      if(0==stricmp(AHost, "(LOCAL)"))// this computer
         strcpy(DestIP,"127.0.0.1");
      else
         if(0==stricmp(AHost, "."))   // this computer
            strcpy(DestIP,"127.0.0.1");
         else
            if(IsIP(AHost))
               strcpy(DestIP,AHost);
            else
               Result=GetHostByName(AHost,DestIP);
   return Result;
}

//imitate a client role connection to the serverAddress:Port,
//force the server's listen socket return from accept-blocking
//当一个服务端监听的Socket处于accept阻塞时，发送一个连接使之返回
void __fastcall TempConnect(const char serverAddress[],
							const int Port)
{
   SOCKET TuningOffSock=INVALID_SOCKET;
   while(INVALID_SOCKET==TuningOffSock)
      TuningOffSock=socket(PF_INET,SOCK_STREAM,0);
   try
   {
      char thisAddress[255];
      memset(thisAddress,0,255);
      if(strlen(serverAddress)==0)
         ResolveHost("LOCALHOST",thisAddress);
      else
         ResolveHost(serverAddress,thisAddress);
      SOCKADDR_IN sockAddr;
      memset((void*)&sockAddr,0,sizeof(sockAddr));
      sockAddr.sin_family=AF_INET;
      sockAddr.sin_port=htons(Port);
      sockAddr.sin_addr.s_addr=inet_addr(thisAddress);
      ForceCloseSocket(TuningOffSock);
      connect(TuningOffSock,
              (LPSOCKADDR)&sockAddr,
              sizeof(sockAddr));
   }
   __finally
   {
      closesocket(TuningOffSock);
      TuningOffSock=INVALID_SOCKET;
   }
}
//强行关闭一个socket
void __fastcall ForceCloseSocket(SOCKET &s,bool bClose)
{
   bool bDontLinger=false;
   setsockopt(s,
              SOL_SOCKET,
              SO_DONTLINGER,
              (char *)&bDontLinger,
              sizeof(bool));

   linger InternalLinger;
   InternalLinger.l_onoff=1;
   InternalLinger.l_linger=0;
   setsockopt(s,
              SOL_SOCKET,
              SO_LINGER,
              (const char*)&InternalLinger,
              sizeof(linger));
  if(bClose)
  {
     closesocket(s);
     s=INVALID_SOCKET;
  }
}
//---------------------------------------------------------------------------