/*

* Copyright (c) 2005-2010 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:  File Transfer Controller implementation

*

*/

// INCLUDE FILES

#include <stringresourcereader.h>

#include <sconftp.rsg>

#include <pathinfo.h>

#include <connect/sbdefs.h> // to get backup/restore mode

#include <driveinfo.h>

#include <bautils.h>

#include <sysutil.h>

#include <CDirectoryLocalizer.h>

#include "sconfshandler.h"

#include "sconconsts.h"

#include "irmcconsts.h"

#include "cntparserclient.h"

#include "cntparserinfolog.h"

#include "debug.h"

// cntparser related constants

_LIT(KPhoneBookIrMCL2Request,"telecom/pb.vcf");

_LIT(KInfoLogIrMCL2Request,"telecom/pb/info.log");

_LIT(KInfoLogIrMCL2File,"IrMC\\info.log");

_LIT(KInfoLogPathAndFileName,"c:\\IrMC\\info.log");

_LIT(KPbPathAndFileName,"c:\\IrMC\\pb.vcf");

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

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

// CSConFsHandler::NewL()

// Two-phase constructor

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

//

CSConFsHandler* CSConFsHandler::NewL( RFs& aFs )

    {

    TRACE_FUNC_ENTRY;

    CSConFsHandler* self = new (ELeave) CSConFsHandler( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_FUNC_EXIT;

    return self;

    }

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

// CSConFsHandler::~CSConFsHandler()

// Destructor

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

//

CSConFsHandler::~CSConFsHandler()

    {

    TRACE_FUNC_ENTRY;

    delete iLocalizer;

    TRACE_FUNC_EXIT;

    }

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

// CSConFsHandler::ParseFolderListL( CBufFlat* aBuffer, const TPtrC aPathName

//                                  , const TInt aMemNumber )

// Parses folder and file listing from specified directory

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

//

TInt CSConFsHandler::ParseFolderListL( CBufFlat* aBuffer, const TPtrC aPathName,

                                       const TInt aMemNumber )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1( "CSConFsHandler::ParseFolderListL aPathName =  %S", &aPathName );

    if( aPathName.Length() == 0 )

        {

        LOGGER_WRITE( "CSConFsHandler::ParseFolderListL( CBufFlat* aBuffer, const TPtrC aPathName ) : No path" );

        return KErrArgument;

        }

    if( aPathName.Length() > KDriveLength && !BaflUtils::FolderExists( iFs, aPathName ) )

        {

        LOGGER_WRITE( "CSConFsHandler::ParseFolderListL( CBufFlat* aBuffer, const TPtrC aPathName ) : Current folder doesn't exist any more" );

        return KErrNotFound;

        }

    TInt driveNumber;

    TInt err = iFs.CharToDrive(aPathName[0], driveNumber);

    if( err )

        {

        LOGGER_WRITE_1( "CSConFsHandler::ParseFolderListL : CharToDrive err: %d", err );

        return KErrNotFound;

        }

    TUint driveStatus;

    err = DriveInfo::GetDriveStatus( iFs, driveNumber, driveStatus);

    if( err )

        {

        LOGGER_WRITE_1( "CSConFsHandler::ParseFolderListL : DriveInfo::GetDriveStatus err: %d", err );

        return KErrNotFound;

        }

    // check mem type (DEV, DEV2, MMC, MMC2..)

    TBuf8<KSConMemTypeMaxLength> memType;

    if( driveStatus & DriveInfo::EDriveInternal )

        {

        memType.Copy( KSConMemoryTypeDev );

        if( aMemNumber > 1 )

            {

            memType.AppendNum(aMemNumber);

            }

        }

    else if( driveStatus & DriveInfo::EDriveRemovable )

        {

        memType.Copy( KSConMemoryTypeMmc );

        if( aMemNumber > 1 )

            {

            memType.AppendNum(aMemNumber);

            }

        }

    CDir *entryList = 0;

    CDir *dirList = 0;

    // show only normal files and folders

    TUint entryAttMask = KEntryAttNormal;

    // get folders and files

    err = iFs.GetDir( aPathName, entryAttMask, ESortByName, 

            entryList, dirList );

    if ( err )

        {

        LOGGER_WRITE_1( "ParseFolderListL GetDir returned: %d", err );

        return err;

        }

    CleanupStack::PushL( entryList );

    CleanupStack::PushL( dirList );

    TInt offset = 0;

    LOGGER_WRITE( "CSConFsHandler::ParseFolderList XML creation" );

    //Create folder XML

    aBuffer->ResizeL( KSConXmlDocBegin().Length() );

    aBuffer->Write( offset, KSConXmlDocBegin );

    offset += KSConXmlDocBegin().Length();

    aBuffer->ExpandL( offset, KSConXmlParentFolder().Length() );

    aBuffer->Write( offset, KSConXmlParentFolder );

    offset += KSConXmlParentFolder().Length();

    HBufC* fullNameBuf = HBufC::NewLC( KMaxPath );

    TPtr fullName = fullNameBuf->Des();

    // Print folders to folder listing object

    for( TInt i = 0; i < dirList->Count(); i++ )

        {

        const TEntry entry = ( *dirList )[i];

        fullName.Copy( aPathName );

        fullName.Append( entry.iName );

        fullName.Append( KPathDelimiter );

        // show path if not exluded

        TBool proceed = !IsExludedPath( fullName );

        if ( proceed )

            {

            PrintFolderL( aBuffer, offset, fullName, memType, entry );

            }

        }

    CleanupStack::PopAndDestroy( fullNameBuf );

    CleanupStack::PopAndDestroy( dirList );

    LOGGER_WRITE("Print files");

    // Print files to folder listing object

    for( TInt j = 0; j < entryList->Count(); j++ )

        {

        const TEntry entry = ( *entryList )[j];

        PrintFileL( aBuffer, offset, entry );

        }

    LOGGER_WRITE("files printed");

    //Write the end of XML

    aBuffer->ExpandL( offset, KSConXmlFolderListEnd().Length() );

    aBuffer->Write( offset, KSConXmlFolderListEnd );

    aBuffer->Compress();

    CleanupStack::PopAndDestroy( entryList );

    LOGGER_WRITE_1( "CSConFsHandler::ParseFolderListL() : returned %d", err );

    return err;

    }

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

// CSConFsHandler::PrintFolderL

// Prints folder entry to folder listing object

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

//

void CSConFsHandler::PrintFolderL( CBufFlat* aBuffer, TInt& aOffset, const TDesC& aFullPath,

                    const TDesC8& aMemType, const TEntry& aFolderEntry )

    {

    TRACE_FUNC_ENTRY;

    // initialize Localizer

    iLocalizer->SetFullPath( aFullPath );

    TBool dataPath( EFalse );

    if ( aFullPath.CompareF( PathInfo::PhoneMemoryRootPath() ) == 0 ) // datapath

        {

        // printable folder is C:\Data (Localized)

        dataPath = ETrue;

        }

    // print foldername

    aBuffer->ExpandL( aOffset, KSConXmlFolderNameBegin().Length() );

    aBuffer->Write( aOffset, KSConXmlFolderNameBegin );

    aOffset += KSConXmlFolderNameBegin().Length();

    HBufC8* folderBuf = HBufC8::NewLC( KMaxFileName );

    TPtr8 folderName = folderBuf->Des();

    User::LeaveIfError( 

        CnvUtfConverter::ConvertFromUnicodeToUtf8( folderName, aFolderEntry.iName ) );

    //Replace special characters

    ReplaceSpecialChars( folderName );

    aBuffer->ExpandL( aOffset, folderName.Length() );

    aBuffer->Write( aOffset, folderName );

    aOffset += folderName.Length();

    CleanupStack::PopAndDestroy( folderBuf );

    // print modified time

    TBuf<KSConDateMaxLength> modifiedTime;

    TTime time = aFolderEntry.iModified;

    time.FormatL( modifiedTime, KSConXmlDate );

    TBuf8<KSConDateMaxLength> modifiedTime8;

    User::LeaveIfError( 

        CnvUtfConverter::ConvertFromUnicodeToUtf8( modifiedTime8, modifiedTime ) );

    aBuffer->ExpandL( aOffset, KSConXmlModified().Length() );

    aBuffer->Write( aOffset, KSConXmlModified );

    aOffset += KSConXmlModified().Length();

    aBuffer->ExpandL( aOffset, modifiedTime8.Length() );

    aBuffer->Write( aOffset, modifiedTime8 );

    aOffset += modifiedTime8.Length();

    // print attributes

    aBuffer->ExpandL( aOffset, KSConXmlUserAttributes().Length() );

    aBuffer->Write( aOffset, KSConXmlUserAttributes );

    aOffset += KSConXmlUserAttributes().Length();

    // Add user-perm info

    if( aFolderEntry.IsReadOnly() )

        {

        aBuffer->ExpandL( aOffset, 

            KSConXmlUserEntryReadOnly().Length() );

        aBuffer->Write( aOffset, KSConXmlUserEntryReadOnly );

        aOffset += KSConXmlUserEntryReadOnly().Length();

        }

    else if( iLocalizer->IsLocalized() || dataPath ) // delete disabled

        {

        aBuffer->ExpandL( aOffset, 

            KSConXmlUserEntryDrive().Length() );

        aBuffer->Write( aOffset, KSConXmlUserEntryDrive );

        aOffset += KSConXmlUserEntryDrive().Length();

        }

    else

        {

        aBuffer->ExpandL( aOffset, 

            KSConXmlUserEntryArchive().Length() );

        aBuffer->Write( aOffset, KSConXmlUserEntryArchive );

        aOffset += KSConXmlUserEntryArchive().Length();

        }

    // print memory type

    aBuffer->ExpandL( aOffset, KSConXmlMemoryType().Length() );

    aBuffer->Write( aOffset, KSConXmlMemoryType );

    aOffset += KSConXmlMemoryType().Length();

    aBuffer->ExpandL( aOffset, aMemType.Length() );

    aBuffer->Write( aOffset, aMemType );

    aOffset += aMemType.Length();

    // print label if exists

    if( iLocalizer->IsLocalized() )

        {

        //get localized folder name

        HBufC8* labelBuf = 

            CnvUtfConverter::ConvertFromUnicodeToUtf8L( iLocalizer->LocalizedName() );

        CleanupStack::PushL( labelBuf );

        TPtrC8 label = labelBuf->Des();

        //memory label

        aBuffer->ExpandL( aOffset, 

            KSConXmlMemoryLabel().Length() );

        aBuffer->Write( aOffset, KSConXmlMemoryLabel );

        aOffset += KSConXmlMemoryLabel().Length();

        aBuffer->ExpandL( aOffset, label.Length() );

        aBuffer->Write( aOffset, label );

        aOffset += label.Length();

        CleanupStack::PopAndDestroy( labelBuf );

        }

    if ( dataPath ) // datapath

        {

        //memory label

        aBuffer->ExpandL( aOffset, 

            KSConXmlMemoryLabel().Length() );

        aBuffer->Write( aOffset, KSConXmlMemoryLabel );

        aOffset += KSConXmlMemoryLabel().Length();

        aBuffer->ExpandL( aOffset, iDataPathName.Length() );

        aBuffer->Write( aOffset, iDataPathName );

        aOffset += iDataPathName.Length();

        }

    // print ending

    aBuffer->ExpandL( aOffset, KSConXmlFileEnd().Length() );

    aBuffer->Write( aOffset, KSConXmlFileEnd );

    aOffset += KSConXmlFileEnd().Length();

    TRACE_FUNC_EXIT;

    }

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

// CSConFsHandler::PrintFileL

// Prints file entry to folder listing object

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

//

void CSConFsHandler::PrintFileL( CBufFlat* aBuffer, TInt& aOffset, const TEntry& aFileEntry )

    {

    LOGGER_WRITE_1("CSConFsHandler::PrintFileL, filename: %S", &aFileEntry.iName );

    HBufC8* fileBuf = HBufC8::NewLC( KMaxFileName );

    TPtr8 fileName = fileBuf->Des();

    User::LeaveIfError( 

        CnvUtfConverter::ConvertFromUnicodeToUtf8( fileName, aFileEntry.iName ) );

    //Replace special characters

    ReplaceSpecialChars( fileName );

    // print filename

    aBuffer->ExpandL( aOffset, KSConXmlFileNameBegin().Length() );

    aBuffer->Write( aOffset, KSConXmlFileNameBegin );

    aOffset += KSConXmlFileNameBegin().Length();

    aBuffer->ExpandL( aOffset, fileName.Length() );

    aBuffer->Write( aOffset, fileName );

    aOffset += fileName.Length();

    // print size

    aBuffer->ExpandL( aOffset, KSConXmlSize().Length() );

    aBuffer->Write( aOffset, KSConXmlSize );

    aOffset += KSConXmlSize().Length();

    fileName.Delete( 0, fileName.Length() ); // re-use fileName descriptor

    fileName.AppendNum( aFileEntry.iSize );

    aBuffer->ExpandL( aOffset, fileName.Length() );

    aBuffer->Write( aOffset, fileName );

    aOffset += fileName.Length();

    CleanupStack::PopAndDestroy( fileBuf );

    // print modified

    TBuf<KSConDateMaxLength> modifiedTime;

    TTime time = aFileEntry.iModified;

    time.FormatL( modifiedTime, KSConXmlDate );

    TBuf8<KSConDateMaxLength> modifiedTime8;

    User::LeaveIfError( 

        CnvUtfConverter::ConvertFromUnicodeToUtf8( modifiedTime8, modifiedTime ) );

    aBuffer->ExpandL( aOffset, KSConXmlModified().Length() );

    aBuffer->Write( aOffset, KSConXmlModified );

    aOffset += KSConXmlModified().Length();

    aBuffer->ExpandL( aOffset, modifiedTime8.Length() );

    aBuffer->Write( aOffset, modifiedTime8 );

    aOffset += modifiedTime8.Length();

    // attributes

    aBuffer->ExpandL( aOffset, KSConXmlUserAttributes().Length() );

    aBuffer->Write( aOffset, KSConXmlUserAttributes );

    aOffset += KSConXmlUserAttributes().Length();

    if( aFileEntry.IsSystem() )

        {

        aBuffer->ExpandL( aOffset, 

            KSConXmlUserEntryReadOnly().Length() );

        aBuffer->Write( aOffset, KSConXmlUserEntryReadOnly );

        aOffset += KSConXmlUserEntryReadOnly().Length();

        }

    else if( aFileEntry.IsReadOnly() )

        {

        LOGGER_WRITE("was readonly" );

        aBuffer->ExpandL( aOffset, 

            KSConXmlUserEntryReadOnly().Length() );

        aBuffer->Write( aOffset, KSConXmlUserEntryReadOnly );

        aOffset += KSConXmlUserEntryReadOnly().Length();

        }

    else

        {

        aBuffer->ExpandL( aOffset, 

            KSConXmlUserEntryArchive().Length() );

        aBuffer->Write( aOffset, KSConXmlUserEntryArchive );

        aOffset += KSConXmlUserEntryArchive().Length();

        }

    //Word document

    if ( aFileEntry.iType.IsPresent( KSConWordUid ) ||

            aFileEntry.iName.Find( KSConEpocWordExt ) == aFileEntry.iName.Length() - 4 )

        {

        aBuffer->ExpandL( aOffset, KSConXmlType().Length() );

        aBuffer->Write( aOffset, KSConXmlType );

        aOffset += KSConXmlType().Length();

        aBuffer->ExpandL( aOffset, KSConXmlTypeWord().Length() );

        aBuffer->Write( aOffset, KSConXmlTypeWord );

        aOffset += KSConXmlTypeWord().Length();

        }

    //Sheet document

    else if ( aFileEntry.iType.IsPresent( KSConSheetUid ) ||

            aFileEntry.iName.Find( KSConEpocSheetExt ) == aFileEntry.iName.Length() - 4 )

        {

        aBuffer->ExpandL( aOffset, KSConXmlType().Length() );

        aBuffer->Write( aOffset, KSConXmlType );

        aOffset += KSConXmlType().Length();

        aBuffer->ExpandL( aOffset, KSConXmlTypeSheet().Length() );

        aBuffer->Write( aOffset, KSConXmlTypeSheet );

        aOffset += KSConXmlTypeSheet().Length();

        }

    aBuffer->ExpandL( aOffset, KSConXmlFileEnd().Length() );

    aBuffer->Write( aOffset, KSConXmlFileEnd );

    aOffset += KSConXmlFileEnd().Length();

    }

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

// CSConFsHandler::GetFileObjectL( CObexFileObject*& aFileObject, 

// const TPtrC aPathName, const TPtrC aFileName )

// Gets a file object

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

//

TInt CSConFsHandler::GetFileObjectL( CObexFileObject*& aFileObject, 

                                const TPtrC aPathName, const TPtrC aFileName )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_2( "CSConFsHandler::GetFileObjectL aFileName =  %S aPathName = %S", &aFileName, &aPathName );

    TInt ret( KErrNone );

    if( ( aPathName.Length() == 0 || aFileName.Length() == 0 ) && 

    !( aFileName==KPhoneBookIrMCL2Request || 

    aFileName==KInfoLogIrMCL2Request ) )

        {

        return KErrArgument;

        }

    if( aPathName.Length() + aFileName.Length() > KMaxFileName )

        {

        return KErrAbort;

        }

    HBufC* pathBuf = HBufC::NewLC( KMaxFileName );

    TPtr pathBufPtr = pathBuf->Des();

    /*These modifiactions are mean to catch an IrMC L2 request. 

    If the request is made, then the requested phonebook file and

    info log -file are created. Path and filename is also changed 

    to point to these created files.*/

    if( aFileName == KPhoneBookIrMCL2Request || 

    aFileName == KInfoLogIrMCL2Request )

        {

        LOGGER_WRITE( "CSConFsHandler: IrMC L2 request!" );

        TInt err;

        TInt status;

        TInt contactsSaved = 0;

        RCntParserServer cntParserServer;

        err = cntParserServer.Connect();

        if( err != KErrNone )

            {

            LOGGER_WRITE( "CSConFsHandler: Cannot connect to the cntparserserver, ABORT!" );

            CleanupStack::PopAndDestroy( pathBuf );

            return KErrAbort;

            }

        LOGGER_WRITE( "CSConFsHandler: Time to call CreateIrMCL2PhoneBook" );

        TBool force = ( aFileName == KInfoLogIrMCL2Request );

        status=cntParserServer.CreateIrMCL2PhoneBook( KMaximumNumberOfContacts,

         force );

        LOGGER_WRITE_1( "CntParserServer.CreateIrMCL2PhoneBook returned %d", status );

        //Check how many vcards were saved

        contactsSaved = cntParserServer.ContactsSaved();    

        LOGGER_WRITE_1( "CntParserServer.ContactsSaved returned %d", contactsSaved );

        err = cntParserServer.Disconnect();

        LOGGER_WRITE_1( "CntParserServer.Disconnect() %d", err );

        if( err != KErrNone )

            {

            CleanupStack::PopAndDestroy( pathBuf );

            return KErrAbort;

            }

        //save info.log, if pb.vcf has changed (Note: KPBNotUpdated is returned

        // if no changes made to pb.vcf)

        if( status == KErrNone )    

            {

            LOGGER_WRITE( "CSConFsHandler: Create info.log" );

            CCntParserInfoLog* infoLog=CCntParserInfoLog::NewL();

            CleanupStack::PushL( infoLog );

            //see KMaximumNumberOfContacts for more details