// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Name        : TTCPMsgContentStart.cpp

// Part of     : ConnectionMgr

// Implementation

// Version     : SIP/4.0

//

#include "TTCPMsgContentStart.h"

#include "sipmessage.h"

#include "SipAssert.h"

#include "MMsgAssemblerContext.h"

#include "MSigCompController.h"

#include "CSIPMsgAssembler.h"

// ----------------------------------------------------------------------------

// TTCPMsgContentStart::DataReceivedL

// ----------------------------------------------------------------------------

//

void TTCPMsgContentStart::DataReceivedL( TPtr8 aData, TUint&  aNextLength )

	{

	CSIPMessage* message = iMsgAssembler.Message();

	// panic if message == 0 in debug mode. leaves in release mode.

	__SIP_ASSERT_LEAVE( message, KErrGeneral );

	// panic if there is no content length in debug mode. 

	// leaves in release mode.                

	__SIP_ASSERT_LEAVE( message->HasAnnouncedContentLength(), 

	                    KErrGeneral );	     

	TUint contentLen = message->AnnouncedContentLength();

	// panic if content length <= 0 in debug mode. 

	// leaves in release mode.                

	__SIP_ASSERT_LEAVE( contentLen > 0, KErrGeneral );	 

    // if message contains already some content, received data is complementing

	// it. this kind of situation might occur when sigcomp splits too big sip 

	// message to pieces

	if ( message->Content().Length() > 0 )

	    {

        iMsgAssembler.MsgBuffer().InsertL( iMsgAssembler.MsgBuffer().Size(), 

                                           message->Content() ); 

        iMsgAssembler.MsgBuffer().Compress();

        // remove old uncomplete content

        HBufC8* uncompletedContent = message->TakeContentOwnershipL(); 

        delete uncompletedContent;          

	    }

	if ( iMsgAssembler.SigComp().IsSupported() &&

	     iMsgAssembler.IsSigComp() &&

	     HandleComplementingSigCompDataL( aData, aNextLength, contentLen ) )

		{

	    return;

		}

	if ( iMsgAssembler.MsgBuffer().Size() > 0 )

		{

		// insert received data to msg buffer.

		iMsgAssembler.MsgBuffer().InsertL(

						        	iMsgAssembler.MsgBuffer().Size(), aData );

		iMsgAssembler.MsgBuffer().Compress();

		// delete the content of received data

		aData.Delete( 0, aData.Length() ); 

		TPtr8 bufPtr = iMsgAssembler.MsgBuffer().Ptr( 0 );

		// check if the msg buffer contains the whole content, if so

		// copy the msg buffer to new data buffer, clean the msg buffer

		// and enter to msg content end state.

		if ( contentLen <= static_cast< TUint >( bufPtr.Length() ) )

			{

			HBufC8* newData = HBufC8::NewLC( bufPtr.Length() );

		    // copy the msg buffer data  new data 

	    	TPtr8 newDataPtr = newData->Des();		    

	   		// delete the content of received data

			aData.Delete( 0, aData.Length() ); 

		    newDataPtr.Append(iMsgAssembler.MsgBuffer().Ptr(0));

		    // clean the msg buffer

			iMsgAssembler.MsgBuffer().Reset();

			iMsgAssembler.MsgBuffer().Compress();	

		    iMsgAssembler.ChangeState( MMsgAssemblerContext::EMsgContentEnd );

			iMsgAssembler.CurrentState().DataReceivedL( newDataPtr, 

			                                            aNextLength );

		    CleanupStack::PopAndDestroy( newData );

			}

		// if the msg buffer contains not enough content, ask the next

		// length to be received.

		else

			{

			aNextLength = contentLen - aData.Length();

			}

		}

	else if ( contentLen <= static_cast< TUint >( aData.Length() ) )

		{

		iMsgAssembler.ChangeState(MMsgAssemblerContext::EMsgContentEnd);

		iMsgAssembler.CurrentState().DataReceivedL( aData, aNextLength );

		}

	else

		{

		iMsgAssembler.MsgBuffer().InsertL(

									iMsgAssembler.MsgBuffer().Size(), aData );

		iMsgAssembler.MsgBuffer().Compress();

		aNextLength = contentLen - aData.Length();

		}

	}

// ----------------------------------------------------------------------------

// TTCPMsgContentStart::HandleComplementingSigCompDataL

// ----------------------------------------------------------------------------

//

TBool TTCPMsgContentStart::HandleComplementingSigCompDataL( 

    TPtr8 aData, 

    TUint& aNextLength,

    TInt aAnnouncedContentLen )

    {

    // If still receiving compressed data, current contents have to be

    // stored until we come back from comp states, in sigcomp point of

    // view message can be complete but it ain't necessary complete

    // in sip point of view. All data in aData or msgbuffer are not 

    // necessarily decompressed - these have to be taken with us when 

    // going back to decompression states

    TInt unconsumedBytes( iMsgAssembler.UnConsumedBytes() );

    TPtr8 msgBufPtr( iMsgAssembler.MsgBuffer().Ptr( 0 ) );

    HBufC8* content = NULL;

    TInt decompressedDataLen = aData.Length() - unconsumedBytes;

   	__SIP_ASSERT_LEAVE( decompressedDataLen > 0, KErrGeneral );

   	TInt msgBufLen( msgBufPtr.Length() );

    TInt decompressedLen( msgBufLen + decompressedDataLen );

   	if ( aAnnouncedContentLen <= decompressedLen )

   	    {

   	    // Enough decompressed content data

   	    return EFalse;

   	    }

    // Store decompressed data to message content

    if ( msgBufLen > 0 )

        {

        content = HBufC8::NewL( decompressedLen );

        TPtr8 contentPtr( content->Des() );

        contentPtr.Copy( msgBufPtr );

        contentPtr.Append( aData.Left( decompressedDataLen ) );

        }

    else

        {

        content = aData.Left( decompressedDataLen ).AllocL();

        }

    // Remove decompressed data which was stored to content   

    aData.Delete( 0, decompressedDataLen ); 

     // Clean msgbuffer

   	iMsgAssembler.MsgBuffer().Reset();

    iMsgAssembler.MsgBuffer().Compress();

    iMsgAssembler.SetUnConsumedBytes( 0 );

    CSIPMessage* message = iMsgAssembler.Message();

    message->SetContent( content ); // ownership is transferred

	content = NULL;

	aNextLength = CSIPMsgAssembler::EMsgBufferSize;

	iMsgAssembler.ChangeState( MMsgAssemblerContext::ECompMsgStart );

	iMsgAssembler.CurrentState().DataReceivedL( aData, aNextLength );

	return ETrue;

    }

// End of File