/*

* Copyright (c) 2004-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*      Helper class to implement attachment handling

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <msventry.h>

#include    <msvstd.h>

#include    <msvapi.h> //Message Server

#include    <centralrepository.h>

#include    <badesca.h>

#include    <cmsvmimeheaders.h>

#include    <mmsvattachmentmanager.h>

#include    <mmsvattachmentmanagersync.h>

#include    <utf.h>

#include    <f32file.h>

#include    <msgtextutils.h>

#include    "mmsconst.h"

#include    "mmsattachmenthandler.h"

#include    "mmsgenutils.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KMms10kilos = 10240;

const TInt KMmsMaxBytesPerCharacter = 4;    

const TInt KMmsTextBufferSize = 256;

const TInt KMmsUnicodeToUtf2MaxIncrease = 2;

const TInt KMmsLengthOfCRlf = 2;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

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

// might leave.

//

CMmsAttachmentHandler::CMmsAttachmentHandler() 

    {

    }

// EPOC default constructor can leave.

void CMmsAttachmentHandler::ConstructL()

    {

    }

// Two-phased constructor.

EXPORT_C CMmsAttachmentHandler* CMmsAttachmentHandler::NewL() 

    {

    CMmsAttachmentHandler* self = new (ELeave) CMmsAttachmentHandler();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CMmsAttachmentHandler::~CMmsAttachmentHandler()

    {

    }

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

// CMmsAttachmentHandler::AttachmentsSizeL

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

//

EXPORT_C TInt CMmsAttachmentHandler::AttachmentsSizeL( CMsvStore& aStore )

    {

    // Caller controls store

    TInt size = 0;

    MMsvAttachmentManager& attachMan = aStore.AttachmentManagerL();

    TInt numAttachments = attachMan.AttachmentCount();

    TInt i;

    for ( i = 0; i < numAttachments; i++ )

        {

        CMsvAttachment* attachmentInfo = attachMan.GetAttachmentInfoL(i);

        CleanupStack::PushL( attachmentInfo );

        CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

        CleanupStack::PushL( mimeHeaders );

        mimeHeaders->RestoreL( *attachmentInfo );

        RFile attaFile = attachMan.GetAttachmentFileL( i );

        CleanupClosePushL( attaFile );

        TInt fileSize = 0;

        // If we cannot access the file, we are in trouble

        User::LeaveIfError( attaFile.Size( fileSize ) ); 

        // This adds up mime header size + actual attachment binary data

        size += mimeHeaders->Size() + fileSize;

        CleanupStack::PopAndDestroy( &attaFile ); // close attaFile

        CleanupStack::PopAndDestroy( mimeHeaders );

        CleanupStack::PopAndDestroy( attachmentInfo );

        }

    return size;

    }

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

// CMmsAttachmentHandler::IsValidFilename

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

//

EXPORT_C TBool CMmsAttachmentHandler::IsValidFilename( RFs& aFs, const TPtrC& aFileName )

    {

    TBool validName = EFalse; //pessimist.

    if ( aFileName.Length() == 0 )

        {

        return EFalse;

        }

    // filename should not start with dot

    // or contain any control characters

    TInt i;

    // First character may not be . or space

    if ( aFileName[0] == 0x2e || aFileName[0] == 0x20 )

        {

        return EFalse;

        }

    for ( i = 0; i < aFileName.Length(); i++ )

        {

        // check for control characters - RFs does not do it.

        if ( aFileName[i] < 0x20 )

            {

            // found a control character - not allowed.

            return EFalse;

            }

        }

    validName = aFs.IsValidName( aFileName );

    return validName;

    }

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

// CMmsAttachmentHandler::CreateAttachmentL

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

//

EXPORT_C void CMmsAttachmentHandler::CreateAttachmentL(

            CMsvStore& aStore,

            RFile& aFile,

            RFs& aFs,

            TDriveUnit aMessageDrive,

            TDesC8& aMimeType,

            CMsvMimeHeaders& aMimeHeaders,

            CMsvAttachment* aAttachmentInfo,

            TMsvAttachmentId& aAttaId)

    {

    // The ownership of aAttachmentInfo will be transferred to attachment manager

    // We must keep it safe until that time  

    CleanupStack::PushL( aAttachmentInfo );

    // Check that sufficient disk space available

    // for attachment binary file and index entry

    TInt error = KErrNone;

    TInt fileSize = 0;

    error = aFile.Size( fileSize );

    User::LeaveIfError( error );

    aAttachmentInfo->SetSize( fileSize );

    if ( aMimeHeaders.SuggestedFilename().Length() == 0 )

        {

        TFileName name;

        error = aFile.Name( name );

        if ( error == KErrNone )

            {

            aMimeHeaders.SetSuggestedFilenameL( name );

            }

        }

    if ( aMimeHeaders.SuggestedFilename().Length() > 0 )

        {

        aAttachmentInfo->SetAttachmentNameL( aMimeHeaders.SuggestedFilename() );

        }

    if ( aMimeType.Length() > 0 )

        {

        aAttachmentInfo->SetMimeTypeL( aMimeType );

        }

    // Check that sufficient disk space available

    // for attachment binary file and index entry

    // This does not include mime headers.

    // The mime headers are covered by KMmsIndexEntryExtra,

    // however the value may be too small, has to be checked.

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL( 

        &aFs, 

        fileSize + KMmsIndexEntryExtra,

        aMessageDrive ) )

        {

        // we use standard error code here

        User::Leave( KErrDiskFull );

        }

    if ( ( aMimeHeaders.ContentType().Length() == 0 ||

        aMimeHeaders.ContentSubType().Length() == 0  ) && aMimeType.Length() > 0 )

        {

        TInt position = aMimeType.Find( KMmsSlash8 );

        if ( position > 0 )

            {

            aMimeHeaders.SetContentTypeL( aMimeType.Left( position ) );

            }

        if ( position < aMimeType.Length() - 1 )

            {

            aMimeHeaders.SetContentSubTypeL( aMimeType.Mid( position + 1 ) );

            }

        }

    MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();

    RFile attaFile;

    // ownership of aAttachmentInfo is transferred to attachment manager.

    attaManSync.CreateAttachmentL( aMimeHeaders.SuggestedFilename(),

        attaFile, aAttachmentInfo );

    aAttaId = aAttachmentInfo->Id();

    CleanupStack::Pop( aAttachmentInfo ); // attachment manager now owns aAttachmentInfo

    // If the previous call was successful, we can now write the data

    // We need a buffer because we read from one file and write to another

    CleanupClosePushL( attaFile );

    if ( fileSize > 0 )

        {

        // Greedy, but we don't try to swallow large files all in one piece

        // Small files may be handled in one piece

        HBufC8* buffer = HBufC8::NewL( Min( fileSize, KMms10kilos ) ); // Try to get at least 10 k

        CleanupStack::PushL( buffer );

        TPtr8 ptr = buffer->Des();

        ptr.SetLength( 1 ); // initialized to something larger that 0, size is adjusted later

        while( ptr.Length() > 0 && error == KErrNone )

            {

            error = aFile.Read( ptr );

            if ( ptr.Length() > 0 && error == KErrNone)

                {

                error = attaFile.Write( ptr );

                }

            }

        if ( error == KErrNone )

            {

            error = attaFile.Flush();

            }

        CleanupStack::PopAndDestroy( buffer );

        buffer = NULL;

        }

    // we must alway close    

    CleanupStack::PopAndDestroy( &attaFile ); // close attaFile

    // Now actual datafile is ready.

    // We still have the atta info, and we must store the mimeheaders

    aMimeHeaders.StoreL( *aAttachmentInfo );

    // Now all should be ready. 

    // Caller must commit store (maybe headers still need to be changed,

    // or maybe several attachments are added before committing store)

    User::LeaveIfError( error );

    }

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

// CMmsAttachmentHandler::CreateTextAttachmentL

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

EXPORT_C void CMmsAttachmentHandler::CreateTextAttachmentL(

    CMsvStore& aStore,

    TMsvAttachmentId& aAttachmentId,

    const TDesC& aText,

    const TDesC& aFile,

    RFs& aFs,

    TDriveUnit aMessageDrive,

    TBool aConvertParagraphSeparator /*= ETrue*/ )

    {

    HBufC* convertedText = NULL;

    TPtrC text;

    if ( aConvertParagraphSeparator )

        {

        convertedText = CMsgTextUtils::ConvertParagraphSeparatorsLC( aText );

        text.Set( convertedText->Des() );

        }

    else

        {

        text.Set( aText );

        }

    const TInt KMmsMaxBytesPerCharacter = 4;    

    HBufC8* buffer = HBufC8::NewL( text.Length() * KMmsMaxBytesPerCharacter ); // paranoid.

    CleanupStack::PushL( buffer );

    TPtr8 buf8 = buffer->Des();

    CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

    CleanupStack::PushL( mimeHeaders );

    // attaInfo must be on top of stack because the ownership will be transferred

    // to attacment manager.    

    CMsvAttachment* attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

    CleanupStack::PushL( attaInfo );

    TPtrC8 contentType;

    contentType.Set( KMmsTextPlain );

    TInt position = contentType.Find( KMmsSlash8 );

    mimeHeaders->SetContentTypeL( contentType.Left( position ) );

    mimeHeaders->SetContentSubTypeL( contentType.Mid( position + 1 ) );

    attaInfo->SetMimeTypeL( contentType );

    attaInfo->SetAttachmentNameL( aFile );

    mimeHeaders->SetMimeCharset( KMmsUtf8 );

    mimeHeaders->SetSuggestedFilenameL( aFile );

    // if conversion fails, something is really seriously wrong

    TInt error = CnvUtfConverter::ConvertFromUnicodeToUtf8( buf8, text );

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL( 

        &aFs,

        buf8.Length() + mimeHeaders->Size() + KMmsIndexEntryExtra,

        aMessageDrive ) )

        {

        // we use standard error code here

        User::Leave( KErrDiskFull );

        }

    else

        {

        User::LeaveIfError( error );    

        }

    attaInfo->SetSize( buf8.Length() );

    mimeHeaders->StoreL( *attaInfo ); // Mime headers are streamed into atta info

    MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();

    RFile attaFile;

    attaManSync.CreateAttachmentL( aFile, attaFile, attaInfo );

    CleanupStack::Pop( attaInfo ); // attaInfo ownership was transferred.

    aAttachmentId = attaInfo->Id();

    // Now our file handle is open for writing

    if ( buf8.Length() > 0 )

        {

        attaFile.Write( buf8 );

        error = attaFile.Flush();

        }

    attaFile.Close();

    if ( error != KErrNone )

        {

        // Something went wrong when we tried to write our data.

        // We must delete the attachment as it does not contain the

        // intended data.

        RemoveAttachmentL( aAttachmentId, aStore );

        aAttachmentId = 0;

        }

    CleanupStack::PopAndDestroy( mimeHeaders );

    CleanupStack::PopAndDestroy( buffer );

    if ( convertedText )

        {

        CleanupStack::PopAndDestroy( convertedText );

        convertedText = NULL;

        }

    User::LeaveIfError( error );    

    }

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

// CMmsAttachmentHandler::CreateUTF8TextAttachmentFromFileL

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

EXPORT_C void CMmsAttachmentHandler::CreateUTF8TextAttachmentFromFileL(

    CMsvStore& aStore,

    TMsvAttachmentId& aAttachmentId,

    RFile& aFile,

    RFs& aFs,

    TDriveUnit aMessageDrive )

    {

    _LIT8 ( KMmsCrLf8, "\x00D\x00A" ); // 8 bit line feed

    TInt size = 0;

    TInt error = KErrNone;

    error = aFile.Size( size );

    User::LeaveIfError( error ); // if can't get file size, we are in trouble

    TFileName* filename = new( ELeave ) TFileName;

    CleanupStack::PushL( filename );

    // 256 characters for each read

    HBufC* textBuffer = HBufC::NewL( KMmsTextBufferSize );

    CleanupStack::PushL( textBuffer );

    TPtr textPtr = textBuffer->Des();

    HBufC8* buffer = HBufC8::NewL( KMmsTextBufferSize * KMmsMaxBytesPerCharacter ); // paranoid.

    TInt fileSize = 0; // we don't know how big the file will be after conversion

    CleanupStack::PushL( buffer );

    TPtr8 buf8 = buffer->Des();

    CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

    CleanupStack::PushL( mimeHeaders );

    // attaInfo must be on top of stack because the ownership will be transferred

    // to attacment manager.    

    CMsvAttachment* attaInfo = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );

    CleanupStack::PushL( attaInfo );

    TPtrC8 contentType;

    contentType.Set( KMmsTextPlain );

    TInt position = contentType.Find( KMmsSlash8 );

    mimeHeaders->SetContentTypeL( contentType.Left( position ) );

    mimeHeaders->SetContentSubTypeL( contentType.Mid( position + 1 ) );

    attaInfo->SetMimeTypeL( contentType );

    filename->Copy( TPtrC() );

  	aFile.Name( *filename ); // if this returns error, filename should be empty - no suggestion.

    attaInfo->SetAttachmentNameL( *filename );

    mimeHeaders->SetSuggestedFilenameL( *filename );

    mimeHeaders->SetMimeCharset( KMmsUtf8 );

    if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL( 

        &aFs,

        size * KMmsUnicodeToUtf2MaxIncrease + mimeHeaders->Size() + KMmsIndexEntryExtra,

        aMessageDrive ) )

        {

        // we use standard error code here

        User::Leave( KErrDiskFull );

        }

    mimeHeaders->StoreL( *attaInfo ); // Mime headers are streamed into atta info

    MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();

    RFile attaFile;

    attaManSync.CreateAttachmentL( *filename, attaFile, attaInfo );

    CleanupStack::Pop( attaInfo ); // attaInfo ownership was transferred.

    aAttachmentId = attaInfo->Id();

    // Now our file handle is open for writing

    error = KErrNone;

    TMmsFileText textFile;

    textFile.Set( aFile );

    while ( error == KErrNone || error == KErrTooBig )

        {

        error = textFile.Read( textPtr );

        TBool appendCRLF = ETrue;

        if ( error == KErrTooBig )

            {

            appendCRLF = EFalse;

            error = KErrNone;

            }

        if ( error != KErrEof )

            {

            // if conversion fails, something is really seriously wrong

            error = CnvUtfConverter::ConvertFromUnicodeToUtf8( buf8, textPtr );

            }

        if ( error == KErrNone )

            {

            error = attaFile.Write( buf8 );

            if ( error == KErrNone )

                {

                fileSize += buf8.Length();

                if ( appendCRLF )

                    {

                    error = attaFile.Write( KMmsCrLf8 );

                    fileSize += KMmsLengthOfCRlf; // add length of carriage return/line feed

                    }

                }

            }

        }

    if ( error == KErrEof )

        {

        // end of file has been reached successfully

        error = KErrNone;

        }

    if ( error == KErrNone )

        {

        error = attaFile.Flush();