/*

* Copyright (c) 2002-2007 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:   Decoding of binary multimedia message

*

*/

#include    <apparc.h>

#include    <s32mem.h>

#include    <utf.h>

#include    <msvids.h>

#include    <escapeutils.h>

#include    <e32math.h>

#include    <badesca.h>

#include    <cmsvmimeheaders.h>

#include    <mmsvattachmentmanager.h>

#include    <mmsvattachmentmanagersync.h>

#include	<fileprotectionresolver.h>

#include    <apmstd.h>

// Features

#include    <featmgr.h>    

#include    <bldvariant.hrh>

#include    "mmsheaders.h"

#include    "mmsconst.h"

#include    "mmsdecode.h"

#include    "mmscodec.h"

#include    "mmsservercommon.h"

#include    "mmssession.h"

#include    "mmsgenutils.h"

#include    "mmsentrywrapper.h"

#include    "mmserrors.h"

#include    "mmsmmboxmessageheaders.h"

#include    "mmsmmboxviewheaders.h"

#include    "mmselementdescriptor.h"

enum TMmsMachineStates

    {

    EMmsIdle,

    EMmsDecodingHeaders,

    EMmsDecodingAttachments,

    EMmsFinished

    };

// These are the stages for chunked encoding.

// The chunked encoding is synchronous, so the stages are different

// from the machine states.    

enum TMmsChunkedDecodingStages

    {

    EMmsNotApplicable, // stage used when not doing chunks

    EMmsHeaders,

    EMmsAttachmentHeaders,

    EMmsAttachmentDataStart, // create attachment file and add data

    EMmsAttachmentDataAppend, // append data to existing attachment

    EMmsDone

    };

static const CMmsDecode::TMmsExtensionLookup KMmsFileExtensionMatchTable[] =

    {

        { _S8( "jpeg" ), _S16( "*.jpg" ) },

        { _S8( "gif" ), _S16( "*.gif" ) },

        { _S8( "text" ), _S16( "*.txt" ) },

        { _S8( "smil" ), _S16( "*.smil" ) },

        { _S8( "wbmp" ), _S16( "*.wbmp" ) },

        { _S8( "png" ), _S16( "*.png" ) },

        { _S8( "amr" ), _S16( "*.amr" ) },

        { _S8( "vcard" ), _S16( "*.vcf" ) },

        { _S8( "calendar" ), _S16( "*.vcs" ) },

        { _S8( "drm.message" ), _S16( "*.dm" ) },

        { _S8( "drm.content" ), _S16( "*.dcf" ) },

        { _S8( "drm.rights+xml" ), _S16( "*.dr" ) },

        { _S8( "drm.rights+wbxml" ), _S16( "*.drc" ) },

        { _S8( "drm.dcf" ), _S16( "*.odf" ) },

        // last entries in the table are empty so that

        // we can find the end of the table

        { _S8( "" ), _S16( "" ) }

    };

// application specific headers with known handling

static const CMmsDecode::TMmsExtensionHeaderLookup KMmsExtensionHeaderLookup[] =

    {

        { _S8( "X-Mms-Vodafone-Notif-Text" ), &KMmsAssignedExtendedNotificationText },

        { _S8( "X-Mms-Vodafone-Notif-EOL" ), &KMmsAssignedExtendedNotificationEOL },

        // end of table

        { _S8( "" ), 0 }

    };

_LIT8( KMmsWapMultipartReport, "application/vnd.wap.multipart.report" );

// fake assigned number - last one possible

const TUint8 KMmsAssignedApplicationVndWapMultipartReport = 0x7F;

// a header that is a text string, not assigned number

const TUint8 KMmsTextHeader = 0x7F;

_LIT8( KMmsExtension, "X-" );

#ifndef _NO_MMSS_LOGGING_

_LIT16( KLogYes, "-- Yes" );

_LIT16( KLogNo, "-- No" );

_LIT16( KLogUnknown, "-- Unknown %d" );

#endif

_LIT8( KmmsSmilMimeType,"application/smil");

_LIT8( KMmsSmilSubtype, "smil" );

_LIT8( KMmsAudioSubtype, "amr" );

_LIT8( KMmsAudioSubtype2, "x-amr" ); // old subtype - someone may send this

// main type for audio, don't mark for example "application/amr" as audiomessage

// as audiomessage UI can't handle it. UI only handles "audio/amr"

_LIT8( KMmsAudioType, "audio" );

_LIT8( KMessageClassPersonal, "Personal" );

_LIT8( KMessageClassAdvertisement, "Advertisement" );

_LIT8( KMessageClassInformational, "Informational" );

_LIT8( KMessageClassAuto, "Auto" );

#ifndef _NO_MMSS_LOGGING_

const TInt KMmsHalfByteShift = 4;

const TUint8 KMms0x0F = 0x0F;

const TInt KMmsDateFormatLength = 30; // length for date string buffer for logging

const TInt KMmsMicroToSeconds = 1000000;

#endif

const TUint8 KMms0x20 = 0x20; // lowest ascii, space

const TInt KMmsMinHeaderLength = 2; // no header can be shorter than this

const TInt KMmsBitsInByte = 8;

const TInt KMmsMaxIntegerLength = 4;

const TInt KMmsMaxLongIntegerLength = 8;

const TUint8 KMms0x80 = 0x80; // 128

const TUint8 KMms0x7F = 0x7F; // 127

const TInt KMms2 = 2; // used to calculate length when converting 8 bit to 16 bit encoding

const TUint8 KMms31 = 31; // uintvar indicator

const TUint8 KMms32 = 32; // low limit for text string encoding

const TUint8 KMms30 = 30; // upper limit for short length encoding

const TInt KMmsUintvarShift = 7; // bit shift for decoding uintvars

const TInt KMms14 = 14; // atta name length for self-generated names

const TInt KMms2k = 2000;

const TInt KMmsTestIllegalValue = 255;

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

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

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

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

// might leave.

// All member variables are automatically zeroed in the constructor

// of a class derived from CBase.

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

//

CMmsDecode::CMmsDecode()

    :CMsgActive ( KMmsActiveObjectPriority ),

    iState ( EMmsIdle )

    {

    }

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

// Symbian OS default constructor can leave.

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

//

void CMmsDecode::ConstructL(RFs& aFs)

    {

    iFs = aFs;

    iMimeHeaders = CMsvMimeHeaders::NewL();

    // This is obsolete. Everything is always logged in debug version

    iLogAllDecoded = ETrue; 

    CActiveScheduler::Add(this);

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMmsDecode* CMmsDecode::NewL(RFs& aFs)

    {

    CMmsDecode* self = new (ELeave) CMmsDecode;

    CleanupStack::PushL( self );

    self->ConstructL(aFs);

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CMmsDecode::~CMmsDecode()

    {

    Cancel();

    delete iMimeHeaders;

    delete iStore; // the store should be committed earlier, not anymore

    delete iRootContentIdBuffer;

    }

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

//

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

//

EXPORT_C void CMmsDecode::StartL(

    MMmsEntryWrapper& aEntryWrapper,

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aDecodeBuffer,

    TRequestStatus& aStatus,

    TInt aStartPosition /* = 0 */,

    TInt aLength /* = 0 */ )

    {

    Reset();

    iEntryWrapper = &aEntryWrapper;

    iDecodeBuffer = &aDecodeBuffer;

    iMmsHeaders = &aMmsHeaders;

    iDRMFlags = 0;

    // length will be checked later when we start actual decoding

    iPosition = aStartPosition;

    if ( aLength == 0 )

        {

        iLength = aDecodeBuffer.Size();

        }

    else

        {

        iLength = aLength + aStartPosition;

        }

    iDumpIncoming = iEntryWrapper->GetDumpFlag();

    DumpL();

    Queue(aStatus);

    CompleteSelf( iError );

    }

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

//

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

//

EXPORT_C void CMmsDecode::DecodeHeadersL(

    MMmsEntryWrapper& aEntryWrapper,

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aDecodeBuffer,

    TInt aStartPosition /* = 0 */,

    TInt aLength /* = 0 */,

    TInt* aNumberOfAttachments /* = 0 */,

    TInt* aDataStart /* = 0 */ )

    {

    // The initial settings are the same as for asynchronous

    // methods, but decoding just headers is fast enough to

    // be done synchronously

    Reset();

    iEntryWrapper = &aEntryWrapper;

    iDecodeBuffer = &aDecodeBuffer;

    iMmsHeaders = &aMmsHeaders;

    iPosition = aStartPosition;

    iNumberOfAttachments = 0;

    iLastHeader = EFalse;

    if ( aLength == 0 )

        {

        iLength = aDecodeBuffer.Size();

        }

    else

        {

        iLength = aLength + aStartPosition;

        }

    if ( aDataStart != 0 )

        {

        // Originally point beyound buffer

        // If data is found, this will be updated

        *aDataStart = iLength;

        }

    if ( aNumberOfAttachments )

        {

        // initialize to no attachments

        *aNumberOfAttachments = 0;

        }

    iMmsHeaders->Reset();

    // Save the time the entry was received into the MMS headers

    // the value in TMsvEntry may change, but this remains

    TTime now;      

    now.UniversalTime();

    iMmsHeaders->SetReceivingTime( now );

    iDumpIncoming = iEntryWrapper->GetDumpFlag();

    DumpL();

    if ( iLength < KMmsMinHeaderLength )

        {

        // cannot decode if nothing to decode

        // each header is at least 2 bytes. 

        // If not at least 2 bytes, no can do.

        iState = EMmsIdle;

        iError = KErrCorrupt;

        User::LeaveIfError( iError );

        }

    // each header byte must be followed by at least one byte value.

    // otherwise the message is corrupted

    // when we reach the header that indicates the start of the attachment

    // structure, we expect that no headers follow the attachment part

    // we could handle even headers following the attachments if we

    // wanted to, but if the specification is followed strictly, the 

    // attachments are the last part in the message.

    // each header is at least 2 bytes - header name and value

    while ( ( iPosition <= iLength - KMmsMinHeaderLength ) &&

        ( iError != KErrCorrupt ) &&

        ( !iLastHeader ) )

        {

        DecodeOneHeaderL();

        }

    iLength = iDecodeBuffer->Size();

    if ( iPosition >= iLength ||

        ( iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewConf &&

          iMmsHeaders->MultipartType() == 0 ) )

        {

        // Only content type header, but no actual attachments

        iNumberOfAttachments = 0;

        }

    // If the caller is interested, return the number of attachments we found

    if ( aNumberOfAttachments )

        {

        *aNumberOfAttachments = iNumberOfAttachments;

        }

    if ( aDataStart != 0 )

        {

        *aDataStart = iPosition;

        }

    // WE DON'T SAVE THE MESSAGE HERE.

    // THE CALLER CONTROLS THE SAVING OF THE MESSAGE

    // AS WE ONLY DECODE HEADERS, AND DON'T HANDLE

    // ATTACHMENTS HERE

    // THERE MAY BE NO ENTRY AVAILABLE FOR SAVING THE HEADERS.

    // We are done - may be called again...

    iState = EMmsIdle;

    User::LeaveIfError( iError );

    }

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

//

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

//

EXPORT_C void CMmsDecode::DecodeAttachmentsL(

    MMmsEntryWrapper& aEntryWrapper,

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aDecodeBuffer,

    TInt aNumberOfAttachments,

    TInt& aStartPosition,

    TRequestStatus& aStatus,

    TBool aDoNotUpdateParentEntry /* = EFalse*/,

    TInt aLength /* = 0 */ )

    {

    // The parent entry is updated after specified number of attachments

    // has been handled.

    // Normally all attachments should be handled together.

    // Handling only some attachments is a special case

    // We must get an edit store when we are called the first time.

    if ( !iStore )

        {

        iStore = iEntryWrapper->EditStoreL();

        }

    iError = KErrNone; // start with clean slate

    iDataStart = aStartPosition;

    iNextStart = aStartPosition;

    iUpdatedPosition = &aStartPosition;

    iDoNotUpdateParentEntry = aDoNotUpdateParentEntry;

    iEntryWrapper = &aEntryWrapper;

    iMmsHeaders = &aMmsHeaders;

    iDecodeBuffer = &aDecodeBuffer;

    iNumberOfAttachments = aNumberOfAttachments;

    iPosition = aStartPosition;

    if ( aLength == 0 )

        {

        iLength = iDecodeBuffer->Size();

        }

    else

        {

        iLength = aStartPosition + aLength;

        }

    iState = EMmsDecodingAttachments;

    Queue(aStatus);

    CompleteSelf( iError );

    }

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

//

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

//

EXPORT_C CMsvMimeHeaders& CMmsDecode::ExtractNextDataPartL(

    CBufFlat& aDecodeBuffer,

    TInt& aStartPosition,

    TInt& aStartOfData,

    TInt& aLengthOfData)

    {

    iMimeHeaders->Reset();

    iDecodeBuffer = &aDecodeBuffer;

    iPosition = aStartPosition;

    iUpdatedPosition = &aStartPosition;

    iLength = iDecodeBuffer->Size();

    TInt headersLength = 0;

    TInt dataLength = 0;

    // This function is only used to extract next data part from multipart structure

    headersLength = GetUintvar();

    dataLength = GetUintvar();

    aStartOfData = iPosition + headersLength;

    iDataStart = aStartOfData;

    aLengthOfData = dataLength;

    aStartPosition = iDataStart + dataLength;

    // Extract mime headers

    // iPosition points to the start of headers

    // First is content type without actual header field, just value

    GetAttachmentContentTypeL();

    while ( iPosition < iDataStart )

        {

        DecodeOneContentHeaderL();

        }

    return *iMimeHeaders;

    }

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

//

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

//

EXPORT_C void CMmsDecode::CommitStoreL()

    {

    if ( iStore )

        {

        iStore->CommitL();

        }

    }

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

//

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

//

EXPORT_C void CMmsDecode::InitializeChunkedMode(

    MMmsEntryWrapper& aEntryWrapper,

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aDecodeBuffer

    )

    {

    Reset();

    iEntryWrapper = &aEntryWrapper;

    iMmsHeaders = &aMmsHeaders;

    iDecodeBuffer = &aDecodeBuffer;

    iDRMFlags = 0;

    iPosition = 0;

    iLength = 0;

    iRemoveDrm = EFalse;

    iDumpIncoming = iEntryWrapper->GetDumpFlag();

    iDecodingStage = EMmsHeaders;

    TRAP_IGNORE(DumpL());

    }

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

// from class MMmsCodecDataSink

//

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

//

TInt CMmsDecode::NextDataPart(

        CBufFlat& aBuffer,

        TInt& aPosition,

        TBool aLastDataChunk )

    {

    if ( iDecodingStage == EMmsNotApplicable )

        {

        aPosition = 0; // if not chunked, nothing handled by data sink -> keep all.

        return KErrNone;

        }

    TMsvEntry entry;    

    iEntryWrapper->GetIndexEntry( entry );

    if ( entry.Id() == KMsvNullIndexEntryId )

        {

        // We have no entry, behave as if in non-chunked mode.

        // We are getting a response that will not be saved

        // in a message entry, but may be decoded in its entirety

        // later.

        aPosition = 0; // if not chunked, nothing handled by data sink -> keep all.

        return KErrNone;

        }

    iDecodeBuffer = &aBuffer;

    iPosition = aPosition;

    // Use iLength to tell how much data must be dumped

    iLength = iDecodeBuffer->Size() - iPosition;

    TRAP_IGNORE(DumpL());