1 /*

     2 * Copyright (c) 2002-2004 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:  ?Description

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <e32base.h>

    22 #include "Base64.h"

    23 #include "RoapParser.h"

    24 #include "RIHello.h"

    25 #include "RIHelloParser.h"

    26 

    27 using namespace Roap;

    28 

    29 // LOCAL CONSTANTS AND MACROS

    30 _LIT8(KStatus, "status");

    31 _LIT8(KType, "type");

    32 _LIT8(KSessionId, "sessionId");

    33 _LIT8(KDeviceDetails, "DeviceDetails");

    34 _LIT8(KPeerKeyIdentifier, "PeerKeyIdentifier");

    35 _LIT8(KCertificateCaching, "CertificateCaching");

    36 _LIT8(KErrorUrl, "errorRedirectURL");

    37 

    38 // ============================ MEMBER FUNCTIONS ===============================

    39 

    40 // -----------------------------------------------------------------------------

    41 // TRIHelloParser::TRIHelloParser

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

    43 // might leave.

    44 // -----------------------------------------------------------------------------

    45 //

    46 TRIHelloParser::TRIHelloParser(

    47     CRIHello* aResponse)

    48     {

    49     iResponse = aResponse;

    50     }

    51 

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

    53 // TRIHelloRespParser::OnStartElementL

    54 // 

    55 // -----------------------------------------------------------------------------

    56 //

    57 void TRIHelloParser::OnStartElementL(

    58     CRoapParser& aParser,

    59     TInt aState,

    60     const RTagInfo& /*aElement*/,

    61     const RAttributeArray& aAttributes)

    62     {

    63     HBufC8* buffer = NULL;

    64 

    65     switch (aState)

    66         {

    67         case ERiHelloState:

    68             {

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

    70             if (buffer != NULL)

    71                 {

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

    73                 delete buffer;

    74                 }

    75             else

    76                 {

    77                 iResponse->iStatus = EUnknownStatus;

    78                 }

    79             iResponse->iSession =

    80                 aParser.GetAttributeValueL(aAttributes, KSessionId);

    81                               

    82             iResponse->iErrorUrl = aParser.GetAttributeValueL(aAttributes, KErrorUrl);

    83             break;

    84             }

    85         case EExtensionState:

    86             {

    87             buffer = aParser.GetAttributeValueL(aAttributes, KType );

    88             if(buffer != NULL)

    89                 {

    90                 if(buffer->Find(KDeviceDetails) >= KErrNone)

    91                     {

    92                     iResponse->iNeedDeviceDetails = ETrue;

    93                     }

    94                  if(buffer->Find(KPeerKeyIdentifier) >= KErrNone)

    95                     {

    96                     iResponse->iPeerKeyIdentifier = ETrue;

    97                     }

    98                  if(buffer->Find(KCertificateCaching) >= KErrNone)

    99                     {

   100                     iResponse->iCertificateCaching = ETrue;

   101                     }

   102                 delete buffer;

   103                 }

   104             break;

   105             }

   106         }

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // TRIHelloRespParser::OnEndElementL

   111 // 

   112 // -----------------------------------------------------------------------------

   113 //

   114 void TRIHelloParser::OnEndElementL(

   115     CRoapParser& aParser,

   116     TInt aState,

   117     const RTagInfo& /*aElement*/)

   118     {

   119     HBufC8* buffer = NULL;

   120     

   121     if( !aParser.iContent )

   122         {

   123         return;

   124         }

   125 

   126     switch (aState)

   127         {

   128         case ESelectedVersionState:

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

   130                 {

   131                 User::Leave( KErrCorrupt );

   132                 }

   133             iResponse->iSelectedVersion.Copy(*aParser.iContent);

   134             break;

   135         case ERiNonceState:

   136             iResponse->iRiNonce = Base64DecodeL(*aParser.iContent);

   137             break;

   138         case ERiIdState:

   139             buffer = Base64DecodeL(*aParser.iContent);

   140             if ( buffer->Length() > SHA1_HASH )

   141                 {

   142                 delete buffer;

   143                 buffer = NULL;

   144                 User::Leave( KErrCorrupt );

   145                 }

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

   147             delete buffer;

   148             break;

   149         case ESelectedAlgorithmState:

   150             buffer = aParser.iContent->AllocLC();

   151             iResponse->iAlgorithms.AppendL( buffer );

   152             CleanupStack::Pop();

   153             break;

   154         case EServerInfoState:

   155             iResponse->iServerInfo = aParser.iContent->AllocL();   

   156             break;

   157         case ETrustedAuthoritiesState:

   158             buffer = Base64DecodeL(*aParser.iContent);

   159             iResponse->iTrustedAuthorities.AppendL(buffer);

   160             break;

   161         case EPeerKeyIdentifierRIHelloState:

   162             buffer = Base64DecodeL(*aParser.iContent);

   163             if ( buffer->Length() > SHA1_HASH )

   164                 {

   165                 delete buffer;

   166                 buffer = NULL;

   167                 User::Leave( KErrCorrupt );

   168                 }

   169             iResponse->iPeerKeyId.Copy(*buffer);

   170             delete buffer;

   171             break;

   172         }

   173     }

   174 

   175 //  End of File