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) 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 : CSIPURI.cpp
// Part of : SIP Codec
// Version : SIP/4.0
//
#include "sipuri.h"
#include "CSIPURIParams.h"
#include "CSIPURIHeaders.h"
#include "sipcodecerr.h"
#include "SIPSyntaxCheck.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include <uricommon.h>
#include "_sipcodecdefs.h"
_LIT8(KSIP, "sip");
_LIT8(KSIPS, "sips");
_LIT8(KColon, ":");
_LIT8(KSemiColon, ";");
_LIT8(KAt, "@");
_LIT8(KQuestionMark, "?");
// -----------------------------------------------------------------------------
// CSIPURI::DecodeL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPURI* CSIPURI::DecodeL (const TDesC8& aValue)
{
__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURI));
CSIPURI* sipUri = CSIPURI::NewLC();
sipUri->ParseL(sipUri->ParseSipSchemeL(aValue));
CleanupStack::Pop(sipUri);
return sipUri;
}
// -----------------------------------------------------------------------------
// CSIPURI::NewL
// -----------------------------------------------------------------------------
//
CSIPURI* CSIPURI::NewL (const CSIPURI& aSIPURI)
{
CSIPURI* self = CSIPURI::NewLC(aSIPURI);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPURI::NewLC
// -----------------------------------------------------------------------------
//
CSIPURI* CSIPURI::NewLC (const CSIPURI& aSIPURI)
{
CSIPURI* self = new(ELeave)CSIPURI(aSIPURI.IsSIPSURI());
CleanupStack::PushL(self);
self->ConstructL(aSIPURI);
return self;
}
// -----------------------------------------------------------------------------
// CSIPURI::NewL
// -----------------------------------------------------------------------------
//
CSIPURI* CSIPURI::NewL ()
{
CSIPURI* self = CSIPURI::NewLC();
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPURI::NewLC
// -----------------------------------------------------------------------------
//
CSIPURI* CSIPURI::NewLC ()
{
CSIPURI* self = new(ELeave)CSIPURI;
CleanupStack::PushL(self);
self->ConstructL ();
return self;
}
// -----------------------------------------------------------------------------
// CSIPURI::CSIPURI
// -----------------------------------------------------------------------------
//
CSIPURI::CSIPURI(TBool aIsSIPSUri)
: iIsSIPSURI(aIsSIPSUri)
{
}
// -----------------------------------------------------------------------------
// CSIPURI::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPURI::ConstructL ()
{
iURIParams = new(ELeave)CSIPURIParams(iIsSIPSURI);
iURIHeaders = new(ELeave)CSIPURIHeaders;
}
// -----------------------------------------------------------------------------
// CSIPURI::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPURI::ConstructL (const CSIPURI& aSIPURI)
{
ConstructL();
iHostPort = CSIPHostPort::NewL(*aSIPURI.iHostPort);
if (aSIPURI.User().Compare(KNullDesC8) != 0)
{
SetUserL(aSIPURI.User());
}
if (aSIPURI.Password().Compare(KNullDesC8) != 0)
{
SetPasswordL(aSIPURI.Password());
}
SetURIParams(CSIPURIParams::NewL(*aSIPURI.iURIParams,aSIPURI.IsSIPSURI()));
SetURIHeaders(CSIPURIHeaders::NewL(*aSIPURI.iURIHeaders));
}
// -----------------------------------------------------------------------------
// CSIPURI::~CSIPURI
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPURI::~CSIPURI ()
{
delete iHostPort;
delete iURIHeaders;
delete iURIParams;
delete iPassword;
delete iUser;
}
// -----------------------------------------------------------------------------
// CSIPURI::IsSIPSURI
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPURI::IsSIPSURI () const
{
return iIsSIPSURI;
}
// -----------------------------------------------------------------------------
// CSIPURI::SetSIPS
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetSIPS(TBool aSIPS)
{
iIsSIPSURI = aSIPS;
}
// -----------------------------------------------------------------------------
// CSIPURI::SetHostPortL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetHostPortL (CSIPHostPort* aHostPort)
{
__ASSERT_ALWAYS (aHostPort != 0, User::Leave(KErrSipCodecHost));
delete iHostPort;
iHostPort = aHostPort;
}
// -----------------------------------------------------------------------------
// CSIPURI::HostPort
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPHostPort& CSIPURI::HostPort () const
{
return *iHostPort;
}
// -----------------------------------------------------------------------------
// CSIPURI::HostPort
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPHostPort& CSIPURI::HostPort ()
{
return *iHostPort;
}
// -----------------------------------------------------------------------------
// CSIPURI::User
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CSIPURI::User () const
{
if (iUser)
{
return *iUser;
}
return KNullDesC8;
}
// -----------------------------------------------------------------------------
// CSIPURI::SetUserL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetUserL (const TDesC8& aUser)
{
__ASSERT_ALWAYS (SIPSyntaxCheck::User(aUser),
User::Leave(KErrSipCodecURI));
HBufC8* tmp = aUser.AllocL();
delete iUser;
iUser = tmp;
}
// -----------------------------------------------------------------------------
// CSIPURI::DeleteUserInfo
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::DeleteUserInfo ()
{
delete iUser; iUser = 0;
DeletePassword();
}
// -----------------------------------------------------------------------------
// CSIPURI::Password
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CSIPURI::Password () const
{
if (iPassword)
{
return *iPassword;
}
return KNullDesC8;
}
// -----------------------------------------------------------------------------
// CSIPURI::SetPasswordL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetPasswordL (const TDesC8& aPassword)
{
__ASSERT_ALWAYS (SIPSyntaxCheck::Password(aPassword),
User::Leave(KErrSipCodecURI));
__ASSERT_ALWAYS (iUser, User::Leave(KErrArgument));
HBufC8* tmp = aPassword.AllocL();
delete iPassword;
iPassword = tmp;
}
// -----------------------------------------------------------------------------
// CSIPURI::DeletePassword
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::DeletePassword ()
{
delete iPassword; iPassword = 0;
}
// -----------------------------------------------------------------------------
// CSIPURI::HasParams
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPURI::HasParams () const
{
return (iURIParams->ParamCount() > 0);
}
// -----------------------------------------------------------------------------
// CSIPURI::TtlParam
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CSIPURI::TtlParam () const
{
RStringF ttl = SIPStrings::StringF(SipStrConsts::ETtl);
return iURIParams->IntParamValue(ttl);
}
// -----------------------------------------------------------------------------
// CSIPURI::SetTtlParamL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetTtlParamL (TInt aValue)
{
RStringF ttl = SIPStrings::StringF(SipStrConsts::ETtl);
iURIParams->SetParamL(ttl,aValue);
}
// -----------------------------------------------------------------------------
// CSIPURI::HasParam
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPURI::HasParam(RStringF aName) const
{
return iURIParams->HasParam(aName);
}
// -----------------------------------------------------------------------------
// CSIPURI::ParamValue
// -----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPURI::ParamValue(RStringF aName) const
{
return iURIParams->ParamValue(aName);
}
// -----------------------------------------------------------------------------
// CSIPURI::SetParamL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetParamL(RStringF aName)
{
iURIParams->SetParamL(aName);
}
// -----------------------------------------------------------------------------
// CSIPURI::SetParamL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::SetParamL(RStringF aName, RStringF aValue)
{
iURIParams->SetParamL(aName,aValue);
}
// -----------------------------------------------------------------------------
// CSIPURI::DeleteParam
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::DeleteParam(RStringF aName)
{
iURIParams->DeleteParam (aName);
}
// -----------------------------------------------------------------------------
// CSIPURI::HasURIHeaders
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPURI::HasURIHeaders (const TDesC8& aName) const
{
return iURIHeaders->HasHeaders(aName);
}
// -----------------------------------------------------------------------------
// CSIPURI::URIHeaderValuesL
// -----------------------------------------------------------------------------
//
EXPORT_C CPtrC8Array* CSIPURI::URIHeaderValuesL (const TDesC8& aName) const
{
return iURIHeaders->HeaderValuesL(aName);
}
// -----------------------------------------------------------------------------
// CSIPURI::AddURIHeaderL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPURI::AddURIHeaderL (const TDesC8& aName,
const TDesC8& aValue)
{
iURIHeaders->AddHeaderL(aName,aValue);
}
// -----------------------------------------------------------------------------
// CSIPURI::DeleteAllURIHeaders
// -----------------------------------------------------------------------------
//
void CSIPURI::DeleteAllURIHeaders ()
{
iURIHeaders->DeleteAll();
}
// -----------------------------------------------------------------------------
// CSIPURI::operator==
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPURI::operator==(const CSIPURI& aURI) const
{
if (aURI.iIsSIPSURI != iIsSIPSURI)
{
return EFalse;
}
TBool hasuserparam((aURI.User().Compare(KNullDesC8) != 0));
TBool hasuser((User().Compare(KNullDesC8) != 0));
if (hasuserparam != hasuser)
{
return EFalse;
}
if (hasuserparam && aURI.User() != User())
{
return EFalse;
}
TBool haspasswordparam((aURI.Password().Compare(KNullDesC8) != 0));
TBool haspassword((Password().Compare(KNullDesC8) != 0));
if (haspasswordparam != haspassword)
{
return EFalse;
}
if (haspasswordparam &&
aURI.Password() != Password())
{
return EFalse;
}
if (!(*iHostPort == *(aURI.iHostPort)))
{
return EFalse;
}
if (!(*aURI.iURIParams == *iURIParams))
{
return EFalse;
}
return (*aURI.iURIHeaders == *iURIHeaders);
}
// -----------------------------------------------------------------------------
// CSIPURI::ToTextL
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSIPURI::ToTextL () const
{
TPtrC8 scheme(KSIP);
if (iIsSIPSURI)
{
scheme.Set(KSIPS);
}
TUint encodedLength = scheme.Length() + KColon().Length();
if (iUser)
{
encodedLength += iUser->Length();
if (iPassword) encodedLength+=KColon().Length()+iPassword->Length();
encodedLength += KAt().Length();
}
HBufC8* hostPort = iHostPort->ToTextLC();
encodedLength += hostPort->Length();
HBufC8* uriParams = iURIParams->ToTextLC();
if (uriParams->Length() > 0) encodedLength += (1+uriParams->Length());
HBufC8* uriHeaders = iURIHeaders->ToTextLC();
if (uriHeaders->Length() > 0) encodedLength += (1+uriHeaders->Length());
// Create and fill the encoded SIP URI
HBufC8* encodedSIPURI = HBufC8::NewL (encodedLength);
TPtr8 encodedSIPURIPtr = encodedSIPURI->Des();
encodedSIPURIPtr.Append(scheme);
encodedSIPURIPtr.Append(KColon);
if (iUser)
{
encodedSIPURIPtr.Append(*iUser);
if (iPassword)
{
encodedSIPURIPtr.Append(KColon);
encodedSIPURIPtr.Append(*iPassword);
}
encodedSIPURIPtr.Append(KAt);
}
encodedSIPURIPtr.Append(*hostPort);
if (uriParams->Length() > 0)
{
encodedSIPURIPtr.Append(KSemiColon);
encodedSIPURIPtr.Append (*uriParams);
}
if (uriHeaders->Length() > 0)
{
encodedSIPURIPtr.Append(KQuestionMark);
encodedSIPURIPtr.Append (*uriHeaders);
}
CleanupStack::PopAndDestroy(uriHeaders);
CleanupStack::PopAndDestroy(uriParams);
CleanupStack::PopAndDestroy(hostPort);
return encodedSIPURI;
}
// -----------------------------------------------------------------------------
// CSIPURI::ParseSipSchemeL
// -----------------------------------------------------------------------------
//
TPtrC8 CSIPURI::ParseSipSchemeL (const TDesC8& aValue)
{
__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURIScheme));
_LIT8(KSIPAndColon, "sip:");
_LIT8(KSIPSAndColon, "sips:");
TPtrC8 schemeAndColon;
TInt sipSchemePos = aValue.FindF(KSIPAndColon);
if (sipSchemePos < 0)
{
TInt sipsSchemePos = aValue.FindF(KSIPSAndColon);
if (sipsSchemePos != 0)
{
User::Leave (KErrSipCodecURIScheme);
}
schemeAndColon.Set(KSIPSAndColon);
iIsSIPSURI = ETrue;
}
else
{
if (sipSchemePos != 0)
{
User::Leave (KErrSipCodecURIScheme);
}
schemeAndColon.Set(KSIPAndColon);
iIsSIPSURI = EFalse;
}
TPtrC8 remainder(aValue.Mid(schemeAndColon.Length()));
return remainder;
}
// -----------------------------------------------------------------------------
// CSIPURI::ParseL
// -----------------------------------------------------------------------------
//
void CSIPURI::ParseL (const TDesC8& aValue)
{
TPtrC8 remainder(aValue);
TInt atPos = 0;
LocateSeparatorL(aValue, '@', atPos);
if (atPos > 0) // has userinfo
{
ParseUserInfoL(aValue.Left(atPos));
remainder.Set(aValue.Mid(atPos+1));
}
TInt semiColonPos = 0;
LocateSeparatorL(remainder, ';', semiColonPos);
if (semiColonPos > 0) // has uri-parameters
{
iHostPort = CSIPHostPort::DecodeL (remainder.Left(semiColonPos));
remainder.Set(remainder.Mid(semiColonPos+1));
TInt questionMarkPos = 0;
LocateSeparatorL(remainder, '?', questionMarkPos);
TPtrC8 uriParams;
if (questionMarkPos > 0) // has uri-headers
{
uriParams.Set(remainder.Left(questionMarkPos));
TPtrC8 uriHeaders(remainder.Mid(questionMarkPos+1));
SetURIHeaders (CSIPURIHeaders::DecodeL(uriHeaders));
}
else // does not have uri-headers
{
uriParams.Set(remainder);
}
SetURIParams(CSIPURIParams::DecodeL(uriParams,iIsSIPSURI));
}
else // does not have uri-parameters
{
TInt questionMarkPos = 0;
LocateSeparatorL(remainder, '?', questionMarkPos);
if (questionMarkPos > 0) // has uri-headers
{
iHostPort = CSIPHostPort::DecodeL (remainder.Left(questionMarkPos));
TPtrC8 uriHeaders(remainder.Mid(questionMarkPos+1));
SetURIHeaders (CSIPURIHeaders::DecodeL(uriHeaders));
}
else
{
iHostPort = CSIPHostPort::DecodeL (remainder);
}
}
}
// -----------------------------------------------------------------------------
// CSIPURI::ParseUserInfoL
// -----------------------------------------------------------------------------
//
void CSIPURI::ParseUserInfoL (const TDesC8& aValue)
{
__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURI));
TInt colonPos = 0;
LocateSeparatorL(aValue, ':', colonPos);
if (colonPos > 0) // has both user and password part
{
SetUserL (aValue.Left(colonPos));
SetPasswordL (aValue.Mid(colonPos+1));
}
else // has only user part
{
SetUserL (aValue);
}
}
// -----------------------------------------------------------------------------
// CSIPURI::LocateSeparatorL
// -----------------------------------------------------------------------------
//
void CSIPURI::LocateSeparatorL(
const TDesC8& aValue,
TChar aSeparator,
TInt& aPosition) const
{
__ASSERT_ALWAYS (aValue.Length() > 0, User::Leave (KErrSipCodecURI));
TInt position = aValue.Locate(aSeparator);
if (position == 0 || position == aValue.Length()-1)
{
User::Leave (KErrSipCodecURI);
}
aPosition = position;
}
// -----------------------------------------------------------------------------
// CSIPURI::SetURIParams
// -----------------------------------------------------------------------------
//
void CSIPURI::SetURIParams (CSIPURIParams* aURIParams)
{
delete iURIParams;
iURIParams = aURIParams;
}
// -----------------------------------------------------------------------------
// CSIPURI::SetURIHeaders
// -----------------------------------------------------------------------------
//
void CSIPURI::SetURIHeaders (CSIPURIHeaders* aURIHeaders)
{
delete iURIHeaders;
iURIHeaders = aURIHeaders;
}