/*
* 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;
}
}
else
{
iDataSupplierStage = EMmsAttachmentData;
}
}
else if ( iDataSupplierStage == EMmsAttachmentData )
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("- data supplier stage: Attachment data") );
#endif
// Add as much attachment data as possible.
// Attachment file is now open, check position
TInt filePosition = 0;
iError = iAttachFile.Seek( ESeekCurrent, filePosition );
if ( iError != KErrNone )
{
return iError;
}
TInt dataLeft = iCurrentFileSize - filePosition;
TInt roomLeft = iBufferSize - iPosition;
if ( roomLeft >= dataLeft )
{
EncodeAttachmentData( iAttachFile, dataLeft );
iPosition += dataLeft;
iAttachFile.Close();
iFileOpen = EFalse;
iCurrentAttachment++;
if ( iCurrentAttachment >= iNumberOfAttachments )
{
iLastChunk = ETrue;
iDataSupplierStage = EMmsHeaders;
}
else
{
// one attachment finished - move to next one
iDataSupplierStage = EMmsAttachmentHeaders;
}
}
else
{
// we have more data than fits into buffer
EncodeAttachmentData( iAttachFile, roomLeft );
iPosition += roomLeft;
// We don't close the file because we still have data.
// We stay in EMmsAttachmentHeaders state
}
}
else
{
// do nothing, keep LINT happy
}
#ifndef _NO_MMSS_LOGGING_
if ( iDataSupplierStage == EMmsHeaders )
{
TMmsLogger::Log( _L("- last chunk released") );
TMmsLogger::Log( _L("- data supplier stage: MMS headers") );
}
#endif
// If we have reached the end and have been asked to release data
// we have nothing left to do.
// dump what we got into file - if needed
if ( iPosition > 0 )
{
DumpAppend();
}
return iError;
}
// ---------------------------------------------------------
// From class MMmsCodecDataSupplier
//
// ---------------------------------------------------------
//
TInt CMmsEncode::OverallDataSize()
{
// If we have encoded all data, iOverallDataSize contains the
// actual amount of data.
// If we are doing chunked encoding, it contains -1.
return iOverallDataSize;
}
// ---------------------------------------------------------
// From class MMmsCodecDataSupplier
//
// ---------------------------------------------------------
//
TInt CMmsEncode::ResetSupplier()
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode: ResetSupplier") );
#endif
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;
}
// start data from the beginning
iError = KErrNone;
iDataSupplierStage = EMmsHeaders;
TRAP( iError, EncodeHeadersChunkedL() );
return iError;
}
// ---------------------------------------------------------
// From class CMsgActive
//
// ---------------------------------------------------------
//
void CMmsEncode::DoRunL()
{
// This routine takes the state machine through the states
// until an error is encountered or the cycle completes.
if ( iError != KErrNone )
{
// We encountered an error, and cannot continue
// For the time being we just give up without trying
// to do any decent cleanup.
iStatus = iError;
// If we return from DoRunL without becoming active again,
// RunL completes.
return;
}
if ( iState != EMmsFinished )
{
SelectNextState();
// If appropriate, ChangeStateL makes us active again
ChangeStateL();
}
else
{
// We are done, we must become idle again
FinishL();
iStatus = iError;
// If we return from DoRunL without becoming active again,
// RunL completes.
}
// As we are using standard Mentact RunL, we must leave
// if we have encountered an error, and do not want to continue
if ( iError != KErrNone && !IsActive() )
{
iPosition = 0;
FinishL();
User::Leave( iError );
}
}
// ---------------------------------------------------------
// From class CMsgActive
//
// ---------------------------------------------------------
//
void CMmsEncode::DoComplete( TInt& /* aStatus */ )
{
// We are exiting the loop - we say we are idle now
iState = EMmsIdle;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::SelectNextState()
{
// If appropriate, the functions called within the switch statement
// will make us active again. If all is done, the asynchronous request
// will complete
switch ( iState )
{
case EMmsIdle:
// start the loop
iState = EMmsEncodingHeaders;
break;
case EMmsEncodingHeaders:
if ( iNumberOfAttachments > 0 )
{
iState = EMmsEncodingAttachments;
}
else
{
iState = EMmsFinished;
}
break;
case EMmsEncodingAttachments:
// if there are more attachments, don't change state
if ( iCurrentAttachment >= iNumberOfAttachments )
{
iState = EMmsFinished;
}
break;
case EMmsFinished:
// No more states
iState = EMmsIdle;
break;
default:
// Illegal state
break;
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::ChangeStateL()
{
switch ( iState )
{
case EMmsEncodingHeaders:
EncodeHeadersL();
break;
case EMmsEncodingAttachments:
EncodeAttachmentL();
iCurrentAttachment++;
break;
case EMmsFinished:
FinishL();
break;
default:
// Should not be here anymore
break;
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::Reset()
{
// close open file in case operation has ended with error
// and the attachment file is still open
if ( iFileOpen )
{
iAttachFile.Close();
iFileOpen = EFalse;
}
iNumberOfAttachments = 0;
iCurrentAttachment = 0;
iError = KErrNone;
iCurrentMessageId = KMsvNullIndexEntryId;
iOverallDataSize = -1;
iLastChunk = ETrue;
iOnlyOneChunk = ETrue;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeHeadersL()
{
// start from the beginning
iPosition = 0;
// we discard old contents of the buffer in case we must expand it
iEncodeBuffer->Reset();
// calculate space needed and resize buffer
TInt size = 0;
size += iMmsHeaders->Size();
User::LeaveIfError( iEntryWrapper->SetCurrentEntry( iCurrentMessageId ) );
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
// AttachmentsSize function asks actual size from files
// in case the info in CMsvAttachment is not up to date.
// This function leaves if the attachment file is not found.
// A message cannot be sent if it refers to attachment files that no
// longer exist.
size += iEntryWrapper->AttachmentsSizeL( *store );
CleanupStack::PopAndDestroy( store );
store = NULL;
size += KMMSBufferExtra; // this is just an estimate of header size...
// extra needed if lots of attachments.
size += KMMSAttachmentExtra * iNumberOfAttachments;
TMemoryInfoV1Buf memory;
UserHal::MemoryInfo( memory );
TInt available = memory().iFreeRamInBytes;
// check that buffer fits, leave a little memory for others too.
if ( size > ( available - KMmsExtra ) )
{
// message is too big - don't even try
iError = KMmsErrorMessageTooBig;
}
if ( iError == KErrNone )
{
iEncodeBuffer->ResizeL( size );
EncodeRequestHeadersL();
}
iStatus = KRequestPending;
SetActive();
// We complete ourselves.
TRequestStatus* status = &iStatus;
User::RequestComplete( status, iError );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeHeadersChunkedL()
{
// The first step of chunked encoding
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: start") );
#endif /* _NO_MMSS_LOGGING_ */
User::LeaveIfError( iEntryWrapper->SetCurrentEntry( iCurrentMessageId ) );
/* Korean req: 415-5434
* Get the target encoding MIB enum from cenrep and encode MMS text objects using coresponding conversion plugins
*/
TInt temp;
iTargetEncodingType = 0;
CRepository* repository = CRepository::NewLC( KUidMmsServerMtm );
if ( repository->Get( KMmsEncodingType, temp ) == KErrNone )
{
iTargetEncodingType = temp;
}
CleanupStack::PopAndDestroy( repository );
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: target encoding type: %d"), iTargetEncodingType );
#endif /* _NO_MMSS_LOGGING_ */
if( iTargetEncodingType != 0 )
{
#ifndef _NO_MMSS_LOGGING_
TRAPD( err, PreProcessAttachmentDataL() );
/* if any error, korean specific encoding failed, But this should not stop from sending MMS using
* existing default encoding. Hence just log the error and continue in any case
*/
if( err != KErrNone )
{
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: PreProcessAttachmentDataL error: %d"), err );
}
#else
TRAP_IGNORE( PreProcessAttachmentDataL() );
#endif /* _NO_MMSS_LOGGING_ */
}
//Open store for read-only purpose
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
// Only new attachment structure is supported
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
iNumberOfAttachments = attachMan.AttachmentCount();
TInt size = 0;
size += iMmsHeaders->Size();
size += KMMSBufferExtra; // this is just an estimate of header size...
// The buffer must be at least big enough to hold all headers
iBufferSize = Max( KMmsChunkedBufferSize, size );
// extra needed if lots of attachments.
// AttachmentsSize function asks actual size from files
// in case the info in CMsvAttachment is not up to date.
// This function leaves if the attachment file is not found.
// A message cannot be sent if it refers to attachment files that no
// longer exist.
size += iEntryWrapper->AttachmentsSizeL( *store );
size += KMMSAttachmentExtra * iNumberOfAttachments;
CleanupStack::PopAndDestroy( store );
store = NULL;
if ( iBufferSize > size )
{
// Our message is small enough to be sent in one chunk.
// It does not make sense to send the message in small chunks
// it the total is only a few kilobytes
iBufferSize = size;
iOnlyOneChunk = ETrue;
iLastChunk = ETrue;
}
else
{
// we need several chunks
iOnlyOneChunk = EFalse;
iLastChunk = EFalse;
}
// start from the beginning
iPosition = 0;
iEncodeBuffer->Reset();
// This leaves if unable to resize.
// We try to keep our buffer small enough so that this does not leave.
iEncodeBuffer->ResizeL( iBufferSize );
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: MMS buff Size(Approx): %d"), iBufferSize );
#endif /* _NO_MMSS_LOGGING_ */ // The message is small enough to be sent as one chunk
EncodeRequestHeadersL();
TInt i = 0;
if ( iOnlyOneChunk )
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: only one chunk") );
#endif /* _NO_MMSS_LOGGING_ */ // The message is small enough to be sent as one chunk
for ( i = 0; ( i < iNumberOfAttachments ) && ( iError == KErrNone ); i++ )
{
iCurrentAttachment = i;
// encode attachments, too, as we have decided that our message
// is small enough to fit into the buffer as one chunk
// DoEncodeAttachment always encodes iCurrentAttachment
// and updates buffer position as needed.
DoEncodeAttachmentL();
// If something goes wrong, DoEncodeAttachmentL() sets iError,
// and StartChunkedL will complete the caller with error.
}
iEncodeBuffer->ResizeL( iPosition );
iOverallDataSize = iEncodeBuffer->Size();
}
else
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: Multiple chunks") );
#endif /* _NO_MMSS_LOGGING_ */ // The message is small enough to be sent as one chunk
// chunked sending - but it should be possible to calculate data size
iOverallDataSize = iPosition; // This is the amount taken by headers
// The message is small enough to be sent as one chunk
for ( i = 0; ( i < iNumberOfAttachments ) && ( iError == KErrNone ); i++ )
{
iCurrentAttachment = i;
// encode attachments, too, as we have decided that our message
// is small enough to fit into the buffer as one chunk
// DoEncodeAttachment always encodes iCurrentAttachment
// and updates buffer position as needed.
iOverallDataSize += DoGetAttachmentEncodingLengthL();
// If something goes wrong, DoEncodeAttachmentL() sets iError,
// and StartChunkedL will complete the caller with error.
}
iCurrentAttachment = 0;
iDataSupplierStage = EMmsAttachmentHeaders;
if ( iError != KErrNone )
{
iOverallDataSize = -1;
}
}
// Dump headers. More data will follow
Dump();
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::EncodeHeadersChunkedL:: end") );
#endif /* _NO_MMSS_LOGGING_ */ // The message is small enough to be sent as one chunk
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeAttachmentL()
{
DoEncodeAttachmentL();
if ( iError != KErrNone )
{
// If we return without becoming active again, RunL completes
// we cannot send this message, because we cannot access attachments
return;
}
iStatus = KRequestPending;
SetActive();
// Now we indicate we already did it.
TRequestStatus* status = &iStatus;
User::RequestComplete( status, iError );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::DoEncodeAttachmentL()
{
// Encode one part
// We must calculate length of headers and content type
User::LeaveIfError( iEntryWrapper->SetCurrentEntry( iCurrentMessageId ) );
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
TInt size = 0;
size = EncodeHeadersAndGetFileL( attachMan );
if ( iError != KErrNone )
{
CleanupStack::PopAndDestroy( store );
return;
}
// The data read function will not leave
EncodeAttachmentData( iAttachFile, size );
iPosition += size;
iAttachFile.Close();
CleanupStack::PopAndDestroy( store );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
TInt CMmsEncode::DoGetAttachmentEncodingLengthL()
{
// calculate length of headers and content type
User::LeaveIfError( iEntryWrapper->SetCurrentEntry( iCurrentMessageId ) );
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
TInt size = 0;
size = GetHeadersAndFileSizeL( attachMan );
CleanupStack::PopAndDestroy( store );
return size;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
TInt CMmsEncode::EncodeHeadersAndGetFileL( MMsvAttachmentManager& aAttachMan )
{
CMsvAttachment* attachmentInfo = NULL;
attachmentInfo = aAttachMan.GetAttachmentInfoL( iCurrentAttachment );
CleanupStack::PushL( attachmentInfo );
iMimeHeaders->RestoreL( *attachmentInfo );
// We don't trust the info, we ask the file itself
// Someone outside the messaging system may have changed the file
// without changing the attachment info
TInt size = 0;
if ( iFileOpen )
{
// close file in case we have been reset while the file is still open
iAttachFile.Close();
iFileOpen = EFalse;
}
iAttachFile = aAttachMan.GetAttachmentFileL( iCurrentAttachment );
iError = iAttachFile.Size( size );
iAttachFile.Close();
if ( iError != KErrNone )
{
CleanupStack::PopAndDestroy( attachmentInfo );
return size;
}
// calculate the length of the headers
TBool foundName = EFalse;
TUint contentTypeSize = 0;
TInt8 contentType = -1; // indicate not found
TPtrC8 contentTypeString;
TUint headerSize = 0;
HBufC8* buf8 = CalculateAttachmentHeaderLengthL(
*attachmentInfo,
headerSize,
foundName,
contentTypeSize,
contentType,
contentTypeString );
CleanupStack::PushL( buf8 );
// We have calculated the header length, now we can encode:
TPtrC8 nameString;
if ( !foundName && buf8 )
{
nameString.Set( buf8->Des() );
}
EncodeAttachmentHeadersL(
size,
headerSize,
foundName,
contentTypeSize,
contentType,
contentTypeString,
nameString );
// now we have put the name all over, we can destroy the buffer
CleanupStack::PopAndDestroy( buf8 );
buf8 = NULL;
CleanupStack::PopAndDestroy( attachmentInfo );
attachmentInfo = NULL;
// Now just write all the data octets
iAttachFile = aAttachMan.GetAttachmentFileL( iCurrentAttachment );
iFileOpen = ETrue;
return size;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
TInt CMmsEncode::GetHeadersAndFileSizeL( MMsvAttachmentManager& aAttachMan )
{
CMsvAttachment* attachmentInfo = NULL;
attachmentInfo = aAttachMan.GetAttachmentInfoL( iCurrentAttachment );
CleanupStack::PushL( attachmentInfo );
iMimeHeaders->RestoreL( *attachmentInfo );
// We don't trust the info, we ask the file itself
// Someone outside the messaging system may have changed the file
// without changing the attachment info
TInt size = 0;
if ( iFileOpen )
{
// close file in case we have been reset while the file is still open
iAttachFile.Close();
iFileOpen = EFalse;
}
iAttachFile = aAttachMan.GetAttachmentFileL( iCurrentAttachment );
iError = iAttachFile.Size( size );
iAttachFile.Close();
if ( iError != KErrNone )
{
CleanupStack::PopAndDestroy( attachmentInfo );
return 0;
}
// calculate the length of the headers
TBool foundName = EFalse;
TUint contentTypeSize = 0;
TInt8 contentType = -1; // indicate not found
TPtrC8 contentTypeString;
TUint headerSize = 0;
HBufC8* buf8 = CalculateAttachmentHeaderLengthL(
*attachmentInfo,
headerSize,
foundName,
contentTypeSize,
contentType,
contentTypeString );
delete buf8; // This is not needed
buf8 = NULL;
CleanupStack::PopAndDestroy( attachmentInfo );
attachmentInfo = NULL;
// We have calculated the header length, now we still need the
// uintvar lengths:
size += GetUintvarLength( size ); // encoding size for attachment length
size += headerSize;
size += GetUintvarLength( headerSize ); // encoding size for header length
return size;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
HBufC8* CMmsEncode::CalculateAttachmentHeaderLengthL(
CMsvAttachment& aAttachmentInfo,
TUint& aHeaderLength,
TBool& aFoundName,
TUint& aContentTypeSize,
TInt8& aContentType,
TPtrC8& aContentTypeString )
{
TInt numNonSafe = 0; // number of characters in filename that would require encoding
// Not all content types have parameters.
// The only parameter we can handle to some extent
// is the character set parameter for text content types.
// The name parameter will always be added if not already present
// Check if we have well-known media.
aContentType = -1; // indicate not found
aContentTypeString.Set( aAttachmentInfo.MimeType() );
if ( aContentTypeString.Length() == 0 )
{
// take type from mime headers
HBufC8* tempContentType = HBufC8::NewL(
iMimeHeaders->ContentType().Length() +
iMimeHeaders->ContentSubType().Length() + 1 );
CleanupStack::PushL( tempContentType );
tempContentType->Des().Copy( iMimeHeaders->ContentType() );
if ( ( iMimeHeaders->ContentType().Find( KMmsSlash8 ) !=
( iMimeHeaders->ContentType().Length() - 1 ) ) &&
( iMimeHeaders->ContentSubType().Find( KMmsSlash8 ) != 0 ) &&
( iMimeHeaders->ContentSubType().Length() != 0 ) )
{
tempContentType->Des().Append( KMmsSlash8 );
}
tempContentType->Des().Append( iMimeHeaders->ContentSubType() );
aAttachmentInfo.SetMimeTypeL( tempContentType->Des() );
CleanupStack::PopAndDestroy( tempContentType );
aContentTypeString.Set( aAttachmentInfo.MimeType() );
}
TInt8 i;
for ( i = 0; i < KNumberContentTypes && aContentType < 0; i++ )
{
if ( aContentTypeString.CompareF(
TPtrC8( KContentTypeTable[i] ) ) == 0 )
{
aContentType = i;
}
}
if ( aContentTypeString.Length() == 0 )
{
aContentTypeString.Set( KMmsUnknownType );
aContentType = -1;
}
// we always add the name parameter to content type, so we always
// use the general form. If no name is given, we use the original filename
// If the name parameter is defined, we use it.
aFoundName = EFalse;
iFileName.SetLength( 0 );
aHeaderLength = 0;
// add media type length
if ( aContentType >= 0 )
{
// well-known media
aHeaderLength += 1;
}
else
{
// Extension media
aHeaderLength += aContentTypeString.Length();
aHeaderLength += 1; // terminating zero
}
// If we have paramters, we must calculate their length.
if ( iMimeHeaders->MimeCharset() != 0 )
{
// charset has well-known encoding
aHeaderLength += 1;
if ( iMimeHeaders->MimeCharset() <= KMmsShortIntegerLimit127 )
{
// short integer
aHeaderLength += 1;
}
else if ( iMimeHeaders->MimeCharset() < KMmsOneByteLimit )
{
// long integer, short length + 1 byte of value
aHeaderLength += KMms2;
}
else if ( iMimeHeaders->MimeCharset() < KMmsTwoByteLimit )
{
// long integer, short length + 2 bytes of value
// so far I don't know any IANA numbers that would
// take more than two hex bytes.
aHeaderLength += KMms3;
}
else if ( iMimeHeaders->MimeCharset() < KMmsThreeByteLimit )
{
// long integer, short length + 3 bytes of value
aHeaderLength += KMms4;
}
else
{
// long integer, short length + 4 bytes of value
// cannot be longer than this in any case
aHeaderLength += KMms5;
}
}
// Then the rest of the parameters, unknown,
// sent as text strings
// If "name" attribute has been defined, we use it.
// if it is not added, we must add it.
// We must ensure that we don't add it twice...
TInt mimeHeaderCount = iMimeHeaders->ContentTypeParams().MdcaCount();
for ( i = 0; i < mimeHeaderCount; i++ )
{
// If we have corrupted parameters (length of name is zero)
// we skip the name/value pair.
// value may be zero, it will be encoded as just the terminating zero
if ( i%2 == 0 &&
iMimeHeaders->ContentTypeParams().MdcaPoint( i ).Length() == 0 )
{
i++;
}
else
{
// 8-byte string size + terminating zero
// If parameter has no value, it still must have
// the "no-value" indicator (just the terminating zero.)
if ( iMimeHeaders->ContentTypeParams().MdcaPoint( i ).CompareF(
KWspNameString ) == 0 && i%2 == 0 )
{
if ( ( i + 1 ) < mimeHeaderCount &&
IsStringSafe( iMimeHeaders->ContentTypeParams().MdcaPoint( i + 1 ),
numNonSafe ) )
{
// We always move the name to the first item.
// It may be this parameter or something else
// Content type parameters are 8-bit strings.
// We can use the name only if it is safe, otherwise it may contain some
// unknown encoding (maybe utf-8).
iFileName.Copy( ( iMimeHeaders->ContentTypeParams().
MdcaPoint( i + 1 ) ).Right( KMmsMaxFileName ) );
i++;
}
else
{
// Skip the next field as it can only be used if it is safe
i++;
}
}
else
{
aHeaderLength += iMimeHeaders->ContentTypeParams().MdcaPoint( i ).Length() + 1;
}
}
}
if ( ( iMimeHeaders->ContentTypeParams().MdcaCount() % 2 ) == 1 )
{
// Odd number. Obviously last paramter has no value.
// Add the "no value" token
aHeaderLength++;
}
// include name parameter to content-type
// if the name was not among our mime headers,
// we must add it.
TInt nameLength = 0;
// We prefer the suggested filename as the content type name parameter.
// If version is 1.3 or later, we can encode a non-safe filename.
// If suggested filename is not safe, but we already have a safe filename
// in iFilename, we don't override it if version is 1.2 or lower
if ( iMimeHeaders->SuggestedFilename().Length() > 0 )
{
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 ||
IsStringSafe( iMimeHeaders->SuggestedFilename() ) ||
iFileName.Length() == 0 )
{
iFileName.Copy( iMimeHeaders->SuggestedFilename().Right( KMmsMaxFileName ) );
}
}
TParse* parse = NULL;
// If we don't have a filename suggestion so far, we just use the
// actual filename the attachment manager has used to save the file.
if ( iFileName.Length() == 0 )
{
parse = new( ELeave )TParse;
CleanupStack::PushL( parse );
// aAttachmentInfo.FilePath() is an actual Symbian filename including path
// so it never can be too long to fit into TParse or TFilename
parse->Set( aAttachmentInfo.FilePath(), NULL, NULL );
iFileName.Copy( parse->NameAndExt() );
CleanupStack::PopAndDestroy( parse );
parse = NULL;
}
// Last effort:
// If our version is 1.2 or lower and the filename suggestion so far
// is not safe, we try content-location. It is always safe
if ( iMmsHeaders->MmsVersion() <= KMmsVersion12 &&
!IsStringSafe( iFileName ) )
{
if ( iMimeHeaders->ContentLocation().Length() > 0 )
{
// content location should be safe.
// However, we must make sure it contains no URI escapes.
// for example space is legal in filename, but not in URI.
HBufC16* decoded = NULL;
TRAPD( error, ( decoded = EscapeUtils::EscapeDecodeL(
iMimeHeaders->ContentLocation() ) ) );
if ( error == KErrNone )
{
iFileName.Copy( decoded->Des().Right( KMmsMaxFileName ) );
delete decoded;
decoded = NULL;
}
else
{
iFileName.Copy( iMimeHeaders->ContentLocation().Right( KMmsMaxFileName ) );
}
}
}
// remove leading and trailing spaces just in case...
iFileName.Trim();
// We should now make sure that the filename is not too long.
// According to MMS conformance specs, the maximum should be 40 characters
// It is unclear if the characters mean the total length or the length
// after conversion to utf-8, but as a first approximation we try
// to ensure that the total does not exceed 40 characters
nameLength = iFileName.Length();
if ( nameLength > KMmsMaxFileNameLength )
{
parse = new( ELeave )TParse;
CleanupStack::PushL( parse );
parse->Set( aAttachmentInfo.FilePath(), NULL, NULL );
iFileName.Copy( parse->Name().Left( KMmsMaxFileNameLength - parse->Ext().Length() ) );
iFileName.Append( parse->Ext() );
CleanupStack::PopAndDestroy( parse );
parse = NULL;
nameLength = iFileName.Length();
}
// If encoding version is <=1.2, make filename safe,
// otherwise use MIME encoding (either base64 or quoted printable)
HBufC8* buf8 = NULL;
TPtrC16 originalName;
TBuf16<1> oneCharacter;
originalName.Set( iFileName );
TInt j;
if ( IsStringSafe( iFileName ) )
{
// filename only contains us-ascii characters - use as is
buf8 = HBufC8::NewL( nameLength );
CleanupStack::PushL( buf8 );
buf8->Des().Copy( iFileName );
}
else
{
if ( iMmsHeaders->MmsVersion() <= KMmsVersion12 )
{
// if version is <= 1.2, the filename must be us-ascii
// replace all illegal characters by underscore
buf8 = HBufC8::NewL( nameLength );
CleanupStack::PushL( buf8 );
for ( j = 0; j < nameLength; j++ )
{
oneCharacter.Copy( originalName.Mid( j, 1 ) );
if ( !IsStringSafe( oneCharacter ) )
{
_LIT( KMmsUnderscore, "_" );
oneCharacter.Copy( KMmsUnderscore );
}
buf8->Des().Append( oneCharacter );
}
}
else
{
// MMS encapsulation version is 1.3 or later
// Using non-ascii characters in filename parameter is allowed
// The filename must be encoded either using base64 or quoted printable
HBufC8* temp = NULL;
temp = CnvUtfConverter::ConvertFromUnicodeToUtf8L( originalName );
CleanupStack::PushL( temp );
// Now we have the filename in utf-8.
// We must check if it contains non-ascii, and if it does,
// we must use base64 or quoted-printable encoding.
TInt numNonSafe;
// Actually we know already that we are not safe. We just need
// to get the number of non-ascii characters
IsStringSafe( temp->Des(), numNonSafe );
// We prefer quoted printable as it looks nicer in case we have mostly ascii,
// and it leaves extension in cleartext anyway
if ( ( temp->Des().Length() + ( KMms2 * numNonSafe ) ) <= KMaxEncodingLength )
{
// use quoted printable, but first convert spaces to underscores
TInt spacePosition = temp->Des().Find( KSpace8 );
while ( spacePosition != KErrNotFound )
{
temp->Des()[ spacePosition ] = KMmsIntUnderscore;
spacePosition = temp->Des().Find( KSpace8 );
}
buf8 = EncodeQuotedPrintableWordL( temp->Des() );
}
else
{
// use base64
// We have not restricted the filename length in utf-8 format,
// so it may be way longer than 40 bytes.
// However, we can calculate the length the buffer needs, so we
// can try. However, we may end up with some soft line break in
// the middle of the parameter which may not be acceptable.
buf8 = EncodeBase64WordL( temp->Des() );
}
CleanupStack::PopAndDestroy( temp );
CleanupStack::PushL( buf8 );
// we must change nameLength here
}
}
// The name is now in buf8, either just copied or encoded
nameLength = buf8->Des().Length();
if ( aFoundName == EFalse )
{
// well-known encoding for the header itself
aHeaderLength++;
aHeaderLength += nameLength;
aHeaderLength += 1; // terminating zero
}
aContentTypeSize = aHeaderLength;
// As we have general form (at least name parameter), we need to indicate the length
if ( aContentTypeSize <= KMms30 )
{
// short length
aHeaderLength += 1;
}
else
{
// length quote + at least one byte of uintvar
aHeaderLength += KMms2;
// Expecting over 128 bytes is paranoid.
if ( aContentTypeSize >= KMms0x7F )
{
aHeaderLength++;
}
}
// Now the rest of the mime headers:
// Content-location
// just a short integer + a null terminated string
if ( iMimeHeaders->ContentLocation().Length() > 0 )
{
aHeaderLength += 1; // encoding of header as short integer
// If we want to make sure we are safe,
// we must call IsStringSafe() function.
// We just assume we are safe now.
aHeaderLength += iMimeHeaders->ContentLocation().Length();
aHeaderLength += 1; // terminating zero
}
// Content-ID
if ( iMimeHeaders->ContentId().Length() > 0 )
{
aHeaderLength += 1; // encoding of header as short integer
// add terminating zero and preceding quote.
// (needed according to WSP 1.3)
aHeaderLength += iMimeHeaders->ContentId().Length() + KMms2;
if ( iMimeHeaders->ContentId().Find( KMmsLeftAngle ) != 0 )
{
aHeaderLength += KMms2; // we must add angle bracket
}
}
// x-type parameters
// Must be stored as name/value pairs like content-type parameters
// X-parameter[i] = parameter name
// X-parameter[i+1] = parameter value
for ( i = 0; i < iMimeHeaders->XTypeParams().MdcaCount(); i++ )
{
// If we have corrupted parameters (length of name is zero)
// we skip the name/value pair.
// value may be zero, it will be encoded as just the terminating zero
if ( i%2 == 0 &&
( iMimeHeaders->XTypeParams().MdcaPoint( i ).Length() == 0 ||
iMimeHeaders->XTypeParams().MdcaPoint( i ).CompareF(
KMmsSeparateDeliveryOmaXHeader ) == 0 ) )
{
// We skip the header and its value if
// a) the header length is 0
// b) the header is X-Oma-Drm-Separate-Delivery
i++;
}
else
{
aHeaderLength += iMimeHeaders->XTypeParams().MdcaPoint( i ).Length() + 1;
}
}
if ( ( iMimeHeaders->XTypeParams().MdcaCount() % 2 ) == 1 )
{
// Odd number. Obviously last paramter has no value.
// Add the "no value" token
aHeaderLength++;
}
// THESE ARE NOT IMPLEMENTED
// Content-disposition & parameters
// Content-description
// Content-base
// Relative path
// version
#ifdef CONTENT_DISPOSITION_TEST
// not supported
// We generate a general header for content disposition
// for tests we use the actual filename.
// In real life the user's filename should not be
// sent out to the world
// Fixed coding:
// Content Disposition, value length, attachment, filename,
// actual filename + terminating 0
// attachment, filename, terminating zero
// content disposition should be text-string, not quoted text string
TInt contentDispositionLength = KMms3 + nameLength;
TInt valueLengthLength = 1;
if ( contentDispositionLength > KMms30 )
{
// lengths 0 - 30 are encoded using "short length"
valueLengthLength++;
//
if ( contentDispositionLength > ShortIntegerLimit127 )
{
valueLengthLength++;
}
// Should never be longer than this.
// I don't think anybody has a filename that is longer than 16383 bytes.
}
aHeaderLength += valueLengthLength + contentDispositionLength + 1;
#endif
CleanupStack::Pop( buf8 );
return buf8; // caller will delete this afterwards
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeAttachmentHeadersL(
TUint aSize,
TUint aHeaderSize,
TBool aFoundName,
TUint aContentTypeSize,
TInt8 aContentType,
TPtrC8& aContentTypeString,
TPtrC8& aNameString )
{
EncodeUintvar( aHeaderSize );
EncodeUintvar( aSize );
TUint8 temp = 0; // used to set the high bit for integers
// if we have character set (or other parameters),
// we must use general encoding
EncodeValueLength( aContentTypeSize );
if ( aContentType >= 0 )
{
temp = aContentType | KMms0x80;
iEncodeBuffer->Write( iPosition, &temp, 1 );
iPosition++;
}
else
{
// we assume this is a safe string
EncodeTextString( aContentTypeString );
}
// Then content type parameters. Mainly character set,
// but maybe something else, too
temp = KWspCharset | KMms0x80; // encode as short integer
EncodeOptionalInteger( temp, iMimeHeaders->MimeCharset() );
// if we didn't find "Name" parameter among our paramters, we
// put it first.
// we need the name later anyway...
if ( !aFoundName )
{
temp = KWspName | KMms0x80; // encode as short integer
EncodeHeaderAndTextString( temp, aNameString );
}
// Then the rest of content type parameters, just text strings.
TInt i = 0;
for ( i = 0; i < iMimeHeaders->ContentTypeParams().MdcaCount(); i++ )
{
// If we have corrupted parameters (length of name is zero)
// we skip the name/value pair.
// value may be zero, it will be encoded as just the terminating zero
if ( i%2 == 0 &&
iMimeHeaders->ContentTypeParams().MdcaPoint( i ).Length() == 0 )
{
i++;
}
else
{
// 8-byte string + terminating zero
// If parameter has no value, it still must have
// the "no-value" indicator (just the terminating zero.)
// The ContentTypeParameters function provides
// an empty string in this case.
if ( iMimeHeaders->ContentTypeParams().MdcaPoint( i ).CompareF(
KWspNameString ) == 0 && i%2 == 0 )
{
if ( aFoundName )
{
temp = KWspName | KMms0x80; // encode as short integer
iEncodeBuffer->Write( iPosition, &temp, 1 );
iPosition++;
}
else
{
// we can use name from mime headers only if it is "safe"
// (contains only us-ascii characters)
// If the name is not safe, the parameter value is skipped
i++;
}
}
else
{
EncodeTextString(
iMimeHeaders->ContentTypeParams().MdcaPoint( i ) );
}
}
}
if ( ( iMimeHeaders->ContentTypeParams().MdcaCount() % 2 ) == 1 )
{
// Odd number. Obviously last paramter has no value.
// Add the "no value" token
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
}
// content-location
temp = KWspContentLocation | KMms0x80; // encode as short integer
EncodeOptionalStringL( temp, iMimeHeaders->ContentLocation() );
// content-id
if ( iMimeHeaders->ContentId().Length() > 0 )
{
HBufC8* tempContentId = HBufC8::NewL( iMimeHeaders->ContentId().Length() + KMms2 );
CleanupStack::PushL( tempContentId );
if ( iMimeHeaders->ContentId().Find( KMmsLeftAngle ) != 0 )
{
tempContentId->Des().Copy( KMmsLeftAngle );
tempContentId->Des().Append( iMimeHeaders->ContentId() );
tempContentId->Des().Append( KMmsRightAngle );
}
else
{
tempContentId->Des().Copy( iMimeHeaders->ContentId() );
}
temp = KWspContentId | KMms0x80; // encode as short integer
iEncodeBuffer->Write( iPosition, &temp, 1 );
iPosition++;
EncodeQuotedTextString( tempContentId->Des() );
CleanupStack::PopAndDestroy( tempContentId );
}
#ifdef CONTENT_DISPOSITION_TEST
// not supported
temp = 0x2E | KMms0x80; // content disposition
iEncodeBuffer->Write( iPosition, &temp, 1 );
iPosition++;
EncodeValueLength( contentDispositionLength );
temp = 0x81; // attachment
iEncodeBuffer->Write( iPosition, &temp, 1 );
iPosition++;
temp = 0x06 | KMms0x80; // filename
// filename should be text-string, not quoted
EncodeHeaderAndTextString( temp, buf8->Des() );
#endif
// x-type parameters
for ( i = 0; i < iMimeHeaders->XTypeParams().MdcaCount(); i++ )
{
// If we have corrupted parameters (length of name is zero)
// we skip the name/value pair.
// value may be zero, it will be encoded as just the terminating zero
if ( i%2 == 0 &&
( iMimeHeaders->XTypeParams().MdcaPoint( i ).Length() == 0 ||
iMimeHeaders->XTypeParams().MdcaPoint( i ).CompareF(
KMmsSeparateDeliveryOmaXHeader ) == 0 ) )
{
// We skip the header and its value if
// a) the header length is 0
// b) the header is X-Oma-Drm-Separate-Delivery
i++;
}
else
{
// 8-byte string + terminating zero
// If parameter has no value, it still must have
// the "no-value" indicator (just the terminating zero.)
// The ContentTypeParameters function provides
// an empty string in this case.
EncodeTextString( iMimeHeaders->XTypeParams().MdcaPoint( i ) );
}
}
if ( ( iMimeHeaders->XTypeParams().MdcaCount() % 2 ) == 1 )
{
// Odd number. Obviously last paramter has no value.
// Add the "no value" token
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
}
// End of MIME headers
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeAttachmentData( RFile& aAttachFile, TInt aSize )
{
// read the attachment file
// set up a pointer to point to iEncodeBuffer at iPosition
TPtr8 pos = iEncodeBuffer->Ptr( iPosition );
// Attachemnt may be a file attacment or a linked file.
// The file pointer will point to unread part if file is read in chunks
iError = aAttachFile.Read( pos, aSize );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::FinishL()
{
// Remove slack to keep garbage out from the end of the file
iEncodeBuffer->ResizeL( iPosition );
iOverallDataSize = iEncodeBuffer->Size();
iState = EMmsIdle;
// Dump the buffer contents into file if requested
Dump();
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeRequestHeadersL()
{
// encode message depending on type
switch ( iMmsHeaders->MessageType() )
{
// KMmsMessageTypeMNotifyRespInd and KMmsMessageTypeAcknowledgeInd and all other PDUs
// that contain only headers and no data should be handled by
// using function
// EncodeHeadersL(CMmsHeaders& aMmsHeaders,CBufFlat& aEncodeBuffer)
case KMmsMessageTypeMSendReq:
EncodeSendRequestHeadersL();
break;
case KMmsMessageTypeMBoxUploadReq:
// This type has attachments and headers
EncodeMMBoxUploadRequestL();
break;
case KMmsMessageTypeMRetrieveConf:
// for test purposes
EncodeRetrieveConfirmationL();
break;
case KMmsMessageTypeMboxViewConf:
// for test purposes
EncodeMMBoxViewConfirmationL();
break;
case KMmsMessageTypeMBoxDescr:
// for test purposes
EncodeMMBoxDescriptionL();
break;
default:
iError = KMmsErrorUnknownMessageType;
break;
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeSendRequestHeadersL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMSendReq,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
// if we have set a date, insert it
EncodeDate( iMmsHeaders->Date() );
// If we have set the sender, encode it
// If not, we ask MMSC to add the sender
EncodeSenderL( iMmsHeaders->Sender() );
// All recipient lists. If no recipients in some of the lists,
// nothing is encoded, no need to check separately
EncodeRecipientL( iMmsHeaders->ToRecipients(), EMmsTo );
EncodeRecipientL( iMmsHeaders->CcRecipients(), EMmsCc );
EncodeRecipientL( iMmsHeaders->BccRecipients(), EMmsBcc );
// Subject
EncodeOptionalStringL( KMmsAssignedSubject, iMmsHeaders->Subject() );
// Message class
EncodeOptionalByte( KMmsAssignedMessageClass,
iMmsHeaders->MessageClass() );
// Expiration time
EncodeOptionalIntervalOrDate( KMmsAssignedExpiry,
iMmsHeaders->ExpiryInterval(),
iMmsHeaders->ExpiryDate() );
// Delivery time
EncodeOptionalIntervalOrDate( KMmsAssignedDeliveryTime,
iMmsHeaders->DeliveryTimeInterval(),
iMmsHeaders->DeliveryDate() );
// Priority
EncodeOptionalByte( KMmsAssignedPriority, iMmsHeaders->MessagePriority() );
// Sender visibility
EncodeOptionalByte( KMmsAssignedSenderVisibility,
iMmsHeaders->SenderVisibility() );
// Delivery report
EncodeOptionalByte( KMmsAssignedDeliveryReport,
iMmsHeaders->DeliveryReport() );
// Read reply
EncodeOptionalByte( KMmsAssignedReadReply, iMmsHeaders->ReadReply() );
// MMS encapsulation 1.1 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion1 )
{
// Do we want to specify reply charging
if ( iMmsHeaders->ReplyCharging() == KMmsReplyChargingRequested ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingRequestedTextOnly )
{
// Reply charging value
EncodeOptionalByte( KMmsAssignedReplyCharging,
iMmsHeaders->ReplyCharging() );
// Reply charging deadline
EncodeOptionalIntervalOrDate( KMmsAssignedReplyChargingDeadline,
iMmsHeaders->ReplyChargingInterval(),
iMmsHeaders->ReplyChargingDate() );
// Reply charging size
EncodeReplyChargingSize( iMmsHeaders->ReplyChargingSize() );
}
// Reply charging ID
EncodeOptionalString( KMmsAssignedReplyChargingID,
iMmsHeaders->ReplyChargingId() );
}
if ( iMmsHeaders->MmsVersion() > KMmsVersion11 )
{
// MMBox related headers - optional
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-Mms-MM-Store
EncodeOptionalByte( KMmsAssignedMmsStore,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsStore() );
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsStore() == KMmsYes )
{
// X-Mms-MM-State
EncodeOptionalByte( KMmsAssignedMMState,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsMMState() );
// X-MMs-MM-Flags
// The keyword token should always be "add" or "remove"
EncodeKeywordArrayL();
}
}
}
// Add encapsulation version 1.3 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 )
{
// X-Mms-Applic-ID, X-Mms-Reply-Applic-ID and X-Mms-Aux-Applic-Info
EncodeApplicationHeadersL();
// X-Mms-Content-Class
EncodeOptionalByte( KMmsAssignedContentClass, iMmsHeaders->ContentClass() );
// X-Mms-DRM-Content
EncodeOptionalByte( KMmsAssignedDrmContent, iMmsHeaders->DrmContent() );
// X-Mms-Adaptation-Allowed
EncodeOptionalByte( KMmsAssignedAdaptationAllowed, iMmsHeaders->AdaptationAllowed() );
}
// Get Root TMsvId from headers if set
TMsvAttachmentId rootId = iMmsHeaders->MessageRoot();
TInt error = KErrNone;
// If we are handling headers only, we may not have iEntryWrapper
if ( iEntryWrapper )
{
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
TRAP( error,
{
CMsvAttachment* attachmentInfo = attachMan.GetAttachmentInfoL(
(TMsvAttachmentId) rootId );
delete attachmentInfo; // we just wanted to check that it was found
}
);
CleanupStack::PopAndDestroy( store );
}
// If we have a valid root part, we send the message as multipart/related.
// Otherwise we send it as multipart mixed.
// We don't try to guess what the root is supposed to be, if it
// is not specified or does not point to an existing attachment.
if ( error == KErrNone && rootId != 0 && iEntryWrapper )
{
EncodeMultipartRelatedHeaderL( rootId );
}
else
{
EncodeMultipartMixedHeaderL();
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeNotifyResponse()
{
// version may be current version or 1.0
// Only byte is used. iMmsHeaders controls the value.
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMNotifyRespInd, iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// insert message status
EncodeMandatoryByte( KMmsAssignedStatus, iMmsHeaders->Status() );
// insert report allowed if present
EncodeOptionalByte( KMmsAssignedReportAllowed,
iMmsHeaders->ReportAllowed() );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeAcknowledgeIndication()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeAcknowledgeInd,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
// insert report allowed if present
EncodeOptionalByte( KMmsAssignedReportAllowed,
iMmsHeaders->ReportAllowed() );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMmsNotificationL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMNotificationInd,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
// for notification sender is optional - added only if it is known
if ( iMmsHeaders->Sender().Length() > 0 )
{
EncodeSenderL( iMmsHeaders->Sender() );
}
EncodeOptionalStringL( KMmsAssignedSubject, iMmsHeaders->Subject() );
EncodeOptionalByte( KMmsAssignedDeliveryReport,
iMmsHeaders->DeliveryReport() );
EncodeOptionalByte( KMmsAssignedMessageClass,
iMmsHeaders->MessageClass() );
iEncodeBuffer->Write( iPosition, &KMmsAssignedMessageSize, 1 );
iPosition++;
TInt64 size = iMmsHeaders->MessageSize();
EncodeLongInteger( size );
EncodeOptionalIntervalOrDate( KMmsAssignedExpiry,
iMmsHeaders->ExpiryInterval(),
iMmsHeaders->ExpiryDate() );
// version 1.1 fields - optional
// reply-charging
// reply-charging deadline
// reply-charging size
// reply-charging ID
if ( iMmsHeaders->MmsVersion() > KMmsVersion1 )
{
// Do we want to specify
if ( iMmsHeaders->ReplyCharging() == KMmsReplyChargingAccepted ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingAcceptedTextOnly )
{
// Reply charging value
EncodeOptionalByte( KMmsAssignedReplyCharging,
iMmsHeaders->ReplyCharging() );
// Reply charging deadline
EncodeOptionalIntervalOrDate( KMmsAssignedReplyChargingDeadline,
iMmsHeaders->ReplyChargingInterval(),
iMmsHeaders->ReplyChargingDate() );
// Reply charging size
EncodeReplyChargingSize( iMmsHeaders->ReplyChargingSize() );
}
// if this is a reply, we may specify the ID
// Reply charging ID
EncodeOptionalString( KMmsAssignedReplyChargingID,
iMmsHeaders->ReplyChargingId() );
}
// version 1.2 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion11 )
{
// MMBox headers
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
EncodeOptionalByte( KMmsAssignedStored,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsStored() );
}
// Distribution indicator
EncodeOptionalByte( KMmsAssignedDistributionIndicator,
iMmsHeaders->DistributionIndicator() );
}
// Element descriptor
// This is somewhat a mystery - not implemented
// version 1.3 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 )
{
// X-Mms-Applic-ID, X-Mms-Reply-Applic-ID and X-Mms-Aux-Applic-Info
EncodeApplicationHeadersL();
// X-Mms-Recommended-Retrieval-Mode
EncodeOptionalByte( KMmsAssignedRecommendedRetrievalMode,
iMmsHeaders->RecommendedRetrievalMode() );
// X-Mms-Recommended-Retrieval-Mode-Text
EncodeOptionalStringL( KMmsAssignedRecommendedRetrievalModeText,
iMmsHeaders->RecommendedRetrievalModeText() );
// X-Mms-Content-Class
EncodeOptionalByte( KMmsAssignedContentClass, iMmsHeaders->ContentClass() );
// X-Mms-DRM-Content
EncodeOptionalByte( KMmsAssignedDrmContent, iMmsHeaders->DrmContent() );
// X-Mms-Replace-ID
EncodeOptionalString( KMmsAssignedReplaceId, iMmsHeaders->ReplaceCancelId() );
}
// We keep this as the last one, though it does not really matter
// Mandatory content-location
// this must be USASCII or URL encoded
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeSendConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMSendConf,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
EncodeMandatoryByte( KMmsAssignedResponseStatus,
iMmsHeaders->ResponseStatus() );
EncodeOptionalStringL( KMmsAssignedResponseText,
iMmsHeaders->ResponseText() );
// if send confirmation returns error, it might not contain message id
EncodeOptionalString( KMmsAssignedMessageId, iMmsHeaders->MessageId() );
// MMBox related headers - optional
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
EncodeOptionalByte( KMmsAssignedStoreStatus,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatus() );
EncodeOptionalStringL( KMmsAssignedStoreStatusText,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatusText() );
if ( iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatus() ==
KMmsStatusOk )
{
// this must be USASCII or URL encoded
// If message was stored to MMBox, this is mandatory
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
}
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeRetrieveConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMRetrieveConf,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
// message id
EncodeOptionalString( KMmsAssignedMessageId, iMmsHeaders->MessageId() );
// if we have set a date, insert it
EncodeDate( iMmsHeaders->Date() );
// If we have set the sender, encode it
if ( iMmsHeaders->Sender().Length() > 0 )
{
EncodeSenderL( iMmsHeaders->Sender() );
}
// previously sent by array
TInt i;
TUint oldPosition;
TUint length;
for ( i = 0; i < iMmsHeaders->PreviouslySentList().Count(); i++ )
{
oldPosition = iPosition;
length = 0;
// Encode once just to find out filed length
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeAddressL( iMmsHeaders->PreviouslySentList()[i]->Sender() );
length += iPosition - oldPosition;
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedPreviouslySentBy, 1 );
iPosition++;
EncodeValueLength( length );
// now we have added length, do the actual encoding
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeAddressL( iMmsHeaders->PreviouslySentList()[i]->Sender() );
oldPosition = iPosition;
length = 0;
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeLongInteger( iMmsHeaders->PreviouslySentList()[i]->Date() );
length += iPosition - oldPosition;
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedPreviouslySentDate, 1 );
iPosition++;
EncodeValueLength( length );
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeLongInteger( iMmsHeaders->PreviouslySentList()[i]->Date() );
}
// All recipient lists. If no recipients in some of the lists,
// nothing is encoded, no need to check separately
EncodeRecipientL( iMmsHeaders->ToRecipients(), EMmsTo );
EncodeRecipientL( iMmsHeaders->CcRecipients(), EMmsCc );
// no Bcc in retrieve confirmation
// Subject
EncodeOptionalStringL( KMmsAssignedSubject, iMmsHeaders->Subject() );
// MMBox headers
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-Mms-MM-State
EncodeOptionalByte( KMmsAssignedMMState,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsMMState() );
// X-MMs-MM-Flags
// The keyword token should always be "add" or "remove"
EncodeKeywordArrayL();
}
// Message class
EncodeOptionalByte( KMmsAssignedMessageClass,
iMmsHeaders->MessageClass() );
// Priority
EncodeOptionalByte( KMmsAssignedPriority, iMmsHeaders->MessagePriority() );
// Delivery report
EncodeOptionalByte( KMmsAssignedDeliveryReport,
iMmsHeaders->DeliveryReport() );
// Read reply
EncodeOptionalByte( KMmsAssignedReadReply, iMmsHeaders->ReadReply() );
// MMS encapsulation 1.1 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion1 )
{
// Do we want to specify reply charging
if ( iMmsHeaders->ReplyCharging() == KMmsReplyChargingAccepted ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingAcceptedTextOnly )
{
// Reply charging value
EncodeOptionalByte( KMmsAssignedReplyCharging,
iMmsHeaders->ReplyCharging() );
// Reply charging deadline
EncodeOptionalIntervalOrDate( KMmsAssignedReplyChargingDeadline,
iMmsHeaders->ReplyChargingInterval(),
iMmsHeaders->ReplyChargingDate() );
// Reply charging size
EncodeReplyChargingSize( iMmsHeaders->ReplyChargingSize() );
}
// Reply charging ID
EncodeOptionalString( KMmsAssignedReplyChargingID,
iMmsHeaders->ReplyChargingId() );
// status of the operation
EncodeOptionalByte( KMmsAssignedRetrieveStatus,
iMmsHeaders->ResponseStatus() );
EncodeOptionalStringL( KMmsAssignedRetrieveText,
iMmsHeaders->ResponseText() );
}
// version 1.2 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion11 )
{
// Distribution indicator
EncodeOptionalByte( KMmsAssignedDistributionIndicator,
iMmsHeaders->DistributionIndicator() );
}
// version 1.3 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 )
{
// X-Mms-Applic-ID, X-Mms-Reply-Applic-ID and X-Mms-Aux-Applic-Info
EncodeApplicationHeadersL();
// X-Mms-Content-Class
EncodeOptionalByte( KMmsAssignedContentClass, iMmsHeaders->ContentClass() );
// X-Mms-DRM-Content
EncodeOptionalByte( KMmsAssignedDrmContent, iMmsHeaders->DrmContent() );
// X-Mms-Replace-ID
EncodeOptionalString( KMmsAssignedReplaceId, iMmsHeaders->ReplaceCancelId() );
}
// Start pointer
TUint ii = 0;
// Get Root TMsvId from headers if set
TMsvId rootId = iMmsHeaders->MessageRoot();
TInt error = KErrNone;
if ( iEntryWrapper )
{
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
TRAP( error,
{
CMsvAttachment* attachmentInfo = attachMan.GetAttachmentInfoL(
(TMsvAttachmentId) rootId );
delete attachmentInfo; // we just wanted to check that it was found
}
);
CleanupStack::PopAndDestroy( store );
}
// If we have a valid root part, we send the message as multipart/related.
// Otherwise we send it as multipart mixed.
// We don't try to guess what the root is supposed to be, if it
// is not specified or does not point to an existing attachment.
if ( error == KErrNone && rootId != 0 && iEntryWrapper )
{
EncodeMultipartRelatedHeaderL( rootId );
}
else
{
EncodeMultipartMixedHeaderL();
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeDeliveryReportL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeDeliveryInd, TPtrC8(),
iMmsHeaders->MmsVersion() );
EncodeHeaderAndTextString( KMmsAssignedMessageId,
iMmsHeaders->MessageId() );
EncodeRecipientL( iMmsHeaders->ToRecipients(), EMmsTo );
// if we have set a date, insert it
EncodeDate( iMmsHeaders->Date() );
// insert message status
EncodeMandatoryByte( KMmsAssignedStatus, iMmsHeaders->Status() );
// version 1.3 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 )
{
// X-Mms-Status-Text
// Status text is stored in the same place as response text and retrieve
// text as only one of them can appear in any PDU
EncodeOptionalStringL( KMmsAssignedStatusText,
iMmsHeaders->ResponseText() );
// X-Mms-Applic-ID, X-Mms-Reply-Applic-ID and X-Mms-Aux-Applic-Info
EncodeApplicationHeadersL();
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeForwardRequestL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeForwardReq,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
// if we have set a date, insert it
EncodeDate( iMmsHeaders->Date() );
// If we have set the sender, encode it
// If not, we ask MMSC to add the sender
EncodeSenderL( iMmsHeaders->Sender() );
// All recipient lists. If no recipients in some of the lists,
// nothing is encoded, no need to check separately
EncodeRecipientL( iMmsHeaders->ToRecipients(), EMmsTo );
EncodeRecipientL( iMmsHeaders->CcRecipients(), EMmsCc );
EncodeRecipientL( iMmsHeaders->BccRecipients(), EMmsBcc );
// Expiration time
EncodeOptionalIntervalOrDate( KMmsAssignedExpiry,
iMmsHeaders->ExpiryInterval(),
iMmsHeaders->ExpiryDate() );
// Delivery time
EncodeOptionalIntervalOrDate( KMmsAssignedDeliveryTime,
iMmsHeaders->DeliveryTimeInterval(),
iMmsHeaders->DeliveryDate() );
// Delivery report allowed
EncodeOptionalByte( KMmsAssignedReportAllowed,
iMmsHeaders->ReportAllowed() );
// Delivery report
EncodeOptionalByte( KMmsAssignedDeliveryReport,
iMmsHeaders->DeliveryReport() );
// Read reply
EncodeOptionalByte( KMmsAssignedReadReply, iMmsHeaders->ReadReply() );
// version 1.2 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion11 )
{
// MMBox related headers - optional
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-Mms-MM-Store
EncodeOptionalByte( KMmsAssignedMmsStore,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsStore() );
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsStore() == KMmsYes ||
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsStored() == KMmsYes )
{
// X-Mms-MM-State
EncodeOptionalByte( KMmsAssignedMMState,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsMMState() );
// X-MMs-MM-Flags
// The keyword token should always be "add" or "remove"
EncodeKeywordArrayL();
}
}
}
// version 1.3 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 )
{
// Do we want to specify reply charging
if ( iMmsHeaders->ReplyCharging() == KMmsReplyChargingRequested ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingRequestedTextOnly )
{
// Reply charging value
EncodeOptionalByte( KMmsAssignedReplyCharging,
iMmsHeaders->ReplyCharging() );
// Reply charging deadline
EncodeOptionalIntervalOrDate( KMmsAssignedReplyChargingDeadline,
iMmsHeaders->ReplyChargingInterval(),
iMmsHeaders->ReplyChargingDate() );
// Reply charging size
EncodeReplyChargingSize( iMmsHeaders->ReplyChargingSize() );
}
}
// Mandatory content-location
// this must be USASCII or URL encoded
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeForwardConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeForwardConf,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
EncodeMandatoryByte( KMmsAssignedResponseStatus,
iMmsHeaders->ResponseStatus() );
EncodeOptionalStringL( KMmsAssignedResponseText,
iMmsHeaders->ResponseText() );
EncodeOptionalString( KMmsAssignedMessageId, iMmsHeaders->MessageId() );
// MMBox related headers - optional
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
EncodeOptionalByte( KMmsAssignedStoreStatus,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatus() );
EncodeOptionalStringL( KMmsAssignedStoreStatusText,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatusText() );
if ( iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatus() ==
KMmsStatusOk )
{
// this must be USASCII or URL encoded
// If message was stored to MMBox, this is mandatory
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
}
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeReadReplyL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( iMmsHeaders->MessageType(), TPtrC8(), iMmsHeaders->MmsVersion() );
// message id
EncodeHeaderAndTextString( KMmsAssignedMessageId,
iMmsHeaders->MessageId() );
// originator of the original message
EncodeRecipientL( iMmsHeaders->ToRecipients(), EMmsTo );
// If we have set the sender, encode it
// If not, we ask MMSC to add the sender
EncodeSenderL( iMmsHeaders->Sender() );
// if we have set a date, insert it
EncodeDate( iMmsHeaders->Date() );
EncodeMandatoryByte( KMmsAssignedReadStatus, iMmsHeaders->ReadStatus() );
// version 1.3 headers - optional
if ( iMmsHeaders->MmsVersion() > KMmsVersion12 )
{
// X-Mms-Applic-ID, X-Mms-Reply-Applic-ID and X-Mms-Aux-Applic-Info
EncodeApplicationHeadersL();
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxStoreRequestL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMboxStoreReq, iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// this must be USASCII or URL encoded
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
// MMBox headers
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-Mms-MM-State
EncodeOptionalByte( KMmsAssignedMMState,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsMMState() );
// X-MMs-MM-Flags
// The keyword token should always be "add" or "remove"
EncodeKeywordArrayL();
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxStoreConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMboxStoreConf, iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// this must be USASCII or URL encoded
EncodeOptionalString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
EncodeMandatoryByte( KMmsAssignedStoreStatus,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatus() );
EncodeOptionalStringL( KMmsAssignedStoreStatusText,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatusText() );
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxViewRequestL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMboxViewReq, iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// Insert content location header. There may be more than one
EncodeContentLocationArray();
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-MMs-MM-Flags. The token should always be "filter"
EncodeKeywordArrayL();
}
if ( iMmsHeaders->ReadOnlyMMBoxViewHeaders() )
{
CMmsMMBoxViewHeaders& viewHeaders = iMmsHeaders->MMBoxViewHeadersL();
// states used as filter
// X-Mms-MM-State may appear multiple times in view request
EncodeMMBoxStates( viewHeaders.MMStateArray() );
// start
EncodeOptionalInteger( KMmsAssignedStart, viewHeaders.MmsStart() );
// limit
if ( viewHeaders.MmsLimit() != KMaxTUint32 )
{
// 0 means no message information, absence means all remaining
// messages.
// If header has value KMaxTUint32, it means that info about all
// remaining messages is wanted.
iEncodeBuffer->Write( iPosition, &KMmsAssignedLimit, 1 );
iPosition++;
EncodeInteger( viewHeaders.MmsLimit() );
}
EncodeAttributes( viewHeaders.AttributeArray() );
// request totals
EncodeOptionalByte( KMmsAssignedTotals, viewHeaders.MmsTotals() );
// request quotas
EncodeOptionalByte( KMmsAssignedQuotas, viewHeaders.MmsQuotas() );
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxViewConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMboxViewConf,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
EncodeMandatoryByte( KMmsAssignedResponseStatus,
iMmsHeaders->ResponseStatus() );
EncodeOptionalStringL( KMmsAssignedResponseText,
iMmsHeaders->ResponseText() );
EncodeContentLocationArray();
// MMBox headers
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-MMs-MM-Flags. The token should always be "filter"
EncodeKeywordArrayL();
}
if ( iMmsHeaders->ReadOnlyMMBoxViewHeaders() )
{
CMmsMMBoxViewHeaders& viewHeaders = iMmsHeaders->MMBoxViewHeadersL();
// states used as filter
// X-Mms-MM-State may appear multiple times in view request
EncodeMMBoxStates( viewHeaders.MMStateArray() );
// start
EncodeOptionalInteger( KMmsAssignedStart, viewHeaders.MmsStart() );
// limit
if ( viewHeaders.MmsLimit() != KMaxTUint32 )
{
// 0 means no message information, absence means all remaining
// messages.
// If header has value KMaxTUint32, it means that info about
// all remaining messages is wanted.
iEncodeBuffer->Write( iPosition, &KMmsAssignedLimit, 1 );
iPosition++;
EncodeInteger( viewHeaders.MmsLimit() );
}
EncodeAttributes( viewHeaders.AttributeArray() );
// totals
TUint oldPosition = iPosition;
TUint length = 0;
if ( viewHeaders.MMBoxTotalNumber() != KMaxTUint32 )
{
oldPosition = iPosition;
EncodeInteger( viewHeaders.MMBoxTotalNumber() );
length = iPosition - oldPosition;
length += 1; // quota token
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedMboxTotals, 1 );
iPosition++;
EncodeValueLength( length );
iEncodeBuffer->Write( iPosition, &KMmsMessageCountToken, 1 );
iPosition++;
EncodeInteger( viewHeaders.MMBoxTotalNumber() );
}
if ( viewHeaders.MMBoxTotalSize() != KMaxTUint32 )
{
oldPosition = iPosition;
EncodeInteger( viewHeaders.MMBoxTotalSize() );
length = iPosition - oldPosition;
length += 1; // quota token
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedMboxTotals, 1 );
iPosition++;
EncodeValueLength( length );
iEncodeBuffer->Write( iPosition, &KMmsMessageSizeToken, 1 );
iPosition++;
EncodeInteger( viewHeaders.MMBoxTotalSize() );
}
// quotas
if ( viewHeaders.MMBoxQuotaNumber() != KMaxTUint32 )
{
oldPosition = iPosition;
EncodeInteger( viewHeaders.MMBoxQuotaNumber() );
length = iPosition - oldPosition;
length += 1; // quota token
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedMboxQuotas, 1 );
iPosition++;
EncodeValueLength( length );
iEncodeBuffer->Write( iPosition, &KMmsMessageCountToken, 1 );
iPosition++;
EncodeInteger( viewHeaders.MMBoxQuotaNumber() );
}
if ( viewHeaders.MMBoxQuotaSize() != KMaxTUint32 )
{
oldPosition = iPosition;
EncodeInteger( viewHeaders.MMBoxQuotaSize() );
length = iPosition - oldPosition;
length += 1; // quota token
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedMboxQuotas, 1 );
iPosition++;
EncodeValueLength( length );
iEncodeBuffer->Write( iPosition, &KMmsMessageSizeToken, 1 );
iPosition++;
EncodeInteger( viewHeaders.MMBoxQuotaSize() );
}
// Message count
// This should in principle come from the viewHeaders.MmsMessageCount()
// But in this context the number of messages will be the number of
// attachments available in this entry
// However, we will use the viewHeaders.MmsMessageCount() to generate
// the header so that we can test that the decoding part can handle
// possible conflict between message number and the number of parts
// in the multipart structure. This header is optional. KMaxTUint32
// will mean unspecified.
if ( viewHeaders.MmsMessageCount() != KMaxTUint32 )
{
iEncodeBuffer->Write( iPosition, &KMmsAssignedMessageCount, 1 );
iPosition++;
EncodeInteger( viewHeaders.MmsMessageCount() );
}
}
if ( iNumberOfAttachments == 0 )
{
EncodeMandatoryByte( KMmsAssignedContentType, KMmsAssignedAny );
}
else
{
EncodeMultipartMixedHeaderL();
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxUploadRequestL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMBoxUploadReq, iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// MMBox headers
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-Mms-MM-State
EncodeOptionalByte( KMmsAssignedMMState,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsMMState() );
// X-MMs-MM-Flags
// The keyword token should always be "add" or "remove"
EncodeKeywordArrayL();
}
// Get Root TMsvId from headers if set
TMsvAttachmentId rootId = iMmsHeaders->MessageRoot();
// Find the matching id from attachment list
TInt error = KErrNone;
if ( iEntryWrapper )
{
CMsvStore* store = iEntryWrapper->ReadStoreL();
CleanupStack::PushL( store );
// Only new attachment structure is supported
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
TRAP( error,
{
CMsvAttachment* attachmentInfo = attachMan.GetAttachmentInfoL(
(TMsvAttachmentId) rootId );
delete attachmentInfo; // we just wanted to check that it was found
}
);
CleanupStack::PopAndDestroy( store );
}
// If we have a valid root part, we send the message as multipart/related.
// Otherwise we send it as multipart mixed.
// We don't try to guess what the root is supposed to be, if it
// is not specified or does not point to an existing attachment.
// actually the content should be an MMS PDU as in M-MBox-Descr PDU
// It is unclear if if should be wrapped in a multipart structure
// (containing only one header)
// or if the content type should be application/vnd.wap.mms-message
if ( error == KErrNone && rootId != 0 && iEntryWrapper )
{
EncodeMultipartRelatedHeaderL( rootId );
}
else
{
EncodeMultipartMixedHeaderL();
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxUploadConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeMBoxUploadConf, iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// this must be USASCII or URL encoded
EncodeOptionalString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
EncodeMandatoryByte( KMmsAssignedStoreStatus,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatus() );
EncodeOptionalStringL( KMmsAssignedStoreStatusText,
iMmsHeaders->MMBoxMessageHeadersL().MmsStoreStatusText() );
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeDeleteRequestL()
{
// Insert message type, TID and version number
EncodeStartingHeaders( iMmsHeaders->MessageType(), iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// Insert content location header. There may be more than one
EncodeContentLocationArray();
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeDeleteConfirmationL()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( iMmsHeaders->MessageType(), iMmsHeaders->Tid(),
iMmsHeaders->MmsVersion() );
// content location, response status and response text headers have
// different format from other PDUs
const RPointerArray<CMmsDeleteResultArray>& resultArray =
iMmsHeaders->DeleteResultArray();
TInt i;
TInt length = 0;
TInt oldPosition = 0;
TUint oldIndex = KMaxTUint32;
for ( i = 0; i < resultArray.Count(); i++ )
{
TUint index = resultArray[i]->Order();
if ( index != oldIndex )
{
// We add status and status text only once, there may be more
// than one content location with the same status
oldIndex = index;
if ( resultArray[i]->ResponseStatus() != 0 )
{
oldPosition = iPosition;
length = 0;
// Encode once just to find out field length
EncodeInteger( index );
length += iPosition - oldPosition;
length ++; // response status is only one byte
iPosition = oldPosition;
// now we have calculated length, do the actual encoding
iEncodeBuffer->Write( iPosition, &KMmsAssignedResponseStatus, 1 );
iPosition++;
EncodeValueLength( length );
EncodeInteger( index );
TUint8 value = (TUint8) resultArray[i]->ResponseStatus();
iEncodeBuffer->Write( iPosition, &value, 1 );
iPosition++;
}
if ( resultArray[i]->ResponseText().Length() > 0 )
{
oldPosition = iPosition;
length = 0;
// Encode once just to find out field length
EncodeInteger( index );
EncodeTextStringL( resultArray[i]->ResponseText() );
length += iPosition - oldPosition;
iPosition = oldPosition;
// now we have calculated length, do the actual encoding
iEncodeBuffer->Write( iPosition, &KMmsAssignedResponseText, 1 );
iPosition++;
EncodeValueLength( length );
EncodeInteger( index );
EncodeTextStringL( resultArray[i]->ResponseText() );
}
}
if ( resultArray[i]->ContentLocation().Length() > 0 )
{
oldPosition = iPosition;
length = 0;
// Encode once just to find out field length
EncodeInteger( index );
EncodeTextString( resultArray[i]->ContentLocation() );
length += iPosition - oldPosition;
iPosition = oldPosition;
// now we have calculated length, do the actual encoding
iEncodeBuffer->Write( iPosition, &KMmsAssignedContentLocation, 1 );
iPosition++;
EncodeValueLength( length );
EncodeInteger( index );
EncodeTextString( resultArray[i]->ContentLocation() );
}
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxDescriptionL()
{
// implemented for test purposes
#ifdef __WINS__
EncodeMandatoryByte( KMmsAssignedMessageType, KMmsMessageTypeMBoxDescr );
// this must be USASCII or URL encoded
EncodeOptionalString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
EncodeOptionalString( KMmsAssignedMessageId, iMmsHeaders->MessageId() );
// MMBox headers
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
// X-Mms-MM-State
EncodeOptionalByte( KMmsAssignedMMState,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->MmsMMState() );
// X-MMs-MM-Flags
// The keyword token should always be "add" or "remove"
EncodeKeywordArrayL();
}
// if we have set a date, insert it
EncodeDate( iMmsHeaders->Date() );
// sender is optional
if ( iMmsHeaders->Sender().Length() > 0 )
{
EncodeSenderL( iMmsHeaders->Sender() );
}
// All recipient lists. If no recipients in some of the lists,
// nothing is encoded, no need to check separately
EncodeRecipientL( iMmsHeaders->ToRecipients(), EMmsTo );
EncodeRecipientL( iMmsHeaders->CcRecipients(), EMmsCc );
EncodeRecipientL( iMmsHeaders->BccRecipients(), EMmsBcc );
// Message class
EncodeOptionalByte( KMmsAssignedMessageClass,
iMmsHeaders->MessageClass() );
// Subject
EncodeOptionalStringL( KMmsAssignedSubject, iMmsHeaders->Subject() );
// Priority
EncodeOptionalByte( KMmsAssignedPriority, iMmsHeaders->MessagePriority() );
// Delivery time
EncodeOptionalIntervalOrDate( KMmsAssignedDeliveryTime,
iMmsHeaders->DeliveryTimeInterval(),
iMmsHeaders->DeliveryDate() );
// Expiration time
EncodeOptionalIntervalOrDate( KMmsAssignedExpiry,
iMmsHeaders->ExpiryInterval(),
iMmsHeaders->ExpiryDate() );
// Delivery report
EncodeOptionalByte( KMmsAssignedDeliveryReport,
iMmsHeaders->DeliveryReport() );
// Read reply
EncodeOptionalByte( KMmsAssignedReadReply, iMmsHeaders->ReadReply() );
if ( iMmsHeaders->MessageSize() > 0 )
{
iEncodeBuffer->Write( iPosition, &KMmsAssignedMessageSize, 1 );
iPosition++;
TInt64 size = iMmsHeaders->MessageSize();
EncodeLongInteger( size );
}
// MMBox description appears from 1.2 onwards - no use to check if we are
// 1.1 or later.
// Do we want to specify reply charging
if ( iMmsHeaders->ReplyCharging() == KMmsReplyChargingRequested ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingRequestedTextOnly ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingAccepted ||
iMmsHeaders->ReplyCharging() == KMmsReplyChargingAcceptedTextOnly )
{
// Reply charging value
EncodeOptionalByte( KMmsAssignedReplyCharging,
iMmsHeaders->ReplyCharging() );
// Reply charging deadline
EncodeOptionalIntervalOrDate( KMmsAssignedReplyChargingDeadline,
iMmsHeaders->ReplyChargingInterval(),
iMmsHeaders->ReplyChargingDate() );
// Reply charging size
EncodeReplyChargingSize( iMmsHeaders->ReplyChargingSize() );
}
// Reply charging ID
EncodeOptionalString( KMmsAssignedReplyChargingID,
iMmsHeaders->ReplyChargingId() );
TInt i;
TUint oldPosition;
TUint length;
for ( i = 0; i < iMmsHeaders->PreviouslySentList().Count(); i++ )
{
oldPosition = iPosition;
length = 0;
// Encode once just to find out field length
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeAddressL( iMmsHeaders->PreviouslySentList()[i]->Sender() );
length += iPosition - oldPosition;
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedPreviouslySentBy, 1 );
iPosition++;
EncodeValueLength( length );
// now we have added length, do the actual encoding
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeAddressL( iMmsHeaders->PreviouslySentList()[i]->Sender() );
oldPosition = iPosition;
length = 0;
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeLongInteger( iMmsHeaders->PreviouslySentList()[i]->Date() );
length += iPosition - oldPosition;
iPosition = oldPosition;
iEncodeBuffer->Write( iPosition, &KMmsAssignedPreviouslySentDate, 1 );
iPosition++;
EncodeValueLength( length );
EncodeInteger( iMmsHeaders->PreviouslySentList()[i]->Order() );
EncodeLongInteger( iMmsHeaders->PreviouslySentList()[i]->Date() );
}
if ( iNumberOfAttachments > 0 )
{
EncodeMultipartMixedHeaderL();
}
#endif
}
// ---------------------------------------------------------
// 8-bit version (no conversions)
// ---------------------------------------------------------
//
void CMmsEncode::EncodeTextString( const TDesC8& aString )
{
// Only Content-Id needs a quoted string, for example
// "<agjrfnjr>
// content-id encoding uses a separate function that adds the quote.
// EncodeQuotedTextString
// Check if we need a Quote (This does not mean the quoted string.)
TInt length = aString.Length();
if ( length > 0 && aString[0] >= KMms0x80 )
{
iEncodeBuffer->Write( iPosition, &KMmsQuote, 1 );
iPosition++;
}
iEncodeBuffer->Write( iPosition, aString, length );
iPosition += length;
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
}
// ---------------------------------------------------------
// 8-bit version (no conversions)
// ---------------------------------------------------------
//
void CMmsEncode::EncodeQuotedTextString( const TDesC8& aString )
{
// Before this function is called, the caller must check
// that the length of the string is not 0. Otherwise this
// makes no sense. You cannot quote a zero-length string
// We need quoted string for content-id.
// So far for nothing else.
// (for the filename in MIME headers, too, just in case)
// We add one quote to the beginning, nothing to the end.
// As we start with a quote, we don't need to check for the special
// Quote that is needed if a string starts with a character above 128
TInt length = aString.Length();
iEncodeBuffer->Write( iPosition, &KMmsStringQuote, 1 );
iPosition++;
iEncodeBuffer->Write( iPosition, aString, length );
iPosition += length;
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
}
// ---------------------------------------------------------
// unicode version
// ---------------------------------------------------------
//
void CMmsEncode::EncodeTextStringL( const TDesC& aString )
{
// What about a RFC2068 quoted strings -
// see explanation in EncodeTextString( const TDesC8& aString ) function
TInt i = 0;
TInt length = aString.Length();
TBool safe = IsStringSafe( aString );
// If the string can be encoded as ASCII, go ahead
if ( safe )
{
TUint8 character;
// No need to check if we need a quote - if we are safe, we have
// no characters >= 128.
for ( i = 0; i < aString.Length(); i++ )
{
character = TUint8( aString[i] & KMms0xFF );
iEncodeBuffer->Write( iPosition, &character, 1 );
iPosition++;
}
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
}
else
{
// if our length is 0, we are safe, no need to check the
// length here anymore
// we must convert to utf-8
//one ucs-2 character should never produce more than 4 bytes when converted to utf-8
HBufC8* buffer = HBufC8::NewL( aString.Length() * KMms4 ); // paranoid.
// we don't leave while we need buffer
TPtr8 buf8 = buffer->Des();
// if conversion fails, something is really seriously wrong
iError = CnvUtfConverter::ConvertFromUnicodeToUtf8( buf8, aString );
length = buf8.Length();
// utf8 character set encoding needs one byte (fits into short integer)
length += KMms2; // add character set encoding byte and trailing NULL
if ( buf8[0] >= KMms0x80 ) // 128
{
length++; // we will need a quote byte at the start...
}
EncodeValueLength( length );
// add one byte of character set
// this is a short integer, high bit must be set
TUint8 charset = KMmsUtf8 | KMms0x80;
iEncodeBuffer->Write( iPosition, &charset, 1 );
iPosition++;
// Check if we need a quote
if ( buf8[0] >= KMms0x80 ) // 128
{
iEncodeBuffer->Write( iPosition, &KMmsQuote, 1 );
iPosition++;
}
// Then write the string itself
iEncodeBuffer->Write( iPosition, buf8, buf8.Length() );
iPosition += buf8.Length();
// Add terminating NULL
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
delete buffer;
buffer = NULL;
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeDate( const TInt64& aDate)
{
if ( aDate == 0 )
{
return;
}
iEncodeBuffer->Write( iPosition, &KMmsAssignedDate, 1 );
iPosition++;
EncodeLongInteger( aDate );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeLongInteger( const TInt64& aLongInteger )
{
TUint8 length = 0; // number of bytes we will need
// The long integer will take 8 bytes or less
TUint8 array[KMms8];
TInt64 temp = aLongInteger;
TInt i = 0;
TInt64 reminder = 0;
for ( i = 7; i >= 0; i-- )
{
reminder = temp % 0x100;
temp = temp / 0x100;
array[i] = TInt8 ( I64INT( reminder ) ) ;
}
length = KMms8;
i = 0;
// The array has 8 elements, so this is safe.
while( ( i < KMms8 ) && ( array[i] == 0 ) )
{
i++;
length--;
}
// a zero should be coded as short integer.
// However, if there is a valid reason to code a zero as a long integer,
// we allow it. The caller should know what he is doing.
if ( length == 0 )
{
length = 1;
}
// write short length
iEncodeBuffer->Write( iPosition, &length, 1 );
iPosition++;
// write as many bytes as were non-zero
// array index will stay withing limits because of the way it was calculated
iEncodeBuffer->Write( iPosition, &(array[KMms8 - length] ), length );
iPosition+= length;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeInteger( TUint aInteger )
{
// KMms1 = 1
// KMms2 = 2
// KMms3 = 3
// KMms4 = 4
// KMms5 = 5
// etc.
TUint8 byte = 0;
if ( aInteger <= KMmsShortIntegerLimit127 )
{
byte = ( TInt8 ) aInteger;
byte |= KMms0x80;
iEncodeBuffer->Write( iPosition, &byte, 1);
iPosition++;
return; // this was easy
}
TUint8 length = KMms4; // number of bytes we will need
TUint8 array[KMms4];
TUint temp = aInteger;
byte = TInt8( ( temp >> KMms24 ) & KMms0xFF );
while ( byte == 0 && length > 0 )
{
length--;
temp = temp << KMms8;
byte = TInt8( ( temp >> KMms24 ) & KMms0xFF );
}
TUint i = 0;
for ( i = 0; i < length; i++ )
{
array[i] = TInt8( ( temp >> ( KMms8 * ( KMms3 - i ) ) ) & KMms0xFF );
}
// write short length
iEncodeBuffer->Write( iPosition, &length, 1 );
iPosition++;
// write as many bytes as were non-zero
// aInteger was tested in the beginning - it needs at least one byte
// So length is at least 1 and the array has been properly initialized.
iEncodeBuffer->Write( iPosition, &array[0], length );
iPosition+= length;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeSenderL( const TPtrC& aSender )
{
iEncodeBuffer->Write( iPosition, &KMmsAssignedFrom, 1 );
iPosition++;
// We must insert value length.
if ( aSender.Length() == 0 )
{
// The MMSC must insert our address
TUint8 length;
length = 1;
iEncodeBuffer->Write( iPosition, &length, 1 );
iPosition++;
iEncodeBuffer->Write( iPosition, &KMmsInsertAddressToken, 1 );
iPosition++;
return;
}
// Now we must insert something
TUint length = 1; // address present token
if ( aSender.Find( KMiuMau ) != KErrNotFound )
{
TBool safe = IsStringSafe( aSender );
if ( safe )
{
// this was easy, just ASCII, no conversion
length += aSender.Length();
length ++; // room for terminating zero
}
else // not USASCII, charset must be specified
{
// worst case scenario.
// must be encoded as UTF-8, value length and character set
// must be added
// one ucs-2 character will not produce more than 4 bytes when converted to utf-8
HBufC8* buffer = HBufC8::NewL( aSender.Length() * KMms4 ); // paranoid.
// we don't need to push buffer onto cleanup stack, as we don't
// leave while we are using it
TPtr8 buf8 = buffer->Des();
// if we get error here, something is badly wrong
iError = CnvUtfConverter::ConvertFromUnicodeToUtf8( buf8, aSender );
length += buf8.Length();
// utf8 character set encoding needs one byte (short integer)
length += KMms2; // add character set encoding byte and trailing NULL
if ( buf8[0] >= KMms0x80 ) // 128
{
length++; // we will need a quote byte at the start...
}
delete buffer;
buffer = NULL;
}
}
else // no miumau found
{
// phone number, must be ASCII
length += aSender.Length();
length ++; // room for terminating zero
length += KMmsPlmnLength; // type indication
// this should be the length, if we have a phone number (no alias.)
}
EncodeValueLength( length );
iEncodeBuffer->Write( iPosition, &KMmsAddressPresentToken, 1 );
iPosition++;
// If the address contains some non-ascii characters,
// it must be converted to utf-8
EncodeAddressL( aSender );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeAddressL( const TPtrC& aAddress )
{
// Supports only address types PLMN and email.
// If the address string contains a @ character,
// it is interpreted as an email
// Internal alias is removed
TMmsAddressType addressType = EMmsAddressTypeUnknown;
HBufC* realAddress = HBufC::NewL( aAddress.Length() );
CleanupStack::PushL( realAddress );
TInt error = KErrNone;
TPtr realAddressPointer = realAddress->Des();
error = TMmsGenUtils::AddressTypeAndRealAddress(
aAddress,
addressType,
realAddressPointer,
aAddress.Length());
if ( error != KErrNone || addressType == EMmsAddressTypeUnknown )
{
// could not resolve. Send unchanged
realAddress->Des().Copy( aAddress );
if ( aAddress.Find( KMiuMau ) != KErrNotFound )
{
addressType = EMmsAddressTypeEmail;
}
else
{
addressType = EMmsAddressTypeMobile;
}
}
if ( addressType == EMmsAddressTypeEmail )
{
// email address
// If the address contains only ASCII characters,
// it can be sent as text string, if not, it must be sent as utf-8
EncodeTextStringL( *realAddress );
}
else
{
// must be a phone number
// We expect for now that the format is correct as is
// All legal characters present in a phone number are ASCII
TInt i = 0;
TUint8 character = 0;
realAddressPointer = realAddress->Des();
for ( i = 0; i < realAddress->Length(); i++ )
{
// The array index is safe because i is always < realAddress->Length().
character = TUint8( realAddressPointer[i] & KMms0xFF );
iEncodeBuffer->Write( iPosition, &character, 1 );
iPosition++;
}
iEncodeBuffer->Write( iPosition, KMmsPlmn, KMmsPlmnLength );
iPosition += KMmsPlmnLength;
iEncodeBuffer->Write( iPosition, &KMmsNull, 1 );
iPosition++;
}
CleanupStack::PopAndDestroy( realAddress );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeValueLength( TUint aLength )
{
TUint8 shortLength = 0;
if ( aLength <= KMms30 )
{
// short length
shortLength = TUint8( aLength ) ;
iEncodeBuffer->Write( iPosition, &shortLength, 1 );
iPosition++;
}
else
{
iEncodeBuffer->Write( iPosition, &KMmsLengthQuote, 1 );
iPosition++;
EncodeUintvar( aLength );
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeUintvar( TUint aInteger )
{
// The value is split into 7 bit chunks, and continue bit set
// when needed.
// No more than 5 bytes will be produced
TUint8 buffer[KMms5];
TUint temp = aInteger;
TInt i;
for ( i = 0; i < KMms5; i++ )
{
buffer[KMms4 - i] = TUint8( temp & KMms0x7F );
temp >>= KMms7;
}
i = 0;
// buffer indexes are safe because the buffer has been defined long enough.
while ( i < KMms4 && buffer[i] == 0 )
{
i++;
}
TInt j;
for ( j = i; j < KMms4; j++ )
{
// buffer indexes are safe because the buffer has been defined long enough.
buffer[j] |= KMms0x80; // set Continue bit, but never to last
}
// buffer indexes are safe because the buffer has been defined long enough.
iEncodeBuffer->Write( iPosition, &buffer[i], KMms5 - i );
iPosition += KMms5 - i;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
TInt CMmsEncode::GetUintvarLength( TUint aInteger )
{
// The value is split into 7 bit chunks, and continue bit set
// when needed.
// No more than 5 bytes will be produced
TUint8 buffer[KMms5];
TUint temp = aInteger;
TInt i;
for (i = 0; i < KMms5; i++ )
{
buffer[KMms4 - i] = TUint8( temp & KMms0x7F );
temp >>= KMms7;
}
i = 0;
// buffer indexes are safe because the buffer has been defined long enough.
while ( i < KMms4 && buffer[i] == 0 )
{
i++;
}
return KMms5 - i;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeRecipientL( const CDesCArray& aRecipientList,
TMmsRecipients aType )
{
TInt i;
TInt size = aRecipientList.Count();
if ( size == 0 )
{
return;
}
TUint8 recipientType = KMmsAssignedTo;
switch ( aType )
{
case EMmsTo:
recipientType = KMmsAssignedTo;
break;
case EMmsCc:
recipientType = KMmsAssignedCc;
break;
case EMmsBcc:
recipientType = KMmsAssignedBcc;
break;
default:
break;
}
for ( i = 0; i < size; i++ )
{
// check for fakes
if ( aRecipientList[i].Length() > 0 )
{
iEncodeBuffer->Write( iPosition, &recipientType, 1 );
iPosition++;
EncodeAddressL( aRecipientList[i] );
}
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeOptionalStringL( TUint8 aHeader,
const TPtrC16& aString )
{
if ( aString.Length() == 0 )
{
return;
}
iEncodeBuffer->Write( iPosition, &aHeader, 1 );
iPosition++;
EncodeTextStringL( aString );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeOptionalString( TUint8 aHeader, const TPtrC8& aString )
{
if ( aString.Length() == 0 )
{
return;
}
EncodeHeaderAndTextString( aHeader, aString );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeIntervalOrDate( TInt aInterval, const TInt64& aDate )
{
TInt64 temp = 0;
TUint8 token = 0;
if ( aDate != 0 )
{
temp = aDate;
token = KMmsAbsoluteToken;
}
else
{
temp = aInterval;
token = KMmsRelativeToken;
}
// calculate value length
TUint length = KMms8;
TUint mask = 0xff000000;
while ( ( I64HIGH( temp ) & mask ) == 0 && length > KMms4)
{
mask >>= KMms8;
length--;
}
mask = 0xff000000;
// Test if the whole high half was zero
if ( I64HIGH( temp ) == 0 )
{
while ( ( I64LOW( temp ) & mask ) == 0 && length > 1)
{
mask >>= KMms8;
length--;
}
}
// now add short length and absolute/relative token
length += KMms2;
EncodeValueLength( length );
iEncodeBuffer->Write( iPosition, &token, 1 );
iPosition++;
EncodeLongInteger( temp );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeReplyChargingSize( TInt aReplyChargingSize )
{
if ( aReplyChargingSize == 0 )
{
return;
}
TInt64 size = aReplyChargingSize;
iEncodeBuffer->Write( iPosition, &KMmsAssignedReplyChargingSize, 1 );
iPosition++;
EncodeLongInteger( size );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeOptionalByte( TUint8 aHeader, TInt aValue )
{
if ( aValue == 0 )
{
return; // not set, nothing to encode, header is optional
}
EncodeMandatoryByte( aHeader, aValue );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMandatoryByte( TUint8 aHeader, TInt aValue )
{
// When ecoding mandatory byte even value 0 is allowed.
// It will become 0x80, and be correctly decoded back to 0.
TUint8 value = TUint8 ( aValue ) | KMms0x80 ;
iEncodeBuffer->Write( iPosition, &aHeader, 1 );
iPosition++;
iEncodeBuffer->Write( iPosition, &value, 1 );
iPosition++;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeOptionalIntervalOrDate( TUint8 aHeader,
TInt aInterval,
const TInt64& aDate )
{
if ( aInterval == 0 && aDate == 0 )
{
return; // not set, nothing to encode, header is optional
}
iEncodeBuffer->Write( iPosition, &aHeader, 1 );
iPosition++;
EncodeIntervalOrDate( aInterval, aDate );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeHeaderAndTextString( TUint8 aHeader,
const TDesC8& aString )
{
iEncodeBuffer->Write( iPosition, &aHeader, 1 );
iPosition++;
EncodeTextString( aString );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
TBool CMmsEncode::IsStringSafe( const TDesC& aString )
{
// Very simple check to see if string is "safe" ASCII
// Used for headers, which are short strings
TInt i;
TBool safe = ETrue;
for ( i = 0; i < aString.Length() && safe; i++ )
{
if ( aString[i] < KMmsLowestAscii || aString[i] >= KMmsHighestAscii )
{
safe = EFalse;
}
}
return safe;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
TBool CMmsEncode::IsStringSafe( const TDesC8& aString, TInt& aNumNonSafe )
{
// Very simple check to see if string is "safe" ASCII
// Used for headers, which are short strings
// spaces count as non-safe because their number must be taken into
// account when calculating the length
const TInt KIntQuestion = 0x3F;
const TInt KIntEquals = 0x3D;
TInt i;
aNumNonSafe = 0;
TBool safe = ETrue;
for ( i = 0; i < aString.Length()/* && safe*/; i++ )
{
if ( aString[i] < KMmsLowestAscii || aString[i] >= KMmsHighestAscii )
{
safe = EFalse;
aNumNonSafe++;
}
if ( aString[i] == KIntQuestion || aString[i] == KIntEquals )
{
// These are safe but must be encoded if quoted printable
// encoding is used. The number is needed to check the header length
aNumNonSafe++;
}
if ( aString[i] == KMmsIntUnderscore )
{
// This must always be encoded as base64 because Symbian
// does not encode underscores when quoted printable is used.
aNumNonSafe = KMaxEncodingLength;
}
}
return safe;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMultipartRelatedHeaderL( const TMsvAttachmentId aRootId )
{
iEncodeBuffer->Write( iPosition, &KMmsAssignedContentType, 1 );
iPosition++;
// We have parameters (start), so we must use Content-general-form
// We need the content-id for the root part. If it is not defined already,
// we must generate one.
TUint headerLength = 1; // one byte for well known media
TInt cleanupCount = 0; // we must keep track what we have on store
User::LeaveIfError( iEntryWrapper->SetCurrentEntry( iCurrentMessageId ) );
CMsvStore* store = iEntryWrapper->EditStoreL();
CleanupStack::PushL( store ); cleanupCount++;
MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
CMsvAttachment* attachmentInfo = NULL;
attachmentInfo = attachMan.GetAttachmentInfoL( (TMsvAttachmentId) aRootId );
CleanupStack::PushL( attachmentInfo ); cleanupCount++;
iMimeHeaders->RestoreL( *attachmentInfo );
if ( iError != KErrNone )
{
CleanupStack::PopAndDestroy( cleanupCount );
return;
}
TPtrC8 cid = iMimeHeaders->ContentId();
TBufC8<KMmsMaxCidLength> target;
// If cid has not been defined, we must generate one
if ( cid.Length() == 0 )
{
TTime now;
now.UniversalTime();
TInt random;
TInt64 seed = now.Int64();
random = Math::Rand( seed );
// type conversions irrelevant - just creating a magic number for content id
target.Des().Num( random );
target.Des().Insert(0, KMmsLeftAngle );
target.Des().Append( KMmsRightAngle );
cid.Set( target.Des() );
// exclude the angle brackets
iMimeHeaders->SetContentIdL( cid.Mid( 1, cid.Length() - KMms2 ) );
// save the cid to be present when we create the attachment headers
// If this does not succeed, the message will have no root.
MMsvAttachmentManagerSync& attachManSync =
store->AttachmentManagerExtensionsL();
iMimeHeaders->StoreL( *attachmentInfo );
attachManSync.ModifyAttachmentInfoL( attachmentInfo );
// attachment manager now own attachemnt info
CleanupStack::Pop( attachmentInfo ); cleanupCount--;
store->CommitL();
attachmentInfo = attachMan.GetAttachmentInfoL( (TMsvAttachmentId) aRootId );
CleanupStack::PushL( attachmentInfo ); cleanupCount++;
}
// add start header length &
// assigned number for start parameter, and terminating zero for cid
headerLength += cid.Length() + KMms2;
if ( cid.Find( KMmsLeftAngle ) != 0 )
{
headerLength += KMms2; // we must add angle bracket
}
// Then the length of the content-type header...
TPtrC8 contentTypeString = iMimeHeaders->ContentType();
HBufC8* tempContentType = HBufC8::NewL( iMimeHeaders->ContentType().Length() +
iMimeHeaders->ContentSubType().Length() + 1 );
CleanupStack::PushL( tempContentType );
tempContentType->Des().Copy( iMimeHeaders->ContentType() );
if ( ( iMimeHeaders->ContentType().Find( KMmsSlash8 ) !=
( iMimeHeaders->ContentType().Length() - 1 ) ) &&
( iMimeHeaders->ContentSubType().Find( KMmsSlash8 ) != 0 ) &&
( iMimeHeaders->ContentSubType().Length() != 0 ) )
{
tempContentType->Des().Append( KMmsSlash8 );
}
tempContentType->Des().Append( iMimeHeaders->ContentSubType() );
attachmentInfo->SetMimeTypeL( tempContentType->Des() );
CleanupStack::PopAndDestroy( tempContentType );
contentTypeString.Set( attachmentInfo->MimeType() );
if ( contentTypeString.Length() == 0 )
{
// We need a content type...
// If we don't know, we say "Any"
contentTypeString.Set( KMmsAny );
}
// Check if we have well-known media.
TInt8 rootContentType = -1;
TInt8 i = 0;
for ( i = 0; i < KNumberContentTypes && rootContentType < 0; i++ )
{
if ( contentTypeString.CompareF( TPtrC8( KContentTypeTable[i] ) ) == 0 )
{
rootContentType = i;
}
}
// start parameter assignment
headerLength += 1;
if ( rootContentType != -1 )
{
// well known content type
headerLength += 1;
}
else
{
// string + terminating zero
headerLength += contentTypeString.Length() + 1;
}
TPtrC8 appIdPtr;
appIdPtr.Set( KMmsJavaApplicationId );
// Java application id parameters added to content-type
if ( iMmsHeaders->ApplicId().Length() > 0 )
{
headerLength += appIdPtr.Length() + 1 ;
headerLength += iMmsHeaders->ApplicId().Length() + 1;
}
appIdPtr.Set( KMmsJavaReplyApplicationId );
if ( iMmsHeaders->ReplyApplicId().Length() > 0 )
{
headerLength += appIdPtr.Length() + 1 ;
headerLength += iMmsHeaders->ReplyApplicId().Length() + 1;
}
// write general encoding length
EncodeValueLength( headerLength );
// Then the Media Type with parameters
// We are multipart/related, which is a well-known media
// encode as short integer
TUint8 byte = KMmsAssignedApplicationVndWapMultipartRelated | KMms0x80;
iEncodeBuffer->Write( iPosition, &byte, 1 );
iPosition++;
// Then the start parameter and cid text string
byte = KWspStart | KMms0x80;
if ( cid.Length() > 0 )
{
HBufC8* tempContentId = HBufC8::NewL( iMimeHeaders->ContentId().Length() + KMms2 );
CleanupStack::PushL( tempContentId );
if ( cid.Find( KMmsLeftAngle ) != 0 )
{
tempContentId->Des().Copy( KMmsLeftAngle );
tempContentId->Des().Append( cid );
tempContentId->Des().Append( KMmsRightAngle );
}
else
{
tempContentId->Des().Copy( cid );
}
EncodeHeaderAndTextString( byte, tempContentId->Des() );
CleanupStack::PopAndDestroy( tempContentId );
}
// next the content type of the root part
byte = KWspRelatedType | KMms0x80;
// and the actual type either as a well-known media type
// or a text string.
if ( rootContentType != -1 )
{
// Well known content type.
// EncodeMandatoryByte will set the high bit
EncodeMandatoryByte( byte, rootContentType );
}
else
{
// string + terminating zero
EncodeHeaderAndTextString( byte, contentTypeString );
}
if ( iMmsHeaders->ApplicId().Length() > 0 ||
iMmsHeaders->ReplyApplicId().Length() > 0 )
{
EncodeApplicationIdParametersL();
}
// encode number of parts
EncodeUintvar( iNumberOfAttachments );
// get rid of stuff we put on stack
CleanupStack::PopAndDestroy( cleanupCount );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMultipartMixedHeaderL()
{
// If Java has added application id or reply-to application id,
// even multipart/mxed type needs parameters.
TUint headerLength = 0; // assume no parameters
if ( iMmsHeaders->ApplicId().Length() > 0 ||
iMmsHeaders->ReplyApplicId().Length() > 0 )
{
headerLength = 1; // one byte for well known media
TPtrC8 appIdPtr;
appIdPtr.Set( KMmsJavaApplicationId );
if ( iMmsHeaders->ApplicId().Length() > 0 )
{
headerLength += appIdPtr.Length() + 1 ;
headerLength += iMmsHeaders->ApplicId().Length() + 1;
}
appIdPtr.Set( KMmsJavaReplyApplicationId );
if ( iMmsHeaders->ReplyApplicId().Length() > 0 )
{
headerLength += appIdPtr.Length() + 1 ;
headerLength += iMmsHeaders->ReplyApplicId().Length() + 1;
}
}
iEncodeBuffer->Write( iPosition, &KMmsAssignedContentType, 1 );
iPosition++;
if ( headerLength > 0 )
{
// write general encoding length
EncodeValueLength( headerLength );
}
// encode as short integer
TUint8 contentType = KMmsAssignedApplicationVndWapMultipartMixed | KMms0x80;
iEncodeBuffer->Write( iPosition, &contentType, 1 );
iPosition++;
if ( iMmsHeaders->ApplicId().Length() > 0 ||
iMmsHeaders->ReplyApplicId().Length() > 0 )
{
EncodeApplicationIdParametersL();
}
// No more parameters for multipart/mixed, actual parts follow
// encode number of parts
EncodeUintvar( iNumberOfAttachments );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeKeywordArrayL()
{
TInt i = 0;
TInt length = 0;
// caller must check that iMmsHeaders->ReadOnlyMMBoxMessageHeaders() is not NULL
CMmsMMBoxMessageHeaders& temp = iMmsHeaders->MMBoxMessageHeadersL();
for ( i = 0; i < temp.KeywordArray().Count(); i++ )
{
length = temp.KeywordArray()[i]->Keyword().Length();
if ( length > 0 )
{
iEncodeBuffer->Write( iPosition, &KMmsAssignedMMFlags, 1 );
iPosition++;
// do some fake encoding to get the text length
TUint oldPosition = iPosition; // we will return here
EncodeTextStringL( temp.KeywordArray()[i]->Keyword() );
length = iPosition - oldPosition;
iPosition = oldPosition; // return to original place
length += 1; // token must come before string
EncodeValueLength( length );
TUint8 token = (TUint8) temp.KeywordArray()[i]->Token();
if ( iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewReq ||
iMmsHeaders->MessageType() == KMmsMessageTypeMboxViewConf ||
iMmsHeaders->MessageType() == KMmsMessageTypeMBoxDescr )
{
// the token must always be filter for MMbox PDUs
token = KMmsFilterToken;
}
iEncodeBuffer->Write( iPosition, &token, 1 );
iPosition++;
EncodeTextStringL( temp.KeywordArray()[i]->Keyword() );
}
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeOptionalInteger( TUint8 aHeader, TUint aValue )
{
if ( aValue == 0 )
{
return; // not set, nothing to encode, header is optional
}
iEncodeBuffer->Write( iPosition, &aHeader, 1 );
iPosition++;
EncodeInteger( aValue );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeAttributes( RArray<TUint>& aAttributeArray )
{
TInt i;
for ( i = 0; i < aAttributeArray.Count(); i++ )
{
EncodeMandatoryByte( KMmsAssignedAttributes, aAttributeArray[i] );
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeMMBoxStates( RArray<TInt>& aStateArray )
{
TInt i;
for ( i = 0; i < aStateArray.Count(); i++ )
{
EncodeMandatoryByte( KMmsAssignedMMState, aStateArray[i] );
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeContentLocationArray()
{
TBool mustCheck = EFalse;
if ( iMmsHeaders->ContentLocation().Length() > 0 )
{
mustCheck = ETrue;
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ContentLocation() );
}
// If there is content location array, encode it, too.
// A content-location should never occur in both places, but we still check
TInt i = 0;
if ( iMmsHeaders->ReadOnlyMMBoxMessageHeaders() )
{
for ( i = 0;
i < iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->ContentLocationList().Count();
i++ )
{
if ( !( mustCheck && iMmsHeaders->ContentLocation().Compare(
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->ContentLocationList()[i] ) == 0 ) )
{
// the content location in the list does not appear as
// separate header, we must add it
EncodeHeaderAndTextString( KMmsAssignedContentLocation,
iMmsHeaders->ReadOnlyMMBoxMessageHeaders()->ContentLocationList()[i] );
}
}
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeStartingHeaders( TInt aMessageType,
const TPtrC8& aTID, TInt aVersion )
{
// EncodeMandatoryByte will always set the high bit.
// Message type
EncodeMandatoryByte( KMmsAssignedMessageType, aMessageType );
// TID if present
EncodeOptionalString( KMmsAssignedTID, aTID );
// MMS encapsulation version
EncodeMandatoryByte( KMmsAssignedMmsVersion, aVersion );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
//
void CMmsEncode::EncodeApplicationIdParametersL()
{
if ( iMmsHeaders->ApplicId().Length() > 0 )
{
EncodeTextString( KMmsJavaApplicationId );
EncodeTextStringL( iMmsHeaders->ApplicId() );
}
if ( iMmsHeaders->ReplyApplicId().Length() > 0 )
{
EncodeTextString( KMmsJavaReplyApplicationId );
EncodeTextStringL( iMmsHeaders->ReplyApplicId() );
}
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
void CMmsEncode::Dump()
{
// no dump if not logging
#ifndef _NO_MMSS_LOGGING_
TInt error = KErrNone;
// if no can do, sorry.
TRAP( error,
{
if ( iEntryWrapper )
{
if ( ( iEntryWrapper->GetDumpFlag() ) &&
iEncodeBuffer &&
iEncodeBuffer->Size() > 0 )
{
iFileName = KMmsDefaultLogDirectory;
TUint att;
if ( iFs.Att( iFileName, att ) == KErrNone )
{
_LIT( KRelated, "Sent.mms");
iParse.Set( iFileName, &KRelated, NULL );
iFileName = iParse.FullName();
User::LeaveIfError( CApaApplication::GenerateFileName(
iFs, iFileName ) );
RFile file;
User::LeaveIfError( file.Create( iFs, iFileName,
EFileWrite | EFileShareExclusive ) );
// for message id generation
iParse.Set( iFileName, NULL, NULL );
// the data is supposed to be in the encode buffer
TPtr8 ptr = iEncodeBuffer->BackPtr( iPosition );
file.Write( ptr );
file.Flush();
// done - close files
file.Close();
}
}
}
}
);
if ( error != KErrNone )
{
TMmsLogger::Log( _L("Dump left with error %d"), error );
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
void CMmsEncode::DumpAppend()
{
// no dump if not logging
#ifndef _NO_MMSS_LOGGING_
TInt error = KErrNone;
// if no can do, sorry.
TRAP( error,
{
if ( iEntryWrapper )
{
if ( ( iEntryWrapper->GetDumpFlag() ) &&
iEncodeBuffer &&
iEncodeBuffer->Size() > 0 )
{
iFileName = KMmsDefaultLogDirectory;
TUint att;
if ( iFs.Att( iFileName, att ) == KErrNone )
{
RFile file;
iFileName = iParse.FullName();
User::LeaveIfError( file.Open( iFs, iFileName,
EFileWrite | EFileShareExclusive ) );
TInt position = 0; // seek to end
file.Seek( ESeekEnd, position );
// the data is supposed to be in the encode buffer
TPtr8 ptr = iEncodeBuffer->BackPtr( iPosition );
file.Write( ptr );
file.Flush();
// done - close files
file.Close();
}
}
}
}
);
if ( error != KErrNone )
{
TMmsLogger::Log( _L("DumpAppend left with error %d"), error );
}
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
void CMmsEncode::EncodeApplicationHeadersL()
{
// Application headers are only supported in WINS for testing purposes
// Complete support for routing messages to arbitrary applications
// requires support for selecting which applications are allowed
// to send messages etc.
#ifdef __WINS__
// The optional string functions check the length
// and return without doing anything if the length of the string is 0
if ( IsStringSafe( iMmsHeaders->ApplicId() ) )
{
// We only send this header if it is us-ascii only
// There is no encoding defined, so if this is converted
// from unicode to some other character set there is
// no guarantee that the recipient can decode it.
EncodeOptionalStringL( KMmsAssignedApplicId, iMmsHeaders->ApplicId() );
}
if ( IsStringSafe( iMmsHeaders->ReplyApplicId() ) )
{
EncodeOptionalStringL( KMmsAssignedReplyApplicId, iMmsHeaders->ReplyApplicId() );
}
EncodeOptionalString( KMmsAssignedAuxApplicInfo, iMmsHeaders->AuxApplicInfo() );
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
void CMmsEncode::EncodeCancelRequest()
{
// implemented for test purposes
#ifdef __WINS__
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeCancelReq,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
EncodeOptionalString( KMmsAssignedCancelId, iMmsHeaders->ReplaceCancelId() );
#endif
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
void CMmsEncode::EncodeCancelResponse()
{
// Insert message type, TID and version number
EncodeStartingHeaders( KMmsMessageTypeCancelConf,
iMmsHeaders->Tid(), iMmsHeaders->MmsVersion() );
EncodeOptionalByte( KMmsAssignedCancelStatus, iMmsHeaders->CancelStatus() );
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
HBufC8* CMmsEncode::EncodeQuotedPrintableWordL( const TPtrC8& aSource )
{
// We have calculated that it fits
TInt bufferLength = KMaxNameBufferLength;
HBufC8* buffer = HBufC8::NewL( bufferLength );
CleanupStack::PushL( buffer );
TPtr8 ptr = buffer->Des();
buffer->Des().Copy( KMmsQuotedPreamble );
ptr.SetLength( bufferLength );
TPtr8 encodeBuffer = ptr.MidTPtr( KMmsPreambleLength );
encodeBuffer.SetLength( 0 ); // empty the buffer
TImCodecQP encoder;
// The function would return the number of characters written to the buffer.
// We don't do anything with the result, so we ignore the return value.
encoder.Encode( aSource, encodeBuffer );
ptr.SetLength( encodeBuffer.Length() + KMmsPreambleLength );
buffer->Des().Append( KMmsEncodingTrailer );
CleanupStack::Pop( buffer );
return buffer;
}
// ---------------------------------------------------------
//
// ---------------------------------------------------------
HBufC8* CMmsEncode::EncodeBase64WordL( const TPtrC8& aSource )
{
// ((length + 2)/3)*4 3 bytes alwaus produces 4 encoded bytes. Allow filler
TInt bufferLength = KMmsEncodingExtraLength + ( aSource.Length() + KMms2 ) / KMms3 * KMms4;
HBufC8* buffer = HBufC8::NewL( bufferLength );
CleanupStack::PushL( buffer );
TPtr8 ptr = buffer->Des();
buffer->Des().Copy( KMmsBase64Preamble );
ptr.SetLength( bufferLength );
TPtr8 encodeBuffer = ptr.MidTPtr( KMmsPreambleLength );
encodeBuffer.SetLength( 0 ); // empty the buffer
TImCodecB64 encoder;
// It is rather unclear what this function actually returns (no documentation found).
// Therefore we just ignore the result.
// Our buffer is long enough for the result to always fit.
encoder.Encode( aSource, encodeBuffer );
ptr.SetLength( encodeBuffer.Length() + KMmsPreambleLength );
buffer->Des().Append( KMmsEncodingTrailer );
CleanupStack::Pop( buffer );
return buffer;
}
// ---------------------------------------------------------
// CMmsEncode::PreProcessAttachmentDataL
// Open the message store(Edit mode) and process attachments for further encoding in required encoding type.
// Update the message store accordingly with the new encoding type and data in the corresponding attachments.
// ---------------------------------------------------------
void CMmsEncode::PreProcessAttachmentDataL()
{
TInt error = KErrNone;
RFile attachFile;
TBool retVal = EFalse;
TInt currAttachI;
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::PreProcessAttachmentDataL- start ") );
#endif /* _NO_MMSS_LOGGING_ */
CMsvStore* editStore = iEntryWrapper->EditStoreL();
CleanupStack::PushL( editStore );
MMsvAttachmentManager& attachMan = editStore->AttachmentManagerL();
MMsvAttachmentManagerSync& attachManagerSync = editStore->AttachmentManagerExtensionsL();
TInt numberOfAttachments = attachMan.AttachmentCount();
CMsvAttachment* attachmentInfo = NULL;
iTextUtils = CMsgTextUtils::NewL( iFs );
for ( currAttachI = 0; ( currAttachI < numberOfAttachments ) && ( error == KErrNone ); currAttachI++ )
{
//gets the ownership from attachment manager
attachmentInfo = attachMan.GetAttachmentInfoL( currAttachI );
CleanupStack::PushL( attachmentInfo );
iMimeHeaders->RestoreL( *attachmentInfo );
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::PreProcessAttachmentDataL- Attchment:%d "), currAttachI );
#endif /* _NO_MMSS_LOGGING_ */
if ( iFileOpen )
{
// close any file in case we have been reset while the file is still open
iAttachFile.Close();
iFileOpen = EFalse;
}
retVal = CheckAndUpdateAttachmentL(*attachmentInfo, *iMimeHeaders);
if( retVal )
{
#ifndef _NO_MMSS_LOGGING_
TRAPD( err,attachManagerSync.ModifyAttachmentInfoL(attachmentInfo);
editStore->CommitL(););
if(err != KErrNone)
{
TMmsLogger::Log( _L("CMmsEncode::PreProcessAttachmentData:: store commit error: %d"), err );
}
else
{
TMmsLogger::Log( _L("CMmsEncode::PreProcessAttachmentData:: store commit success") );
}
#else
TRAP_IGNORE( attachManagerSync.ModifyAttachmentInfoL(attachmentInfo);
editStore->CommitL(););
#endif /* _NO_MMSS_LOGGING_ */
/* attachmentInfo ownership is transfered to attachment manager
* Hence, JUST pop attachmentInfo, DO NOT Destroy.
*/
CleanupStack::Pop( attachmentInfo );
}
else
{
CleanupStack::PopAndDestroy( attachmentInfo );
attachmentInfo = NULL;
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::PreProcessAttachmentData:: Tgt encoding NOT Reqd.") );
#endif /* _NO_MMSS_LOGGING_ */
}
}
CleanupStack::PopAndDestroy( editStore );
delete iTextUtils;
iTextUtils = NULL;
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::PreProcessAttachmentDataL- end ") );
#endif /* _NO_MMSS_LOGGING_ */
}
// ---------------------------------------------------------
// CMmsEncode::CheckAndUpdateAttachmentL
// Check and proceed if given attachment can be encoded using target encoding type based on its content type.
// Returns False if target encoding is not supported for this content type.
// ---------------------------------------------------------
TBool CMmsEncode::CheckAndUpdateAttachmentL( CMsvAttachment& aAttachmentInfo,
CMsvMimeHeaders& aMimeHeaders )
{
//get the content type string... and set to attachment if required
TInt contentType = -1; // indicate not found
TPtrC8 contentTypeString;
TBool retVal = EFalse;
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::CheckAndUpdateAttachmentL- start ") );
#endif /* _NO_MMSS_LOGGING_ */
HBufC8* tempContentType = NULL;
contentTypeString.Set( aAttachmentInfo.MimeType() );
if ( contentTypeString.Length() == 0 )
{
// take type from mime headers
TInt cotentLength = aMimeHeaders.ContentType().Length();
TInt subCotentLength = aMimeHeaders.ContentSubType().Length();
tempContentType = HBufC8::NewL( cotentLength + subCotentLength + 1 );
CleanupStack::PushL( tempContentType );
tempContentType->Des().Copy( aMimeHeaders.ContentType() );
if ( ( aMimeHeaders.ContentType().Find( KMmsSlash8 ) != ( cotentLength - 1 ) ) &&
( aMimeHeaders.ContentSubType().Find( KMmsSlash8 ) != 0 ) && ( subCotentLength != 0 ) )
{
tempContentType->Des().Append( KMmsSlash8 );
}
tempContentType->Des().Append( aMimeHeaders.ContentSubType() );
aAttachmentInfo.SetMimeTypeL( tempContentType->Des() );
contentTypeString.Set( aAttachmentInfo.MimeType() );
}
//map the content type string to content type
TInt8 i;
for ( i = 0; i < KNumberContentTypes && contentType < 0; i++ )
{
if ( contentTypeString.CompareF( TPtrC8( KContentTypeTable[i] ) ) == 0 )
{
contentType = i;
}
}
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::CheckAndUpdateAttachmentL- content type:%d" ), contentType );
#endif /* _NO_MMSS_LOGGING_ */
//check if this content type need to be encoded using korean specific
if( IsConversionSupportedContentType( contentType ) )
{
/* Do the attachment data conversion from "src type" to "target type" for the given "attached file".
* Target type encodng MIB enum is obtained from cenrep.
*/
retVal = ProcessAndConvertAttachmentDataL( aMimeHeaders.MimeCharset(),
iTargetEncodingType,
aAttachmentInfo);
if( retVal )
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::CheckAndUpdateAttachmentL- conv success: Tgt Enc: %d"), iTargetEncodingType );
#endif /* _NO_MMSS_LOGGING_ */
//set new charset type in headers and update attachment info
aMimeHeaders.SetMimeCharset( iTargetEncodingType );
aMimeHeaders.StoreL(aAttachmentInfo); // save the new charset to attachment as well
/* mimetype might get reset to original mimeheader content type.
* ensure the full content type(if created from mime content and subcontent) is set to attachment
*/
if( tempContentType != NULL )
{
aAttachmentInfo.SetMimeTypeL( tempContentType->Des() );
CleanupStack::PopAndDestroy( tempContentType );
}
}
}
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::CheckAndUpdateAttachmentL- End , retVal: %d"), retVal );
#endif /* _NO_MMSS_LOGGING_ */
return retVal;
}
// ---------------------------------------------------------
// CMmsEncode::ProcessAndConvertAttachmentDataL
// converts of attachment data from source to target encoding type.
// |src charset buffer| --->coverted to ---> |unicode buffer| ---> converted to ---> |target charset|
// Returns false if data is already int target format, or plugins are missing, or file operation issues.
// ---------------------------------------------------------
TBool CMmsEncode::ProcessAndConvertAttachmentDataL( TUint aSrcCharSetMIBEnum,
TUint aTargetCharSetMIBEnum,
CMsvAttachment& aAttachmentInfo)
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentDataL- start ") );
#endif /* _NO_MMSS_LOGGING_ */
if( aSrcCharSetMIBEnum == aTargetCharSetMIBEnum )
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentDataL- src and dest are same ") );
#endif /* _NO_MMSS_LOGGING_ */
//if source and target charset MIB enums are same.
return EFalse; // no conversion
}
//get source and target charset mapping here. if any error, return
TUint srcCharSetId = iTextUtils->MibIdToCharconvIdL( aSrcCharSetMIBEnum );
TUint targetCharSetId = iTextUtils->MibIdToCharconvIdL( aTargetCharSetMIBEnum );
if( srcCharSetId == targetCharSetId || KDefaultCharConvCharset == targetCharSetId)
{
/* If target charset plugin is missing, then default is returned.
Do not encode to any target encoding type, send data as is .
*/
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentDataL- missing plugin: Tgt Charset %x"), targetCharSetId );
#endif /* _NO_MMSS_LOGGING_ */
return EFalse;
}
RFile attachFile;
TInt error;
const TDesC& fileName = aAttachmentInfo.FilePath();
error = attachFile.Open(iFs, fileName, EFileWrite);
if(error != KErrNone)
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentData:: file: %s, open error: %d"), fileName, error );
#endif /* _NO_MMSS_LOGGING_ */
attachFile.Close();
return EFalse;
}
TInt maxLength;
error = attachFile.Size(maxLength);
if( error != KErrNone || maxLength == 0 )
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentData:: file size: %d, error: %d"), maxLength, error );
#endif /* _NO_MMSS_LOGGING_ */
attachFile.Close();
return EFalse;
}
//read the original file data into srcBuffer
TInt cleanupCount = 0;
HBufC8* srcBuffer = HBufC8::NewLC( maxLength );
cleanupCount++;
TPtr8 srcPtr = srcBuffer->Des();
attachFile.Read( srcPtr, maxLength );
//intermediate buffer in the form of unicode.
HBufC16* unicodeBuffer(NULL);
//Convert, scrBuffer to unicode format if not already in unicode format
if(srcCharSetId != 0)
{
//Convert from respective foreign charset to unicode buffer.
//returns buf16 pointer descriptor
TRAPD(err, unicodeBuffer = iTextUtils->ConvertToUnicodeL(srcPtr, srcCharSetId) );
if( err != KErrNone )
{
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentData:: ConvertToUnicodeL error: %d"), err );
#endif /* _NO_MMSS_LOGGING_ */
delete unicodeBuffer;
attachFile.Close();
CleanupStack::PopAndDestroy( cleanupCount, srcBuffer ); // srcBuffer
return EFalse;
}
CleanupStack::PushL( unicodeBuffer );
cleanupCount++;
}
else
{
TInt unicodeStdHeaderWordLE = 0xFEFF;
TInt unicodeStdHeaderWordBE = 0xFFFE;
//data is already in unicode format. need to extract the data to 16-bit buffer
unicodeBuffer = HBufC16::NewLC( maxLength/2 );//maxlength value is in terms of bytes
cleanupCount++;
TPtr16 ptr = unicodeBuffer->Des();
iTextUtils->ConvertPtrToDesC16(srcPtr, ptr);
/* In case if attachment is UTF-16 format, it will have the UTF-16 representation word(2 butes)
* at the start. Find and delete it before passing the data for conversion
*/
if( ptr[0] == unicodeStdHeaderWordLE || ptr[0] == unicodeStdHeaderWordBE )
{
ptr.Delete(0, 1);
}
}
//Now convert unicode buffer to respective target charset type.
if( targetCharSetId != 0 )
{
// reset this file and write new encoded data to it directly
error = attachFile.SetSize(0);
#ifndef _NO_MMSS_LOGGING_
if( error != KErrNone )
{
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentData:: file size: %d, error: %d"), maxLength, error );
//attachFile.Close();
//return EFalse;
}
#endif /* _NO_MMSS_LOGGING_ */
/* convert to target charset id.
* Ideally, this should not leave with plugin-NOT-found, since it it already verified
*/
iTextUtils->ConvertToFileL(*unicodeBuffer, attachFile, targetCharSetId );
}
else
{
TPtr16 ptr = unicodeBuffer->Des();
//Reset/erase old file content.
TInt err = attachFile.SetSize(0);
//write new encoded data to file using write stream
RFileWriteStream writer( attachFile );
writer.PushL();
writer.WriteL( ptr );
//writer.CommitL();
writer.Pop();
writer.Close();
}
//close file
attachFile.Close();
CleanupStack::PopAndDestroy( cleanupCount, srcBuffer ); //unicodeBuffer, srcBuffer
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::ProcessAndConvertAttachmentDataL- End, retVal: TRUE") );
#endif /* _NO_MMSS_LOGGING_ */
return ETrue;
}
// ---------------------------------------------------------
// CMmsEncode::IsConversionSupportedContentType
// checks if input content type is supported for target encoding
// ---------------------------------------------------------
TBool CMmsEncode::IsConversionSupportedContentType( TInt aContentType )
{
/* Currently only "text/plain" content types are supported for korean encoding.
* Add to the switch case, if any new content type can be supported as well.
*
* IMPORTANT:
* Ensure the values added map to corresponding content type entry in the table KContentTypeTable[],
* defined in ../inc/mmscodec.h
*/
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::IsConversionSupportedContentType- start: %d "), aContentType );
#endif /* _NO_MMSS_LOGGING_ */
TBool retVal = EFalse;
switch( aContentType )
{
case 0x03 : // "text/plain"
{
retVal = ETrue;
break;
}
default:
//do nothing
break;// to avoid compile errors/warning
}
#ifndef _NO_MMSS_LOGGING_
TMmsLogger::Log( _L("CMmsEncode::IsConversionSupportedContentType- end ") );
#endif /* _NO_MMSS_LOGGING_ */
return retVal;
}
// ================= OTHER EXPORTED FUNCTIONS ==============
// End of File