This release addresses the following:
- Multiple concurrent file transfer bug fixes. i.e. one device is concurrently receiving multiple files from multiple devices
// Copyright (c) 2002-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 : CSIPMsgAssembler.cpp
// Part of : ConnectionMgr
// Version : SIP/4.0
//
#include "SipLogs.h"
#include "SipAssert.h"
#include "sipmessage.h"
#include "TTCPMsgInit.h"
#include "TTCPMsgHeaderStart.h"
#include "TTCPMsgHeaderEnd.h"
#include "TTCPMsgContentStart.h"
#include "TTCPMsgContentEnd.h"
#include "TTCPCompMsgStart.h"
#include "TTCPCompMsgEnd.h"
#include "TTCPMsgComplete.h"
#include "CSIPMsgAssembler.h"
#include "MSIPMsgAssemblerOwner.h"
#include "MSigCompController.h"
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::NewL
// -----------------------------------------------------------------------------
//
CSIPMsgAssembler* CSIPMsgAssembler::NewL ( MSIPMsgAssemblerOwner& aMsgOwner,
MSigCompController& aSigComp )
{
CSIPMsgAssembler* self = CSIPMsgAssembler::NewLC(aMsgOwner, aSigComp);
CleanupStack::Pop();
return self;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::NewLC
// -----------------------------------------------------------------------------
//
CSIPMsgAssembler* CSIPMsgAssembler::NewLC ( MSIPMsgAssemblerOwner& aMsgOwner,
MSigCompController& aSigComp )
{
CSIPMsgAssembler* self = new (ELeave) CSIPMsgAssembler(aMsgOwner, aSigComp);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::~CSIPMsgAssembler
// -----------------------------------------------------------------------------
//
CSIPMsgAssembler::~CSIPMsgAssembler ()
{
delete iMsgBuf;
delete iMessage;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::CSIPMsgAssembler
// -----------------------------------------------------------------------------
//
CSIPMsgAssembler::CSIPMsgAssembler(MSIPMsgAssemblerOwner& aMsgOwner,
MSigCompController& aSigComp)
: iMsgOwner ( aMsgOwner ),
iSigComp ( aSigComp ),
iStates ( EMsgMaxStates ),
iStateValue( MMsgAssemblerContext::EMsgInit ),
iIsSigComp ( EFalse ),
iUnConsumedBytes( 0 )
{
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::ConstructL ()
{
iMsgBuf = CBufFlat::NewL(100);
iStates.AppendL( TTCPMsgInit( *this ),
sizeof( TTCPMsgInit ) );
iStates.AppendL( TTCPMsgHeaderStart( *this ),
sizeof( TTCPMsgHeaderStart ) );
iStates.AppendL( TTCPMsgHeaderEnd( *this ),
sizeof( TTCPMsgHeaderEnd ) );
iStates.AppendL( TTCPMsgContentStart( *this ),
sizeof( TTCPMsgContentStart ) );
iStates.AppendL( TTCPMsgContentEnd( *this ),
sizeof( TTCPMsgContentEnd ) );
iStates.AppendL( TTCPCompMsgStart( *this ),
sizeof( TTCPCompMsgStart ) );
iStates.AppendL( TTCPCompMsgEnd( *this ),
sizeof( TTCPCompMsgEnd ) );
iStates.AppendL( TTCPMsgComplete( *this ),
sizeof( TTCPMsgComplete ) );
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::InputL
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::InputL ( HBufC8* aData, TUint& aNextLength )
{
__ASSERT_DEBUG(aData != 0,
User::Panic(_L("CSIPMsgAssembler::InputL, aData == 0"),
KErrArgument));
__ASSERT_DEBUG(aData->Length() != 0,
User::Panic(_L("CSIPMsgAssembler::InputL, aData->Length() == 0"),
KErrArgument));
aNextLength = CSIPMsgAssembler::EMsgBufferSize;
TCleanupItem cleanupItem( ResetState, this );
CleanupStack::PushL( cleanupItem );
TPtr8 dataPtr = aData->Des();
CurrentState().DataReceivedL( dataPtr, aNextLength );
CleanupStack::Pop(); // cleanupItem
delete aData;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::MsgOwner
// -----------------------------------------------------------------------------
//
MSIPMsgAssemblerOwner& CSIPMsgAssembler::MsgOwner()
{
return iMsgOwner;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::SigComp
// -----------------------------------------------------------------------------
//
MSigCompController& CSIPMsgAssembler::SigComp()
{
return iSigComp;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::MsgBuffer
// -----------------------------------------------------------------------------
//
CBufFlat& CSIPMsgAssembler::MsgBuffer()
{
return *iMsgBuf;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::Message
// -----------------------------------------------------------------------------
//
CSIPMessage* CSIPMsgAssembler::Message()
{
return iMessage;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::SetMessage
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::SetMessage( CSIPMessage* aMessage )
{
delete iMessage;
iMessage = aMessage;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::DetachMsg
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::DetachMsg()
{
iMessage = NULL;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::ChangeState
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::ChangeState(
MMsgAssemblerContext::TTCPMsgStateValue aStateValue )
{
iStateValue = aStateValue;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::CurrentState
// -----------------------------------------------------------------------------
//
TTCPMsgState& CSIPMsgAssembler::CurrentState()
{
return const_cast< TTCPMsgState& >( iStates.At( iStateValue ) );
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::SetIsSigComp
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::SetIsSigComp( TBool aIsSigComp )
{
iIsSigComp = aIsSigComp;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::IsSigComp
// -----------------------------------------------------------------------------
//
TBool CSIPMsgAssembler::IsSigComp() const
{
return iIsSigComp;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::SetUnConsumedBytes
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::SetUnConsumedBytes( TInt aUnConsumedBytes )
{
iUnConsumedBytes = aUnConsumedBytes;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::UnConsumedBytes
// -----------------------------------------------------------------------------
//
TInt CSIPMsgAssembler::UnConsumedBytes() const
{
return iUnConsumedBytes;
}
// -----------------------------------------------------------------------------
// CSIPMsgAssembler::ResetState
// -----------------------------------------------------------------------------
//
void CSIPMsgAssembler::ResetState ( TAny* aMsgAssembler )
{
__SIP_ASSERT_RETURN( aMsgAssembler, KErrGeneral );
CSIPMsgAssembler* msgAssembler =
reinterpret_cast<CSIPMsgAssembler*>( aMsgAssembler );
msgAssembler->ChangeState( MMsgAssemblerContext::EMsgInit );
}