/*

* Copyright (c) 2007-2008 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:   Uncompress the zipped vpn policies.

*

*/

#include "zipfiledecompressor.h"

#include <zipfile.h>

#include <bautils.h>

CZipFileDecompressor* CZipFileDecompressor::NewL()

    {

    CZipFileDecompressor* self = new (ELeave) CZipFileDecompressor;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CZipFileDecompressor::CZipFileDecompressor()

: CActive(EPriorityStandard)

    {

    CActiveScheduler::Add(this);

    }

void CZipFileDecompressor::ConstructL()

    {

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

    }

CZipFileDecompressor::~CZipFileDecompressor()

    {

    Cancel();

    iUncompressedFile.Close();

    delete iUncompressedData;

    delete iZipFileMemberIterator; 

    delete iZipFile;    

    if (iCloseZippedFile)

        {

        iZippedFile.Close();

        iCloseZippedFile = EFalse;

        }

    iFileServer.Close();

    }

void CZipFileDecompressor::DecompressZipFile(const TDesC& aSourceFile, 

                                             const TDesC& aTargetDir,

                                             TRequestStatus& aClientStatus)

    {

    __ASSERT_ALWAYS(!IsActive(), User::Invariant());    

    iClientStatus = &aClientStatus;

    *iClientStatus = KRequestPending;

    RFile zippedFile;

    TInt err = zippedFile.Open(iFileServer, aSourceFile, EFileRead);

    if (err == KErrNone)

        {

        iCloseZippedFile = ETrue;

        DecompressZipFile(zippedFile, 

                          aTargetDir,

                          aClientStatus);

        }

    else

        {

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* ownStatus = &iStatus;

        User::RequestComplete(ownStatus, err);        

        }

    }

void CZipFileDecompressor::DecompressZipFile(RFile& aSourceFile, 

                                             const TDesC& aTargetDir,

                                             TRequestStatus& aClientStatus)

    {

    __ASSERT_ALWAYS(!IsActive(), User::Invariant());

    iClientStatus = &aClientStatus;

    *iClientStatus = KRequestPending;

    TRAPD(err, DecompressZipFileL(aSourceFile, aTargetDir));

    if (err != KErrNone)

        {

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* ownStatus = &iStatus;

        User::RequestComplete(ownStatus, err);

        }

    }

void CZipFileDecompressor::DecompressZipFileL(RFile& aSourceFile, 

                                              const TDesC& aTargetDir)

    {

    iZippedFile = aSourceFile;

    BaflUtils::EnsurePathExistsL(iFileServer, aTargetDir);

    User::LeaveIfError(iFileServer.SetSessionPath(aTargetDir));

    iZipFile = CZipFile::NewL(iFileServer, iZippedFile);

    iZipFileMemberIterator = iZipFile->GetMembersL();

    CZipFileMember* member = iZipFileMemberIterator->NextL();

    if (!member)

        {

        User::Leave(KErrArgument);   

        }

    CleanupStack::PushL(member);        

    DecompressNextMemberL(*member);

    CleanupStack::PopAndDestroy(member);

    }

void CZipFileDecompressor::DecompressNextMemberL(CZipFileMember& aMember)

    {

    __ASSERT_ALWAYS(!iUncompressedFile.SubSessionHandle(), 

                    User::Invariant());

    __ASSERT_ALWAYS(!iUncompressedData, User::Invariant());

    //Ignore entries that has zero uncompressed size.

    //(This includes e.g. directories) 

    if (aMember.UncompressedSize() > 0)

        {

        const TChar KDirectorySeparator('\\');

        TUint32 uncompressedSize = aMember.UncompressedSize();

        HBufC8* uncompressedData = HBufC8::NewLC(uncompressedSize);

        RZipFileMemberReaderStream* readerStream;

        User::LeaveIfError(iZipFile->GetInputStreamL(&aMember, readerStream));

        CleanupStack::PushL(readerStream);

        TPtr8 uncompressedDataPtr = uncompressedData->Des();

        User::LeaveIfError(readerStream->Read(uncompressedDataPtr, 

                                              uncompressedDataPtr.MaxLength()));

        CleanupStack::PopAndDestroy(readerStream);

        HBufC* fileName = aMember.Name()->AllocLC();

        TPtr fileNamePtr= fileName->Des();

        TInt lastDirectorySeparator = fileName->LocateReverse(KDirectorySeparator);

        if (lastDirectorySeparator >= 0)

            {

            fileNamePtr = fileName->Mid(lastDirectorySeparator+1);

            }

        TParsePtr fileNameParser(fileNamePtr);

        User::LeaveIfError(iUncompressedFile.Replace(iFileServer, 

                                                     fileNameParser.NameAndExt(), 

                                                     EFileWrite));            

        CleanupStack::PopAndDestroy(fileName);

        CleanupStack::Pop(uncompressedData);

        iUncompressedData = uncompressedData;

        iUncompressedFile.Write(*iUncompressedData, iStatus);

        SetActive();

        }

    else

        {

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* ownStatus = &iStatus;

        User::RequestComplete(ownStatus, KErrNone);

        }

    }

void CZipFileDecompressor::RunL()

    {

    delete iUncompressedData;

    iUncompressedData = NULL;

    iUncompressedFile.Close();

    if (iStatus.Int() == KErrNone)

        {

        CZipFileMember* member = iZipFileMemberIterator->NextL();

        if (member)

            {

            CleanupStack::PushL(member);

            DecompressNextMemberL(*member);

            CleanupStack::PopAndDestroy(member);

            }

        else

            {

            delete iZipFileMemberIterator; 

            iZipFileMemberIterator = NULL;

            delete iZipFile;    

            iZipFile = NULL;                    

            if (iCloseZippedFile)

                {

                iZippedFile.Close();

                iCloseZippedFile = EFalse;

                }

            User::RequestComplete(iClientStatus, KErrNone);            

            }

        }

    else

        {

        delete iZipFileMemberIterator; 

        iZipFileMemberIterator = NULL;

        delete iZipFile;    

        iZipFile = NULL;               

        if (iCloseZippedFile)

            {

            iZippedFile.Close();

            iCloseZippedFile = EFalse;

            }

        User::RequestComplete(iClientStatus, iStatus.Int());

        }

    }

void CZipFileDecompressor::DoCancel()

    {

    //No Cancel for write...

    }

void CZipFileDecompressor::Cancel()

    {

    CActive::Cancel();

    delete iUncompressedData;

    iUncompressedData = NULL;

    iUncompressedFile.Close();

    delete iZipFileMemberIterator; 

    iZipFileMemberIterator = NULL;

    delete iZipFile;    

    iZipFile = NULL;

    if (iCloseZippedFile)

        {

        iZippedFile.Close();

        iCloseZippedFile = EFalse;

        }

    }

TInt CZipFileDecompressor::RunError(TInt aError)

    {

    delete iUncompressedData;

    iUncompressedData = NULL;

    iUncompressedFile.Close();

    delete iZipFileMemberIterator; 

    iZipFileMemberIterator = NULL;

    delete iZipFile;    

    iZipFile = NULL;    

    if (iCloseZippedFile)

        {

        iZippedFile.Close();

        iCloseZippedFile = EFalse;

        }

    User::RequestComplete(iClientStatus, aError);

    return KErrNone;    

    }