socket cp2

最新推荐文章于 2021-07-13 17:36:20 发布
最新推荐文章于 2021-07-13 17:36:20 发布
阅读量657 收藏
点赞数
分类专栏： 通讯 文章标签： socket winapi ioc null tcp iterator

-------------cpio.h

#pragma once
#include "SocketPool.h"
#include <list>
#include <afxmt.h>
#include "dll.h"

extern IOCP_API int  g_running;
class IOCP_API CIOCP
{
public:
 CIOCP(void);
 virtual ~CIOCP(void);
public:

 // 开始服务,port 为监听的TCP端口号,工作于TCP监听状态，其他方法请重写start方法
 int Start(int port, int maxConnection);

 // 停止服务
 int Stop(void);

 //处理IOCP上的消息
 int ProcessIOCPMessage(ClientSocket* pClinetSocket, OVERLAPPEDEX* pOlex);

 //工作线程处理逻辑
 int WorkerThreadLogic(void);

 //写数据
 int WriteMessage(ClientSocket* pClinetSocket, BYTE* msg, int len,
              const BOOL bSaveSend = TRUE);

 //向一个UDP地址发送数据
 int WriteMessageTo(ClientSocket* pClinetSocket, BYTE* msg, int len, sockaddr_in& addrTo,
  const BOOL bSaveSend = TRUE);

 //受到数据
 virtual int RecvMessage(ClientSocket* pClinetSocket) = 0;


 //新收到一个连接
 virtual int NotifyNewConnect(ClientSocket* pClientSocket) = 0;

 //断开一个连接
 virtual int NotifyDisconnect(ClientSocket* pClientSocket) = 0;

 //日志
 virtual void Log(const char* msg,const LOG_PRINT__TYPE type = LOG_NOTIFY) = 0;

 //处理完成端口上接受和发送udp消息的接口函数
 virtual int ProcessUDPMessage(ClientSocket* pClientSock, OVERLAPPEDEX* pOLEX);

 //收到UDP数据
 virtual int RecvUDPMessage(ClientSocket* pClinetSocket) = 0;
 
 //当accept缓冲区消耗完时，负责添加新的缓冲区
 DWORD  AcceptExThread();

 //检查连接建立后是不是很长一短时间没有发送数据，如果是则断开连接
 DWORD  TcpLinkCheckthread();

public:
 int m_iServerPort;

protected:
 HANDLE m_hAcceptExThreadEvent; //tcp接收缓冲区消耗尽触发的事件
 DWORD m_dwThreadCount;
 HANDLE hCompletePort;
 SOCKET m_listenSocket;
 SOCKET m_udpSocket;    //udp socket
 SOCKET m_udpProxySocket;    //udp 代理 socket
 INT    m_iMaxConnections;
 CClientSocketPool m_clientSocketPool;
 std::list<OVERLAPPEDEX*> m_lstOlePool; //重叠缓存池

 std::list<OVERLAPPEDEX*> m_lstOlePoolAll; //重叠缓存池

 CCriticalSection cs; //临界内存，保证多线程安全

public:
 int CloseClientSock(ClientSocket* pClientSocket);
 //2008-9-9 add
 int AddTcpSocket( ClientSocket* pClientSock );
 int AddUDPSocket(ClientSocket* pClientSock );
protected:
 //初始化IOCP，创建ICOP句柄和开启工作线程
 BOOL InitIocp(void);
 
};

 

------------------------------cpio.cpp

 

 

#include "afx.h"
#include "IOCP.h"
#include <algorithm>
#include <Objbase.h>
IOCP_API int  g_running = FALSE;

DWORD WINAPI WorkerThreadFunc(LPVOID pParam);
DWORD WINAPI AcceptExThread(LPVOID pParam);
DWORD WINAPI TcpLinkCheckthread(LPVOID pParam);


//tcp保活时间结构体
struct tcp_keepalive {
 u_long  onoff;
 u_long  keepalivetime;
 u_long  keepaliveinterval;
};

// New WSAIoctl Options
#define SIO_RCVALL            _WSAIOW(IOC_VENDOR,1)
#define SIO_RCVALL_MCAST      _WSAIOW(IOC_VENDOR,2)
#define SIO_RCVALL_IGMPMCAST  _WSAIOW(IOC_VENDOR,3)
#define SIO_KEEPALIVE_VALS    _WSAIOW(IOC_VENDOR,4)
#define SIO_ABSORB_RTRALERT   _WSAIOW(IOC_VENDOR,5)
#define SIO_UCAST_IF          _WSAIOW(IOC_VENDOR,6)
#define SIO_LIMIT_BROADCASTS  _WSAIOW(IOC_VENDOR,7)
#define SIO_INDEX_BIND        _WSAIOW(IOC_VENDOR,8)
#define SIO_INDEX_MCASTIF     _WSAIOW(IOC_VENDOR,9)
#define SIO_INDEX_ADD_MCAST   _WSAIOW(IOC_VENDOR,10)
#define SIO_INDEX_DEL_MCAST   _WSAIOW(IOC_VENDOR,11)


CIOCP::CIOCP(void)
{
 hCompletePort = NULL;
 m_listenSocket = INVALID_SOCKET;
    m_udpSocket = INVALID_SOCKET;
 m_udpProxySocket = INVALID_SOCKET;
 
 m_iServerPort = 2000;
 m_iMaxConnections = 20000;
 m_dwThreadCount = 0;
 m_hAcceptExThreadEvent = ::CreateEvent(NULL, TRUE, FALSE, _T("AcceptExThreadEvent") );
}

/***********************************************************************************************************/
//Function: ~CIOCP
//Notes: 释构函数，将内存池m_lstOlePool的资源释放
//

/***********************************************************************************************************/
CIOCP::~CIOCP(void)
{
 //释放资源
 cs.Lock();  //加锁
 std::list<OVERLAPPEDEX*>::const_iterator itr = m_lstOlePoolAll.begin();
 for (; itr != m_lstOlePoolAll.end(); ++itr)
 {
  delete *itr;
 }
 m_lstOlePoolAll.clear();
 CloseHandle(m_hAcceptExThreadEvent);
 cs.Unlock();  //解锁

 if (hCompletePort != NULL)
 {
  Stop();
 }
}

BOOL CIOCP::InitIocp()
{
 m_dwThreadCount =  0;
 
 //运行标志置1
 InterlockedExchange((long *)&g_running, 1);
 
 //创建完成端口
 hCompletePort  = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0);
 if ( 0 == hCompletePort)
 {
  Log("创建完成端口失败!");
  return CREATE_COMPLETE_PORT_FAILURE;
 }

 SYSTEM_INFO systemInfo;
 ::GetSystemInfo(&systemInfo);
 m_dwThreadCount = systemInfo.dwNumberOfProcessors * WORKER_THREAD_PER_CPU;


 //创建Worker线程
 for (DWORD i = 0; i < m_dwThreadCount; ++i)
 {
  HANDLE h = CreateThread(NULL,0,WorkerThreadFunc,this,0,NULL);
  CloseHandle(h);
 }
 return 0;
}


// 开始服务
int CIOCP::Start(int port , int maxConnection)
{
 m_iServerPort = port;
 m_iMaxConnections = maxConnection;

 //初始化IOCP
 BOOL binit = InitIocp();
 if (binit != 0)
 {
  return binit;
 }
 //获取主机地址
 hostent*  pHostEnt = gethostbyname("");
 char*  szIpAddr = inet_ntoa(*(struct in_addr *)*pHostEnt->h_addr_list);
 int nServerip = inet_addr(szIpAddr);

 //创建Listen Socket
 m_listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 if ( INVALID_SOCKET == m_listenSocket )
 {
  Log("创建监听端口失败！");
  return CREATE_LISTEN_PORT_FAILURE;
 }

 CreateIoCompletionPort((HANDLE)m_listenSocket,hCompletePort,0,m_dwThreadCount);

 //获取AcceptEx函数指针
 GUID wsaidAcceptEx = WSAID_ACCEPTEX;    
 DWORD dwBytes = 0;
 LPFN_ACCEPTEX m_lpfnAcceptEx;
 WSAIoctl(m_listenSocket,
   SIO_GET_EXTENSION_FUNCTION_POINTER,
   &wsaidAcceptEx,
   sizeof(wsaidAcceptEx),
   &m_lpfnAcceptEx,
   sizeof(m_lpfnAcceptEx),
   &dwBytes,
   NULL,
   NULL);

 //开始Listen
 SOCKADDR_IN addr;
 memset(&addr,0,sizeof(addr));
 addr.sin_family = AF_INET;  
 addr.sin_addr.s_addr =  inet_addr("0.0.0.0"); //htonl(INADDR_ANY);  
 addr.sin_port = htons(m_iServerPort);
 bind(m_listenSocket,(PSOCKADDR)&addr,sizeof(addr));  
 int res = listen(m_listenSocket, 8);


 //当tcp没有接收缓冲区的侍候，会触发此事件
 if (m_hAcceptExThreadEvent)
 {
  ::WSAEventSelect( m_listenSocket, m_hAcceptExThreadEvent, FD_ACCEPT );
  HANDLE h = CreateThread(NULL, 0, ::AcceptExThread, this, 0, NULL);
  CloseHandle(h);
 } 

 HANDLE h = CreateThread(NULL, 0, ::TcpLinkCheckthread, this, 0, NULL);
 CloseHandle(h);

 //初始化ClientSocket池
 Log("正在初始化Client Socket池,请稍候...");
 m_clientSocketPool.Initialize(m_iMaxConnections, m_listenSocket, hCompletePort);

 Log("服务器已经启动!");
 return 0;
}

 

// 停止服务
int CIOCP::Stop(void)
{
 InterlockedExchange((long *)&g_running, 0);

 //关闭Socket池中的连接
 Log("正在关闭Client Socket池,请稍候...");
 m_clientSocketPool.Close();
 
 //关闭Listen socket
 closesocket(m_listenSocket);
 m_listenSocket = INVALID_SOCKET;

 //关闭udp socket
 closesocket(m_udpSocket);
 m_udpSocket = INVALID_SOCKET;
 
 //关闭完成端口
 if (hCompletePort != NULL)
 {
  CloseHandle(hCompletePort);
  hCompletePort = NULL ;
 }

 Log("服务器停止!");
 return 0;
}

 

int CIOCP::WorkerThreadLogic(void)
{
 DWORD bytesTransferred;
 ClientSocket* pClientSock;
 OVERLAPPEDEX* pOLEX;

 while (1 == InterlockedExchange((long *)&g_running, g_running))
 {
  pClientSock = NULL;
  BOOL rtStatus = GetQueuedCompletionStatus(hCompletePort,
             &bytesTransferred,
             (LPDWORD) &pClientSock,
             (LPOVERLAPPED*)&pOLEX,
             INFINITE);

  if ( 0 == InterlockedExchange((long *)&g_running, g_running))
  {
   break;
  }

  if ( FALSE == rtStatus )
  {
    DWORD  errCode = GetLastError();
   if ( ERROR_NETNAME_DELETED  == errCode )
   {
    if (NULL == pClientSock && NULL != pOLEX)
    {
     Log("CloseClientSock");
     m_clientSocketPool.ReleaseClientSock(pOLEX->pClientSock);
    }
    else
    {
     CloseClientSock(pClientSock);
    }
   }
   else if(ERROR_OPERATION_ABORTED != errCode ||  WAIT_TIMEOUT != errCode )
   {
    Log("GetQueuedCompletionStatus 出错！");
   }
  
   continue;
  }

  //如果是udp连接
  if ( pOLEX && pOLEX->pClientSock && pOLEX->pClientSock->bIsUPDSock)
  {
   pClientSock = pOLEX->pClientSock;
   pClientSock->bytesTransferred = bytesTransferred;
   BOOL  bReadNextMessage = ProcessUDPMessage(pClientSock, pOLEX);
   if (bReadNextMessage)  //投递下一个数据接收
   {
    DWORD flag = MSG_PARTIAL;
    DWORD ioSize = 0;
    pClientSock->olex.ioType = READ;

    //设置剩余缓冲区长度
    pClientSock->olex.wsabuf.len = DATA_BUF_LENGHT  -
     ((int)pClientSock->olex.wsabuf.buf - (int)pClientSock->olex.buf);

    int rtSend = WSARecvFrom(
     pClientSock->socket,
     &pClientSock->olex.wsabuf,
     1,
     &pClientSock->bytesTransferred,
     &flag,
     (sockaddr*)pClientSock->AddressBuffer,
     &pClientSock->iAddrLen,
     (LPOVERLAPPED)&pClientSock->olex,
     0);
   }

  }
  else if( pOLEX && pOLEX->pClientSock)
  {
   pClientSock = pOLEX->pClientSock;
   pClientSock->bytesTransferred = bytesTransferred;

   int  bReadNextMessage = TRUE;
   try
   {
    bReadNextMessage = ProcessIOCPMessage(pClientSock, pOLEX);
   }
   catch (...)
   {
    Log("处理数据包异常！");
    bReadNextMessage = TRUE;
   }
   
   
   //准备接受下一个数据包
   if ( bReadNextMessage )
   {
    DWORD flag = MSG_PARTIAL;
    DWORD ioSize = 0;
    pClientSock->olex.ioType = READ;

    //设置剩余缓冲区长度
    pClientSock->olex.wsabuf.len = DATA_BUF_LENGHT  -
     ((int)pClientSock->olex.wsabuf.buf - (int)pClientSock->olex.buf);

    int rtSend = WSARecv(pClientSock->socket,
         &pClientSock->olex.wsabuf,
         1,
         &pClientSock->bytesTransferred,
         &flag,
         (LPOVERLAPPED)&pClientSock->olex,
         0);

    if ( SOCKET_ERROR == rtSend &&
     WSA_IO_PENDING != GetLastError())
    {
     //CloseClientSock(pClientSock);    
    }

   }
  }
 }

 return 0;
}


/***********************************************************************************************************/
//Function: ProcessIOCPMessage
//Notes: 处理完成端口上接受和发送数据的函数
//
//Input:  pClientSock用户端口对象，  pOLEX重叠缓冲区指针

/***********************************************************************************************************/
//处理IOCP上的消息
int CIOCP::ProcessIOCPMessage(ClientSocket* pClientSock, OVERLAPPEDEX* pOLEX)
{
 //再上次操作中是否读了数据
 BOOL  bRecved = FALSE;

 if (pOLEX && WRITE == pOLEX->ioType)
 {
  if (pOLEX->bSaveSend)  //bSaveSend表示用安全重叠方式处理数据的发送，发送完后回收资源
  {
   cs.Lock();
   m_lstOlePool.push_back(pOLEX);
   cs.Unlock();
  }
  if (!pClientSock->bIsServer)
  {
   //CloseClientSock(pClientSock);
  }
  Log("已经发送完数据!/r/n");
  bRecved = TRUE;
 }
 else
 {
  DWORD dwRet = 0;
  switch(pClientSock->olex.ioType)
  {
  case ACCEPT:
   setsockopt(pClientSock->socket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
    (char *)&m_listenSocket, sizeof (pClientSock->socket));
   
   //设置保活时间为10秒，发送次数为2
   //struct tcp_keepalive alive;
   //alive.onoff = TRUE;
   //alive.keepalivetime = 100000;
   //alive.keepaliveinterval = 2;
   //if (WSAIoctl(pClientSock->socket, SIO_KEEPALIVE_VALS, &alive, sizeof(alive),
   // NULL, 0, &dwRet, NULL, NULL) == SOCKET_ERROR)
   //{
   // Log("WSAIotcl(SIO_KEEPALIVE_VALS) failed; %d/n");
   //}

   bRecved = NotifyNewConnect(pClientSock);
   break;

  case READ:
   if( 0 == pClientSock->bytesTransferred)
   {
    CloseClientSock(pClientSock);
    bRecved = TRUE;
   }
   else
    bRecved = RecvMessage(pClientSock);
   break;

  case WRITE:
   Log("已经发送完数据!");
   bRecved = TRUE;
   break;
        default:
   break;
  }
 }
    return ! bRecved;
}

/***********************************************************************************************************/
//Function: WriteMessage
//Notes: 发送数据包到完成端口，如果是udp则采用udp方式，如果是tcp socket则采用tcp方式发送
//
//Input:  ClientSocket* pClientSock 客户端口信息指针， BYTE* msg消息内容指针，int len数据长度，
//        const BOOL bSaveSend是否采用安全的重叠方式发送

/***********************************************************************************************************/
int CIOCP::WriteMessage(ClientSocket* pClientSock, BYTE* msg, int len, const BOOL bSaveSend)
{
 if (NULL == pClientSock || NULL == msg)
 {
  Log("套接字非法");
  return 0;
 }
 if (pClientSock->bIsUPDSock)  //如果是UPD socket，则采用UDP的方式发送
 {
  int addrlen = sizeof(sockaddr_in);
  int errCode = sendto(pClientSock->socket, (CHAR*)msg, len, 0,
              (sockaddr*)pClientSock->AddressBuffer, addrlen);
  if (errCode == SOCKET_ERROR)
  {
            errCode = GetLastError();
  }
  return errCode;
 }
 else if (!bSaveSend)
 {
  send(pClientSock->socket,(CHAR*)msg, len, 0);
  return 0;
 }
 else
 {
  if( len > DATA_BUF_LENGHT)
  {
   Log("发送的数据过长");
   return 0;
  }
  OVERLAPPEDEX* pOlex = NULL;

  //上锁
  cs.Lock();
  if (m_lstOlePool.empty())  //没有可用资源则new
  {
   pOlex = new OVERLAPPEDEX;
   m_lstOlePoolAll.push_back(pOlex);
   if (m_lstOlePoolAll.size() > 10000)//防止快速过量申请缓存
   {
    Sleep(m_lstOlePoolAll.size()/10000);
   }
  }
  else  //从缓冲池中分配
  {
   pOlex = *m_lstOlePool.begin();
   m_lstOlePool.pop_front();
  }
  cs.Unlock(); //解锁
  
  *pOlex = pClientSock->olex;

  pOlex->bSaveSend = TRUE;
  memcpy(&(pOlex->buf), msg, len);

  pOlex->ioType = WRITE;
  pOlex->wsabuf.len = len;
  pOlex->wsabuf.buf = (CHAR*)&(pOlex->buf);
  pOlex->bytesTransferred = len;


  //发送数据到客户端
  DWORD flag = MSG_PARTIAL;
  int rtSend = WSASend(pClientSock->socket,
   &pOlex->wsabuf,
   1,
   &(pOlex->bytesTransferred),
   flag,
   (LPOVERLAPPED)pOlex,
   0);

  if ( SOCKET_ERROR == rtSend &&
   WSA_IO_PENDING != GetLastError())
  {
   delete pOlex;
   CloseClientSock(pClientSock);    
  }
 }
 return 0;

}

/***********************************************************************************************************/
//Function: WriteMessage
//Notes: 向一个UDP地址发送数据
//
//Input:  ClientSocket* pClientSock 客户端口信息指针， BYTE* msg消息内容指针，int len数据长度，
//        const BOOL bSaveSend是否采用安全的重叠方式发送

/***********************************************************************************************************/
int CIOCP::WriteMessageTo(ClientSocket* pClinetSocket, BYTE* msg, int len, sockaddr_in& addrTo,
       const BOOL bSaveSend)
{
 //如果不是udp数据的套接字，则报错
 if (!pClinetSocket->bIsUPDSock)
 {
  Log("WriteMessageTo 只能发送udp数据包！");
  return 0;
 }
 if (bSaveSend)  //使用阻塞的方式发送
 {
  int addrlen = sizeof(sockaddr_in);
  int errCode = sendto(m_udpProxySocket, (CHAR*)msg, len, 0,
   (sockaddr*)&addrTo, addrlen);
  if (errCode == SOCKET_ERROR)
  {
   errCode = GetLastError();
  }
 }
 {
  if( len > DATA_BUF_LENGHT)
  {
   Log("发送的数据过长");
   return 0;
  }
  OVERLAPPEDEX* pOlex = NULL;

  //上锁
  cs.Lock();
  if (m_lstOlePool.empty())  //没有可用资源则new
  {
   pOlex = new OVERLAPPEDEX;
   m_lstOlePoolAll.push_back(pOlex);
   if (m_lstOlePoolAll.size() >= 100)
   {
    m_lstOlePool.insert(m_lstOlePool.end() ,m_lstOlePoolAll.begin() ,m_lstOlePoolAll.end());
   }
  }
  else  //从缓冲池中分配
  {
   pOlex = *m_lstOlePool.begin();
   m_lstOlePool.pop_front();
  }
  cs.Unlock(); //解锁

  *pOlex = pClinetSocket->olex;

  pOlex->bSaveSend = TRUE;
  memcpy(&(pOlex->buf), msg, len);

  pOlex->ioType = WRITE;
  pOlex->wsabuf.len = len;
  pOlex->wsabuf.buf = (CHAR*)&(pOlex->buf);
  pOlex->bytesTransferred = len;

  int addrlen = sizeof(sockaddr_in);

  //发送数据到客户端
  DWORD flag = 0;//MSG_WAITALL;
  int rtSend = WSASendTo(pClinetSocket->socket,
   &pOlex->wsabuf,
   1,
   &(pOlex->bytesTransferred ),
   flag,
   (sockaddr*)&addrTo,
   addrlen,
   (LPOVERLAPPED)pOlex,
   0);
 }
 return 0;
}

//线程函数入口
DWORD WINAPI WorkerThreadFunc(LPVOID pParam)
{
// ::CoInitializeEx(NULL,COINIT_APARTMENTTHREADED);
 ((CIOCP*)pParam)->WorkerThreadLogic(); 

 return 0;
}


int CIOCP::CloseClientSock( ClientSocket* pClientSocket )
{
 if (pClientSocket && !pClientSocket->bIsUPDSock)  //如果是tcp连接
 {
  m_clientSocketPool.ReleaseClientSock(pClientSocket);
  NotifyDisconnect(pClientSocket);
 }
 return 0;
}


/***********************************************************************************************************/
//Function: ProcessUDPMessage
//Notes: 处理完成端口上UDP接受和发送数据的函数
//
//Input:  pClientSock用户端口对象，  pOLEX重叠缓冲区指针

/***********************************************************************************************************/
//处理IOCP上的消息
int CIOCP::ProcessUDPMessage(ClientSocket* pClientSock, OVERLAPPEDEX* pOLEX)
{
 //再上次操作中是否读完了数据
 BOOL  bRecved = FALSE;
 if (pOLEX && WRITE == pOLEX->ioType)
 {
  if (pOLEX->bSaveSend)  //bSaveSend表示用安全重叠方式处理数据的发送，发送完后回收资源
  {
   cs.Lock();
   m_lstOlePool.push_back(pOLEX);
   cs.Unlock();
  }
  Log("已经发送完数据!");
  bRecved = TRUE;
 }
 else
 {
  switch(pClientSock->olex.ioType)
  {
  case READ:
   bRecved = RecvUDPMessage(pClientSock);
   break;

  case WRITE:
   Log("已经发送完UDP数据!");
   bRecved = TRUE;
   break;
  default:
   break;
  }
 }

 return !bRecved;
}

 

//增加一个TCP连接，并投递一个读操作
int CIOCP::AddTcpSocket( ClientSocket* pClientSock )
{
 if ( pClientSock )
 {
  // if (pClientSock->bIsServer)
  // {
  // clientSocketPool.SettingClientSocket(pClientSock);
  //}
  // else
  //{
  //关联完成端口
  CreateIoCompletionPort((HANDLE)pClientSock->socket, hCompletePort, (DWORD)pClientSock, 0);
  
  //异步等待Socket连接
  memset( &(pClientSock->olex) , 0, sizeof(OVERLAPPEDEX));
  
  pClientSock->bIsUPDSock = FALSE;   //设置UDP连接标志
  pClientSock->olex.pClientSock = pClientSock;
  
  pClientSock->bytesTransferred = 0;
  
  DWORD flag = MSG_PARTIAL;
  DWORD ioSize = 0;
  pClientSock->olex.ioType = READ;
  
  //设置剩余缓冲区长度
  pClientSock->olex.wsabuf.buf = pClientSock->olex.buf;
  pClientSock->olex.wsabuf.len = DATA_BUF_LENGHT;
  
  int rtSend = WSARecv(pClientSock->socket,
   &pClientSock->olex.wsabuf,
   1,
   &pClientSock->bytesTransferred,
   &flag,
   (LPOVERLAPPED)&pClientSock->olex,
   0);
  
  if ( SOCKET_ERROR == rtSend &&
   WSA_IO_PENDING != GetLastError())
  {
   return FALSE;
   //CloseClientSock(pClientSock);    
  }
  //}
  
 }
 else
 {
  return FALSE;
 }
 return TRUE;
}


int CIOCP::AddUDPSocket( ClientSocket*  pClientSock)
{
 int res = 0;
 if ( pClientSock )
 {
  SOCKET socket = pClientSock->socket;

  //关联完成端口
  CreateIoCompletionPort((HANDLE)pClientSock->socket, hCompletePort,(DWORD)pClientSock, 0);

  //准备接受数据包

  //异步等待Socket连接
  memset( &(pClientSock->olex) , 0, sizeof(OVERLAPPEDEX));
  pClientSock->olex.pClientSock = pClientSock;
  pClientSock->olex.wsabuf.buf = pClientSock->olex.buf;
  pClientSock->bytesTransferred = 0;
  pClientSock->bIsUPDSock = TRUE;   //设置UDP连接标志
  pClientSock->iAddrLen = sizeof(sockaddr_in);

  DWORD flag = MSG_PARTIAL;
  DWORD ioSize = 0;
  pClientSock->olex.ioType = READ;
  pClientSock->olex.wsabuf.len = DATA_BUF_LENGHT;

  int rtSend = WSARecvFrom(
   pClientSock->socket,
   &pClientSock->olex.wsabuf,
   1,
   &pClientSock->bytesTransferred,
   &flag,
   (sockaddr*)pClientSock->AddressBuffer,
   &pClientSock->iAddrLen,
   (LPOVERLAPPED)&pClientSock->olex,
   0);
  res = GetLastError();
  if ( SOCKET_ERROR == rtSend &&
   WSA_IO_PENDING != GetLastError())
  {
   closesocket(pClientSock->socket);
   return FALSE;
  }
  pClientSock = NULL;
 }
 return TRUE;
}

/***********************************************************************************************************/
//Function: AcceptExThread
//Notes: 处理完成端口上UDP接受和发送数据的函数

/***********************************************************************************************************/
DWORD  CIOCP::AcceptExThread()
{
 // 负责保证有足够多的 AcceptEx 可以接受连接请求的线程
 while (1 == InterlockedExchange((long *)&g_running, g_running))
 {
  DWORD dwRes = ::WaitForSingleObject( m_hAcceptExThreadEvent, INFINITE );
  if( dwRes == WAIT_FAILED )
  {
   break;
  }
  ::ResetEvent( m_hAcceptExThreadEvent );

  //当资源不够时，每次增加10个
  m_clientSocketPool.AddTCPAcceptBuff(10);
 }
 return 0;
}

/***********************************************************************************************************/
//Function: AcceptExThread
//Notes: /线程函数入口
//
/***********************************************************************************************************/
DWORD WINAPI AcceptExThread(LPVOID pParam)
{
 if (pParam)
 {
  ((CIOCP*)pParam)->AcceptExThread(); 
 }
 return 0;
}

/***********************************************************************************************************/
//Function: TcpLinkCheckthread
//Notes: /线程函数入口
//
/***********************************************************************************************************/
DWORD WINAPI TcpLinkCheckthread(LPVOID pParam)
{
 if (pParam)
 {
  ((CIOCP*)pParam)->AcceptExThread(); 
 }
 return 0;
}

/***********************************************************************************************************/
//Function: TcpLinkCheckthread
//Notes: 检查tcp连接是不是建立后没有发送数据，如果建立连接后5分钟不发送数据则自动断开

/***********************************************************************************************************/
DWORD  CIOCP::TcpLinkCheckthread()
{
 //下面方法还不能防止攻击，暂时屏蔽
 return 0;

 // 负责保证有足够多的 AcceptEx 可以接受连接请求的线程
 std::list<ClientSocket*> clientSocketList;
 int iSecs = 0;
 int iBytes =  sizeof( int );
 while (1 == InterlockedExchange((long *)&g_running, g_running))
 {
  //获取所有的连接缓冲区
  m_clientSocketPool.GetTcpClientSock(clientSocketList);
  
  std::list<ClientSocket*>::iterator itr = clientSocketList.begin();
  for (; itr != clientSocketList.end(); ++itr)
  {
   if (*itr)
   {
    iSecs = 0;
    getsockopt((*itr)->socket, SOL_SOCKET, SO_CONNECT_TIME, (char *)&iSecs, &iBytes ); 
    
    //避免一个连接占用时间过长
    if (iSecs > 6000000)
    {
     CloseClientSock(*itr);
    }
   }
  }
  //没5分钟检查一次
  Sleep(300000);
 }
 return 0;
}

mwc123mwc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Omron欧姆龙 PLC CP2E系列
06-14
Omron欧姆龙 PLC CP2E系列
【网络篇】socket编程——TCP（史上最全）
Linux驱动相关内容及Android开发
03-19 6050
（1）TCP 是面向连接的运输层协议。应用程序在使用 TCP 协议之前，必须先建立 TCP 连接。在传送数据完毕后，必须释放已经建立的 TCP 连接 （2）每一条 TCP 连接只能有两个端点，每一条 TCP 连接只能是点对点的(一对一) （3）TCP 提供可靠交付（确认机制、拥塞控制、流量控制、超时重传）的服务。通过 TCP 连接传送的数据，无差错、不丢失、不重复，并且按序到达 （4）TCP 提供全双工通信。TCP 允许通信双方的应用进程在任何时候都能发送数据。TCP 连接的两端都设有发送缓存和接受缓存
使用socket实现TCP和UDP传输
sinat_38102206的博客
05-15 4万+
转载自：https://blog.csdn.net/timmiy/article/details/51946093             https://blog.csdn.net/timmiy/article/details/52016946socket是通过TCP，UDP，IP协议来进行通信，效率较高。（一）运用TCP协议进行socket通信TCP是面向连接的，它在进行通信之前呢，需要双方先...
Socket TCP 通信简要讲解
qq_42282577的博客
07-13 3489
一、Socket理解 1、在Tcp/IP协议中，Socket即为套接字，简单点来说，就是用来唯一标识网络通讯中的一个进程。为“IP地址+TCP或UDP端口号”，这个标识的全部组成，就叫做套接字 2、在TCP协议中，客户端和服务器端，各自会生成一个套接字来将两个进程连接起来。那么这个Socket Pair 就用来唯一标识这个连接 3、Socket 可以形象用来形容网络中一对一的关系，所以在TCP/IP协议中，应用层编程接口称为Socket API ...
socket编程之实现一个简单的TCP通信
热门推荐
YANG
03-29 9万+
一、理解socket1、socket即为套接字，在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一的标识网络通讯中的一个进程，“IP地址+TCP或UDP端口号”就为socket。 2、在TCP协议中，建立连接的两个进程（客户端和服务器）各自有一个socket来标识，则这两个socket组成的socket pair就唯一标识一个连接。 3、socket本身就有“插座”的意思，因此用来形容
TCP、UDP、HTTP、SOCKET、WebSocket之间的区别
火星男孩的分享空间
06-05 3万+
TCP/IP协议栈主要分为四层:应用层、传输层、网络层、数据链路层, 每层都有相应的协议，如下图IP：网络层协议；（高速公路）TCP和UDP：传输层协议；（卡车）HTTP：应用层协议；（货物）。HTTP(超文本传输协议)是利用TCP在两台电脑(通常是Web服务器和客户端)之间传输信息的协议。客户端使用Web浏览器发起HTTP请求给Web服务器，Web服务器发送被请求的信息给客户端。SOCKET：套
CP2E指令.pdf
07-24
欧姆龙，最新PLC编程指令手册，CP2E，各种指令使用方法，详细介绍顺序输出指令，顺序输入指令，顺序控制指令，定时器计数器的指令
cp2
02-15
介绍TODO：简要介绍您的项目。 让本节解释该项目背后的目标或动机。入门TODO：指导用户启动您的代码并在自己的系统上运行。 在本节中，您可以讨论： 安装过程软件依赖最新发行API参考构建和测试待办事项：描述并显示...
cp2k manual
04-08
cp2k是基于cp方法运行从头算分子动力学的开源程序，本说明提供具体参数设置方法
CP2
03-04
是为创建的时尚，响应式博客主题。... 预览 状态 下载及安装 要开始使用此模板，请选择以下选项之一以开始使用： 通过npm安装： npm i startbootstrap-clean-blog ...用法 ... 这些是您唯一需要担心的文件，您可以忽略其他...
基于matlab实现的空间调制通信过程，包含信号调制、天线选择等发送过程，以及采用最大似然估计的检测过程 .rar
最新发布
05-02
基于matlab实现的空间调制通信过程，包含信号调制、天线选择等发送过程，以及采用最大似然估计的检测过程。.rar
基于matlab的关于生猪养殖场经营管理的研究.docx
05-02
本文档是课题研究的研究报告内含调研以及源码设计以及结果分析
网络作为特征提取器-python源码.zip
05-02
网络作为特征提取器-python源码.zip
JavaScript-javaweb项目
05-02
JavaScript-javaweb项目
node-v12.11.0-linux-arm64.tar.xz
05-02
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
仿Slideby触屏版html5响应式手机wap网站模板下载.zip
05-02
触屏版自适应手机wap软件网站模板 触屏版自适应手机wap软件网站模板
node-v10.18.1-linux-arm64.tar.xz
05-02
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
IEC 60695-11-3：2012.pdf
05-02
IEC 60695-11-3：2012.pdf
2021-2010上市公司和讯网社会责任评级CSR-股东员工客户消费者环境社会责任分项评级
05-02
上市公司和讯网社会责任评级CSR-股东责任员工责任客户消费者环境社会责任分项评级 得分（2010-2021年） "中国上市公司-和讯网社会责任数据"是 一份来自和讯网的数据集，它同步并收集了中国上市公司关于社会责任的相关信息。包括了 公司在股东责任、员工责任、供应商客户消费者权益责任、环境责任、社会责任中的表现和 成绩，以反映公司承担社会责任的程度。可以帮助大家了解公司在承担社会责任方面的具体 表现。这对于研究公司社会责任与公司业绩、公司声誉、公司风险等方面的关系具有参考意 义。 一、数据介绍 数据名称：上市公司和讯网社会责任评级CSR-股东责任员工责任 客户消费者环境社会责任分项评级得分 数据年份：2010-2021年 样本数量：每 年含2300-4600左右上市公司数据，总数据量40058条（注：因披露口径原因 ，2021年仅有430+上市公司数据） 数据格式：Excel面板数据 二、指标说 明 共计11个指标：股票名称、股票代码、年份、总得分、等级、股东责任、员工责任、 供应商客户和消费者权益责任、环境责任、社会责任、统计日期 三、部分excel数据 展示
欧姆龙cp2e socket编程
07-28
欧姆龙CP2E系列PLC可以使用Socket编程实现以太网通信。通过Socket编程，可以实现PLC与其他设备之间的数据传输和通信。例如，可以使用Socket编程实现PLC作为客户端与Modbus TCP服务器进行通信，支持多种功能码，如01...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值