/*

* 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 <pathinfo.h>

#include <stringresourcereader.h>

#include <bautils.h>

#include <driveinfo.h>

#include <sconftp.rsg>

#include <centralrepository.h>

#include <sysutildomaincrkeys.h>

#include "debug.h" 

#include "sconftp.h"

#include "sconfshandler.h"

#include "sconinboxhandler.h"

#include "sconconsts.h"

const TInt KPackageSize = 65536;

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

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

// CreateCSConFTPL()

// Entry to CSConFTP

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

//

EXPORT_C CSConFTP* CreateCSConFTPL()

    {

    TRACE_FUNC;

    return CSConFTP::NewL();

    }

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

// CSConFTP::NewL()

// Two-phase constructor

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

//

CSConFTP* CSConFTP::NewL()

    {

    TRACE_FUNC_ENTRY;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_FUNC_EXIT;

    return self;

    }

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

// CSConFTP::~CSConFTP()

// Destructor

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

//

CSConFTP::~CSConFTP()

    {

    TRACE_FUNC_ENTRY;

    delete iSConInboxHandler;

    iSConInboxHandler = NULL;

    delete iSConFsHandler;

    iSConFsHandler = NULL;

    delete iBuffer;

    iBuffer = NULL;

    iFs.Delete( iTempFileName );

    iFs.Close();

    TRACE_FUNC_EXIT;

    }

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

// CSConFTP::GetFolderObjectL( CObexBufObject*& aObjectList )

// Gets object that contains folder listing from inbox or file system

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

//

TInt CSConFTP::GetFolderObjectL( CObexBufObject*& aObjectList )

    {

    TRACE_FUNC_ENTRY;

    TInt ret( KErrNone );

    TInt offset = 0;

    TChar driveLetter;

    TBuf8<KSConDriveNameLength> tmpBuf8;

    iBuffer->Reset();

    //default folder list - lists all available drives, inbox

    if( iPathName.Length() == 0 )

        {

        TInt devDriveCount = 0;

        TInt mmcDriveCount = 0;

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

        iBuffer->Write( offset, KSConXmlDocBegin );

        offset += KSConXmlDocBegin().Length();

        //Write all drivers to folderlisting object

        TDriveList driveList;

        // Get all drives that are visible to the user.

        TInt driveCount;

        User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveList, driveCount ) );

        for( TInt i = EDriveA; i < KMaxDrives; i++ )

            {

            if( driveList[i] )

                {

                TUint driveStatus;

                User::LeaveIfError( DriveInfo::GetDriveStatus( iFs, i, driveStatus ) );

                LOGGER_WRITE_1( "DriveInfo for drive: %d", i);

                if( !(driveStatus & DriveInfo::EDrivePresent )

                    || driveStatus & DriveInfo::EDriveCorrupt

                    || (driveStatus & DriveInfo::EDriveRemote) )

                    {

                    LOGGER_WRITE_1( "skip drive %d", i);

                    continue;

                    }

                User::LeaveIfError( iFs.DriveToChar( i, driveLetter ) );

                //Letter to uppercase form.

                driveLetter.UpperCase();

                //Folder begin

                iBuffer->ExpandL( offset, 

                KSConXmlFolderNameBegin().Length() );

                iBuffer->Write( offset, KSConXmlFolderNameBegin );

                offset += KSConXmlFolderNameBegin().Length();

                iBuffer->ExpandL( offset, KSConDriveCName().Length() );

                tmpBuf8.Delete( 0, tmpBuf8.Length() );

                tmpBuf8.Append( driveLetter );

                tmpBuf8.Append( KDriveDelimiter );

                iBuffer->Write( offset, tmpBuf8 );

                offset += KSConDriveNameLength;

                //permission

                iBuffer->ExpandL( offset, 

                KSConXmlUserAttributes().Length() );

                iBuffer->Write( offset, KSConXmlUserAttributes );

                offset += KSConXmlUserAttributes().Length();

                if( driveStatus & DriveInfo::EDriveInternal && devDriveCount==0 )

                    {

                    //permission always R for first internal drive

                    iBuffer->ExpandL( offset, 

                    KSConXmlUserEntryReadOnly().Length() );

                    iBuffer->Write( offset, KSConXmlUserEntryReadOnly );

                    offset += KSConXmlUserEntryReadOnly().Length();

                    }

                else

                    {

                    //permission always RW

                    iBuffer->ExpandL( offset, 

                    KSConXmlUserEntryDrive().Length() );

                    iBuffer->Write( offset, KSConXmlUserEntryDrive );

                    offset += KSConXmlUserEntryDrive().Length();

                    }

                //memory type

                iBuffer->ExpandL( offset, 

                KSConXmlMemoryType().Length() );

                iBuffer->Write( offset, KSConXmlMemoryType );

                offset += KSConXmlMemoryType().Length();

                if( driveStatus & DriveInfo::EDriveInternal )

                    {

                    LOGGER_WRITE( "DriveInfo::EDriveInternal" );

                    // DEV type

                    devDriveCount++;

                    if( devDriveCount > 1 )

                        {

                        // DEV2

                        TBuf8<KSConMemTypeMaxLength> memType;

                        memType.Copy( KSConMemoryTypeDev );

                        memType.AppendNum(devDriveCount);

                        iBuffer->ExpandL( offset, memType.Length() );

                        iBuffer->Write( offset, memType );

                        offset += memType.Length();

                        }

                    else

                        {

                        // DEV

                        iBuffer->ExpandL( offset, 

                        KSConMemoryTypeDev().Length() );

                        iBuffer->Write( offset, KSConMemoryTypeDev );

                        offset += KSConMemoryTypeDev().Length();

                        }

                    }

                if( driveStatus & DriveInfo::EDriveRemovable )

                    {

                    LOGGER_WRITE( "DriveInfo::EDriveRemovable" );

                    // MMC type

                    mmcDriveCount++;

                    if( mmcDriveCount > 1 )

                        {

                        // MMC2

                        TBuf8<KSConMemTypeMaxLength> memType;

                        memType.Copy( KSConMemoryTypeMmc );

                        memType.AppendNum(mmcDriveCount);

                        iBuffer->ExpandL( offset, memType.Length() );

                        iBuffer->Write( offset, memType );

                        offset += memType.Length();

                        }

                    else

                        {

                        // MMC

                        iBuffer->ExpandL( offset, 

                        KSConMemoryTypeMmc().Length() );

                        iBuffer->Write( offset, KSConMemoryTypeMmc );

                        offset += KSConMemoryTypeMmc().Length();

                        }

                    }

                //memory label

                iBuffer->ExpandL( offset, 

                KSConXmlMemoryLabel().Length() );

                iBuffer->Write( offset, KSConXmlMemoryLabel );

                offset += KSConXmlMemoryLabel().Length();

                TInt err( KErrNotFound );

                TBuf8<KMaxFileName> volumeName;

                if( driveStatus & DriveInfo::EDriveRemovable || devDriveCount == 1 )

                    {

                    // get Volume name for C-drive(Phone) and E-drive(MMC)

                    err = GetVolumeNameL( i, volumeName );

                    }

                else

                    {

                    // Get localized name for DEV2 (Mass memory)

                    //Read memory string and convert it

                    TFileName file( KSConResourceName );

                    BaflUtils::NearestLanguageFile( iFs, file );

                    CStringResourceReader* reader = CStringResourceReader::NewL( file );

                    CnvUtfConverter::ConvertFromUnicodeToUtf8( volumeName, 

                        reader->ReadResourceString( R_SECON_VALUE_MASS_STORAGE ) );

                    delete reader;

                    err = KErrNone;

                    }

                if ( err == KErrNone )

                    {

                    iBuffer->ExpandL( offset, 

                    volumeName.Length() );

                    iBuffer->Write( offset, volumeName );

                    offset += volumeName.Length();

                    }

                //Write the end of filelist to folderlisting object

                iBuffer->ExpandL( offset, KSConXmlFileEnd().Length() );

                iBuffer->Write( offset, KSConXmlFileEnd );

                offset += KSConXmlFileEnd().Length();

                }

            }

        //Write the end of folderlist to folderlisting object

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

        iBuffer->Write( offset, KSConXmlFolderListEnd );

        iBuffer->Compress();

        }

    else

        {

        if( IsCurrentVolumeOK() )

            {

            ret = iSConFsHandler->ParseFolderListL( iBuffer, iPathName, iCurrentDriveTypeNumber );

            }

        else

            {

            ret = KErrNotFound;

            }

        }

    //Put data to aObjectList

    delete aObjectList;

    aObjectList = NULL;

    aObjectList = CObexBufObject::NewL( iBuffer );

    aObjectList->SetTypeL( KSConFolderListType );

    aObjectList->SetLengthL( iBuffer->Size() );

    LOGGER_WRITE_1( "CSConFTP::GetFolderObjectL( CObexBufObject*& aObjectList ) : returned %d", ret );

    return ret;

    }

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

// CSConFTP::GetFileObjectL( CObexFileObject*& aFileObject )

// Gets object that contains a file from file system

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

//

TInt CSConFTP::GetFileObjectL( CObexFileObject*& aFileObject )

    {

    TRACE_FUNC_ENTRY;

    TInt ret( KErrNone );

    if( aFileObject->Name().Length() == 0 )

        {

        return KErrBadName;

        }

    // check is current drive ok

    if( iPathName.Length() > 0 )

        {

        TPath path( KSConAllowedPath );

        path.Append( KPathDelimiter );

        if( iPathName.CompareF( path ) != 0 )

            {

            // was normal path (not KSConAllowedPath)

            if( !IsCurrentVolumeOK() )

                {

                return KErrNotFound;

                }

            }

        }

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

    TPtr namePtr = nameBuf->Des();

    namePtr.Append( aFileObject->Name() );

    if( namePtr.LocateReverse( KPathDelimiter ) == namePtr.Length()-1 )

        {

        namePtr.Delete( namePtr.Length()-1, 1 );

        }

    ret = iSConFsHandler->GetFileObjectL( aFileObject, iPathName, namePtr );

    CleanupStack::PopAndDestroy( nameBuf );

    LOGGER_WRITE_1( "CSConFTP::GetFileObjectL() : returned %d", ret );

    return ret;

    }

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

// CSConFTP::PutFileObjectInitL( CObexBufObject*& aObject, 

//                                  CBufFlat*& aBuffer )

// Initializes the receiving from the client.

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

//

TInt CSConFTP::PutFileObjectInitL( CObexBufObject*& aObject, 

                                    CBufFlat*& aBuffer )

    {

    TRACE_FUNC_ENTRY;

    TInt ret( KErrNone );

    RFile file;

    TBool lowMemory = IsCurrentDiskSpaceBelowCritical();

    //if Inbox then save temp file to default drive

    if( iPathName.Length() == 0 )

        {

        //When proprietary profile (PC Suite), doesn't allow to use Inbox

        if( iProfile == EProprietary )

            {

            LOGGER_WRITE( "CSConFTP::PutFileObjectInitL() : iProfile EProprietary" );

            ret = file.Temp( iFs, PathInfo::PhoneMemoryRootPath(), iTempFileName,

            EFileWrite | EFileShareExclusive );

            file.Close();

            if( ret == KErrNone )

                {

                CreateObexBufObjectL( aObject, aBuffer );

                }

            }

        else

            {

            LOGGER_WRITE( "CSConFTP::PutFileObjectInitL() : not EProprietary" );

            if( lowMemory )

                {

                // do not even try to save

                LOGGER_WRITE( "CSConFTP::PutFileObjectInitL() : disk full" );

                ret = KErrNoMemory;

                }

            else

                {

                ret = iSConInboxHandler->CreateInboxAttachmentL( aObject, aBuffer );

                }

            }

        return ret;

        }

    else

        {

        LOGGER_WRITE_1("iPathName: %S", &iPathName);

        // check is current drive ok 

        if( !IsCurrentVolumeOK() )

            {

            LOGGER_WRITE( "CSConFTP::PutFileObjectInitL() : drive not visible" );

            ret = KErrNotFound;

            }

        else

            {

            ret = file.Temp( iFs, iPathName, iTempFileName, EFileWrite | 

            EFileShareExclusive );

            }

        }

    file.Close();

    if( ret == KErrNone )

        {

        CreateObexBufObjectL( aObject, aBuffer );

        if( lowMemory )

            {

            // return error. it's up to pccon/ftp plugin howto handle it..

            LOGGER_WRITE( "CSConFTP::PutFileObjectInitL() : low memory" );

            ret = KErrNoMemory;

            }

        }

    LOGGER_WRITE_1( "CSConFTP::PutFileObjectInitL( CObexBufObject*& aObject, CBufFlat*& aBuffer ) : returned %d", ret );

    return ret;

    }

void CSConFTP::CreateObexBufObjectL( CObexBufObject*& aObject, CBufFlat*& aBuffer )

    {

    delete aObject;

    aObject = NULL;

    aObject = CObexBufObject::NewL( NULL );

    delete aBuffer;

    aBuffer = NULL;

    aBuffer = CBufFlat::NewL( KSConBufferSize );

    aBuffer->ResizeL( KSConBufferSize );

    TObexFilenameBackedBuffer bufferdetails( *aBuffer, iTempFileName, 

                    CObexBufObject::EDoubleBuffering );

    TRAPD( err, aObject->SetDataBufL( bufferdetails ));

    if ( err == KErrNoMemory )

        {

        LOGGER_WRITE( "KErrNoMemory, Using singe buffer strategy");

        // If fails, use singe buffer strategy to save RAM

        TObexFilenameBackedBuffer lowMemBufferdetails( *aBuffer, iTempFileName, 

                    CObexBufObject::ESingleBuffering );

        aObject->SetDataBufL( lowMemBufferdetails );

        }

    }

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

// CSConFTP::PutFileObjectFinalizeL( CObexBufObject*& aObject )

// Stores the relayed file object to inbox or file system.

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

//

TInt CSConFTP::PutFileObjectFinalizeL( CObexBufObject*& aObject )

    {

    TRACE_FUNC_ENTRY;

    TInt ret( KErrNone );

    // if iPathName is not defined trying to save to inbox, no need to call IsCurrentVolumeOK()

    if( iPathName.Length() > 0 && !IsCurrentVolumeOK() )

        {

        // Memory card removed

        LOGGER_WRITE( "CSConFTP::PutFileObjectFinalizeL() : disk err, return KErrNotFound" );

        return KErrNotFound;

        }

    else if ( iPathName.Length() + aObject->Name().Length() > KMaxFileName )

        {

        LOGGER_WRITE( "CSConFTP::PutFileObjectFinalizeL() : Too long filename, return KErrBadName");

        return KErrBadName;

        }

    TBool lowMemory = IsCurrentDiskSpaceBelowCritical();

    if ( lowMemory )

        {

        LOGGER_WRITE( "CSConFTP::PutFileObjectFinalizeL() : Low memory, return KErrNoMemory");

        return KErrNoMemory;

        }

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

    TPtr fullPathPtr = fullPathBuf->Des();

    fullPathPtr.Copy( iPathName );

    fullPathPtr.Append( aObject->Name() );

    // Save to inbox if path is not set.

    if( iPathName.Length() == 0 )

        {

        LOGGER_WRITE( "CSConFTP::PutFileObjectFinalizeL before SaveObjectToInbox" );

        ret = iSConInboxHandler->SaveObjToInboxL( aObject );

        LOGGER_WRITE_1( "CSConFTP::PutFileObjectFinalize SaveObjectToInbox returned %d", ret );

        }

    else if( iPathName.CompareF( K_C_ROOT ) == 0 )

        {

        // Saving to root of C:\ is not allowed

        ret = KErrAccessDenied;

        }

    //Save to file system

    else

        {

        TTime time = aObject->Time();

        // UTC offset   

        time -= User::UTCOffset();      

        delete aObject;

        aObject = NULL;

        ret = iSConFsHandler->SaveFileObjectL( fullPathPtr, time, 

        iTempFileName );

        }

    CleanupStack::PopAndDestroy( fullPathBuf );

    LOGGER_WRITE_1( "CSConFTP::PutFileObjectFinalizeL( CObexBufObject*& aObject ) : returned %d", ret );

    return ret;

    }

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