/*
* Copyright (c) 2004-2006 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: Implementation of PnPMS components
*
*/


// INCLUDE FILES
#include <e32svr.h>
#include "NHeadWrapperParser.h"
#include "NHwrParserLogger.h"
#include "HttpProvHeaders.h"
#include "HttpProvContent.h"
#include "HttpProvContentType.h"
#include "SupportedContentTypes.h"

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

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::CNHeadWrapperParser
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CNHeadWrapperParser::CNHeadWrapperParser()
    {
    }
    
// Destructor
EXPORT_C CNHeadWrapperParser::~CNHeadWrapperParser()
    {
    LOGSTRING("~CNHeadWrapperParser");
    delete iHttpProvHeaders;
    delete iHttpProvContentType;
    LOGSTRING("~CNHeadWrapperParser - done");
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CNHeadWrapperParser* CNHeadWrapperParser::NewL(const TPtrC8& aWrapperData)
    {
    CNHeadWrapperParser* self = new (ELeave) CNHeadWrapperParser;
    CleanupStack::PushL( self );
    self->ConstructL( aWrapperData );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CNHeadWrapperParser::ConstructL( const TPtrC8& aWrapperData )
    {
    iWrapperData.Set( aWrapperData );
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::ParseL
// -----------------------------------------------------------------------------
//
EXPORT_C THttpProvStates::TProvisioningStatus CNHeadWrapperParser::Parse()
    {
    LOGSTRING("CNHeadWrapperParser::Parse - begin");
    TRAPD( err, DoParseL() );
    if( err != KErrNone )
        {
        LOGSTRING("CNHeadWrapperParser::Parse ret: EStatusWrapperParsingFailed");
        return THttpProvStates::EStatusWrapperParsingFailed; // Do not continue
        }
        
    TRAP( err, CheckHeadWrapperL() );

    // CheckHeadWrapperL might leave with one of TProvisioningStatus codes
    // or with standard error codes
    if( err < 0 )    // standar error codes
        {
        LOGSTRING("CNHeadWrapperParser::Parse ret: EStatusWrapperParsingFailed");
        return THttpProvStates::EStatusWrapperParsingFailed;
        }
    else            // one of TProvisioningStatus
        {
        LOGSTRING2("CNHeadWrapperParser::Parse ret: %d", err);
        return (THttpProvStates::TProvisioningStatus) err;
        }
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::DoParseL
// -----------------------------------------------------------------------------
//
void CNHeadWrapperParser::DoParseL()
    {
    LOGSTRING( "CNHeadWrapperParser::DoParseL - begin" );
    LOGSTRING( "Check wrapper length " );
    // Check wrapper length min 6 bytes
    if( iWrapperData.Length() < 6 )
        {
        User::Leave( KErrCorrupt );
        }

    LOGSTRING( "Check signature" );
    // Check signature
    _LIT8( KHeadWrapperSignature, "NHWR" );
    if( iWrapperData.Left(4).Compare( KHeadWrapperSignature ) != 0 )
        {
        User::Leave( KErrCorrupt );
        }

    // Parse version
    TUint8 version = (iWrapperData)[4];
    if( version != 1 )
        {
        User::Leave( KErrNotSupported );
        }
        
    LOGSTRING( "Parse content type" );
    // Parse content type
    TUint8 contentTypeLen = (iWrapperData)[5];
    LOGSTRING2( "content type len: %i", contentTypeLen );

    if( iWrapperData.Length() < 6 + contentTypeLen )
        {   
        User::Leave( KErrCorrupt );
        }

    if( contentTypeLen < 1 )
        {
        User::Leave( KErrCorrupt );
        }

    iContentTypeField.Set( iWrapperData.Mid( 6, contentTypeLen ) );

    // Parse Headers and Content Length
    LOGSTRING( "Parse headers and data length" );
    if( iWrapperData.Length() < 6+contentTypeLen+2 ) //  +2 min for length datas
        {
        User::Leave( KErrCorrupt );
        }
    TUint32    headersLen = 0; //(*iWrapperData)[6+contentTypeLen+1];
    TUint32    contentLen = 0; //(*iWrapperData)[6+contentTypeLen+2];
    TUint headersVarLen = 0;
    TUint contentVarLen = 0;

    if( ParseUintVar( iWrapperData.Mid( 6+contentTypeLen ),
                      headersLen, headersVarLen ) != KErrNone )
        {
        User::Leave( KErrCorrupt );
        }
    LOGSTRING2( "headersLen %i", headersLen );
    LOGSTRING2( "headersVarLen %i", headersLen );

    if( ParseUintVar( iWrapperData.Mid( 6+contentTypeLen+headersVarLen ),
                      contentLen, contentVarLen ) != KErrNone )
        {
        LOGSTRING( "content length failed" );
        User::Leave( KErrCorrupt );
        }
    LOGSTRING2( "contentLen %i", contentLen );
    LOGSTRING2( "contentVarLen %i", contentVarLen );

    // Final check for sizes
    if( iWrapperData.Length() != (TInt)( 6+contentTypeLen+headersVarLen
        +contentVarLen+headersLen+contentLen ) )
        {
        LOGSTRING( "Lengths do not match" );
        LOGSTRING2( "Expected length %i", (TInt)( 6+contentTypeLen+headersVarLen
                                            +contentVarLen+headersLen+contentLen ) );
        LOGSTRING2( "Actual data length %i", iWrapperData.Length() );
        User::Leave( KErrCorrupt );
        }

    if( headersLen > 0 )
        {
        iHeaders.Set( iWrapperData.Mid( 6+contentTypeLen+headersVarLen
                                         +contentVarLen, headersLen ) ); 
        }

    LOGSTRING( "Parse content" );
    iContent.Set( iWrapperData.Mid( 6+contentTypeLen+headersVarLen+contentVarLen+headersLen,contentLen ) );

    // Log
#ifdef _DEBUG
    TInt i(0);
    LOGSTRING( "Content type:" );
    for( i = 0; i < iContentTypeField.Length(); i += 128 )
        {
        TPtrC8 logText = iContentTypeField.Right( iContentTypeField.Length() - i );
        LOGTEXT( logText );
        }

    if( iHeaders.Length() )
        {
        LOGSTRING( "Headers:" );
        for( i = 0; i < iHeaders.Length(); i += 128 )
            {
            TPtrC8 logText = iHeaders.Right( iHeaders.Length() - i );
            LOGTEXT( logText );
            }
        }

    LOGSTRING( "Content:" );
    for( i = 0; i < iContent.Length(); i += 128 )
        {
        TPtrC8 logText = iContent.Right( iContent.Length() - i );
        LOGTEXT( logText );
        }
#endif
    LOGSTRING( "CNHeadWrapperParser::DoParseL - end" );
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::CheckHeadWrapperL
// -----------------------------------------------------------------------------
//
void CNHeadWrapperParser::CheckHeadWrapperL()
    {
    LOGSTRING( "CNHeadWrapperParser::CheckHeadWrapperL()" );
    LOGSTRING( "Get content type" );
    if( iContentTypeField.Length() < 1 )
        {
        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
        }

    LOGSTRING( "Create CHttpProvContentType" );
    if( iHttpProvContentType )
        {
        delete iHttpProvContentType;
        iHttpProvContentType = 0;
        }
    TRAPD( err, iHttpProvContentType = CHttpProvContentType::NewL( iContentTypeField ) );
    LOGSTRING( "Create CHttpProvContentType 2" );
    if( err != KErrNone )
        {
        LOGSTRING2( "Content type, create failed: %i", err );
        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
        }

    LOGSTRING( "Get headers" );
    if( iHeaders.Length() < 1 )
        {
        LOGSTRING( "no headers" );
        // Plug and Play Mobile Services Specification.doc:
        // "The Headers field MAY contain headers defining additional
        // Meta data about the content"
        // if there is no headers in the wrapper we will just leave,
        // we do not want to open any unauthorized content:
        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
        }

    delete iHttpProvHeaders;
    iHttpProvHeaders = 0;
    iHttpProvHeaders = CHttpProvHeaders::NewL( iHeaders );
    
    LOGSTRING( "Get wrapper content" );
    if( iContent.Length() < 1 )
        {
        User::Leave( THttpProvStates::EStatusWrapperParsingFailed );
        }

    CHttpProvContent* c = CHttpProvContent::NewLC( iContent );

    TInt res( KErrNone );
    TRAP( err, res = c->AuthenticateL( *iHttpProvHeaders, *iHttpProvContentType ) );
    if( res == KHttpProvAuthResultTokenExpired )
        {
        User::Leave( THttpProvStates::EStatusTokenExpired );
        }
    else if( res!=KHttpProvAuthResultAuthenticated || err != KErrNone )
        {
        LOGSTRING2("AuthenticationFailed, res: %i", res );
        LOGSTRING2("err: %i", err );
        User::Leave( THttpProvStates::EStatusSignatureFailed );
        }

    CleanupStack::PopAndDestroy(c);
    LOGSTRING( "CNHeadWrapperParser::CheckHeadWrapperL() - done" );
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::ParseUintVar
// -----------------------------------------------------------------------------
//
TInt CNHeadWrapperParser::ParseUintVar(const TDesC8& aVarDes, TUint32& aVar, TUint &aVarLength)
    {
    TUint32 finalValue = 0;
    TInt i;
    for(i=0; i<5; i++)
        {
        if(aVarDes.Length()<=i)
            {
            return KErrCorrupt;
            }

        TUint8 val = aVarDes[i];
        finalValue <<= 7;
        finalValue |= (((TUint32)val)&0x7F);
        if( !(val&0x80 ) )
            {
            break;
            }
        }

    if(i==5)
        {
        return KErrCorrupt;
        }
    else
        {
        aVar = finalValue;
        aVarLength = i+1;
        return KErrNone;
        }
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetHeaders
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CNHeadWrapperParser::GetHeadersL() const
    {
    if( iHeaders.Length() < 1 )
        {
        User::Leave( KErrNotFound );
        }
    return iHeaders;
    }


// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetContentType
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CNHeadWrapperParser::GetContentTypeL() const
    {
    if( !iHttpProvContentType )
        {
        User::Leave( KErrNotFound );
        }
    return iHttpProvContentType->ContentTypeL();
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetContent
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CNHeadWrapperParser::GetContentL() const
    {
    if( iContent.Length() < 1 )
        {
        User::Leave( KErrNotFound );
        }
    return iContent;
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetReportUrlL
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CNHeadWrapperParser::GetReportUrlL() const
    {
    if( !iHttpProvHeaders )
        {
        User::Leave( KErrNotFound );
        }
    return iHttpProvHeaders->GetParamValL( KReportUrl );
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetProvisioningActivation
// -----------------------------------------------------------------------------
//
EXPORT_C TProvisioningActivation CNHeadWrapperParser::GetProvisioningActivation() const
    {
    // The default value is "User selects"
    TProvisioningActivation value( EProvisioningActivationUser );

    if( !iHttpProvHeaders )
        {
        return value;
        }

    TInt err( KErrNone );
    TPtrC8 descValue( KNullDesC8 );
    TRAP( err, descValue.Set( iHttpProvHeaders->GetParamValL( KProvisioningActivation ) ) );
    if( err != KErrNone )
        {
        return value;
        }

    TInt intValue(0);
    TLex8 parser( descValue );
    err = parser.Val( intValue );

    // ignore illegal values
    if( err != KErrNone )
        {
        return value;
        }

    if( intValue < EProvisioningActivationUser || intValue > EProvisioningActivationOff )
        {
        return value;
        }

    // cast
    value = (TProvisioningActivation) intValue;
    return value;
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetUserInteraction
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CNHeadWrapperParser::GetUserInteraction() const
    {
    // The default value is EFalse
    TBool value( EFalse );

    if( !iHttpProvHeaders )
        {
        return value;
        }

    TInt err( KErrNone );
    TRAP( err, value = GetBoolParamValueL( KUserInteraction ) );
    return value;
    }

// -----------------------------------------------------------------------------
// CNHeadWrapperParser::GetBoolParamValueL
// -----------------------------------------------------------------------------
//
TBool CNHeadWrapperParser::GetBoolParamValueL( const TDesC8& aParam ) const
    {
    LOGSTRING("CNHeadWrapperParser::GetBoolParamValueL");
    LOGTEXT( aParam );
    const TDesC8& paramVal = iHttpProvHeaders->GetParamValL( aParam );
    LOGTEXT( paramVal );
    if( paramVal.Compare( KStringValueTrue ) == 0 )
        {
        return ETrue;
        }
    return EFalse;        
    }

// End of File