/*

* Copyright (c) 2002-2009 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:  

*     binary encoding of a multimedia message

*

*/

//#define CONTENT_DISPOSITION_TEST

// INCLUDE FILES

#include    <e32std.h>

#include    <apparc.h>

#include    <s32mem.h>

#include    <msventry.h>

#include    <utf.h>

#include    <e32math.h>

#include    <msvids.h>

#include    <escapeutils.h>

#include    <badesca.h>

#include    <mmsvattachmentmanager.h>

#include    <mmsvattachmentmanagersync.h>

#include    <cmsvmimeheaders.h>

#include    <imcvcodc.h>

#include    <msgtextutils.h>

#include    <msvstore.h>

#include    <charconv.h>

#include    <centralrepository.h>          // link against centralrepository.lib

#include    "MmsEnginePrivateCRKeys.h"

#include    "mmsheaders.h"

#include    "mmsconst.h"

#include    "mmscodec.h"

#include    "mmsencode.h"

#include    "mmsservercommon.h"

#include    "mmssession.h"

#include    "mmsgenutils.h"

#include    "mmserrors.h"

#include    "mmsentrywrapper.h"

#include    "mmsmmboxmessageheaders.h"

#include    "mmsmmboxviewheaders.h"

#include    "mmssendingchain.h"

const TInt KMmsExtra = 1024; // extra memory left for others

const TInt KMmsShortIntegerLimit127 = 127; // limit for short integer length

const TInt KMmsOneByteLimit = 0x100;

const TInt KMmsTwoByteLimit = 0x10000;

const TInt KMmsThreeByteLimit = 0x1000000;

const TInt KMms2 = 2;

const TInt KMms3 = 3;

const TInt KMms4 = 4;

const TInt KMms5 = 5;

const TInt KMms7 = 7;

const TInt KMms8 = 8;

const TInt KMms24 = 24; // shift of three half bytes

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

const TUint8 KMms0x80 = 0x80; // 128

const TUint8 KMms0x7F = 0x7F; // 127

const TUint8 KMms0xFF = 0xFF;

const TInt KMmsMaxCidLength = 18;

// max filename length according to MMS conformance specs

const TInt KMmsMaxFileNameLength = 40;

// if 40 bytes are encoded in base 64, the result is 56 bytes

// (two bytes of padding are needed to make the number divisible by 3)

const TInt KMaxEncodingLength = 56;

// Maximum length of output buffer needed for encoding the filename

// Max 56 bytes for actual encoding and 12 bytes for character set (utf8)

// and encoding scheme indicator 68 for final result, but we allocate

// the maximum Mime header length to be sure everything fits.

const TInt KMaxNameBufferLength = 75;

const TInt KMmsEncodingExtraLength = 12;

const TInt KMmsPreambleLength = 10;

_LIT8( KMmsQuotedPreamble, "=?utf-8?Q?" );

_LIT8( KMmsBase64Preamble, "=?utf-8?B?" );

_LIT8( KMmsEncodingTrailer, "?=" );

const TInt KMmsIntUnderscore = 0x5F; // underscore

enum TMmsMachineStates

    {

    EMmsIdle,

    EMmsEncodingHeaders,

    EMmsEncodingAttachments,

    EMmsFinished

    };

// These are the stages for chunked encoding.

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

// from the machine states.    

enum TMmsChunkedEncodingStages

    {

    EMmsHeaders,

    EMmsAttachmentHeaders,

    EMmsAttachmentData

    };

// ==================== 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.

// Priority is set slightly above standard (1 instead of 0) to make sure

// that message is sent as soon as possible (user input has priority 10).

// Variables related to chunked encoding are initialized to indicate

// one complete chunk only.

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

//

CMmsEncode::CMmsEncode()

    :CMsgActive ( KMmsActiveObjectPriority ),

    iState ( EMmsIdle ),

    iOverallDataSize ( -1 ),

    iLastChunk ( ETrue ),

    iOnlyOneChunk( ETrue )

    {

    }

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

// Symbian OS default constructor can leave.

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

//

void CMmsEncode::ConstructL( RFs& aFs )

    {

    iFs = aFs;

    CActiveScheduler::Add( this );

    }

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

// Two-phased constructor.

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

//

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

    {

    CMmsEncode* self = new ( ELeave ) CMmsEncode;

    CleanupStack::PushL( self );

    self->ConstructL( aFs );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CMmsEncode::~CMmsEncode()

    {

    Cancel();

    if ( iFileOpen )

        {

        iAttachFile.Close();

        iFileOpen = EFalse;

        }

    // Do not delete pointers that were presents from the caller.

    // The caller still owns that data

    delete iMimeHeaders; // this is ours too.

    }

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

//

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

//

EXPORT_C void CMmsEncode::StartL(

    MMmsEntryWrapper& aEntryWrapper,

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aEncodeBuffer,

    TRequestStatus& aStatus )

    {

    // This is the entry point for encoding all PDUs that contain both headers

    // and data.

    // For normal use the only PDUs in this category would be M-send.req and

    // M-MBox-Upload.req, but for testing purposes the following PDUs may

    // also be handled using this entry point:

    // M-retrieve.conf (for testing purposes)

    // M-Mbox-View.conf (for testing purposes)

    // M-Mbox-Descr (for testing purposes) 

    // Old asynchronous encoding is retained.

    // Reset sets all chunk-related variables to indicate one chunk which is the last one

    Reset();

    iEntryWrapper = &aEntryWrapper;

    iMmsHeaders = &aMmsHeaders;

    iEncodeBuffer = &aEncodeBuffer;

    if ( iMimeHeaders )

        {

        iMimeHeaders->Reset();

        }

    else

        {

        iMimeHeaders = CMsvMimeHeaders::NewL();

        }

    // We need to know the message entry ID

    // The wrapper originally points to the message entry

    TMsvEntry indexEntry;

    iError = iEntryWrapper->GetIndexEntry( indexEntry );

    iCurrentMessageId = indexEntry.Id();

    CMsvStore* store = iEntryWrapper->ReadStoreL();

    CleanupStack::PushL( store );

    // Only new attachment structure is supported    

    MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

    iNumberOfAttachments = attachMan.AttachmentCount();

    CleanupStack::PopAndDestroy( store );

    Queue( aStatus );

    iStatus = KRequestPending;

    SetActive();

    // Pretend that we called an asynchronous service

    // in order to get into the state machine loop

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, iError );

    }

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

//

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

//

EXPORT_C void CMmsEncode::EncodeHeadersL(

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aEncodeBuffer )

    {

    // This function is used to encode all PDUs that contain only headers,

    // not data. Some are responses sent to MMSC, some are requests that

    // contain headers only.

    // Nothing is read from storage, everything to be encoded is contained

    // in the headers.

    // No active object is invoked, this is a synchronous function

    // Old one-chunk encoding is retained for encoding headers only.

    // Reset sets all chunk-related variables to indicate one chunk which is the last one

    Reset(); // also sets iError to KErrNone

    iMmsHeaders = &aMmsHeaders;

    iEncodeBuffer = &aEncodeBuffer;

    // start from the beginning

    iPosition = 0;

    // we discard old contents of the buffer in case we must expand it

    iEncodeBuffer->Reset();

    // We are a bit greedy here so that we don't need

    // to change the code if there is a minor change in the specs.

    iEncodeBuffer->ResizeL( iMmsHeaders->Size() + KMMSBufferExtra );

    // encode message depending on type

    // these are all types that contain headers only, never data

    switch ( iMmsHeaders->MessageType() )

        {

        case KMmsMessageTypeMNotifyRespInd:

            EncodeNotifyResponse();

            break;

        case KMmsMessageTypeAcknowledgeInd:

            EncodeAcknowledgeIndication();

            break;

        case KMmsMessageTypeMNotificationInd:

            EncodeMmsNotificationL();

            break;

        case KMmsMessageTypeForwardReq:

            EncodeForwardRequestL();

            break;

        case KMmsMessageTypeReadRecInd:

            EncodeReadReplyL();

            break;

        case KMmsMessageTypeMboxStoreReq:

            EncodeMMBoxStoreRequestL();

            break;

        case KMmsMessageTypeMboxViewReq:

            // This may contain keywords. Reserve some extra space

            EncodeMMBoxViewRequestL();

            break;

        case KMmsMessageTypeMBoxDeleteReq:

        case KMmsMessageTypeDeleteReq:

            EncodeDeleteRequestL();

            break;

        case KMmsMessageTypeCancelConf:

            EncodeCancelResponse();

            break;

        case KMmsMessageTypeReadOrigInd:

            // This is for testing purposes.

            // identical to ReadRecInd except for PDU type

            // This would be the PDU sent to originator by MMSC

            EncodeReadReplyL();

            break;

        case KMmsMessageTypeMSendConf:

            // for testing purposes

            EncodeSendConfirmationL();

            break;

        case KMmsMessageTypeDeliveryInd:

            // for testing purposes

            EncodeDeliveryReportL();

            break;

        case KMmsMessageTypeForwardConf:

            // for testing purposes

            EncodeForwardConfirmationL();

            break;

        case KMmsMessageTypeMboxStoreConf:

            // for testing purposes

            EncodeMMBoxStoreConfirmationL();

            break;

        case KMmsMessageTypeMBoxUploadConf:

            // for testing purposes

            EncodeMMBoxUploadConfirmationL();

            break;

        case KMmsMessageTypeMBoxDeleteConf:

        case KMmsMessageTypeDeleteConf:

            // for testing purposes

            EncodeDeleteConfirmationL();

            break;

        case KMmsMessageTypeCancelReq:

            // for testing purposes

            EncodeCancelRequest();

            break;

#ifdef __WINS__

        case KMmsMessageTypeMSendReq:

            EncodeSendRequestHeadersL();

            break;

        case KMmsMessageTypeMBoxUploadReq:

            // This type has attachments and headers

            // This function encodes headers only

            EncodeMMBoxUploadRequestL();

            break;

        case KMmsMessageTypeMRetrieveConf:

            // for test purposes

            EncodeRetrieveConfirmationL();

            break;

        case KMmsMessageTypeMboxViewConf:

            // for test purposes

            EncodeMMBoxViewConfirmationL();

            break;

        case KMmsMessageTypeMBoxDescr:

            // for test purposes

            EncodeMMBoxDescriptionL();

            break;

#endif

        default:

            // Illegal message type.

            iEncodeBuffer->Reset();

            iPosition = 0;

            break;

        }

    // Remove slack to keep garbage out from the end of the file

    iEncodeBuffer->ResizeL( iPosition );

    // Dump the buffer contents into file if requested

    Dump();

    iOverallDataSize = iEncodeBuffer->Size();

    }

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

//

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

//

EXPORT_C void CMmsEncode::StartChunkedL(

    MMmsEntryWrapper& aEntryWrapper,

    CMmsHeaders& aMmsHeaders,

    CBufFlat& aEncodeBuffer,

    TRequestStatus& aStatus )

    {

    // This is the entry point for chunked encoding all PDUs that contain both headers

    // and data.

    // Reset sets all chunk-related variables to indicate one chunk which is the last one

#ifndef _NO_MMSS_LOGGING_

    TMmsLogger::Log( _L("CMmsEncode: Start chunked") );

#endif

    Reset(); // also sets iError to KErrNone

    iDataSupplierStage = EMmsHeaders;

    iEntryWrapper = &aEntryWrapper;

    iMmsHeaders = &aMmsHeaders;

    iEncodeBuffer = &aEncodeBuffer;

    if ( iMimeHeaders )

        {

        iMimeHeaders->Reset();

        }

    else

        {

        iMimeHeaders = CMsvMimeHeaders::NewL();

        }

    // We need to know the message entry ID

    // The wrapper originally points to the message entry

    TMsvEntry indexEntry;

    iError = iEntryWrapper->GetIndexEntry( indexEntry );

    iCurrentMessageId = indexEntry.Id();

    // Encode headers to the buffer

    // The rest will follow when next data chunk is requested.

    EncodeHeadersChunkedL();

	aStatus=KRequestPending;

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, iError );

    }

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

// From class MMmsCodecDataSupplier

//

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

//

TInt CMmsEncode::GetNextDataPart( TPtrC8& aDataPart, TBool& aLastDataChunk )

    {

    TInt error = KErrNone;

    if ( !iEncodeBuffer || iEncodeBuffer->Size() == 0 )

        {

        // called out of context or no message data available

        error = KErrNotFound;

        }

    else

        {

        aDataPart.Set( iEncodeBuffer->BackPtr( iPosition ) ); 

        }

    aLastDataChunk = iLastChunk;

    return error;

    }

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

// From class MMmsCodecDataSupplier

//

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

//

TInt CMmsEncode::ReleaseData()

    {

    if ( iOnlyOneChunk )

        {

        // if we have only one chunk we always point to the beginning

        // the buffer gets cleared when all data has been handled

        return KErrNone;

        }

    iPosition = 0;

    // encode next data part into the buffer

    if ( iDataSupplierStage == EMmsAttachmentHeaders && iNumberOfAttachments == 0 )

        {

        iLastChunk = ETrue;

        iDataSupplierStage = EMmsHeaders;

        }

    else if ( iDataSupplierStage == EMmsAttachmentHeaders )

        {

#ifndef _NO_MMSS_LOGGING_

        TMmsLogger::Log( _L("- data supplier stage: Attachment headers") );

#endif

        iError = iEntryWrapper->SetCurrentEntry( iCurrentMessageId );

        if ( iError != KErrNone )

            {

            return iError;

            }

        iCurrentFileSize = 0;

        CMsvStore* store = NULL;

        TRAP( iError, 

            {

            store = iEntryWrapper->ReadStoreL();

            CleanupStack::PushL( store );

            MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

            iCurrentFileSize = EncodeHeadersAndGetFileL( attachMan );

            CleanupStack::PopAndDestroy( store );

            });

        if ( iError != KErrNone )

            {

            return iError;

            }

        // Now we have the attachment headers in our buffer.

        // If there is room, put data there, too

        if ( iBufferSize - iPosition >= iCurrentFileSize )

            {

#ifndef _NO_MMSS_LOGGING_

            TMmsLogger::Log( _L("- enough room left in buffer for attachment data") );

#endif

            EncodeAttachmentData( iAttachFile, iCurrentFileSize );

            iPosition += iCurrentFileSize;

            iAttachFile.Close();

            iFileOpen = EFalse;

            iCurrentAttachment++;

            if ( iCurrentAttachment >= iNumberOfAttachments )

                {

                iLastChunk = ETrue;

                iDataSupplierStage = EMmsHeaders;

                }

            else

                {

                // one attachment finished - move to next one

                iDataSupplierStage = EMmsAttachmentHeaders;

                }