/*

* Copyright (c) 2004 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:  XML Parser implementation

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <utf.h>

#include <imcvcodc.h>

#include <PEngWVPresenceErrors2.h>

#include "CPEngXMLParser.h"

#include "MPEngAdvTransactionStatus2.h"

#include "CPEngParserStack.h"

// =================== MACROS =======================

#define STORE_AND_RETURN_IF_IN_ERROR( aParser, aErr ) \

    if ( aErr < KErrNone ) \

        { \

        aParser->SetError( aErr ); \

        return NW_STAT_FAILURE; \

        } \

// ================= LOCAL FUNCTIONS =======================

/**

 * Maps given CSP status code to WV error code range

 * defined in PEngWVPresenceErrors.h

 *

 * @since 3.0

 * @param aCSPStatusCode The CSP status code to map.

 * @return WV Error code.

 */

TInt MapWVCspStatusToError( TInt aCSPStatusCode )

    {

    //Map the CSP successful (200) ==> KErrNone

    if ( aCSPStatusCode == 200 )

        {

        return KErrNone;

        }

    return KPEngErrorWVServerResponseBase - aCSPStatusCode;

    }

/**

 * Checks is the given CSP status code in the CSP status code range.

  *

 * @since 3.0

 * @param aCSPStatusCode The CSP status code to check.

 * @return ETrue if the given int is inside of the CSP status code range.

 *         Else EFalse.

 */

TInt IsInCspStatusCodeRange( TInt aCSPStatusCode )

    {

    return ( aCSPStatusCode >= KPEngWVStatusCodeBase ) &&

           ( aCSPStatusCode <= KPEngWVStatusCodeTop );

    }

/**

 * Decodes given CSP status code descriptor block

 * to WV error code.

 *

 * @since 3.0

 * @param aCSPStatusCode The CSP status code to map.

 * @param aWVErrorCode The mapped error code

 * @return ETrue if the decode was successful.

 *         Else EFalse.

 */

TBool DecodeWVCspStatusCodeToError( const TDesC8& aCSPStatusCode,

                                    TInt& aWVErrorCode )

    {

    //Try decode the CSP status code to integer & map it to WV Error Code

    TInt cspStatusInt;

    TLex8 lexer( aCSPStatusCode );

    lexer.SkipSpace();

    TInt lexErr = lexer.Val( cspStatusInt );

    if ( lexErr == KErrNone )

        {

        if ( IsInCspStatusCodeRange( cspStatusInt ) )

            {

            aWVErrorCode = MapWVCspStatusToError( cspStatusInt );

            return ETrue;

            }

        }

    return EFalse;

    }

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

// Two-phased constructor.

EXPORT_C CPEngXMLParser* CPEngXMLParser::NewLC()

    {

    CPEngXMLParser* self = new ( ELeave ) CPEngXMLParser;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CPEngXMLParser::~CPEngXMLParser()

    {

    iResults.Close();

    delete iIntervals;

#if _BullseyeCoverage

    cov_write();

#endif

    }

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

// might leave.

//

CPEngXMLParser::CPEngXMLParser()

    {

    }

// Symbian OS default constructor can leave.

void CPEngXMLParser::ConstructL()

    {

    iIntervals = CPEngParserStack::NewL();

    iCallBacks.StartDocument_CB = StartDocument_CB; //StartDocument_CB;

    iCallBacks.EndDocument_CB = EndDocument_CB; //EndDocument_CB;

    iCallBacks.Tag_Start_CB = Tag_Start_CB;

    iCallBacks.Attr_Start_CB = NULL; //Attr_Start_CB;

    iCallBacks.Attr_VarVal_CB = NULL; //Attr_VarVal_CB;

    iCallBacks.Attributes_End_CB = NULL; //Attributes_End_CB;

    iCallBacks.Tag_End_CB = Tag_End_CB;

    iCallBacks.Content_CB = NULL; //Content_CB;

    iCallBacks.Cdata_CB = NULL; //Cdata_CB;

    iCallBacks.Comment_CB = NULL; //Comment_CB;

    iCallBacks.PiForm_CB = NULL; //PiForm_CB;

    iCallBacks.Exception_CB = Exception_CB;  // Mostly for debugging purposes

    iCallBacks.Extension_CB = NULL; //Extension_CB;

    iCallBacks.Attr_Entity_VarVal_CB = NULL; //Attr_Entity_VarVal_CB;

    iCallBacks.pClientPointer = ( void* ) this;

    }

// ---------------------------------------------------------

// CPEngAttributeLibraryModel::DecodeL()

//

// ---------------------------------------------------------

//

TBool CPEngXMLParser::DecodeL( const TDesC8& aBuffer,

                               const TDesC8& aString,

                               TBool aTags,

                               TInt aLevel )

    {

    iMaxParseLevel = aLevel;

    iData.Set( aBuffer );

    iSearchable.Set( aString );

    iIncludeTags = aTags;

    ResetResults();

    NW_XML_Reader_InitFromBuffer( &iReader, aBuffer.Size(), const_cast<TUint8*>( iData.Ptr() ) );

    NW_XML_Reader_SetEncoding( &iReader, HTTP_iso_8859_1 );

    //Parse & Handle Errors

    NW_Status_t status = NW_XML_Parse( &iReader, &iCallBacks );

    if ( iError != KErrNone )

        {

        User::Leave( iError );

        }

    if ( status == NW_STAT_OUT_OF_MEMORY )

        {

        User::Leave( KErrNoMemory );

        }

    if ( status != NW_STAT_SUCCESS )

        {

        User::Leave( KPEngNwErrInternalServerOrNetworkError );

        }

    //And return did we find something

    if ( iResults.Count() > 0 )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

// ---------------------------------------------------------

// CPEngXMLParser::Count()

// Returns the result count

// ---------------------------------------------------------

//

TInt CPEngXMLParser::Count()

    {

    return iResults.Count();

    }

// ---------------------------------------------------------

// CPEngXMLParser::ResultL()

// ---------------------------------------------------------

//

TPtrC8 CPEngXMLParser::ResultL( TInt aIndex )

    {

    //Get plain result

    if ( aIndex >= iResults.Count() || aIndex < 0 )

        {

        User::Leave( KErrArgument );

        }

    return iResults[aIndex];

    }

// ---------------------------------------------------------

// CPEngXMLParser::ResultAsNarrowTextL()

// ---------------------------------------------------------

//

HBufC8* CPEngXMLParser::ResultAsNarrowTextL( TInt aIndex )

    {

    //Performed steps:

    //1. UnEscapes XML entities.

    return DoXMLUnEscapingL( ResultL( aIndex ) );

    }

// ---------------------------------------------------------

// CPEngXMLParser::ResultAsUnicodeTextL()

// ---------------------------------------------------------

//

HBufC16* CPEngXMLParser::ResultAsUnicodeTextL( TInt aIndex )

    {

    // Performed steps:

    // 1. UnEscapes XML entities.

    // 2. Converts text from Utf8 to Unicode.

    HBufC8* xmlUnEscaped = DoXMLUnEscapingL( ResultL( aIndex ) );

    CleanupStack::PushL( xmlUnEscaped );

    HBufC16* unicode = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *xmlUnEscaped );

    CleanupStack::PopAndDestroy( xmlUnEscaped );

    return unicode;

    }

// ---------------------------------------------------------

// CPEngXMLParser::ResultAsWVAddressL()

// ---------------------------------------------------------

//

HBufC16* CPEngXMLParser::ResultAsWVAddressL( TInt aIndex )

    {

    // Performed steps:

    // 1. UnEscapes XML entities.

    // 2. Converts text from Utf8 to Unicode.

    // 3. UnEscapes WV Address characters

    HBufC8* xmlUnEscaped = DoXMLUnEscapingL( ResultL( aIndex ) );

    CleanupStack::PushL( xmlUnEscaped );

    HBufC16* unicode = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *xmlUnEscaped );

    CleanupStack::PopAndDestroy( xmlUnEscaped );

    CleanupStack::PushL( unicode );

    HBufC16* wvAddress = DoWVAddressUnescapeL( *unicode );

    CleanupStack::PopAndDestroy( unicode );

    return wvAddress;

    }

// ---------------------------------------------------------

// CPEngXMLParser::ResultAsBase64DecodedL()

// ---------------------------------------------------------

//

HBufC8* CPEngXMLParser::ResultAsBase64DecodedL(  TInt aIndex )

    {

    // Performed steps:

    // 1. Coverts data from the BASE64 format

    HBufC8* decodedBuffer8 = HBufC8::NewLC( ResultL( aIndex ).Length() );

    TPtr8 decodedPtr8( decodedBuffer8->Des() );

    TImCodecB64 base64Decoder;

    base64Decoder.Initialise();

    // Decode returns ETrue, more data is needed to complete the decoding

    // ==> in this case the received buffer is considered as corrupted

    TBool moreDataNeeded = base64Decoder.Decode( ResultL( aIndex ), decodedPtr8 );

    if ( moreDataNeeded )

        {

        User::Leave( KErrCorrupt );

        }

    decodedBuffer8 = decodedBuffer8->ReAllocL( decodedBuffer8->Length() );

    CleanupStack::Pop(); //decodedBuffer8

    return decodedBuffer8;

    }

// ---------------------------------------------------------

// CPEngXMLParser::ParseResultL()

// Parses the generic WV result from the XML packet

// ---------------------------------------------------------

//

TInt CPEngXMLParser::ParseResultL( const TDesC8& aBuffer,

                                   TInt aOperationID,

                                   MPEngAdvTransactionStatus2& aStatus,

                                   TBool& aResultRequired )

    {

    return DoParseResultL( aBuffer,

                           aStatus,

                           aOperationID,

                           NULL,

                           NULL,

                           aResultRequired );

    }

// ---------------------------------------------------------

// CPEngXMLParser::ParseResultL()

// Parses the generic WV result from the XML packet

// ---------------------------------------------------------

//

TInt CPEngXMLParser::ParseResultL( const TDesC8& aBuffer,

                                   TInt aOperationID,

                                   MPEngAdvTransactionStatus2& aStatus )

    {

    //By default - result is required

    TBool resultRequired = ETrue;

    return DoParseResultL( aBuffer,

                           aStatus,

                           aOperationID,

                           NULL,

                           NULL,

                           resultRequired );

    }

// ---------------------------------------------------------

// CPEngXMLParser::ParseContactListResultL()

// Parses the contact list related WV result from the

// XML packet.

// ---------------------------------------------------------

//

TInt CPEngXMLParser::ParseContactListResultL( const TDesC8& aBuffer,

                                              TInt aOperationID,

                                              const TDesC& aContactList,

                                              MPEngAdvTransactionStatus2& aStatus )

    {

    //By default - result is required

    TBool resultRequired = ETrue;

    return DoParseResultL( aBuffer,

                           aStatus,

                           aOperationID,

                           NULL,

                           &aContactList,

                           resultRequired );

    }

// ---------------------------------------------------------

// CPEngXMLParser::Close()

// ---------------------------------------------------------

//

void CPEngXMLParser::Close()

    {

    delete this;

    }

// ---------------------------------------------------------

// CPEngXMLParser::ResetResults()

// ---------------------------------------------------------

//

void CPEngXMLParser::ResetResults()

    {

    iResults.Reset();

    iIntervals->Reset();

    iParsingLevel = 0;

    iError = KErrNone;

    }

// ---------------------------------------------------------

// CPEngXMLParser::DoWVAddressUnescapeL()

// ---------------------------------------------------------

//

HBufC16* CPEngXMLParser::DoWVAddressUnescapeL( const TDesC16& aSrc )

    {

    HBufC16* destBuffer = HBufC16::NewLC( aSrc.Length() );

    TPtr16 dest( destBuffer->Des() );

    // the length of the escape sequence, without the percent sign

    TBuf8<2> value;

    TInt srcLen( aSrc.Length() );

    for ( TInt i( 0 ); i < srcLen; i++ )

        {

        if ( aSrc[i] == '%' )

            {

            // check if there is enough characters to resolve the next real,

            // unescaped character

            if ( ( i + 2 ) >= srcLen )

                {

                // not enough chars to resolve the last escaped sequence

                // bail out

                break;

                }

            // let's take the next two characters, the encoded char is

            // of format %20

            value.Zero();

            value.Append( aSrc[++i] );

            value.Append( aSrc[++i] );

            // find the hexadecimal value from the string

            // and convert it to a character

            TLex8 lexer( value );

            TUint8 charVal;

            TInt retVal( lexer.Val( charVal, EHex ) );

            if ( retVal == KErrGeneral )

                {

                // could not convert escape chars to character value

                // just append the percent sign and characters

                dest.Append( '%' );

                dest.Append( value[0] );

                dest.Append( value[1] );

                }

            else if ( retVal != KErrNone )

                {

                User::Leave( retVal );

                }

            else

                {

                // append the found character to the destination buffer

                TChar escapedChar( charVal );

                dest.Append( escapedChar );

                }

            }

        else

            {

            // the character wasn't any escaped sequence starter -> just copy it

            dest.Append( aSrc[i] );

            }

        }

    destBuffer = destBuffer->ReAllocL( destBuffer->Length() );

    CleanupStack::Pop(); //old destBuffer

    return destBuffer;

    }

// ---------------------------------------------------------

// CPEngXMLParser::DoXMLUnEscaping()

// Decodes the XML escaped character sequences

// ---------------------------------------------------------

//

HBufC8* CPEngXMLParser::DoXMLUnEscapingL( const TDesC8& aSrc )

    {

    HBufC8* destBuffer = HBufC8::NewLC( aSrc.Length() );

    TPtr8 dest( destBuffer->Des() );

    TInt srcLen( aSrc.Length() );

    for ( TInt i( 0 ); i < srcLen; i++ )

        {

        if ( aSrc[i] == '&' )

            {

            // check if there is enough characters to resolve the next real,

            // unescaped character

            if ( ( i + 2 ) >= srcLen )

                {

                // not enough chars to resolve the last escaped sequence

                // bail out

                break;