1 // Copyright (c) 2004-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          : CSIPSecurityServerHeader.cpp

    15 // Part of       : SIP Codec

    16 // Version       : SIP/4.0 

    17 //

    18 

    19 

    20 

    21 #include "sipsecurityserverheader.h"

    22 #include "CSIPTokenizer.h"

    23 #include "sipcodecerr.h"

    24 #include "sipstrings.h"

    25 #include "sipstrconsts.h"

    26 #include "_sipcodecdefs.h"

    27 

    28 

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

    30 // CSIPSecurityServerHeader::DecodeL

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

    32 //

    33 EXPORT_C RPointerArray<CSIPSecurityServerHeader> 

    34 CSIPSecurityServerHeader::DecodeL (const TDesC8& aValue)

    35 	{

    36     RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);

    37     CSIPHeaderBase::PushLC(&baseheaders);

    38     RPointerArray<CSIPSecurityServerHeader> serverHeaders;

    39     CleanupClosePushL(serverHeaders);

    40     TInt count = baseheaders.Count();

    41     for (TInt i=0; i < count; i++)

    42 		{

    43 		CSIPSecurityServerHeader* header = 

    44             static_cast<CSIPSecurityServerHeader*>(baseheaders[i]);

    45 		User::LeaveIfError (serverHeaders.Append(header));

    46 		}

    47     CleanupStack::Pop(2); //serverHeaders, baseheaders

    48     baseheaders.Close();

    49     return serverHeaders;

    50 	}

    51 

    52 // -----------------------------------------------------------------------------

    53 // CSIPSecurityServerHeader::NewL

    54 // -----------------------------------------------------------------------------

    55 //

    56 EXPORT_C CSIPSecurityServerHeader* CSIPSecurityServerHeader::NewL(

    57     const TDesC8& aMechanism)

    58     {

    59 	CSIPSecurityServerHeader* self = 

    60         CSIPSecurityServerHeader::NewLC(aMechanism);

    61 	CleanupStack::Pop(self);

    62 	return self;

    63     }

    64 

    65 // -----------------------------------------------------------------------------

    66 // CSIPSecurityServerHeader::NewLC

    67 // -----------------------------------------------------------------------------

    68 //

    69 EXPORT_C CSIPSecurityServerHeader* CSIPSecurityServerHeader::NewLC(

    70     const TDesC8& aMechanism)

    71     {

    72 	CSIPSecurityServerHeader* self = new(ELeave)CSIPSecurityServerHeader;

    73 	CleanupStack::PushL(self);

    74     self->CSIPSecurityHeaderBase::ConstructL(aMechanism);

    75 	return self;

    76     }

    77 

    78 // -----------------------------------------------------------------------------

    79 // CSIPSecurityServerHeader::CSIPSecurityServerHeader

    80 // -----------------------------------------------------------------------------

    81 //

    82 CSIPSecurityServerHeader::CSIPSecurityServerHeader()

    83 	{

    84 	}

    85 

    86 // -----------------------------------------------------------------------------

    87 // CSIPSecurityServerHeader::~CSIPSecurityServerHeader

    88 // -----------------------------------------------------------------------------

    89 //

    90 EXPORT_C CSIPSecurityServerHeader::~CSIPSecurityServerHeader()

    91 	{

    92 	}

    93 

    94 // -----------------------------------------------------------------------------

    95 // CSIPSecurityServerHeader::CloneL

    96 // From CSIPHeaderBase:

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

    98 //

    99 EXPORT_C CSIPHeaderBase* CSIPSecurityServerHeader::CloneL () const

   100 	{

   101     CSIPSecurityServerHeader* clone = new(ELeave) CSIPSecurityServerHeader;

   102     CleanupStack::PushL( clone );

   103     clone->ConstructL( *this );

   104     CleanupStack::Pop( clone );

   105 	return clone;

   106 	}

   107 

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

   109 // CSIPSecurityServerHeader::Name

   110 // From CSIPHeaderBase:

   111 // -----------------------------------------------------------------------------

   112 //		

   113 EXPORT_C RStringF CSIPSecurityServerHeader::Name() const

   114     {

   115     return SIPStrings::StringF(SipStrConsts::ESecurityServerHeader);

   116     }

   117 

   118 // -----------------------------------------------------------------------------

   119 // CSIPSecurityServerHeader::BaseDecodeL

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

   121 //

   122 RPointerArray<CSIPHeaderBase> 

   123 CSIPSecurityServerHeader::BaseDecodeL(const TDesC8& aValue)

   124     {

   125 	__ASSERT_ALWAYS (aValue.Length() > 0, 

   126                      User::Leave(KErrSipCodecSecurityHeader));

   127 

   128 	RPointerArray<CSIPHeaderBase> headers;

   129     CSIPHeaderBase::PushLC(&headers);

   130 	CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ',');

   131 	for (TInt i=0; i < tokenizer->Tokens().Count(); i++)

   132 		{

   133         CSIPSecurityServerHeader* header = 

   134             new(ELeave) CSIPSecurityServerHeader;

   135         CleanupStack::PushL(header);

   136         header->ConstructL();

   137 		header->ParseL (tokenizer->Tokens()[i]);

   138 		headers.AppendL(header);

   139 		CleanupStack::Pop(header);

   140 		}

   141 	CleanupStack::PopAndDestroy(tokenizer);

   142 	CleanupStack::Pop(); // headers 

   143 	return headers;

   144     }