/*
 * Copyright (c) 2000 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 applicationmanagement components
 *
 */

#include "amdeploymentcomponentdata.h"

#include <bautils.h>
#include <sisdataprovider.h>

#include <DRMLicenseManager.h>
#include "debug.h"
#include <pathinfo.h>
#include <zipfilemember.h>

_LIT8( KSisxMimeType, "x-epoc/x-sisx-app" );
_LIT( KTempDir, "piptemp\\" );
_LIT8( KPipMimeType, "application/x-pip" );
_LIT8( KDrmMessageMimeType, "application/vnd.oma.drm.message" );
_LIT8( KDrmContentMimeType, "application/vnd.oma.drm.content" );
_LIT8( KSisMimeType, "application/vnd.symbian.install");

using namespace NApplicationManagement;

/**
 *  Data class to Data access
 */
CDeploymentComponentData::CDeploymentComponentData()
    {
    }

CDeploymentComponentData::CDeploymentComponentData(TType aType,
        const TDesC8 &aDataFile) :
    iDataFileName(aDataFile), iType(aType)
    {

    }

void CDeploymentComponentData::ConstructL(const TDesC8 &aData,
        const TDesC8 &aMime)
    {
    SetDataL(aData, aMime);
    }

CDeploymentComponentData &CDeploymentComponentData::operator=(
        const CDeploymentComponentData &aData )
    {
    if( &aData != this )
        {
        SetDataL( aData.Data(), aData.MimeType() );
        iType = aData.iType;
        iDataFileName = aData.iDataFileName;
        }
    return *this;
    }

void CDeploymentComponentData::ConstructLoadL(RReadStream &aStream)
    {
    TUint32 len(aStream.ReadUint32L() );
    aStream.ReadL(iDataFileName, len);

    len = aStream.ReadUint32L();
    aStream.ReadL(iMimeType, len);
    }

CDeploymentComponentData* CDeploymentComponentData::NewL(TType aType,
        const TDesC8 &aData, const TDesC8 &aMime, const TDesC8 &aDataFile)
    {
    CDeploymentComponentData *self = CDeploymentComponentData::NewLC(aType,
            aData, aMime, aDataFile);
    CleanupStack::Pop();
    return self;
    }

CDeploymentComponentData* CDeploymentComponentData::NewLC(TType aType,
        const TDesC8 &aData, const TDesC8 &aMime, const TDesC8 &aDataFile)
    {
    CDeploymentComponentData *self = new ( ELeave ) CDeploymentComponentData( aType, aDataFile);
    CleanupStack::PushL(self) ;
    self->ConstructL(aData, aMime);
    return self;
    }

CDeploymentComponentData* CDeploymentComponentData::LoadL(
        RReadStream &aBuffer)
    {
    CDeploymentComponentData *self =
            CDeploymentComponentData::LoadLC(aBuffer);
    CleanupStack::Pop();
    return self;
    }

CDeploymentComponentData* CDeploymentComponentData::LoadLC(
        RReadStream &aBuffer)
    {
    CDeploymentComponentData *self = new ( ELeave ) CDeploymentComponentData();
    CleanupStack::PushL(self) ;
    self->ConstructLoadL(aBuffer);
    return self;
    }

CDeploymentComponentData::~CDeploymentComponentData()
    {
    RDEBUG8_3("CDeploymentComponentData::~CDeploymentComponentData 0x%X - 0x%X", reinterpret_cast<TUint>(this),
            reinterpret_cast<TUint>(this)+sizeof( CDeploymentComponentData ) );

    delete iData;
    iData = NULL;
    }

TInt CDeploymentComponentData::DataLengthL() const
    {
    TInt ret( 0);
    if (iData == NULL)
        {
        if (iDataFileName.Length() > 0)
            {
            RFs fs;
            User::LeaveIfError(fs.Connect() );
            CleanupClosePushL(fs); // 1
            TEntry entry;
            TFileName fileName;
            fileName.Copy(iDataFileName);
            User::LeaveIfError(fs.Entry(fileName, entry) );
            ret = entry.iSize;
            CleanupStack::PopAndDestroy( &fs);
            }
        }
    else
        {
        ret = iData->Length();
        }
    return ret;
    }

const TDesC8 &CDeploymentComponentData::Data() const
    {
    if (iData == NULL)
        {
        TRAPD( err, LoadDataL() )
        ;
        if (err != KErrNone)
            {
            return KNullDesC8();
            }
        }
    if (iData != NULL)
        {
        return *iData;
        }
    else
        {
        return KNullDesC8();
        }
    }

void CDeploymentComponentData::LoadDataL() const
    {

    if (iDataFileName.Length() > 0)
        {
        RFs fs;
        User::LeaveIfError(fs.Connect() );
        CleanupClosePushL(fs); // 1
        RFile file;
        TFileName fileName;
        fileName.Copy(iDataFileName);
        TInt err(file.Open(fs, fileName, EFileRead) );
        if (err == KErrNone)
            {
            CleanupClosePushL(file); // 2
            TInt fsize;
            User::LeaveIfError(file.Size(fsize) );
            iData = HBufC8::NewL(fsize);
            TPtr8 ptr(iData->Des() );
            User::LeaveIfError(file.Read(ptr) );
            CleanupStack::PopAndDestroy( &file);
            }
        else
            {
            RDEBUG_3( "ERROR Leaving CDeploymentComponentData::Data - SEVERE Could not open data file '%S': %d!",
                    &fileName, err );
            User::Leave(KErrNotFound) ;
            }
        CleanupStack::PopAndDestroy( &fs);
        }
    else
        {
        RDEBUG( "ERROR Leaving CDeploymentComponentData::LoadDataL() - No file to load!" );
        User::Leave(KErrNotFound) ;
        }
    }

TUid CDeploymentComponentData::SetDataL(const TDesC8& aMimeType)
    {
    RDEBUG8_2("CDeploymentComponentData::SetDataL() aMimeType: (%S)", &aMimeType);

    TUid ret(TUid::Null());
    iMimeType = aMimeType.Left(KMaxMimeLength);

    if (IsSISInstallFile(aMimeType) )
        {
        RFs fs;
        User::LeaveIfError(fs.Connect() );
        CleanupClosePushL(fs);
        ret = ResolveUidL(fs);
        CleanupStack::PopAndDestroy( &fs);
        }
    RDEBUG8_2("CDeploymentComponentData::SetDataL() UID: (0x%x)", ret.iUid);
    return ret;
    }

TUid CDeploymentComponentData::SetDataL(const TFileName &aData,
        const TDesC8& aMimeType)
    {
    RDEBUG_2("CDeploymentComponentData::SetDataL() TFileName: (%S)", &aData);

    TUid ret(TUid::Null());
    iMimeType = aMimeType.Left(KMaxMimeLength) ;
    RFs fs;
    User::LeaveIfError(fs.Connect() );
    CleanupClosePushL(fs);
    CFileMan *fm = CFileMan::NewL(fs);
    CleanupStack::PushL(fm);
    TFileName fn;
    fn.Copy(iDataFileName);
    User::LeaveIfError(fm->Copy(aData, fn) );

    if (IsSISInstallFile(aMimeType) )
        {
        ret = ResolveUidL(fs);
        }

    CleanupStack::PopAndDestroy(fm);
    CleanupStack::PopAndDestroy( &fs);
    RDEBUG_2("CDeploymentComponentData::SetDataL() (%d)", ret.iUid);

    return ret;
    }

TUid CDeploymentComponentData::SetDataL(const TDesC8 &aData,
        const TDesC8 &aMimeType)
    {
    TUid ret(TUid::Null());
    if (iData)
        {
        delete iData;
        iData = NULL;
        }
    iData = aData.AllocL();
    ret = SetDataL(aMimeType);
    return ret;
    }

TBool CDeploymentComponentData::IsSISInstallFile(const TDesC8 &aMimeType)
    {
    TBool isSIS(EFalse);

    if (aMimeType == KSisxMimeType || aMimeType == KPipMimeType || aMimeType
            == KDrmMessageMimeType || aMimeType == KDrmContentMimeType || aMimeType == KSisMimeType)
        {
        isSIS = ETrue;
        }

    return isSIS;
    }

TUid CDeploymentComponentData::ResolveUidL(RFs& aFs)
    {
    RDEBUG("CDeploymentComponentData::ResolveUidL()");

    TUid ret(TUid::Null() );
    HBufC* buf = HBufC::NewLC(KMaxFileName);
    TPtr16 ptr = buf->Des();
    ptr.Copy(iDataFileName);

    // if PIP/DRM package, we need to use license manager to extract the sis file
    if (iMimeType == KPipMimeType || iMimeType == KDrmMessageMimeType
            || iMimeType == KDrmContentMimeType)
        {
        RDEBUG8_2("	-> mime: %S", &iMimeType );

        RFile originalFile;
        RFile decryptedFile;
        TFileName decryptedTempFileName;

        RDEBUG_2("	-> opening original file: %S", &ptr );
        // leave if can not open the original file
        User::LeaveIfError(originalFile.Open(aFs, ptr, EFileWrite) );
        RDEBUG("	-> done");

        // First construct the temp path
        User::LeaveIfError(aFs.PrivatePath(decryptedTempFileName) );
        // set drive letter into the path
        decryptedTempFileName.Insert( 0, TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive() );
        // append "piptemp\\"	
        decryptedTempFileName.Append(KTempDir);
        // create the folder
        aFs.MkDir(decryptedTempFileName);

        // Use license manager to extract files from the pip package
        CDRMLicenseManager* licenseMgr = CDRMLicenseManager::NewL();
        CleanupStack::PushL(licenseMgr);
        // decryp from the original file into the temp file   
        RDEBUG_2("	-> extracting SIS file into: %S", &decryptedTempFileName);
        User::LeaveIfError(licenseMgr->ExtractSISFileL(originalFile,
                decryptedTempFileName) );
        RDEBUG("	-> done");

        // Get the sis file name 
        decryptedTempFileName.Append( *(licenseMgr->GetSISMemberL()->Name() ));
        // open temporary handle to it.
        RDEBUG_2("	-> opening decrypted file: %S", &decryptedTempFileName );
        User::LeaveIfError(decryptedFile.Open(aFs, decryptedTempFileName,
                EFileShareAny) );
        RDEBUG("	-> done");
        // parse the uid from the file
        ret = ParseUidFromSisFileL(decryptedFile);

        // no use anymore for the decrypted file
        decryptedFile.Close();
        // delete the temp file
        TInt err = aFs.Delete(decryptedTempFileName);
        if (err != KErrNone)
            {
            RDEBUG_2("**** ERROR, unable to delete temporary file: %S", &decryptedTempFileName );
            }

        CleanupStack::PopAndDestroy(licenseMgr);
        decryptedFile.Close();
        originalFile.Close();
        }
    else
        if (iMimeType == KSisxMimeType || iMimeType == KSisMimeType )
            {
            RDEBUG("	-> mime: x-epoc/x-sisx-app");
            RFile originalFile;
            RDEBUG_2("	-> opening file: %S", &ptr );
            User::LeaveIfError(originalFile.Open(aFs, ptr, EFileRead) );
            RDEBUG("	-> opened ok");
            ret = ParseUidFromSisFileL(originalFile);
            originalFile.Close();
            }

        else
            {
            RDEBUG8_2( "**** ERROR - CDeploymentComponentData::ResolveUidL( ) - cannot get uid from mime type: %S", &iMimeType );
            }

    CleanupStack::PopAndDestroy(buf);
    return ret;
    }

void CDeploymentComponentData::SerializedFormL(RWriteStream &aBuffer) const
    {
    aBuffer.WriteUint32L(iDataFileName.Length() );
    aBuffer.WriteL(iDataFileName);

    aBuffer.WriteUint32L(iMimeType.Length() );
    aBuffer.WriteL(iMimeType);

    }

void CDeploymentComponentData::DestroyL(RFs &aFs) const
    {
    TFileName fn;
    fn.Copy(iDataFileName);
    aFs.Delete(fn) ;
    }

const TDesC8 &CDeploymentComponentData::DataFileName() const
    {
    return iDataFileName;
    }

void CDeploymentComponentData::PersistL(RFs &aFs)
    {
    if (iData)
        {
        RFile file;
        TFileName aFile;
        aFile.Copy(iDataFileName) ;
        RDEBUG_3( "CDeploymentComponentData::PersistL() - Saving '%S', dataLenght %d", &aFile, (iData ? iData->Length() : 0) );
        User::LeaveIfError(file.Replace(aFs, aFile, EFileWrite) );
        CleanupClosePushL(file) ;

        file.Write( *iData) ;
        file.Flush();
        delete iData;
        iData = NULL;
        CleanupStack::PopAndDestroy( &file) ; // file
        }
    else
        {
        RDEBUG( "CDeploymentComponentData::PersistL() - Already persisted" );
        }
    RDEBUG( "CDeploymentComponentData::PersistL() - Done" );
    }

TInt CDeploymentComponentData::SerializedFormLength() const
    {
    return iDataFileName.Length() + (2 * 4) + iMimeType.Length();
    }

void CDeploymentComponentData::SetDataFileNameL(const TDesC8 &aNewFileName)
    {
    if (aNewFileName.Length() > 0)
        {
        RFs fs;
        User::LeaveIfError(fs.Connect() );
        CleanupClosePushL(fs);
        TFileName newfile;
        newfile.Copy(aNewFileName);
        TFileName oldfile;
        oldfile.Copy(iDataFileName);
        User::LeaveIfError(BaflUtils::RenameFile(fs, oldfile, newfile) );
        CleanupStack::PopAndDestroy( &fs);
        iDataFileName = aNewFileName;
        }
    else
        {
        RDEBUG( "CDeploymentComponentData::SetDataFileNameL - ERROR Cannot set empty filename!" );
        User::Leave(KErrArgument);
        }
    }
void CDeploymentComponentData::SetMimeTypeL(const TDesC8 &aMimeType)
{
	iMimeType = aMimeType.Left(KMaxMimeLength) ;
}
void CDeploymentComponentData::ResetData(RFs &aFs)
    {
    TRAP_IGNORE(DestroyL( aFs ));
    iDataFileName = KNullDesC8();
    delete iData;
    iData = NULL;
    }

TUid CDeploymentComponentData::ParseUidFromSisFileL(RFile& aHandleToFile)
    {
    RDEBUG("CDeploymentComponentData::ParseUidFromSisFileL");

    TUid appUid;
    TInt uidLen = sizeof(TInt32);
    TInt seekLen = sizeof(TInt32) + sizeof(TInt32);
    User::LeaveIfError(aHandleToFile.Seek(ESeekStart, seekLen));
    TPckg<TInt32> uid1(appUid.iUid);
    User::LeaveIfError(aHandleToFile.Read(uid1, uidLen));

    if (uid1.Length() != uidLen)
        {
        RDEBUG("**** ERROR - uid length inconsistency - underflow");
        User::Leave(KErrUnderflow);
        }

    RDEBUG_2("	-> returning SIS UID: %d", appUid.iUid );
    return appUid;
    }

//  End of File