/*

* Copyright (c) 2004-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:  Implementation of the license manager functionality used in the

*                install process

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32base.h>

#include <apmstd.h>

#include <e32math.h>

#include <f32file.h>

#include <s32buf.h>

#include <s32crypt.h>

#include <utf.h>

#include <DRMRights.h>

#include <DRMCommon.h>

#include <Oma1DcfCreator.h>

#include <sysutil.h>     // Disk space checking

#include "zipfile.h"

#include "zipfilememberiterator.h"

#include "DRMLicenseManager.h"

// LOCAL CONSTANTS AND MACROS

_LIT(KDefinitionFileName, "datafiles.def");

_LIT(KSISSuffix, ".sis");

_LIT(KSISXSuffix, ".sisx");

_LIT8(KDefaultMIMEType, "application/binary");

_LIT8( KIssuer , "Rights-Issuer" );

const TInt KSISBufferSize = 512;

const TInt KMaxTypeLength = 11 + 2; // Length of "application" + CR + LF

const TInt KMaxFileDescriptionLength = KMaxPath + KMaxPath + KMaxDataTypeLength;

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

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

// DriveOfPathL

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

LOCAL_C inline TInt DriveOfPathL(

    RFs& aFs,

    const TDesC aPathName,

    TInt aFallbackDrive = KDefaultDrive )

    {

    // find drive for destination for free space check

    TInt driveNumber( KDefaultDrive );

    TParsePtrC pptr( aPathName );

    TInt err( KErrNone );

    if ( pptr.DrivePresent() )

        {

        err = RFs::CharToDrive( pptr.Drive()[ 0 ], driveNumber );

        User::LeaveIfError( err );

        }

    else if ( aFallbackDrive != KDefaultDrive )

        {

        driveNumber = aFallbackDrive;

        }

    else

        {

        HBufC* sessionPath( HBufC::NewLC( KMaxPath ) );

        TPtr pathPtr( sessionPath->Des() );

        User::LeaveIfError( aFs.SessionPath( pathPtr ) );

        TParsePtrC sPPtr( pathPtr );

        if ( sPPtr.DrivePresent() )

            {

            err = RFs::CharToDrive( sPPtr.Drive()[ 0 ], driveNumber );

            User::LeaveIfError( err );

            }

        else

            {

            driveNumber = RFs::GetSystemDrive();

            }

        CleanupStack::PopAndDestroy( sessionPath );

        }

    return driveNumber;

    }

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

// CheckNeededFreeSpaceL

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

LOCAL_C void CheckNeededFreeSpaceL(

    RFs& aFs,

    CZipFile*& aZipFile,

    RPointerArray< TDRMDataFile >& aDataFiles,

    const TDesC& aDestination,

    TInt& aError )

    {

    static const TInt KExtraSpaceForDcf( 1024 );

    CArrayFixFlat< TInt >* arrayOfNeededSpaces( NULL );

    // Get target drive for relative files

    TInt driveForRelativePath( DriveOfPathL( aFs, aDestination ) );

    arrayOfNeededSpaces = new ( ELeave ) CArrayFixFlat< TInt >( KMaxDrives );

    CleanupStack::PushL(  arrayOfNeededSpaces );

    arrayOfNeededSpaces->SetReserveL( KMaxDrives );

    for ( TInt j( 0 ); j < KMaxDrives; ++j )

        {

        arrayOfNeededSpaces->AppendL(0);

        }

    for ( TInt i = 0; i < aDataFiles.Count() && aError == KErrNone; i++ )

        {

        TDRMDataFile* dataFile(

            static_cast< TDRMDataFile* >( aDataFiles[ i ] ) );

        CZipFileMember* member(

            aZipFile->CaseInsensitiveMemberL( dataFile->iSourceName ) );

        if ( member )

            {

            CleanupStack::PushL( member );

            TInt driveNumber( DriveOfPathL(

                    aFs, dataFile->iTargetName, driveForRelativePath ) );

            ( *arrayOfNeededSpaces )[ driveNumber ] +=

                member->UncompressedSize() + KExtraSpaceForDcf;

            CleanupStack::PopAndDestroy( member );

            }

        else

            {

            aError = CDRMLicenseManager::EPIPInvalid;

            }

        }

    for ( TInt j( 0 ); j < KMaxDrives; ++j )

        {

        TUint element( ( *arrayOfNeededSpaces )[ j ] );

        if ( element && // no need to check if no space required

            SysUtil::DiskSpaceBelowCriticalLevelL( &aFs, element, j) )

            {

            User::Leave( KErrDiskFull );

            }

        }

    CleanupStack::PopAndDestroy( arrayOfNeededSpaces );

    }

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

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

// CDRMLicenseManager::CDRMLicenseManager

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

// might leave.

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

//

CDRMLicenseManager::CDRMLicenseManager():

    iFs(NULL), iRights(NULL), iRightsIssuer(NULL)

    {

    }

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

// CDRMLicenseManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDRMLicenseManager::ConstructL()

    {

    iFs = new RFs();

    User::LeaveIfNull(iFs);

    User::LeaveIfError(iFs->Connect());

    }

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

// CDRMLicenseManager::NewL

// Two-phased constructor.

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

//

EXPORT_C CDRMLicenseManager* CDRMLicenseManager::NewL()

    {

    CDRMLicenseManager* self = new( ELeave ) CDRMLicenseManager;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C CDRMLicenseManager::~CDRMLicenseManager()

    {

    iFs->Close();

    delete iFs;

    iDataFiles.ResetAndDestroy();

    if (iZipFile)

        {

        iZipFile->Close();

        delete iZipFile;

        }

    if (iRights)

        {

        delete iRights;

        }

    if (iRightsIssuer)

        {

        delete iRightsIssuer;

        }

    }

    {

    TInt err(KErrNotFound);

    HBufC8* name = HBufC8::NewLC(16);

    TPtr8 headerName( name->Des() );

    headerName.Copy( KIssuer );

    DRMCommon* c = DRMCommon::NewL();

    CleanupStack::PushL(c);

    err = c->GetFileHeader(aFileName, headerName, aRightsIssuerURL);

    CleanupStack::PopAndDestroy(c);

    CleanupStack::PopAndDestroy(name);

    if(err == DRMCommon::EOk && aRightsIssuerURL)

        {

        return ETrue;

        }

    return EFalse;

    }

    {

    TInt err(KErrNotFound);

    HBufC8* name = HBufC8::NewLC(16);

    TPtr8 headerName( name->Des() );

    headerName.Copy( KIssuer );

    DRMCommon* c = DRMCommon::NewL();

    CleanupStack::PushL(c);

    err = c->GetFileHeader(aFileName, headerName, aRightsIssuerURL);

    CleanupStack::PopAndDestroy(c);

    CleanupStack::PopAndDestroy(name);

    if(err == DRMCommon::EOk && aRightsIssuerURL)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CDRMLicenseManager::ProcessL

// Read the PIP definition file and encrypt each referenced data file

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

//

EXPORT_C TInt CDRMLicenseManager::ProcessL(

    const TDesC& aZIPFile,

    const TDesC& aDestination)

    {

    TInt r = KErrNone;

    DRMCommon* drm = NULL;

    RPointerArray<CDRMRights>* rights = NULL;

    // Clean up

    if (iZipFile)

        {

        iZipFile->Close();

        delete iZipFile;

        iZipFile = NULL;

        }

    if (iRights)

        {

        delete iRights;

        iRights = NULL;

        }

    if (iRightsIssuer)

        {

        delete iRightsIssuer;

        iRightsIssuer = NULL;

        }

    GetRightsIssuerL(aZIPFile, iRightsIssuer);

    iDataFiles.ResetAndDestroy();

    // Get rights object for the PIP file

    iZipFile = CZipFile::NewL(*iFs, aZIPFile);

    drm = DRMCommon::NewL();

    CleanupStack::PushL(drm);

    r = drm->GetDetailedFileRights(aZIPFile, rights);

    // Read the definition file

    if (r == KErrNone)

        {

        iRights = (*rights)[0];

        rights->Remove(0);

        rights->ResetAndDestroy();

        delete rights;

        r = ReadDefinitionFileL();

        }

    // Process data files

    if (r == KErrNone)

        {

        r = ProcessDataFilesL(aDestination);

        }

    CleanupStack::PopAndDestroy(drm);

    return r;

    }

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

// CDRMLicenseManager::ProcessL

// Read the PIP definition file and encrypt each referenced data file

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

//

EXPORT_C TInt CDRMLicenseManager::ProcessL(

    RFile& aZIPFile,

    const TDesC& aDestination)

    {

    TInt r = KErrNone;

    DRMCommon* drm = NULL;

    RPointerArray<CDRMRights>* rights = NULL;

    // Clean up

    if (iZipFile)

        {

        iZipFile->Close();

        delete iZipFile;

        iZipFile = NULL;

        }

    if (iRights)

        {

        delete iRights;

        iRights = NULL;

        }

    if (iRightsIssuer)

        {

        delete iRightsIssuer;

        iRightsIssuer = NULL;

        }

    GetRightsIssuerL(aZIPFile, iRightsIssuer);

    iDataFiles.ResetAndDestroy();

    // Get rights object for the PIP file

    iZipFile = CZipFile::NewL(*iFs, aZIPFile);

    drm = DRMCommon::NewL();

    CleanupStack::PushL(drm);

    r = drm->GetDetailedFileRights(aZIPFile, rights);

    // Read the definition file

    if (r == KErrNone)

        {

        iRights = (*rights)[0];

        rights->Remove(0);

        rights->ResetAndDestroy();

        delete rights;

        r = ReadDefinitionFileL();

        }

    // Process data files

    if (r == KErrNone)

        {

        r = ProcessDataFilesL(aDestination);

        }

    CleanupStack::PopAndDestroy(drm);

    return r;

    }

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

// CDRMLicenseManager::ExtractSISFileL

// Find the SIS member of the ZIP file and write it to the target destination.

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

//

EXPORT_C TInt CDRMLicenseManager::ExtractSISFileL(

    const TDesC& aZIPFile,

    const TDesC& aDestination)

    {

    CZipFileMember* sisFile = NULL;

    TInt r = KErrNone;

    if (iZipFile)

        {

        iZipFile->Close();

        delete iZipFile;

        iZipFile = NULL;

        }

    if (iRightsIssuer)

        {

        delete iRightsIssuer;

        iRightsIssuer = NULL;

        }

    GetRightsIssuerL(aZIPFile, iRightsIssuer);

    iZipFile = CZipFile::NewL(*iFs, aZIPFile);

    __UHEAP_MARK;

    sisFile = GetSISMemberL();

    if (sisFile)

        {

        WriteSISMemberL(sisFile, aDestination);

        delete sisFile;

        }

    else

        {

        r = ESISNotFound;

        }

    __UHEAP_MARKEND;

    return r;

    }

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

// CDRMLicenseManager::ExtractSISFileL

// Find the SIS member of the ZIP file and write it to the target destination.

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

//

EXPORT_C TInt CDRMLicenseManager::ExtractSISFileL(

    RFile& aZIPFile,

    const TDesC& aDestination)

    {

    CZipFileMember* sisFile = NULL;

    TInt r = KErrNone;

    if (iZipFile)

        {

        iZipFile->Close();

        delete iZipFile;

        iZipFile = NULL;

        }

    if (iRightsIssuer)

        {

        delete iRightsIssuer;

        iRightsIssuer = NULL;

        }

    GetRightsIssuerL(aZIPFile, iRightsIssuer);

    iZipFile = CZipFile::NewL(*iFs, aZIPFile);

    __UHEAP_MARK;

    sisFile = GetSISMemberL();

    if (sisFile)

        {

        WriteSISMemberL(sisFile, aDestination);

        delete sisFile;

        }

    else

        {

        r = ESISNotFound;

        }

    __UHEAP_MARKEND;

    return r;

    }

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

// CDRMLicenseManager::GetSISMemberL

// Finds the SIS member in the ZIP file by looking for the .sis file ending.

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

//

EXPORT_C CZipFileMember* CDRMLicenseManager::GetSISMemberL(void)

    {

    CZipFileMemberIterator* members = NULL;

    CZipFileMember* sisFile = NULL;

    CZipFileMember* member = NULL;

    members = iZipFile->GetMembersL();

    CleanupStack::PushL(members);

    member = members->NextL();

    while (member && !sisFile)

        {

        if (member->Name()->Right(4).CompareF(KSISSuffix) == 0)

            {

            sisFile = member;

            }

        else if (member->Name()->Right(5).CompareF(KSISXSuffix) == 0)

            {

            sisFile = member;

            }

        else

            {

            delete member;

            member = NULL;

            member = members->NextL();

            }

        }

    CleanupStack::PopAndDestroy(members);

    if(!sisFile)

        {

        User::Leave(KErrNotFound);

        }

    return sisFile;

    }

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

// CDRMLicenseManager::WriteSISMemberL

// Write a SIS member to disk.