BOOL CNetPTCPConnection::StartWork()
{
//PrintNetLog(0xffffffff,"(%d)Connection开始工作",GetID());
m_pEpollEventRouter->Init(this);
m_Socket.SetState(CNetSocket::SS_CONNECTED);
if(!m_Socket.EnableBlocking(FALSE))
{
OnConnection(FALSE);
PrintNetLog(0xffffffff,"(%d)Connection开始非阻塞模式失败！",GetID());
m_Socket.Close();
return FALSE;
}
if(!GetServer()->BindSocket(m_Socket.GetSocket(),m_pEpollEventRouter))
{
OnConnection(FALSE);
PrintNetLog(0xffffffff,"(%d)Connection绑定Epoll失败！",GetID());
m_Socket.Close();
return FALSE;
}
//CEasyString ConnectionName;
//ConnectionName.Format("[%s:%d]",GetRemoteAddress().GetIPString(),GetRemoteAddress().GetPort());
//SetName(ConnectionName);;
//PrintNetLog(0xffffffff,"%s连接建立[%u]",GetName(),(UINT)m_Socket.GetSocket());
OnConnection(TRUE);
return TRUE;
}
BOOL CNetPTCPConnection::OnEpollEvent(UINT EventID)
{
if(m_Socket.IsConnected())
{
if(EventID&(EPOLLERR|EPOLLHUP))
{
PrintNetLog(0xffffffff,"CNetPTCPConnection::Epoll发生错误%d！",errno);
Disconnect();
return TRUE;
}
if(EventID&EPOLLIN)
{
DoRecv();
}
if(EventID&EPOLLOUT)
{
DoSend();
}
}
else
{
PrintNetLog(0xffffffff,"(%d)Connection未连接，Epoll事件被忽略！",GetID());
}
return FALSE;
}
BOOL CIOCPFileAccessor::OpenByHandle(HANDLE FileHandle,int DataQueueSize,int RequestQueuSize,int ErrorQueuSize)
{
if(FileHandle==INVALID_HANDLE_VALUE)
{
return FALSE;
}
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
Close();
}
if(GetServer()==NULL)
return FALSE;
if(m_pIOCPEventRouter==NULL)
{
m_pIOCPEventRouter=GetServer()->CreateEventRouter();
m_pIOCPEventRouter->Init(this);
}
if(!m_DataQueue.Create(DataQueueSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建数据缓冲失败"));
return FALSE;
}
if(RequestQueuSize==0)
{
m_UseAsyncQuery=true;
PrintNetLog(0,_T("CIOCPFileAccessor::开启异步请求模式"));
}
else
{
m_UseAsyncQuery=false;
if(!m_RequestQueue.Create(RequestQueuSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建请求缓冲失败"));
return FALSE;
}
}
if(!m_ErrorQueue.Create(ErrorQueuSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建错误缓冲失败"));
return FALSE;
}
if(!GetServer()->BindFile(FileHandle))
{
return FALSE;
}
m_FileHandle=FileHandle;
m_ReadPosition.QuadPart=0;
m_WritePosition.QuadPart=0;
OnOpen();
return TRUE;
}
void CNetPTCPConnection::DoRecv()
{
CAutoLock Lock(m_RecvLock);
while(true)
{
CEpollEventObject * pEpollEventObject=GetServer()->CreateEventObject();
if(pEpollEventObject)
{
pEpollEventObject->SetType(IO_RECV);
pEpollEventObject->SetParentID(GetID());
int RecvSize=recv(
m_Socket.GetSocket(),
pEpollEventObject->GetDataBuff()->GetBuffer(),
pEpollEventObject->GetDataBuff()->GetBufferSize(),
0);
if(RecvSize>0)
{
GetServer()->AddTCPRecvBytes(RecvSize);
pEpollEventObject->GetDataBuff()->SetUsedSize(RecvSize);
OnRecvData(*(pEpollEventObject->GetDataBuff()));
GetServer()->DeleteEventObject(pEpollEventObject);
continue;
}
else if(RecvSize==0)
{
GetServer()->DeleteEventObject(pEpollEventObject);
PrintNetLog(0xffffffff,"CNetPTCPConnection收到连接关闭信号！");
Disconnect();
return;
}
else
{
GetServer()->DeleteEventObject(pEpollEventObject);
int ErrorCode=errno;
switch(ErrorCode)
{
case EAGAIN:
return;
default:
PrintNetLog(0xffffffff,"CNetPTCPConnection::Recv失败(%u),Socket关闭",ErrorCode);
Disconnect();
return;
}
}
}
else
{
PrintNetLog(0xffffffff,"CNetPTCPConnection创建Recv用EpollEventObject失败！");
Disconnect();
return;
}
}
}
BOOL CIOCPFileAccessor::QueryRead(ULONG64 StartPos,ULONG64 ReadSize)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
while(ReadSize)
{
ULONG64_CONVERTER Pos;
Pos.QuadPart=StartPos;
ULONG64 PacketSize=ReadSize;
if(PacketSize>MAX_DATA_PACKET_SIZE)
PacketSize=MAX_DATA_PACKET_SIZE;
ReadSize-=PacketSize;
COverLappedObject * pOverLappedObject=GetServer()->CreateOverLappedObject();
if(pOverLappedObject==NULL)
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::创建Write用OverLappedObject失败！"));
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL);
return FALSE;
}
pOverLappedObject->SetType(IO_FILE_READ);
pOverLappedObject->SetIOCPEventRouter(m_pIOCPEventRouter);
pOverLappedObject->GetDataBuff()->SetUsedSize((int)PacketSize);
pOverLappedObject->SetParentID(GetID());
pOverLappedObject->GetOverlapped()->Offset=Pos.LowPart;
pOverLappedObject->GetOverlapped()->OffsetHigh=Pos.HighPart;
if(m_UseAsyncQuery)
{
if(!DoOverlappedOperation(pOverLappedObject))
{
GetServer()->DeleteOverLappedObject(pOverLappedObject);
return FALSE;
}
}
else
{
if(!m_RequestQueue.PushBack(pOverLappedObject))
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::请求缓冲队列已满！"));
GetServer()->DeleteOverLappedObject(pOverLappedObject);
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL);
return FALSE;
}
}
Pos.QuadPart+=PacketSize;
}
DoNextOverlappedOperation();
return TRUE;
}
return FALSE;
}
BOOL CIOCPFileAccessor::DoOverlappedOperation(COverLappedObject * pOverLappedObject)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
if(pOverLappedObject->GetType()==IO_FILE_READ)
{
if(!ReadFile(m_FileHandle,
pOverLappedObject->GetDataBuff()->GetBuffer(),
pOverLappedObject->GetDataBuff()->GetUsedSize(),
NULL,pOverLappedObject->GetOverlapped()))
{
int ErrorCode=GetLastError();
if(ErrorCode!=ERROR_IO_PENDING)
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::发出Read请求失败%d！"),ErrorCode);
PushError(FET_SYSTEM_ERROR,ErrorCode,
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
return FALSE;
}
}
return TRUE;
}
else if(pOverLappedObject->GetType()==IO_FILE_WRITE)
{
if(!WriteFile(m_FileHandle,
pOverLappedObject->GetDataBuff()->GetBuffer(),
pOverLappedObject->GetDataBuff()->GetUsedSize(),
NULL,pOverLappedObject->GetOverlapped()))
{
int ErrorCode=GetLastError();
if(ErrorCode!=ERROR_IO_PENDING)
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::发出Write请求失败%d！"),ErrorCode);
PushError(FET_SYSTEM_ERROR,ErrorCode,
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
return FALSE;
}
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::未知的Overlapped请求%d！"),pOverLappedObject->GetType());
PushError(FET_UNKNOW,0);
return FALSE;
}
}
return FALSE;
}
BOOL CNetServer::BindFile(HANDLE FileHandle)
{
if(m_hIOCP == NULL)
{
PrintNetLog(0xffffffff,_T("(%d)完成端口没有初始化,无法绑定FileHandle！"),GetID());
return FALSE;
}
if(FileHandle == INVALID_HANDLE_VALUE)
{
PrintNetLog(0xffffffff,_T("(%d)FileHandle没有初始化,无法绑定FileHandle！"),GetID());
return FALSE;
}
HANDLE hPort = CreateIoCompletionPort(FileHandle, m_hIOCP, 0, 0 );
return TRUE;
}
BOOL CNetServer::BindSocket(SOCKET Socket)
{
if(m_hIOCP == NULL)
{
PrintNetLog(0xffffffff,_T("(%d)完成端口没有初始化,无法绑定Socket！"),GetID());
return FALSE;
}
if(Socket == INVALID_SOCKET)
{
PrintNetLog(0xffffffff,_T("(%d)Socket没有初始化,无法绑定Socket！"),GetID());
return FALSE;
}
HANDLE hPort = CreateIoCompletionPort((HANDLE)Socket, m_hIOCP, 0, 0 );
return TRUE;
}
CBaseTCPConnection * CEasyNetLinkService::CreateConnection(CIPAddress& RemoteAddress)
{
if(m_IPList.GetCount())
{
bool IsMatch=false;
for(size_t i=0;i<m_IPList.GetCount();i++)
{
if(m_IPList[i].IsMatch(RemoteAddress))
{
IsMatch=true;
break;
}
}
if(!IsMatch)
{
PrintNetLog(0xffffff,_T("连接[%s]不在IP列表中，被拒绝"),RemoteAddress.GetIPString());
return NULL;
}
}
CEasyNetLinkConnection * pConnection=NULL;
if(m_pManager)
{
pConnection=m_pManager->CreateAcceptConnection(GetReportID());
if(pConnection)
{
pConnection->SetMaxPacketSize(m_MaxPacketSize);
pConnection->EnableReallocConnectionID(NeedReallocConnectionID());
}
}
return pConnection;
}
void CNetServer::OnTerminate()
{
if( m_pIOCPThreads )
{
for( int i = 0;i < m_IOCPThreadCount;i ++ )
{
m_pIOCPThreads[i].SafeTerminate();
}
delete[] m_pIOCPThreads;
m_pIOCPThreads = NULL;
}
OnShutDown();
CloseHandle( m_hIOCP );
m_hIOCP = NULL;
if(m_OverLappedObjectPool.GetObjectCount())
{
PrintNetLog(0xffffffff,_T("(%d)关闭，开始统计OverLappedObject使用状况！"),GetID());
PrintObjectStatus();
}
m_OverLappedObjectPool.Destory();
m_EventRouterPool.Destory();
CNetSocket::NetCleanup();
}
BOOL CIOCPThread::OnRun()
{
DWORD NumberOfBytes = 0;
ULONG_PTR CompletionKey = 0;
OVERLAPPED_EX * pOverlapped=NULL;
if( GetQueuedCompletionStatus( m_hIOCP,&NumberOfBytes,&CompletionKey,(LPOVERLAPPED*)(&pOverlapped),100 ))
{
pOverlapped->pOverLappedObject->GetDataBuff()->SetUsedSize(NumberOfBytes);
pOverlapped->pOverLappedObject->SetEventID(IOE_PACKET);
pOverlapped->pOverLappedObject->Process(IOE_PACKET);
}
else
{
if(pOverlapped)
{
UINT ErrorCode=GetLastError();
if(ErrorCode!=64&&ErrorCode!=1236)
PrintNetLog(0xff,_T("IOCP返回错误%d(%d)"),
ErrorCode,
pOverlapped->pOverLappedObject->GetType());
pOverlapped->pOverLappedObject->SetErrorCode(ErrorCode);
pOverlapped->pOverLappedObject->SetEventID(IOE_ERROR);
pOverlapped->pOverLappedObject->Process(IOE_ERROR);
}
}
return TRUE;
}
BOOL CNetPTCPConnection::QuerySend(LPCVOID pData,int Size)
{
//CAutoLock Lock(m_EasyCriticalSection);
if(m_Socket.IsConnected())
{
while(Size)
{
int PacketSize=Size;
if(PacketSize>MAX_DATA_PACKET_SIZE)
PacketSize=MAX_DATA_PACKET_SIZE;
Size-=PacketSize;
CEpollEventObject * pEpollEventObject=GetServer()->CreateEventObject();
if(pEpollEventObject==NULL)
{
PrintNetLog(0xffffffff,"Connection创建Send用OverLappedObject失败！");
return FALSE;
}
pEpollEventObject->SetType(IO_SEND);
pEpollEventObject->GetDataBuff()->SetUsedSize(0);
pEpollEventObject->SetParentID(GetID());
if(!pEpollEventObject->GetDataBuff()->PushBack(pData,PacketSize))
{
GetServer()->DeleteEventObject(pEpollEventObject);
PrintNetLog(0xffffffff,"Connection要发送的数据包过大！");
return FALSE;
}
pData=(char *)pData+PacketSize;
if(!m_SendQueue.PushBack(pEpollEventObject))
{
PrintNetLog(0xffffffff,"CNetPTCPConnection::发送队列已满！");
GetServer()->DeleteEventObject(pEpollEventObject);
Disconnect();
return FALSE;
}
}
DoSend();
return TRUE;
}
return FALSE;
}
BOOL CNetServer::DeleteOverLappedObject(COverLappedObject * pOverLappedObject)
{
pOverLappedObject->Destory();
if(!m_OverLappedObjectPool.DeleteObject(pOverLappedObject->GetID()))
{
PrintNetLog(0xffffffff,_T("(%d)Server无法删除COverLappedObject(%d)！"),GetID(),pOverLappedObject->GetID());
return FALSE;
}
return TRUE;
}
void CNetServer::PrintObjectStatus()
{
int AcceptCount=0;
int RecvCount=0;
int SendCount=0;
int OtherCount=0;
LPVOID Pos=m_OverLappedObjectPool.GetFirstObjectPos();
while(Pos)
{
COverLappedObject * pObject=m_OverLappedObjectPool.GetNext(Pos);
switch(pObject->GetType())
{
case IO_RECV:
RecvCount++;
break;
case IO_SEND:
SendCount++;
break;
case IO_ACCEPT:
AcceptCount++;
break;
default:
OtherCount++;
}
}
UINT UsedCount,FreeCount;
m_OverLappedObjectPool.Verfy(UsedCount,FreeCount);
PrintNetLog(0,_T("有%d(%u,%u,%u)个OverLapped对象使用中,其中Accept=%d,Recv=%d,Send=%d,Other=%d"),
m_OverLappedObjectPool.GetObjectCount(),
UsedCount,FreeCount,UsedCount+FreeCount,
AcceptCount,
RecvCount,
SendCount,
OtherCount);
PrintNetLog(0,_T("有%d个EventRouter使用中"),m_EventRouterPool.GetObjectCount());
}
void rpc2_PrintHEntry(struct HEntry *hPtr, FILE *tFile)
{
if (tFile == NULL) tFile = rpc2_logfile; /* it's ok, call-by-value */
fprintf(tFile, "\nHost 0x%lx state is...\n\tNextEntry = 0x%lx PrevEntry = 0x%lx MagicNumber = %s\n",
(long)hPtr, (long)hPtr->Next, (long)hPtr->Prev, WhichMagic(hPtr->MagicNumber));
rpc2_printaddrinfo(hPtr->Addr, tFile);
fprintf(tFile, "\tLastWord = %ld.%06ld\n", hPtr->LastWord.tv_sec, hPtr->LastWord.tv_usec);
fprintf(tFile, "\tRTT = %ld.%03ld\n",
hPtr->RTT >> RPC2_RTT_SHIFT, hPtr->RTT % ((1 << RPC2_RTT_SHIFT) - 1));
fprintf(tFile, "\tBandwidth = out: %u:%u B/s, in: %u:%u B/s\n",
hPtr->BWlo_out, hPtr->BWhi_out, hPtr->BWlo_in, hPtr->BWhi_in);
PrintNetLog("RPC2", hPtr->RPC2_NumEntries, hPtr->RPC2_Log, tFile);
PrintNetLog("SE", hPtr->SE_NumEntries, hPtr->SE_Log, tFile);
(void) fflush(tFile);
}
BOOL CNetServer::DeleteEventRouter(CIOCPEventRouter * pEventRouter)
{
pEventRouter->Destory();
if(!m_EventRouterPool.DeleteObject(pEventRouter->GetID()))
{
PrintNetLog(0xffffffff,_T("(%d)Server无法删除CIOCPEventRouter(%d)！"),GetID(),pEventRouter->GetID());
return FALSE;
}
return TRUE;
}
CIOCPEventRouter * CNetServer::CreateEventRouter()
{
CIOCPEventRouter * pEventRouter=NULL;
UINT ID=0;
ID=m_EventRouterPool.NewObject(&pEventRouter);
if(pEventRouter)
{
pEventRouter->SetID(ID);
return pEventRouter;
}
PrintNetLog(0xffffffff,_T("(%d)Server无法创建CIOCPEventRouter！"),GetID());
return NULL;
}
bool CNetConnection::StealFrom(CNameObject * pObject,UINT Param)
{
CAutoLock Lock1(m_RecvLock);
CAutoLock Lock2(m_SendLock);
PrintNetLog(0xffffffff,"(%d)执行连接替换(%d)！",GetID(),pObject->GetID());
if(pObject->IsKindOf(GET_CLASS_INFO(CNetConnection)))
{
Destory();
if(!CNameObject::StealFrom(pObject,Param))
return false;
CNetConnection * pConnection=(CNetConnection *)pObject;
if(!m_Socket.StealFrom(&(pConnection->m_Socket),Param))
return false;
m_pServer=pConnection->m_pServer;
m_WantClose=pConnection->m_WantClose;
m_pEpollEventRouter=pConnection->m_pEpollEventRouter;
pConnection->m_pEpollEventRouter=NULL;
if(m_pEpollEventRouter)
m_pEpollEventRouter->SetEventHander(this);
CEpollEventObject * pEpollEventObject;
m_RecvQueue.Create(pConnection->m_RecvQueue.GetBufferSize());
while(pConnection->m_RecvQueue.PopFront(pEpollEventObject))
{
m_RecvQueue.PushBack(pEpollEventObject);
}
m_SendQueue.Create(pConnection->m_SendQueue.GetBufferSize());
while(pConnection->m_SendQueue.PopFront(pEpollEventObject))
{
m_SendQueue.PushBack(pEpollEventObject);
}
return true;
}
return false;
}
void CNetPTCPConnection::DoSend()
{
CAutoLock Lock(m_SendLock);
CEpollEventObject * pEpollEventObject=NULL;
while(m_SendQueue.PopFront(pEpollEventObject))
{
int SendSize=send(
m_Socket.GetSocket(),
pEpollEventObject->GetDataBuff()->GetBuffer(),
pEpollEventObject->GetDataBuff()->GetUsedSize(),
0);
if(SendSize>=0)
{
GetServer()->AddTCPSendBytes(SendSize);
if(SendSize<(int)pEpollEventObject->GetDataBuff()->GetUsedSize())
{
pEpollEventObject->GetDataBuff()->PopFront(NULL,SendSize);
m_SendQueue.PushFront(pEpollEventObject);
return;
}
}
else
{
int ErrorCode=errno;
if(ErrorCode==EAGAIN)
{
m_SendQueue.PushFront(pEpollEventObject);
return;
}
else
{
PrintNetLog(0xffffffff,"Send失败(%u)",ErrorCode);
Disconnect();
return;
}
}
GetServer()->DeleteEventObject(pEpollEventObject);
}
}
COverLappedObject * CNetServer::CreateOverLappedObject()
{
COverLappedObject * pOverLappedObject=NULL;
pOverLappedObject=m_OverLappedObjectPool.NewObject();
if(pOverLappedObject)
{
if(pOverLappedObject->GetParentID())
{
PrintImportantLog(0,_T("分配了未释放的OverLappedObject"));
}
pOverLappedObject->Create(this);
return pOverLappedObject;
}
PrintNetLog(0xffffffff,_T("(%d)Server无法创建COverLappedObject！"),GetID());
return NULL;
}
BOOL CNetServer::OnStart()
{
if(!CBaseServer::OnStart())
return FALSE;
if(m_hIOCP!=NULL)
return FALSE;
CNetSocket::NetStartup();
m_OverLappedObjectPool.Create(m_IOCPObjectPoolSize,m_IOCPObjectPoolGrowSize,m_IOCPObjectPoolGrowLimit);
m_EventRouterPool.Create(m_EventRouterPoolSize,m_EventRouterPoolGrowSize,m_EventRouterPoolGrowLimit);
m_hIOCP = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
if( m_hIOCP == NULL )
{
PrintNetLog(0xffffffff,_T("(%d)创建完成端口失败(%d)！"),GetID(),GetLastError());
return FALSE;
}
SYSTEM_INFO si;
GetSystemInfo( &si );
m_IOCPThreadCount = si.dwNumberOfProcessors * m_IOCPThreadNumPerCPU;
m_pIOCPThreads = new CIOCPThread[m_IOCPThreadCount];
for( int i = 0;i < m_IOCPThreadCount;i ++ )
{
m_pIOCPThreads[i].SetIOCPHandle(m_hIOCP);
m_pIOCPThreads[i].Start();
}
if(!OnStartUp())
{
return FALSE;
}
return TRUE;
}
BOOL CIOCPThread::OnStart()
{
PrintNetLog(0xff,_T("IOCP工作线程启动"));
return TRUE;
}
void CIOCPThread::OnTerminate()
{
PrintNetLog(0xff,_T("IOCP工作线程退出"));
}
BOOL CIOCPFileAccessor::Open(LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
int DataQueueSize,
int RequestQueuSize,
int ErrorQueuSize)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
Close();
}
if(GetServer()==NULL)
return FALSE;
if(m_pIOCPEventRouter==NULL)
{
m_pIOCPEventRouter=GetServer()->CreateEventRouter();
m_pIOCPEventRouter->Init(this);
}
if(!m_DataQueue.Create(DataQueueSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建数据缓冲失败"));
return FALSE;
}
if(RequestQueuSize==0)
{
m_UseAsyncQuery=true;
PrintNetLog(0,_T("CIOCPFileAccessor::开启异步请求模式"));
}
else
{
m_UseAsyncQuery=false;
if(!m_RequestQueue.Create(RequestQueuSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建请求缓冲失败"));
return FALSE;
}
}
if(!m_ErrorQueue.Create(ErrorQueuSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建错误缓冲失败"));
return FALSE;
}
dwFlagsAndAttributes|=FILE_FLAG_OVERLAPPED;
m_FileHandle=::CreateFile(lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes,
dwCreationDisposition,dwFlagsAndAttributes,NULL);
if(m_FileHandle==INVALID_HANDLE_VALUE)
{
UINT ErrorCode=GetLastError();
PrintNetLog(0,_T("CIOCPFileAccessor::打开文件失败%u"),ErrorCode);
PushError(FET_SYSTEM_ERROR,ErrorCode);
return FALSE;
}
if(!GetServer()->BindFile(m_FileHandle))
{
Close();
return FALSE;
}
m_ReadPosition.QuadPart=0;
m_WritePosition.QuadPart=0;
OnOpen();
return TRUE;
}
BOOL CIOCPFileAccessor::OnIOCPEvent(int EventID,COverLappedObject * pOverLappedObject)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
if(EventID==IOE_PACKET)
{
if(pOverLappedObject->GetType()==IO_FILE_WRITE)
{
if(m_DataQueue.PushBack(pOverLappedObject))
{
if(!m_UseAsyncQuery)
{
if(!DoNextOverlappedOperation())
{
}
}
return TRUE;
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::数据队列已满！"));
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL,pOverLappedObject->GetType(),
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else if(pOverLappedObject->GetType()==IO_FILE_READ)
{
if(m_DataQueue.PushBack(pOverLappedObject))
{
if(!m_UseAsyncQuery)
{
if(!DoNextOverlappedOperation())
{
}
}
return TRUE;
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::数据队列已满！"));
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL,pOverLappedObject->GetType(),
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::收到非法IOCP包！"));
PushError(FET_UNKNOW,0,
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::收到IOCP错误！"));
PushError(FET_SYSTEM_ERROR,pOverLappedObject->GetErrorCode(),
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::文件未打开IOCP包被忽略！"));
}
GetServer()->DeleteOverLappedObject(pOverLappedObject);
return TRUE;
}
