int Connections::PushPacket(Packet* pPacket)
{
FUNCTION_BEGIN();
if (false == IsStatus(CONNSTATUS_ACTIVE))
{
return 1;//ERR_NET_CONNECTION_STATUS_WRONG
}
if (false == pPacket->IsValidPacket())
{
return 2;//ERR_NET_PACKET_INVALID
}
_mutexSend.Lock();
if (pPacket->GetPacketLen() > GetMaxSendPacketSize())
{
_mutexSend.Unlock();
return 3;//ERR_NET_PACKET_EXCEED_ALLOWED_SIZE
}
if (_sendBuffer.GetPushAvailableSize() <= pPacket->GetUsedSize())
{
if (false == IsSetControlFlag(CONTROL_FLAG_USE_SEND_QUEUE))
{
_mutexSend.Unlock();
return 4;//ERR_NET_SESSION_SEND_BUFFER_OVERFLOW
}
else
{
Packet * QueuedPacket = new Packet(*pPacket);
if (NULL == QueuedPacket)
{
_mutexSend.Unlock();
return 5;//ERR_SYS_MEMORY_ALLOC_FAIL
}
if (false == _sendQueue.PushPacket(QueuedPacket))
{
SAFE_DELETE(QueuedPacket);
_mutexSend.Unlock();
return 6;//ERR_NET_SESSION_SEND_BUFFER_OVERFLOW;
}
_mutexSend.Unlock();
return 0;
}
}
memcpy(_sendBuffer.GetQueuePushPtr(), pPacket->GetPacketBuffer(), pPacket->GetUsedSize());
Packet sendPacket(_sendBuffer.GetQueuePushPtr());
BYTE Sequence = (BYTE)(_PacketSendCount & PACKET_MAX_SEQUENCE);
SetSequence(sendPacket.GetPacketHeader(), Sequence);
int rc = 0;
if (_PacketEncoder)
{
rc = _PacketEncoder->TxEncrypt(sendPacket);
if (0 != rc)
{
_mutexSend.Unlock();
return 7;//ERR_NET_PACKET_ENCRYPT_FAIL
}
}
_sendBuffer.IncreasePushPos(pPacket->GetUsedSize());
IncreasePacketSend();
if (false == _IsSending)
{
rc = PostSend();
if (0 != rc)
{
_mutexSend.Unlock();
return rc;
}
_IsSending = true;
}
_mutexSend.Unlock();
return 0;
}
//-----------------------------------------------------------------------------------
// Purpose :
// Return :
//-----------------------------------------------------------------------------------
// Called by Worker TH ( IOCP )
//-----------------------------------------------------------------------------------
int CNtlConnection::CompleteSend(DWORD dwTransferedBytes)
{
UNREFERENCED_PARAMETER( dwTransferedBytes );
FUNCTION_BEGIN();
IncreaseBytesSend( dwTransferedBytes );
m_mutexSend.Lock();
m_sendBuffer.IncreasePopPos( dwTransferedBytes );
int rc = 0;
if( IsSetControlFlag( CONTROL_FLAG_USE_SEND_QUEUE ) )
{
CNtlPacket * pSendPacket = m_sendQueue.PeekPacket();
while( pSendPacket )
{
if( m_sendBuffer.GetPushAvailableSize() <= pSendPacket->GetUsedSize() )
{
break;
}
BYTE bySequence = (BYTE) ( m_dwPacketSendCount & PACKET_MAX_SEQUENCE );
SetSequence( pSendPacket->GetPacketHeader(), bySequence );
#if __SGPRO_BOTSYSTEM_SENDANDRECVTESTCODE__
#else
if( m_pPacketEncoder )
{
rc = m_pPacketEncoder->TxEncrypt( *pSendPacket );
if( NTL_SUCCESS != rc )
{
m_mutexSend.Unlock();
NTL_LOGDL( LOG_NETWORK, "Session[%X] TxEncrypt Error[%d:%s]", this, rc, NtlGetErrorMessage(rc) );
return NTL_ERR_NET_PACKET_ENCRYPT_FAIL;
}
}
#endif
memcpy( m_sendBuffer.GetQueuePushPtr(), pSendPacket->GetPacketBuffer(), pSendPacket->GetUsedSize() );
m_sendBuffer.IncreasePushPos( pSendPacket->GetUsedSize() );
IncreasePacketSend();
m_sendQueue.PopPacket();
SAFE_DELETE( pSendPacket );
pSendPacket = m_sendQueue.PeekPacket();
}
}
if( m_sendBuffer.GetCurSize() )
{
rc = PostSend();
if( NTL_SUCCESS != rc )
{
m_bSending = false;
m_mutexSend.Unlock();
// [1/20/2007 zeroera] : ¼³¸í : Send¿¡ ÀÇÇÑ Close ±â´ÉÀ» ¸·À½. TH1ÀÌ Recv Áß¿¡ TH2 °¡ Send ÇÏ¿© CloseÇÏ°Ô µÇ¸é ¹®Á¦°¡ ¹ß»ý ÇÒ ¼ÒÁö°¡ ÀÖÀ½
//return rc;
Disconnect( false );
NTL_LOGDL( LOG_NETWORK, "Session[%X] PostSend Error[%d:%s]", this, rc, NtlGetErrorMessage(rc) );
return NTL_SUCCESS;
}
}
else
{
m_bSending = false;
}
m_mutexSend.Unlock();
//NTL_PRINT(PRINT_SYSTEM, "Session[%X]\tCompleteSend Complete SendBufferSize[%d] TotalSendBytes[%u]", this, m_sendBuffer.GetCurSize(), m_dwTotalSendSize );
return NTL_SUCCESS;
}
int Connections::CompleteSend(DWORD TransferedBytes)
{
UNREFERENCED_PARAMETER(TransferedBytes);
FUNCTION_BEGIN();
IncreaseBytesSend(TransferedBytes);
_mutexSend.Lock();
_sendBuffer.IncreasePopPos(TransferedBytes);
int rc = 0;
if (IsSetControlFlag(CONTROL_FLAG_USE_SEND_QUEUE))
{
Packet * SendPacket = _sendQueue.PeekPacket();
while (SendPacket)
{
if (_sendBuffer.GetPushAvailableSize() <= SendPacket->GetUsedSize())
{
break;
}
BYTE Sequence = (BYTE)(_PacketSendCount & PACKET_MAX_SEQUENCE);
SetSequence(SendPacket->GetPacketHeader(), Sequence);
if (_PacketEncoder)
{
rc = _PacketEncoder->TxEncrypt(*SendPacket);
if (0 != rc)
{
_mutexSend.Unlock();
Logger::Log("Session[%X] TxEncrypt Error[%d]\n", this, rc);
return 1; //ERR_NET_PACKET_ENCRYPT_FAIL
}
}
memcpy(_sendBuffer.GetQueuePushPtr(), SendPacket->GetPacketBuffer(), SendPacket->GetUsedSize());
_sendBuffer.IncreasePushPos(SendPacket->GetUsedSize());
IncreasePacketSend();
_sendQueue.PopPacket();
SAFE_DELETE(SendPacket);
SendPacket = _sendQueue.PeekPacket();
}
}
if (_sendBuffer.GetCurSize())
{
rc = PostSend();
if (0 != rc)
{
_IsSending = false;
_mutexSend.Unlock();
Disconnect(false);
Logger::Log("Session[%X] PostSend Error[%d]\n", this, rc);
return 0;
}
}
else
{
_IsSending = false;
}
_mutexSend.Unlock();
return 0;
}
//-----------------------------------------------------------------------------------
// Purpose :
// Return :
//-----------------------------------------------------------------------------------
// Called by App TH, Worker TH ( Send )
//-----------------------------------------------------------------------------------
int CNtlConnection::PushPacket(CNtlPacket * pPacket)
{
FUNCTION_BEGIN();
if( false == IsStatus( STATUS_ACTIVE ) )
{
return NTL_ERR_NET_CONNECTION_STATUS_WRONG;
}
if( false == pPacket->IsValidPacket() )
{
return NTL_ERR_NET_PACKET_INVALID;
}
m_mutexSend.Lock(); // ¹ØÀ¸·Î ³»¸®¸é µ¿±âÈ°¡ ±úÁø´Ù [5/30/2008 SGpro]
if( pPacket->GetPacketLen() > GetMaxSendPacketSize() )
{
m_mutexSend.Unlock();
return NTL_ERR_NET_PACKET_EXCEED_ALLOWED_SIZE;
}
if( m_sendBuffer.GetPushAvailableSize() <= pPacket->GetUsedSize() )
{
if( false == IsSetControlFlag( CONTROL_FLAG_USE_SEND_QUEUE ) )
{
m_mutexSend.Unlock();
return NTL_ERR_NET_SESSION_SEND_BUFFER_OVERFLOW;
}
else
{
CNtlPacket * pQueuedPacket = new CNtlPacket( *pPacket );
if( NULL == pQueuedPacket )
{
m_mutexSend.Unlock();
return NTL_ERR_SYS_MEMORY_ALLOC_FAIL;
}
if( false == m_sendQueue.PushPacket( pQueuedPacket ) )
{
SAFE_DELETE( pQueuedPacket );
m_mutexSend.Unlock();
return NTL_ERR_NET_SESSION_SEND_BUFFER_OVERFLOW;
}
m_mutexSend.Unlock();
return NTL_SUCCESS;
}
}
//m_mutexSend.Lock(); //¿©±â¿¡ µÎ¸é µ¿±âÈ°¡ ±úÁø´Ù [5/30/2008 SGpro]
memcpy( m_sendBuffer.GetQueuePushPtr(), pPacket->GetPacketBuffer(), pPacket->GetUsedSize() );
// [9/10/2007 zeroera] : ¼³¸í : È¿À²¼ºÀ» À§ÇØ ÆÐŶ ¹öÆÛ¿¡ ÀÖ´Â µ¥ÀÌŸ¸¦ °¡Áö°í ¾ÏÈ£È ÇÑ´Ù
CNtlPacket sendPacket( m_sendBuffer.GetQueuePushPtr() );
BYTE bySequence = (BYTE) ( m_dwPacketSendCount & PACKET_MAX_SEQUENCE );
SetSequence( sendPacket.GetPacketHeader(), bySequence );
int rc = NTL_SUCCESS;
#if __SGPRO_BOTSYSTEM_SENDANDRECVTESTCODE__
#else
if( m_pPacketEncoder )
{
rc = m_pPacketEncoder->TxEncrypt( sendPacket );
if( NTL_SUCCESS != rc )
{
m_mutexSend.Unlock();
return NTL_ERR_NET_PACKET_ENCRYPT_FAIL;
}
}
#endif
m_sendBuffer.IncreasePushPos( pPacket->GetUsedSize() );
IncreasePacketSend();
if( false == m_bSending )
{
rc = PostSend();
if( NTL_SUCCESS != rc )
{
m_mutexSend.Unlock();
return rc;
}
m_bSending = true;
}
m_mutexSend.Unlock();
return NTL_SUCCESS;
}
