/*

* 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:  Implementation of the Manager Interface

*

*/

// INCLUDE FILES

#include <caf/caf.h>

#include <caf/cafplatform.h>

#include <http.h>

#include <http/rhttpheaders.h>

#include <stringpool.h>

#include <utf.h>

#include <w32std.h>

#include <apparc.h>

#include <apgtask.h>

#include <apgcli.h>

#include <apaserverapp.h>

#include <sysutil.h>

#include <centralrepository.h>

#include "Oma2AgentManager.h"

#include "Oma2AgentAttributes.h"

#include "Oma1Dcf.h"

#include "oma2dcf.h"

#include "DRMRightsClient.h"

#include "DrmUtilityInternalcrkeys.h"      // Cenrep extension for OmaBased

using namespace ContentAccess;

const TInt KMinimumOma1DcfLength = 16;

const TInt KCenRepDataLength( 50 );

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

LOCAL_C void DecryptL(

    const TDesC8& aContent,

    TDes8& aOutput)

    {

    COma1Dcf* dcf = NULL;

    TBuf8<KDCFKeySize> iv;

    TPtr8 input(NULL, 0);

    RDRMRightsClient client;

    TPtr8 ptr(NULL, 0);

    dcf = COma1Dcf::NewL(aContent.Mid(1));

    CleanupStack::PushL(dcf);

    User::LeaveIfError(client.Connect());

    CleanupClosePushL(client);

    User::LeaveIfError(client.Consume(aContent[0], *dcf->iContentID));

    User::LeaveIfError(client.InitializeKey(*dcf->iContentID));

    iv.Copy(aContent.Mid(dcf->iOffset + 1, KDCFKeySize));

    aOutput.Copy(&aContent[dcf->iOffset + KDCFKeySize + 1], dcf->iDataLength -

        KDCFKeySize);

    ptr.Set(&aOutput[0], aOutput.Length(), aOutput.Length());

    User::LeaveIfError(client.Decrypt(iv, ptr, ETrue));

    dcf->iPlainTextLength = aOutput.Length();

    dcf->iPadding = dcf->iDataLength - dcf->iPlainTextLength;

    client.Consume(EStop, *dcf->iContentID);

    CleanupStack::PopAndDestroy(2); // client, dcf

    }

LOCAL_C TInt SetName( const TDesC8& aContentUri,

    const TDesC& aContentName )

    {

    RDRMRightsClient client;

    TInt r = KErrNone;

    r = client.Connect();

    if( !r )

        {

        r = client.SetName( aContentUri, aContentName );

        }

    client.Close();

    return r;

    }

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

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

// COma2AgentManager::COma2AgentManager

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

// might leave.

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

//

COma2AgentManager::COma2AgentManager(void):

    iNotifier(NULL),

    iWatchedId(NULL)

    {

    }

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

// COma2AgentManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void COma2AgentManager::ConstructL()

    {

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iFs.ShareAuto());

    iFileManager = CFileMan::NewL(iFs);

    TInt err( KErrNone );

    TRAP(err, FetchOmaBasedInfoL() );

    if( err)

        {

        if( iOmaBasedMimeType )

            {

            delete iOmaBasedMimeType;

            }

        iOmaBasedMimeType = NULL;

        }

    }

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

// COma2AgentManager::FetchOmaBasedInfoL

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

//

void COma2AgentManager::FetchOmaBasedInfoL()

    {

    TInt err = KErrNone;

    CRepository* repository( NULL );

    RBuf bOmaBasedMimeType;

    CleanupClosePushL(bOmaBasedMimeType);

    bOmaBasedMimeType.CreateL( KCenRepDataLength );

    TRAP( err, repository = CRepository::NewL( KCRUidOmaBased ) );

    if ( !err )

        {

        CleanupStack::PushL( repository );

        err = repository->Get( KOmaBasedMimeType, bOmaBasedMimeType );

        if( !err )

            {

            iOmaBasedMimeType = CnvUtfConverter::ConvertFromUnicodeToUtf8L( bOmaBasedMimeType );

            }

        CleanupStack::PopAndDestroy( repository );

        }

    CleanupStack::PopAndDestroy();

    User::LeaveIfError( err );

    }

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

// COma2AgentManager::NewL

// Two-phased constructor.

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

//

COma2AgentManager* COma2AgentManager::NewL()

    {

    COma2AgentManager* self = NewLC();

    CleanupStack::Pop(self);

    return self;

    }

COma2AgentManager* COma2AgentManager::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

COma2AgentManager::~COma2AgentManager()

    {

    delete iFileManager;

    iFs.Close();

    if (iNotifier != NULL)

        {

        if( iWatchedId )

            {

            TRAP_IGNORE(iNotifier->UnRegisterEventObserverL(*this, KEventAddRemove, *iWatchedId));

            TRAP_IGNORE(iNotifier->UnRegisterEventObserverL(*this, KEventModify, *iWatchedId));

            }

        delete iNotifier;

        }

    delete iWatchedId;

    delete iOmaBasedMimeType;

    }

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

// COma2AgentManager::DeleteFile

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

//

TInt COma2AgentManager::DeleteFile(const TDesC& aFileName)

    {

    return iFs.Delete(aFileName);

    }

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

// COma2AgentManager::CopyFile

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

//

TInt COma2AgentManager::CopyFile(

    const TDesC& aSource,

    const TDesC& aDestination)

    {

    TInt driveNumber = 0;

    TChar drive( aDestination[0] );

    RFile file;

    TInt size = 0;

    TInt result = KErrNone;

    TInt err = KErrNone;

    TBool retval = KErrNone;

    // Check the destination drive letter

    result = iFs.CharToDrive(drive,driveNumber);

    if( result )

        {

        return result;

        }

    // open the file to read the size

    result = file.Open(iFs, aSource, EFileShareReadersOrWriters|EFileRead);

    if( result )

        {

        return result;

        }

    // read the size

    result = file.Size( size );

    // close the file

    file.Close();

    if( result )

        {

        return result;

        }

    // check that the drive has enough space for the copy operation

    TRAP( err, retval = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs,

                                                               size,

                                                               driveNumber ) )

    if( retval )

        {

        return KErrDiskFull;

        }

    return iFileManager->Copy( aSource, aDestination);

    }

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

// CWmDrmAgentManager::CopyFile

//

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

//

TInt COma2AgentManager::CopyFile(RFile& aSource,

    const TDesC& aDestination)

    {

    TInt driveNumber = 0;

    TChar drive( aDestination[0] );

    TInt size = 0;

    TInt result = KErrNone;

    RFile output;

    TFileName fileName;

    TInt err = KErrNone;

    TBool retval = KErrNone;

    // Same file, do not even try to copy

    // And since they are the same don't return an error

    aSource.FullName( fileName );

    if( !aDestination.CompareF( fileName ) )

        {

        return KErrNone;

        }

    // Check the destination drive letter

    result = iFs.CharToDrive(drive,driveNumber);

    if( result )

        {

        return result;

        }

    // read the size

    result = aSource.Size( size );

    if( result )

        {

        return result;

        }

    // check that the drive has enough space for the copy operation

    TRAP( err, retval = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs,

                                                               size,

                                                               driveNumber ) )

    if( retval )

        {

        return KErrDiskFull;

        }

    // Perform the copy:

    // Rewind just in case:

    size = 0;

    result = aSource.Seek(ESeekStart, size);

    if( !result )

        {

        result = iFileManager->Copy(aSource, aDestination);

        }

    return result;

    }

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

// COma2AgentManager::RenameFile

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

//

TInt COma2AgentManager::RenameFile(

    const TDesC& aSource,

    const TDesC& aDestination)

    {

    TInt driveNumber = 0;

    TChar drive( aDestination[0] );

    RFile file;

    TInt size = 0;

    TInt err = KErrNone;

    TBool retval = KErrNone;

    TInt result( iFileManager->Rename(aSource, aDestination) );

    // If the files are on a different drive, Rename will fail

    // Therefore we simulate the Move by doing a Copy, followed by Delete

    if ( result != KErrNone )

        {

        // Check the destination drive letter

        result = iFs.CharToDrive(drive,driveNumber);

        if( result )

            {

            return result;

            }

        // open the file to read the size

        result = file.Open(iFs, aSource, EFileShareReadersOrWriters|EFileRead);

        if( result )

            {

            return result;

            }

        // read the size

        result = file.Size( size );

        // close the file

        file.Close();

        if( result )

            {

            return result;

            }

        // check that the drive has enough space for the copy operation

        TRAP( err, retval = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs,

                                                                   size,

                                                                   driveNumber ) )

        if( retval )

            {

            return KErrDiskFull;

            }

        result = iFileManager->Copy(aSource,aDestination);

        if (result == KErrNone)

            {

            // If the copy was successful try and delete the original

            result = iFileManager->Delete(aSource);

            if (result != KErrNone)

                {

                // Delete failed so try to cleanup the destination file

                // as we're going to exit with an error

                // We can safely ignore any error from this as the previous error

                // is more important to propagate, since this is just cleanup

                iFileManager->Delete(aDestination);

                }

            }

        }

    return result;

    }

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

// COma2AgentManager::MkDir

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

//

TInt COma2AgentManager::MkDir(

    const TDesC& aPath)

    {

    return iFs.MkDir( aPath );

    }

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

// COma2AgentManager::MkDirAll

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

//

TInt COma2AgentManager::MkDirAll(

    const TDesC& aPath)

    {

    return iFs.MkDirAll( aPath );

    }

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

// COma2AgentManager::RmDir

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

//

TInt COma2AgentManager::RmDir(

    const TDesC& aPath)

    {

    return iFileManager->RmDir( aPath );

    }

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

// COma2AgentManager::GetDir

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

//

TInt COma2AgentManager::GetDir(

    const TDesC& aName,

    TUint aEntryAttMask,

    TUint aEntrySortKey,

    CDir*& aEntryList) const

    {

    return iFs.GetDir( aName, aEntryAttMask, aEntrySortKey, aEntryList );

    }

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

// COma2AgentManager::GetDir

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

//

TInt COma2AgentManager::GetDir(

    const TDesC& aName,

    TUint aEntryAttMask,

    TUint aEntrySortKey,

    CDir*& aEntryList,

    CDir*& aDirList) const

    {

    return iFs.GetDir( aName, aEntryAttMask, aEntrySortKey, aEntryList, aDirList );

    }

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

// COma2AgentManager::GetDir

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

//

TInt COma2AgentManager::GetDir(

    const TDesC& aName,

    const TUidType& aEntryUid,

    TUint aEntrySortKey,

    CDir*& aFileList) const

    {

    return iFs.GetDir( aName, aEntryUid, aEntrySortKey, aFileList );

    }

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

// COma2AgentManager::GetAttribute

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

//

TInt COma2AgentManager::GetAttribute(

    TInt aAttribute,

    TInt& aValue,

    const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    CDcfCommon* dcfFile = NULL;

    TRAP(r, dcfFile = CDcfCommon::NewL(aVirtualPath.URI()));

    if( r )

        {

        return r;

        }

    aValue = TOma2AgentAttributes::GetAttribute(*dcfFile, aAttribute, aVirtualPath);

    delete dcfFile;

    return r;