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) 2005-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 : CSipCSServerITC.cpp
// Part of : SIPServerCore
// Version : SIP/4.0
//
#include "CSipCSServerITC.h"
#include "CSIPCSSerializer.h"
#include "SipCSServer.pan"
#include "siprequest.h"
#include "sipresponse.h"
#include "siprouteheader.h"
#include "sipfromheader.h"
#include "TSIPRemoteTargetAndProxy.h"
#include "uricontainer.h"
#include "SipLogs.h"
// -----------------------------------------------------------------------------
// CSipCSServerITC::NewL
// -----------------------------------------------------------------------------
//
CSipCSServerITC* CSipCSServerITC::NewL ()
{
CSipCSServerITC* self = CSipCSServerITC::NewLC ();
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::NewLC
// -----------------------------------------------------------------------------
//
CSipCSServerITC* CSipCSServerITC::NewLC ()
{
CSipCSServerITC* self = new (ELeave) CSipCSServerITC;
CleanupStack::PushL (self);
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::CSipCSServerITC
// -----------------------------------------------------------------------------
//
CSipCSServerITC::CSipCSServerITC ()
{
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ConstructL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::ConstructL ()
{
iSerializer = CSIPCSSerializer::NewL();
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::~CSipCSServerITC
// -----------------------------------------------------------------------------
//
CSipCSServerITC::~CSipCSServerITC ()
{
delete iSerializer;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::Serializer
// -----------------------------------------------------------------------------
//
CSIPCSSerializer& CSipCSServerITC::Serializer ()
{
return *iSerializer;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
CBufFlat& aSipHeaders) const
{
TPtr8 headerBufPtr = aSipHeaders.Ptr(0);
WriteL(ESipItcArgMessageHeaders,aMessage,headerBufPtr);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
const TDesC8& aDes,
TSipItcArguments aItcArgIndex) const
{
WriteL(aItcArgIndex,aMessage,aDes);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
const TSIPIds& aIds) const
{
TPckgBuf<TSIPIds> sipIdsPckg(aIds);
WriteL(ESipItcArgIds, aMessage, sipIdsPckg);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
const TSIPMessageBufSizes aSizes) const
{
TPckgBuf<TSIPMessageBufSizes> bufSizesPckg(aSizes);
WriteL(ESipItcArgBufSizes, aMessage, bufSizesPckg);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
const CSIPHeaderBase& aHeader) const
{
CBufFlat* headerBuf = iSerializer->ExternalizeValueLC(aHeader);
TPtr8 headerBufPtr(headerBuf->Ptr(0));
WriteL(ESipItcArgMessageHeaders,aMessage,headerBufPtr);
CleanupStack::PopAndDestroy(headerBuf);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
TInt aValue,
TSipItcArguments aItcArgIndex) const
{
TPckg<TInt> handlePckg(aValue);
WriteL(aItcArgIndex, aMessage, handlePckg);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
CSIPConnection::TState aState) const
{
TPckg<CSIPConnection::TState> statePckg(aState);
WriteL(ESipItcArgConnectionState, aMessage, statePckg);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
MDesC8Array& aSecurityMechanisms) const
{
CBufFlat* buf = iSerializer->ExternalizeLC(aSecurityMechanisms);
TPtr8 bufPtr = buf->Ptr(0);
WriteL(ESipItcArgAuthenticationMechanism, aMessage, bufPtr);
CleanupStack::PopAndDestroy(buf);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (const RMessage2& aMessage,
const TInetAddr& aInetAddr) const
{
TPckgBuf<TInetAddr> addrPckg(aInetAddr);
WriteL(ESipItcArgLocalAddr, aMessage, addrPckg);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadAppUidL
// -----------------------------------------------------------------------------
//
TUid CSipCSServerITC::ReadAppUidL (const RMessage2& aMessage) const
{
TPckgBuf<TUid> appUidPckg;
aMessage.ReadL(ESipItcArgAppUid, appUidPckg);
return appUidPckg();
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadRequestL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::ReadRequestL (const RMessage2& aMessage,
CSIPRequest& aRequest,
TBool aMethodExpected) const
{
HBufC8* headers = ReadLC(aMessage,ESipItcArgMessageHeaders);
if (headers->Length() > 0)
{
iSerializer->InternalizeL(*headers,aRequest,aMethodExpected);
}
CleanupStack::PopAndDestroy(headers);
HBufC8* content = ReadL(aMessage,ESipItcArgMessageContent);
aRequest.SetContent(content);
__SIP_MESSAGE_LOG("ServerCore",aRequest)
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadRequestL
// -----------------------------------------------------------------------------
//
void
CSipCSServerITC::ReadRequestL (const RMessage2& aMessage,
CSIPRequest& aRequest,
TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy,
TBool aMethodExpected,
TBool aProxyExpected) const
{
HBufC8* headers = ReadLC(aMessage,ESipItcArgMessageHeaders);
if (headers->Length() == 0)
{
User::Leave(KErrArgument);
}
iSerializer->InternalizeL(*headers,aRequest,aRemoteTargetAndProxy,
aMethodExpected,aProxyExpected);
CleanupStack::PopAndDestroy(headers);
CleanupStack::PushL(aRemoteTargetAndProxy.iRemoteTarget);
CleanupStack::PushL(aRemoteTargetAndProxy.iProxy);
HBufC8* content = ReadL(aMessage,ESipItcArgMessageContent);
aRequest.SetContent(content);
CleanupStack::Pop(aRemoteTargetAndProxy.iProxy);
CleanupStack::Pop(aRemoteTargetAndProxy.iRemoteTarget);
__SIP_MESSAGE_LOG("ServerCore",aRequest)
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadResponseLC
// -----------------------------------------------------------------------------
//
CSIPResponse* CSipCSServerITC::ReadResponseLC (const RMessage2& aMessage) const
{
HBufC8* headers = ReadLC(aMessage,ESipItcArgMessageHeaders);
if (headers->Length() == 0)
{
User::Leave(KErrArgument);
}
CSIPResponse* response = iSerializer->InternalizeL(*headers);
CleanupStack::PopAndDestroy(headers);
CleanupStack::PushL(response);
HBufC8* content = ReadL(aMessage,ESipItcArgMessageContent);
response->SetContent(content);
__SIP_MESSAGE_LOG("ServerCore",*response)
return response;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadProxyLC
// -----------------------------------------------------------------------------
//
CSIPRouteHeader* CSipCSServerITC::ReadProxyLC (const RMessage2& aMessage) const
{
HBufC8* proxyBuf = ReadLC(aMessage,ESipItcArgMessageHeaders);
if (proxyBuf->Length() == 0)
{
User::Leave(KErrArgument);
}
CSIPRouteHeader* proxy = iSerializer->InternalizeProxyL(*proxyBuf);
CleanupStack::PopAndDestroy(proxyBuf);
CleanupStack::PushL(proxy);
return proxy;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadSipIdsL
// -----------------------------------------------------------------------------
//
TSIPIds CSipCSServerITC::ReadSipIdsL (const RMessage2& aMessage) const
{
TPckgBuf<TSIPIds> sipIdsPckg;
aMessage.ReadL(ESipItcArgIds, sipIdsPckg);
return sipIdsPckg();
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadSIPSockOptL
// -----------------------------------------------------------------------------
//
TSIPSockOpt CSipCSServerITC::ReadSIPSockOptL (const RMessage2& aMessage) const
{
TPckgBuf<TSIPSockOpt> sipSockOptPckg;
aMessage.ReadL(ESipItcArgSockOpt, sipSockOptPckg);
return sipSockOptPckg();
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::ReadL (const RMessage2& aMessage,
TInt& aValue,
TSipItcArguments aItcArgIndex) const
{
aValue = ITCArgInt(aItcArgIndex,aMessage);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadLC
// -----------------------------------------------------------------------------
//
HBufC8* CSipCSServerITC::ReadLC (const RMessage2& aMessage,
TSipItcArguments aItcArgIndex) const
{
TInt length = aMessage.GetDesLength (aItcArgIndex);
if (length < 0)
{
User::Leave (KErrBadDescriptor);
}
HBufC8* buf = HBufC8::NewLC (length);
if (length > 0)
{
TPtr8 bufPtr(buf->Des());
aMessage.ReadL (aItcArgIndex, bufPtr);
}
return buf;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadCredentialsLC
// -----------------------------------------------------------------------------
//
CDesC8Array*
CSipCSServerITC::ReadCredentialsLC (const RMessage2& aMessage) const
{
HBufC8* credentialsBuf = ReadLC(aMessage,ESipItcArgCredentials);
CDesC8Array* credentials =
iSerializer->InternalizeCredentialsL(*credentialsBuf);
CleanupStack::Pop(credentialsBuf);
CleanupStack::PushL(credentials);
return credentials;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::Complete
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::Complete (const RMessage2& aMessage,
TInt aCompletionCode) const
{
aMessage.Complete (aCompletionCode);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::PanicClient
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::PanicClient(const RMessage2& aMessage, TInt aPanic) const
{
RThread client;
aMessage.Client(client);
client.Panic(KSipCSServerPanic, aPanic);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ITCArgPtr
// -----------------------------------------------------------------------------
//
const TAny* CSipCSServerITC::ITCArgPtr (TSipItcArguments aItcArgIndex,
const RMessage2& aMessage) const
{
const TAny* ptr;
switch (static_cast<TInt>(aItcArgIndex))
{
case 0: ptr = aMessage.Ptr0(); break;
case 1: ptr = aMessage.Ptr1(); break;
case 2: ptr = aMessage.Ptr2(); break;
case 3: ptr = aMessage.Ptr3(); break;
default: ptr = 0; break;
}
return ptr;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ITCArgInt
// -----------------------------------------------------------------------------
//
TInt CSipCSServerITC::ITCArgInt (TSipItcArguments aItcArgIndex,
const RMessage2& aMessage) const
{
TInt integer;
switch (static_cast<TInt>(aItcArgIndex))
{
case 0: integer = aMessage.Int0(); break;
case 1: integer = aMessage.Int1(); break;
case 2: integer = aMessage.Int2(); break;
case 3: integer = aMessage.Int3(); break;
default: integer = KErrArgument; break;
}
return integer;
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::WriteL
// -----------------------------------------------------------------------------
//
void CSipCSServerITC::WriteL (TSipItcArguments aItcArgIndex,
const RMessage2& aMessage,
const TDesC8& aDes) const
{
TInt length = aMessage.GetDesMaxLength(aItcArgIndex);
if (length < 0)
{
User::Leave (KErrArgument);
}
if (length < aDes.Length())
{
User::Leave (KErrOverflow);
}
aMessage.WriteL (aItcArgIndex, aDes);
}
// -----------------------------------------------------------------------------
// CSipCSServerITC::ReadL
// -----------------------------------------------------------------------------
//
HBufC8* CSipCSServerITC::ReadL (const RMessage2& aMessage,
TSipItcArguments aItcArgIndex) const
{
HBufC8* buf = ReadLC(aMessage,aItcArgIndex);
CleanupStack::Pop(buf);
return buf;
}