C++ (Cpp) GetMaxSendPacketSize Exemples

Exemple #1

Fichier : Connections.cpp Projet : ChowZenki/dboserver

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;
}

Exemple #2

Fichier : NtlConnection.cpp Projet : JunRyuu/AKCore

//-----------------------------------------------------------------------------------
//		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;
}