1 /*

     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  MeteringReportResponse Parser

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <e32base.h>

    22 #include "Base64.h"

    23 #include "RoapParser.h"

    24 #include "MeteringReportResp.h"

    25 #include "MeteringReportRespParser.h"

    26 

    27 using namespace Roap;

    28 

    29 // LOCAL CONSTANTS AND MACROS

    30 _LIT8(KStatus, "status");

    31 

    32 // ============================ MEMBER FUNCTIONS ===============================

    33 

    34 // -----------------------------------------------------------------------------

    35 // TRegistrationRespParser::TRegistrationRespParser

    36 // C++ default constructor can NOT contain any code, that

    37 // might leave.

    38 // -----------------------------------------------------------------------------

    39 //

    40 TMeteringRespParser::TMeteringRespParser(

    41     CMeteringResp* aResponse)

    42     {

    43     iResponse = aResponse;

    44     }

    45 

    46 // -----------------------------------------------------------------------------

    47 // TMeteringRespParser::OnStartElementL

    48 // -----------------------------------------------------------------------------

    49 //

    50 void TMeteringRespParser::OnStartElementL(

    51     CRoapParser& aParser,

    52     TInt aState,

    53     const RTagInfo& /*aElement*/,

    54     const RAttributeArray& aAttributes)

    55     {

    56     HBufC8* buffer = NULL;

    57 

    58     switch (aState)

    59         {

    60         case EMeteringReportResponseState:

    61             buffer = aParser.GetAttributeValueL(aAttributes, KStatus);

    62             if ( buffer )

    63                 {

    64                 CleanupStack::PushL( buffer );

    65 

    66                 // In case of a malformer request

    67                 _LIT8(KStatus, "MalFormedRequest");

    68                 if ( buffer->Compare( KStatus ) == 0 )

    69                     {

    70                     iResponse->iStatus = EMalformedRequest;

    71                     }

    72                 else

    73                     {

    74                     iResponse->iStatus = aParser.ConvertRoapStatus( *buffer );

    75                     }

    76                 CleanupStack::PopAndDestroy( buffer );

    77                 }

    78             else

    79                 {

    80                 iResponse->iStatus = EUnknownStatus;

    81                 }

    82             break;

    83         default:

    84             break;

    85         }

    86     }

    87 

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

    89 // TMeteringRespParser::OnEndElementL

    90 // -----------------------------------------------------------------------------

    91 //

    92 void TMeteringRespParser::OnEndElementL(

    93     CRoapParser& aParser,

    94     TInt aState,

    95     const RTagInfo& /*aElement*/)

    96     {

    97     HBufC8* buffer = NULL;

    98 

    99     if ( !aParser.iContent )

   100         {

   101         return;

   102         }

   103 

   104     switch (aState)

   105         {

   106         case EDeviceIdState:

   107             buffer = Base64DecodeL( *aParser.iContent );

   108             CleanupStack::PushL( buffer );

   109             if ( buffer->Length() != SHA1_HASH )

   110                 {

   111                 CleanupStack::PopAndDestroy( buffer );

   112                 User::Leave( KErrCorrupt );

   113                 }

   114             iResponse->iDeviceId.Copy( *buffer );

   115             CleanupStack::PopAndDestroy( buffer );

   116             break;

   117         case ERiIdState:

   118             buffer = Base64DecodeL( *aParser.iContent );

   119             CleanupStack::PushL( buffer );

   120             if ( buffer->Length() != SHA1_HASH )

   121                 {

   122                 User::Leave( KErrCorrupt );

   123                 }

   124             iResponse->iRiId.Copy( *buffer );

   125             CleanupStack::PopAndDestroy( buffer );

   126             buffer=NULL;

   127             break;

   128         case ENonceState:

   129             if( aParser.iContent->Length() )

   130                 {

   131                 buffer = Base64DecodeL( *aParser.iContent );

   132                 CleanupStack::PushL( buffer );

   133                 if ( buffer->Length() != KDeviceNonceLength )

   134                     {

   135                     User::Leave( KErrCorrupt );

   136                     }

   137                 CleanupStack::Pop( buffer );

   138                 iResponse->iDeviceNonce = buffer;

   139                 buffer=NULL;

   140                 }

   141             else

   142                 {

   143                 User::Leave( KErrCorrupt );

   144                 }

   145             break;

   146         case ESignatureState:

   147             iResponse->iSignature = Base64DecodeL( *aParser.iContent );

   148             break;

   149         case ECertificateState:

   150             buffer = Base64DecodeL( *aParser.iContent );

   151             CleanupStack::PushL( buffer );

   152             iResponse->iCertificateChain.AppendL( buffer );

   153             CleanupStack::Pop( buffer );

   154             break;

   155         case EOcspResponseState:

   156             buffer = Base64DecodeL(*aParser.iContent);

   157             CleanupStack::PushL(buffer);

   158             iResponse->iOcspResponse.AppendL(buffer);

   159             CleanupStack::Pop( buffer );

   160             break;

   161         case EPostResponseUrlState:

   162             if ( aParser.iContent )

   163                 {

   164                 iResponse->iPrUrl = aParser.iContent->AllocL();

   165                 }

   166             else

   167                 {

   168                 User::Leave( KErrCorrupt );

   169                 }

   170             break;

   171         default:

   172             break;

   173         }

   174     }

   175 

   176 //  End of File