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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Name          : CURIContainer.cpp

    15 // Part of       : SIP Codec

    16 // Version       : SIP/4.0 

    17 //

    18 

    19 

    20 

    21 #include "uricontainer.h"

    22 #include "sipstrings.h"

    23 #include "sipstrconsts.h"

    24 #include "sipuri.h"

    25 #include "sipcodecerr.h"

    26 #include "SIPHeaderLookup.h"

    27 #include "_sipcodecdefs.h"

    28 

    29 // ----------------------------------------------------------------------------

    30 // CURIContainer::DecodeL

    31 // ----------------------------------------------------------------------------

    32 //

    33 EXPORT_C CURIContainer* CURIContainer::DecodeL(const TDesC8& aValue)

    34 	{

    35     HBufC8* trimmedValue = aValue.AllocLC();

    36     trimmedValue->Des().Trim();

    37 

    38     __ASSERT_ALWAYS(trimmedValue->Length() > 0, User::Leave(KErrSipCodecURI));

    39 

    40     CURIContainer* container = new(ELeave) CURIContainer;

    41     CleanupStack::PushL(container);

    42     container->ConstructL();

    43     if(SIPHeaderLookup::ConvertToSIPURI())

    44         {

    45         if(FindSIP(*trimmedValue))

    46             {

    47             CSIPURI* sipuri = CSIPURI::DecodeL(*trimmedValue);

    48             CleanupStack::PushL(sipuri);

    49             container->iSIPURI = sipuri;

    50             CleanupStack::Pop(sipuri);

    51             }

    52         else

    53             {

    54             CUri8* uri8 = CreateUri8L(*trimmedValue);

    55             CleanupStack::PushL(uri8);

    56             container->iUri8 = uri8;

    57             CleanupStack::Pop(uri8);

    58             }

    59         }

    60     else

    61         {

    62         CUri8* uri8 = CreateUri8L(*trimmedValue);

    63         CleanupStack::PushL(uri8);

    64         container->iUri8 = uri8;

    65         CleanupStack::Pop(uri8);

    66         }

    67     CleanupStack::Pop(container);

    68     

    69     CleanupStack::PopAndDestroy(trimmedValue);

    70     

    71     return container;

    72 	}

    73 

    74 // ----------------------------------------------------------------------------

    75 // CURIContainer::NewL

    76 // ----------------------------------------------------------------------------

    77 //

    78 EXPORT_C CURIContainer* CURIContainer::NewL(CUri8* aUri8)

    79     {

    80     CURIContainer* self = CURIContainer::NewLC(aUri8);

    81     CleanupStack::Pop(self);

    82     return self;

    83     }

    84 

    85 // ----------------------------------------------------------------------------

    86 // CURIContainer::NewLC

    87 // ----------------------------------------------------------------------------

    88 //

    89 EXPORT_C CURIContainer* CURIContainer::NewLC(CUri8* aUri8)

    90     {

    91     CURIContainer* self = new(ELeave) CURIContainer;

    92     CleanupStack::PushL(self);

    93     self->ConstructL(aUri8);

    94     return self;

    95     }

    96 

    97 // ----------------------------------------------------------------------------

    98 // CURIContainer::NewL

    99 // ----------------------------------------------------------------------------

   100 //

   101 EXPORT_C CURIContainer* CURIContainer::NewL(const CURIContainer& aURI)

   102     {

   103 	CURIContainer* self = CURIContainer::NewLC(aURI);

   104 	CleanupStack::Pop(self);

   105 	return self;

   106     }

   107 

   108 // ----------------------------------------------------------------------------

   109 // CURIContainer::NewLC

   110 // ----------------------------------------------------------------------------

   111 //

   112 EXPORT_C CURIContainer* CURIContainer::NewLC(const CURIContainer& aURI)

   113     {

   114 	CURIContainer* self = new (ELeave) CURIContainer;

   115 	CleanupStack::PushL(self);

   116 	self->ConstructL(aURI);

   117 	return self;

   118     }

   119 

   120 // ----------------------------------------------------------------------------

   121 // CURIContainer::~CURIContainer

   122 // ----------------------------------------------------------------------------

   123 //

   124 EXPORT_C CURIContainer::~CURIContainer()

   125     {

   126     delete iSIPURI;

   127     delete iUri8;

   128     SIPHeaderLookup::Close();

   129     }

   130 

   131 // ----------------------------------------------------------------------------

   132 // CURIContainer::ConstructL

   133 // ----------------------------------------------------------------------------

   134 //

   135 void CURIContainer::ConstructL()

   136     {

   137     SIPHeaderLookup::OpenL();

   138     }

   139 

   140 // ----------------------------------------------------------------------------

   141 // CURIContainer::ConstructL

   142 // ----------------------------------------------------------------------------

   143 //

   144 void CURIContainer::ConstructL(CUri8* aUri8)

   145     {

   146     SIPHeaderLookup::OpenL();

   147     if(SIPHeaderLookup::ConvertToSIPURI())

   148         {

   149         if(FindSIP(aUri8->Uri().UriDes()))

   150             {

   151             iSIPURI = CSIPURI::DecodeL(aUri8->Uri().UriDes());

   152             delete aUri8;

   153             }

   154         else

   155             {

   156             iUri8 = aUri8;

   157             }

   158         }

   159     else

   160         {

   161         iUri8 = aUri8;

   162         }

   163     }

   164 

   165 // ----------------------------------------------------------------------------

   166 // CURIContainer::ConstructL

   167 // ----------------------------------------------------------------------------

   168 //

   169 void CURIContainer::ConstructL(const CURIContainer& aURI)

   170     {

   171     SIPHeaderLookup::OpenL();

   172     if(aURI.IsSIPURI())

   173         {

   174         HBufC8* sipuriastext = aURI.iSIPURI->ToTextL();

   175         CleanupStack::PushL(sipuriastext);

   176         iSIPURI = CSIPURI::DecodeL(*sipuriastext);

   177         CleanupStack::PopAndDestroy(sipuriastext);

   178         }

   179     else

   180         {

   181         iUri8 = CUri8::NewL(aURI.Uri8()->Uri());

   182         }

   183     }

   184 

   185 // ----------------------------------------------------------------------------

   186 // CURIContainer::IsSIPURI

   187 // ----------------------------------------------------------------------------

   188 //

   189 EXPORT_C TBool CURIContainer::IsSIPURI() const

   190     {

   191     if(iSIPURI)

   192         {

   193         return ETrue;

   194         }

   195     return EFalse;

   196     }

   197 

   198 // ----------------------------------------------------------------------------

   199 // CURIContainer::SIPURI

   200 // ----------------------------------------------------------------------------

   201 //

   202 EXPORT_C CSIPURI* CURIContainer::SIPURI()

   203     {

   204     return iSIPURI;

   205     }

   206 

   207 // ----------------------------------------------------------------------------

   208 // CURIContainer::SIPURI

   209 // ----------------------------------------------------------------------------

   210 //

   211 EXPORT_C const CSIPURI* CURIContainer::SIPURI() const

   212     {

   213     return iSIPURI;

   214     }

   215 

   216 // ----------------------------------------------------------------------------

   217 // CURIContainer::Uri8

   218 // ----------------------------------------------------------------------------

   219 //

   220 EXPORT_C const CUri8* CURIContainer::Uri8() const

   221     {

   222     return iUri8;

   223     }

   224 

   225 // ----------------------------------------------------------------------------

   226 // CURIContainer::operator==

   227 // ----------------------------------------------------------------------------

   228 //

   229 EXPORT_C TBool CURIContainer::operator==(const CURIContainer& aURI) const

   230     {

   231     if(aURI.IsSIPURI() && IsSIPURI())

   232         {

   233         return (*iSIPURI == *aURI.iSIPURI);

   234         }

   235     if(!aURI.IsSIPURI() && !IsSIPURI())

   236         {

   237         if(aURI.Uri8()->Uri().UriDes().Compare(Uri8()->Uri().UriDes()) == 0)

   238             {

   239             return ETrue;

   240             }

   241         return EFalse;

   242         }

   243     return EFalse;

   244     }

   245 

   246 // ----------------------------------------------------------------------------

   247 // CURIContainer::ToTextL

   248 // ----------------------------------------------------------------------------

   249 //

   250 EXPORT_C HBufC8* CURIContainer::ToTextL() const

   251     {

   252     __ASSERT_ALWAYS((iUri8 || iSIPURI), User::Leave(KErrSipCodecURIContainer));

   253 

   254 	if(iSIPURI)

   255 	    {

   256         return iSIPURI->ToTextL();

   257 	    }

   258     return iUri8->Uri().UriDes().AllocL();

   259     }

   260 

   261 // ----------------------------------------------------------------------------

   262 // CURIContainer::InternalizeL

   263 // ----------------------------------------------------------------------------

   264 //

   265 EXPORT_C CURIContainer* CURIContainer::InternalizeL(RReadStream& aReadStream)

   266     {

   267     CURIContainer* container = new(ELeave) CURIContainer;

   268     CleanupStack::PushL(container);

   269     container->ConstructL();

   270     container->DoInternalizeL(aReadStream);

   271     CleanupStack::Pop(container);

   272     return container;

   273     }

   274 

   275 // ----------------------------------------------------------------------------

   276 // CURIContainer::ExternalizeL

   277 // ----------------------------------------------------------------------------

   278 //

   279 EXPORT_C void CURIContainer::ExternalizeL(RWriteStream& aWriteStream) const

   280     {

   281     if(IsSIPURI())

   282         {

   283         HBufC8* tmp = iSIPURI->ToTextL();

   284         CleanupStack::PushL(tmp);

   285         aWriteStream.WriteUint32L(tmp->Des().Length());

   286         aWriteStream.WriteL(tmp->Des());

   287         CleanupStack::PopAndDestroy(tmp);

   288         }

   289     else

   290         {

   291         TPtrC8 uri8(iUri8->Uri().UriDes());

   292         aWriteStream.WriteUint32L(uri8.Length());

   293         aWriteStream.WriteL(uri8);

   294         }

   295     }

   296 

   297 // ----------------------------------------------------------------------------

   298 // CURIContainer::CloneAsUri8L

   299 // ----------------------------------------------------------------------------

   300 //

   301 EXPORT_C CUri8* CURIContainer::CloneAsUri8L() const

   302     {

   303     HBufC8* uriAsText = ToTextL();

   304     CleanupStack::PushL(uriAsText);

   305     CUri8* clone = CreateUri8L(*uriAsText);

   306     CleanupStack::PopAndDestroy(uriAsText);

   307     return clone;

   308     }

   309 

   310 // ----------------------------------------------------------------------------

   311 // CURIContainer::DoInternalizeL

   312 // ----------------------------------------------------------------------------

   313 //

   314 void CURIContainer::DoInternalizeL(RReadStream& aReadStream)

   315     {

   316     TInt length(aReadStream.ReadUint32L());

   317     HBufC8* buffer = HBufC8::NewLC(length);

   318     TPtr8 bufptr(buffer->Des());

   319     aReadStream.ReadL(bufptr, length);

   320     if(SIPHeaderLookup::ConvertToSIPURI())

   321         {

   322         if(FindSIP(bufptr))

   323             {

   324             iSIPURI = CSIPURI::DecodeL(bufptr);

   325             }

   326         else

   327             {

   328             iUri8 = CreateUri8L(bufptr);

   329             }

   330         }

   331     else

   332         {

   333         iUri8 = CreateUri8L(bufptr);

   334         }

   335     CleanupStack::PopAndDestroy(buffer);

   336     }

   337 

   338 // ----------------------------------------------------------------------------

   339 // CURIContainer::CreateUri8L

   340 // ----------------------------------------------------------------------------

   341 //

   342 CUri8* CURIContainer::CreateUri8L(const TDesC8& aValue)

   343     {

   344     TUriParser8 parser;

   345     User::LeaveIfError(parser.Parse(aValue));

   346     TPtrC8 scheme(parser.Extract(EUriScheme));

   347     if (scheme.CompareF(SIPStrings::StringF(SipStrConsts::ESip).DesC()) == 0)

   348         {

   349         User::LeaveIfError(parser.Validate());

   350         }

   351     return CUri8::NewL(parser);

   352     }

   353 

   354 // ----------------------------------------------------------------------------

   355 // CURIContainer::FindSIP

   356 // ----------------------------------------------------------------------------

   357 //

   358 TBool CURIContainer::FindSIP(const TDesC8& aValue)

   359     {

   360     _LIT8(KSIP, "sip:");

   361     _LIT8(KSIPS, "sips:");

   362     TPtrC8 value(aValue);

   363     if(value.FindF(KSIP) == 0 ||

   364        value.FindF(KSIPS) == 0)

   365         {

   366         return ETrue;

   367         }

   368     return EFalse;

   369     }

   370