/*

* Copyright (c) 2002 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:  Helps in saving/loading a push message.

*

*/

//  INCLUDE FILES

#include <e32base.h>

#include <msvstore.h>

#include <hash.h>

#include <chttpresponse.h>

#include <centralrepository.h>

#include "ProvisioningVariant.hrh"

#include "CWPPushMessage.h"

#include "ProvisioningDebug.h"

#include "ProvisioningUIDs.h"

#include "CWPEngine.pan"

#include "ProvisioningInternalCRKeys.h"

// CONSTANTS

/// Short integers must be masked with this to get real number

const TUint KShortIntegerMask = 0x7f;

/// In q-values if the number is above this number, there are more bytes.

const TUint KQValueContinuation = 0x80;

/// Quotes strings start with this constant.

const TUint KQuotedStringStart = 34;

/// Quotes strings start with this constant.

const TUint KQuotedTextStringStart = 127;

/// Maximum length of a long integer.

const TUint KMaxLongIntegerLength = 30;

/// Types of coding a value in a parameter

enum TParameterCodingType {

    EQValue,

    EWellKnownCharset,

    EVersionValue,

    EIntegerValue,

    ETextString,

    EFieldName,

    EShortInteger,

    EConstrainedEncoding,

    EDeltaSecondsValue,

    ENoValue,

    ETextValue,

    EDateValue

    };

/// Well-known parameter assignments and their mappings to value types

/// (WAP-230-WSP-20010705-a, table 38)

const TParameterCodingType KParameterTypes[] = 

    {

    EQValue,

    EWellKnownCharset,

    EVersionValue,

    EIntegerValue,

    ENoValue,

    ETextString,

    ETextString,

    EFieldName,

    EShortInteger,

    EConstrainedEncoding,

    ETextString,

    ETextString,

    ETextString,

    ETextString,

    EDeltaSecondsValue,

    ETextString,

    ENoValue,

    EShortInteger,

    ETextValue,

    EDateValue,

    EDateValue,

    EDateValue,

    EIntegerValue,

    ETextValue,

    ETextValue,

    ETextValue,

    ETextValue,

    ETextValue,

    ETextValue,

    ETextValue

    };

/// Date-values are seconds from this date

_LIT( KDateValueStart, "19700101:000000.000000" );

/// WSP constant for field SEC

const TInt KWSPHeaderSEC = 0x11;

/// WSP constant for field MAC

const TInt KWSPHeaderMAC = 0x12;

/// Number of BCD digits in byte

const TInt KNumDigitsInByte = 2;

/// Number of bits in half-byte

const TInt KNumBitsInNibble = 4;

/// Ascii code for zero

const TUint8 KZero = '0';

/// Padding half-byte

const TUint8 KPadNibble = 0xf;

/// First nibble

const TUint8 KFirstNibble = 0x1;

/// Parity bit number in first nibble

const TUint KParityBitNum = 3;

/// Content type code for OMA Provisioning messages

const TUint8 KContentType = 0xb6;

/// Provisioning message format version when stored in Messaging Store

const TInt KProvisioningMsgVersion = 1;

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

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

// CWPPushMessage::CWPPushMessage

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

// might leave.

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

//

CWPPushMessage::CWPPushMessage()

: iInitiator( KNullDesC8 ), iSEC( KSECNONE )

    {

    }

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

// CWPPushMessage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWPPushMessage::ConstructL()

    {

    iHeader = CHTTPResponse::NewL();

    }

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

// CWPPushMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CWPPushMessage* CWPPushMessage::NewL()

    {

    CWPPushMessage* self = NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// CWPPushMessage::NewLC

// Two-phased constructor.

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

//

EXPORT_C CWPPushMessage* CWPPushMessage::NewLC()

    {

    CWPPushMessage* self = new( ELeave ) CWPPushMessage;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CWPPushMessage::~CWPPushMessage()

    {

    delete iBody;

    delete iHeader;

    delete iOriginator;

    }

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

// CWPPushMessage::StoreL

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

//

EXPORT_C void CWPPushMessage::StoreL( CMsvStore& aStore ) const

    {

    TUid uid;

    uid.iUid = KProvisioningMessageStreamUid;

    aStore.Remove( uid );

    RMsvWriteStream stream;

    stream.AssignLC( aStore, uid );

    ExternalizeL( stream );

    CleanupStack::PopAndDestroy(); // stream

    }

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

// CWPPushMessage::RestoreL

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

//

EXPORT_C void CWPPushMessage::RestoreL( CMsvStore& aStore )

    {

    RMsvReadStream stream;

    stream.OpenLC( aStore, TUid::Uid( KProvisioningMessageStreamUid ) );

    InternalizeL( stream );

    CleanupStack::PopAndDestroy(); // stream

    ParseHeaderL();

    }

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

// CWPPushMessage::ExternalizeL

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

//

EXPORT_C void CWPPushMessage::ExternalizeL( RWriteStream& aStream ) const

    {

    // Save version

    aStream.WriteInt32L( KProvisioningMsgVersion );

    // Save the header

    aStream.WriteInt32L( iHeader->Response().Length() );

    aStream << iHeader->Response();

    aStream.WriteInt8L( iAuthenticated );

    aStream.WriteInt8L( iSaved );

    // Save the body

    aStream.WriteInt32L( iBody->Length() );

    aStream << *iBody;

    // The sender

    if( iOriginator )

        {

        aStream.WriteInt32L( iOriginator->Length() );

        aStream << *iOriginator;

        }

    else

        {

        aStream.WriteInt32L( KNullDesC8().Length() );

        }

    aStream.CommitL();

    }

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

// CWPPushMessage::InternalizeL

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

//

EXPORT_C void CWPPushMessage::InternalizeL( RReadStream& aStream )

    {

    // Restore the header

    TInt version( aStream.ReadInt32L() );

    TInt length( aStream.ReadInt32L() );

    HBufC8* header = HBufC8::NewLC( aStream, length );

    iAuthenticated = aStream.ReadInt8L();

    iSaved = aStream.ReadInt8L();

    // Restore the body

    length = aStream.ReadInt32L();

    HBufC8* body = HBufC8::NewL( aStream, length );

    // Store header and body

    CleanupStack::Pop(); // header

    Set( header, body );

    if( version == KProvisioningMsgVersion )

        {

        length = aStream.ReadInt32L();

        if( length > 0 )

            {

            delete iOriginator;

            iOriginator = NULL;

            iOriginator = HBufC8::NewL( aStream, length );

            }

        }

    }

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

// CWPPushMessage::SetL

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

//

EXPORT_C void CWPPushMessage::SetL( const TDesC8& aHeader, const TDesC8& aBody )

    {

    HBufC8* header = aHeader.AllocLC();

    HBufC8* body = aBody.AllocL();

    CleanupStack::Pop(); // header

    Set( header, body );

    }

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

// CWPPushMessage::Set

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

//

EXPORT_C void CWPPushMessage::Set( HBufC8* aHeader, HBufC8* aBody )

    {

    __ASSERT_DEBUG( aHeader && aBody, Panic( EWPNullMessage ) );

    iHeader->AddResponse( aHeader );

    delete iBody;

    iBody = aBody;

    }

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

// CWPPushMessage::SetOriginatorL

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

//

EXPORT_C void CWPPushMessage::SetOriginatorL( const TDesC8& aOrig )

    {

    HBufC8* orig = aOrig.AllocL();

    delete iOriginator;

    iOriginator = orig;

    }

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

// CWPPushMessage::Header

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

//

EXPORT_C const TDesC8& CWPPushMessage::Header() const

    {

    if( iHeader )

        {

        return iHeader->Response();

        }

    else

        {

        return KNullDesC8;

        }

    }

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

// CWPPushMessage::Body

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

//

EXPORT_C const TDesC8& CWPPushMessage::Body() const

    {

    if( iBody )

        {

        return *iBody;

        }

    else

        {

        return KNullDesC8;

        }

    }

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

// CWPPushMessage::Originator

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

//

EXPORT_C const TDesC8& CWPPushMessage::Originator() const

    {

    if( iOriginator )

        {

        return *iOriginator;

        }

    else

        {

        return KNullDesC8;

        }

    }

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

// CWPPushMessage::SetAuthenticated

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

//

EXPORT_C void CWPPushMessage::SetAuthenticated( TBool aAuthenticated )

    {

    iAuthenticated = aAuthenticated;

    }

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

// CWPPushMessage::Authenticated

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

//

EXPORT_C TBool CWPPushMessage::Authenticated() const

    {

    return iAuthenticated;

    }

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

// CWPPushMessage::SetSaved

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

//

EXPORT_C void CWPPushMessage::SetSaved( TBool aSaved )

    {

    iSaved = aSaved;

    }

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

// CWPPushMessage::Saved

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

//

EXPORT_C TBool CWPPushMessage::Saved() const

    {

    return iSaved;

    }

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

// CWPPushMessage::InitiatorURI

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

//

EXPORT_C const TDesC8& CWPPushMessage::InitiatorURI() const

    {

    return iInitiator;

    }

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

// CWPPushMessage::MAC

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

//

EXPORT_C const TDesC8& CWPPushMessage::MAC() const

    {

    return iMAC;

    }

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

// CWPPushMessage::SEC

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

//

EXPORT_C TUint CWPPushMessage::SEC() const

    {

    return iSEC;

    }

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

// CWPPushMessage::PushFlag

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

//

EXPORT_C TInt CWPPushMessage::PushFlag() const

    {

    return iPushFlag;

    }

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

// CWPPushMessage::ParseHeader

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

//

EXPORT_C void CWPPushMessage::ParseHeaderL()

    {

    // CHTTPResponse panicks if it is used for parsing a zero-length 

    // descriptor.

    if( iHeader->Response().Length() > 0 )

        {

        // We use lexer for safety.

        TLex8 contentType( ContentTypeHeader( *iHeader ) );

        if( !contentType.Eos() )

            {

            ParseContentType( contentType );

            }

        TLex8 initiatorURI( InitiatorURIHeader( *iHeader ) );

        if( !initiatorURI.Eos() )

            {

            ParseInitiatorURI( initiatorURI );

            }

        TLex8 pushFlag( PushFlagHeader( *iHeader ) );

        if( !pushFlag.Eos() )

            {

            ParsePushFlag( pushFlag );

            }

        }

    }

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

// CWPPushMessage::ParseInitiatorURI

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

//

void CWPPushMessage::ParseInitiatorURI( TLex8& aPointer )

    {

    iInitiator.Set( GetTextString( aPointer ) );

    }

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

// CWPPushMessage::ParsePushFlag

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

//

void CWPPushMessage::ParsePushFlag( TLex8& aPointer )

    {

    TInt64 pushFlag( GetIntegerValue( aPointer ) );

    iPushFlag = I64LOW(pushFlag);

    }

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

// CWPPushMessage::ParseContentType

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

//

void CWPPushMessage::ParseContentType( TLex8& aPointer )

    {

    // Go through the whole content type header.

    while( !aPointer.Eos() )

        {

        // Each parameter might be well-known (integer) or unknown (text)

        if( IsIntegerValue( aPointer ) )

            {

            // For well-known parameters, the token is an integer value

            TUint paramToken( I64LOW( GetIntegerValue( aPointer ) ) );

            // These are filled with results from parsing.

            TInt resultInteger( 0 );

            TPtrC8 resultString;

            // Make sure paramToken fits into KParameterTypes table

            if( paramToken 

                < sizeof(KParameterTypes)/sizeof(TParameterCodingType))

                {

                // Get the coding and use it to determine how we should decode 

                // the next parameter value. We actually ignore all results