Exemplo n.º 1
0
unsigned FillBufferByCom( ComEvaluator& evalutor , SBuffer& buffer , IComPacket* cp )
{

    bool done = false;
    int  count = 1;
    unsigned result;
    while ( !done )
    {
        try
        {
            result = ComEvaluator::fillBuffer( cp , buffer );
            done = true;
        }
        catch ( BufferException& e )
        {
            buffer.grow( ( buffer.getMaxSize() * 3 ) / 2 );
            Msg( e.what() );
        }
        catch ( ComException& e )
        {
            Msg( e.what() );
            return 0;
        }
        ++count;
    }
    return result;
}
Exemplo n.º 2
0
    HRESULT GetTokenFromPublicKey(SBuffer &publicKeyBLOB,
                                  SBuffer &publicKeyTokenBLOB)
    {
        HRESULT hr = S_OK;
        BINDER_LOG_ENTER(W("GetTokenFromPublicKey"));

        const BYTE *pByteKey = publicKeyBLOB;
        DWORD dwKeyLen = publicKeyBLOB.GetSize();
        BYTE *pByteToken = NULL;
        DWORD dwTokenLen = 0;

        if (!StrongNameTokenFromPublicKey(const_cast<BYTE *>(pByteKey),
                                          dwKeyLen,
                                          &pByteToken,
                                          &dwTokenLen))
        {
            BINDER_LOG(W("StrongNameTokenFromPublicKey failed!"));
            IF_FAIL_GO(StrongNameErrorInfo());
        }
        else
        {
            _ASSERTE(pByteToken != NULL);
            publicKeyTokenBLOB.Set(pByteToken, dwTokenLen);
            StrongNameFreeBuffer(pByteToken);
        }

    Exit:
        BINDER_LOG_LEAVE_HR(W("GetTokenFromPublicKey"), hr);
        return hr;
    }
Exemplo n.º 3
0
bool EvalCommand( UdpChain& chain , ComEvaluator& evaluator , SBuffer& buffer , ComConnection* con /*= NULL */ )
{
    unsigned size;
    while( chain.readPacket( buffer , size ) )
    {
        size_t oldSize = buffer.getAvailableSize();

        if ( oldSize < size )
            throw ComException( "error UDP Packet" );

        do
        {
            if ( !evaluator.evalCommand( buffer , con ) )
            {
                ::Msg( "readPacket Error Need Fix" );
                return false;
            }
        }
        while( oldSize - buffer.getAvailableSize() < size );

        if ( oldSize - buffer.getAvailableSize() != size )
            throw ComException( "error UDP Packet" );
    }

    return true;
}
Exemplo n.º 4
0
	void Game::takeData( SBuffer& buffer )
	{
		unsigned size = mStepVec.size();
		buffer.fill( size );

		for( int i = 0 ; i < mStepVec.size() ; ++i )
		{
			StepInfo& info = mStepVec[i];
			buffer.fill( info.idxPlay );
		}
	}
Exemplo n.º 5
0
void ZapImage::OutputInliningTableForReadyToRun()
{
    SBuffer serializedInlineTrackingBuffer;
    m_pPreloader->GetSerializedInlineTrackingMap(&serializedInlineTrackingBuffer);
    ZapNode * pBlob = ZapBlob::NewAlignedBlob(this, (PVOID)(const BYTE*) serializedInlineTrackingBuffer, serializedInlineTrackingBuffer.GetSize(), 4);
    m_pDebugSection->Place(pBlob);
    GetReadyToRunHeader()->RegisterSection(READYTORUN_SECTION_INLINING_INFO, pBlob);
}
Exemplo n.º 6
0
	bool Game::restoreData( SBuffer& buffer )
	{
		mStepVec.clear();

		restart();

		unsigned size;
		buffer.take( size );

		for( int i = 0 ; i < size ; ++i )
		{
			int idxPos;
			buffer.take( idxPos );
			if ( idxPos == -1 )
			{
				pass();
			}
			else if ( play( mBoard.getPos( idxPos ) ) )
			{
				return false;
			}
		}
		return true;
	}
Exemplo n.º 7
0
bool UdpChain::readPacket( SBuffer& buffer , unsigned& readSize )
{
    if ( !buffer.getAvailableSize() )
        return false;

    uint32  incoming;
    uint32  outgoing;

    int count = 0;

    uint32 maxOutgoing = 0;
    while( buffer.getAvailableSize() )
    {
        buffer.take( incoming );
        buffer.take( outgoing );
        buffer.take( readSize );

        if ( maxOutgoing < outgoing )
            maxOutgoing = outgoing;

        if ( incoming <= mIncomingAck )
        {

            if ( readSize > buffer.getAvailableSize() )
            {
                ::Msg( "UdpChain::error incoming data" );
                return false;
            }

            {
                //::Msg( "UdpChain::old incoming data" );
                buffer.shiftUseSize( readSize );
            }
        }
        else if ( incoming > mIncomingAck )
        {
            mIncomingAck = incoming;

            if ( readSize )
                break;
        }

        ++count;
    }

    refrushReliableData( maxOutgoing );
    //Msg( "readPacket %u %u %u" , outgoing , incoming , readSize );
    return buffer.getAvailableSize() != 0;
}
Exemplo n.º 8
0
bool UdpChain::sendPacket( long time , TSocket& socket , SBuffer& buffer , NetAddress& addr  )
{
    if ( buffer.getFillSize() == 0 && time - mTimeLastUpdate > mTimeResendRel )
    {
        if ( mBufferRel.getFillSize() == 0 )
            return false;
    }

    uint32  outgoing = ++mOutgoingSeq;
    uint32  incoming = mIncomingAck;

    uint32 bufSize = (uint32)buffer.getFillSize();

    if ( bufSize )
    {
        if ( mBufferRel.getFreeSize() < bufSize )
        {
            mBufferRel.grow( mBufferRel.getMaxSize() * 2 );
            Msg( "UDPChain::sendPacket : ReliableBuffer too small" );
        }

        size_t oldSize = mBufferRel.getFillSize();

        mBufferRel.fill( outgoing );
        mBufferRel.fill( incoming );
        mBufferRel.fill( bufSize );
        mBufferRel.append( buffer );

        checkBuffer( mBufferRel.getData() , (int)mBufferRel.getFillSize() );

        DataInfo info;
        info.size     = (uint32)( mBufferRel.getFillSize() - oldSize );
        info.sequence = outgoing;
        mInfoList.push_back( info );

        buffer.clear();
        mOutgoingAck = outgoing;
    }


    mBufferCache.clear();
    try
    {
        if ( mOutgoingRel < mOutgoingAck )
        {
            mBufferCache.append( mBufferRel );
        }
        else
        {
            mBufferCache.fill( outgoing );
            mBufferCache.fill( incoming );
            mBufferCache.fill( 0 );
        }

        int count = 0;
        while( mBufferCache.getAvailableSize() )
        {
            int numSend = mBufferCache.take( socket , addr );

            ++count;
            if ( count == 10 )
            {
                return false;
            }
        }
        mTimeLastUpdate = time;
    }
    catch ( BufferException& )
    {
        mBufferCache.resize( mBufferCache.getMaxSize() * 2 );
        return false;
    }

    //Msg( "sendPacket %u %u %u" , outgoing , incoming , bufSize );
    return true;

}