/*

* Copyright (c) 2007 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:  CManifestReader implementation file

*

*/

#include <caf/content.h>

#include <zipfile.h>

#include <utf.h>

#include <e32cmn.h>

#include <javaattribute.h>

#include "appmngr2midletmanifestreader.h"

#include "logger.h"                         // LOG

const TInt KAllRead = -1;

const TInt KAttributeMinSize = 3;

const TInt KFilePrefix = 4;

_LIT(KManifestEntryName, "META-INF/MANIFEST.MF");

const TUint32 LF  = 10;

const TUint32 CR  = 13;

const TUint32 SP  = 32;

const TUint32 COLON = 58;

AppMngr2MidletManifestReader::AppMngr2MidletManifestReader(RFs& aFs) :

        mFs(aFs), mSessionOpen(false)

{

}

AppMngr2MidletManifestReader::~AppMngr2MidletManifestReader()

{

    // Close the file session (if opened by ManifestReader)

    if (mSessionOpen)

    {

        mFs.Close();

    }

}

void AppMngr2MidletManifestReader::ReadManifestL(

    const TDesC& aManifestFile,

    RPointerArray<MJavaAttribute>& aAttributes)

{

    if (mManifestContent.get())

    {

        mManifestContent.reset(0);

    }

    ContentL(aManifestFile);

    ReadAttributesL(aAttributes);

}

void AppMngr2MidletManifestReader::ReadAttributesL(

    RPointerArray<MJavaAttribute>& aAttributes)

{

    TPtr16 contentPtr(mManifestContent->Des());

    //remove white space from the beginning of the file

    contentPtr.TrimLeft();

    TInt attributeIndex = -1;

    // Continue until new line is found and manifest content is more than 3.

    // It can't be shorter than a:b\n. Actually spec specifies that it must be 'a: b\n'

    // that makes four but for the robustness as also user inserted variables

    // are read. Parameter can be e.g. either TestCase1:myCase or TestCase1: myCase.

    while ((attributeIndex = ReadLineIndexL(EFalse)) != KAllRead)

    {

        HBufC16* attribute = contentPtr.Left(attributeIndex).AllocLC();

        TPtr16 attributePtr(attribute->Des());

        attributePtr.Trim();

        TInt colonIndex = attributePtr.Locate(COLON);

        // Invalid attribute. Name not found

        if (KErrNotFound == colonIndex)

        {

            ELOG(EJavaAppMngrPlugin, "MF parsing failed: No attribute name defined");

            //User::Leave(KJavaParseNameAttributeMissing);

            User::Leave(KErrArgument);

        }

        // Implementation expects that attribute name fits to first line.

        HBufC16* name = attributePtr.Left(colonIndex).AllocLC();

        TPtr16 namePtr(name->Des());

        namePtr.Trim();

        ValidateAttributeNameL(namePtr);

        // Rest of the manifest data can be continuational value.

        HBufC16* value = HBufC16::NewLC(contentPtr.Length());

        TPtr16 valuePtr(value->Des());

        // Skip colon

        valuePtr.Append(attributePtr.Mid(colonIndex + 1));

        valuePtr.Trim();

        ReadContinuationLineL(valuePtr, contentPtr, attributeIndex);

        // If manifest attribute value is not defined attribute is

        // skipped and it is not returned to caller.

        if (valuePtr.Length() > 0)

        {

            CJavaAttribute* javaAttribute

            = CJavaAttribute::NewL(namePtr, valuePtr, EFalse);

            aAttributes.Append(javaAttribute);

        }

        CleanupStack::PopAndDestroy(value);

        CleanupStack::PopAndDestroy(name);

        CleanupStack::PopAndDestroy(attribute);

        // Delete already handled attribute from the buffer.

        // Content is read until the enter and it must be deleted to reach next one.

        contentPtr.Delete(0, attributeIndex + 1);

        contentPtr.TrimLeft();

    }

}

void AppMngr2MidletManifestReader::ContentL(const TDesC& aManifestFileName)

{

    RFile file;

    TInt err = file.Open(mFs,

                         aManifestFileName,

                         EFileStream | EFileShareAny | EFileRead);

    User::LeaveIfError(err);

    CleanupClosePushL(file);

    std::auto_ptr<HBufC8>fileStart(HBufC8::NewL(KFilePrefix));

    TPtr8 fileStartPtr(fileStart->Des());

    std::auto_ptr<HBufC16>filePrefix(HBufC16::NewL(KFilePrefix));

    TPtr16 filePrefixPtr(filePrefix->Des());

    err = file.Read(fileStartPtr, KFilePrefix);

    User::LeaveIfError(err);

    err = CnvUtfConverter::ConvertToUnicodeFromUtf8(

              filePrefixPtr, fileStartPtr);

    if (KErrNone != err)

    {

        ELOG1(EJavaAppMngrPlugin, "MF UTF-8 to unicode conversion failed: %d", err);

        // User::Leave(KJavaErrNoneUTF8);

        User::Leave(KErrArgument);

    }

    if (fileStartPtr.Length() < KFilePrefix)

    {

        ELOG(EJavaAppMngrPlugin, "Not enough content at manifest file");

        // User::Leave(KJavaErrInvalidManifest);

        User::Leave(KErrArgument);

    }

    // Check from CAF if file is DRM protected.

    TBool drmProtected = EFalse;

    std::auto_ptr<ContentAccess::CContent>content(

        ContentAccess::CContent::NewL(file));

    err = content->GetAttribute(ContentAccess::EIsProtected, drmProtected);

    if (KErrNone != err)

    {

        ELOG1(EJavaAppMngrPlugin, "DRM protection check failed: %d", err);

        User::Leave(KErrArgument);

    }

    // Detect JAR package. JAR is either a DRM protected file or a ZIP file.

    // ZIP file has PK\003\004 prefix.

    if (drmProtected

            || (filePrefixPtr[0] == 0x50

                && filePrefixPtr[1] == 0x4B

                && filePrefixPtr[2] == 0x03

                && filePrefixPtr[3] == 0x04))

    {

        ReadManifestContentFromPackageL(file);

    }

    else

    {

        // Plain manifest file

        ReadManifestContentL(file);

    }

    CleanupStack::PopAndDestroy(&file);

}

void AppMngr2MidletManifestReader::ReadManifestContentL(RFile& aManifestFile)

{

    // Reads the entire file into a heap descriptor. Use the content

    // access framework to access the manifest.

    ContentAccess::CContent* content

    = ContentAccess::CContent::NewLC(aManifestFile);

    ContentAccess::CData* manifestFile

    = content->OpenContentL(ContentAccess::EPeek);

    CleanupStack::PushL(manifestFile);

    HBufC8* manifestFileData = ReadRawManifestFileL(*manifestFile);

    TPtr8 ptr(manifestFileData->Des());

    CleanupStack::PopAndDestroy(manifestFile);

    CleanupStack::PopAndDestroy(content);

    CleanupStack::PushL(manifestFileData);

    mManifestContent.reset(HBufC16::NewL(ptr.Size()));

    TPtr16 ucsPtr(mManifestContent->Des());

    TInt err = CnvUtfConverter::ConvertToUnicodeFromUtf8(ucsPtr, ptr);

    if (KErrNone != err)

    {

        ELOG1(EJavaAppMngrPlugin, "MF UTF-8 to unicode conversion failed: %d", err);

        //User::Leave(KJavaErrNoneUTF8);

        User::Leave(KErrArgument);

    }

    CleanupStack::PopAndDestroy(manifestFileData);

}

HBufC8* AppMngr2MidletManifestReader::ReadRawManifestFileL(

    ContentAccess::CData& aManifestFile)

{

    // Reads size of file

    TInt manifestSize;

    aManifestFile.DataSizeL(manifestSize);

    // allocates buffer for file contents, if this is too big and device runs

    // out of memory function will leave. Do not really care about this as file

    // was unlikely to have been a manifest file at all.

    HBufC8* manifestFileData = HBufC8::NewMaxLC(manifestSize);

    TPtr8 manifestFileDataPtr(manifestFileData->Des());

    // Now read the manifest file

    User::LeaveIfError(aManifestFile.Read(manifestFileDataPtr, manifestSize));

    CleanupStack::Pop(manifestFileData);

    return manifestFileData;

}

void AppMngr2MidletManifestReader::ReadManifestContentFromPackageL(

    RFile& aPackageFile)

{

    CZipFile* zipFile = CZipFile::NewL(mFs, aPackageFile);

    CleanupStack::PushL(zipFile);

    // Seek manifest file

    CZipFileMember* zippedFile =

        zipFile->CaseSensitiveOrCaseInsensitiveMemberL(KManifestEntryName());

    if (!zippedFile)

    {

        ELOG(EJavaAppMngrPlugin, "Package is missing manifest");

        //User::LeaveIfError(KJavaErrMissingManifest);

        User::Leave(KErrArgument);

    }

    CleanupStack::PushL(zippedFile);

    TUint uncompressedSize = zippedFile->UncompressedSize();

    if ((TUint)uncompressedSize>=(KMaxTInt/2))

    {

        ELOG(EJavaAppMngrPlugin, "Invalid manifest");

        //User::Leave(KJavaErrInvalidManifest);

        User::Leave(KErrArgument);

    }

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

    RZipFileMemberReaderStream* zippedStream = 0;

    TInt err = zipFile->GetInputStreamL(zippedFile, zippedStream);

    User::LeaveIfError(err);

    CleanupStack::PushL(zippedStream);

    TPtr8 ptr(resultData->Des());

    User::LeaveIfError(zippedStream->Read(ptr, uncompressedSize));

    CleanupStack::PopAndDestroy(zippedStream);

    mManifestContent.reset(HBufC16::NewL(uncompressedSize));

    TPtr16 ucsPtr(mManifestContent->Des());

    err = CnvUtfConverter::ConvertToUnicodeFromUtf8(ucsPtr, ptr);

    if (KErrNone != err)

    {

        ELOG1(EJavaAppMngrPlugin, "UTF-8 to unicode conversion failed: %d", err);

        //User::Leave(KJavaErrNoneUTF8);

        User::Leave(KErrArgument);

    }

    CleanupStack::PopAndDestroy(resultData);

    CleanupStack::PopAndDestroy(zippedFile);

    CleanupStack::PopAndDestroy(zipFile);

}

TInt AppMngr2MidletManifestReader::ReadLineIndexL(TBool aContinuation)

{

    TPtr16 contentPtr(mManifestContent->Des());

    if (contentPtr.Length() < KAttributeMinSize)

    {

        // EOF. This covers also case where all rest of the data

        // was whitespace characters trimmed were trimmed off before

        // going to next line.

        return KAllRead;

    }

    TInt attributeIndex = contentPtr.Locate(LF);

    TInt tmp = contentPtr.Locate(CR);

    // New line can be CR LF | LF | CR. Let's take

    // the first appearance of new line character.

    if ((tmp < attributeIndex && tmp != KErrNotFound)

            || attributeIndex == KErrNotFound)

    {

        // This covers also new line indicated only with CR.

        attributeIndex = tmp;

    }

    if (KErrNotFound == attributeIndex && KErrNotFound == tmp)

    {

        // Check if no enter after last line

        if (contentPtr.Length() > KAttributeMinSize)

        {

            attributeIndex = contentPtr.Length();

        }

        else

        {

            ELOG(EJavaAppMngrPlugin, "No attribute found");

            //User::Leave(KJavaErrInvalidManifest);

            User::Leave(KErrArgument);

        }

    }

    else if ((attributeIndex < KAttributeMinSize) && !aContinuation)

    {

        // Minimum parameter length is 4 e.g. 'a: b\n' or 'a:b\n'

        // This is a bit more robust than manifest specification as

        // it expects nameCOLONSPACEvalue format.

        ELOG(EJavaAppMngrPlugin, "Invalid attribute");

        //User::Leave(KJavaErrInvalidManifest);

        User::Leave(KErrArgument);

    }

    else if (attributeIndex <= 0)

    {

        // Minimum continuation parameter length is 1 e.g. 'a\n'

        ELOG(EJavaAppMngrPlugin, "Invalid continuation attribute");

        //User::Leave(KJavaErrInvalidManifest);

        User::Leave(KErrArgument);

    }

    return attributeIndex;

}

void AppMngr2MidletManifestReader::ReadContinuationLineL(TDes16& aValue,

        TDes& aContent,

        TInt& aIndex)

{

    TBool continuation = ETrue;

    while (continuation)

    {

        if (aContent.Length() <= aIndex + 2)

        {

            // Last line

            continuation = EFalse;

        }

        // Continuation can be CR LF SPACE | LF SPACE | CR SPACE

        else if ((aContent[ aIndex ] == CR

                  && aContent[ aIndex + 1 ] == LF

                  && aContent[ aIndex + 2 ] == SP)

                 ||

                 (aContent[ aIndex ] == CR

                  && aContent[ aIndex + 1 ] == SP)

                 ||

                 (aContent[ aIndex ] == LF

                  && aContent[ aIndex + 1 ] == SP))

        {

            // Clean previous entry.

            aContent.Delete(0, aIndex + 1);

            // Delete continuation indicator. Trim cannot be used here. If continuation

            // starts with SP it will be trimmed out and that must be prevented.

            // CR SP or LF SP case

            if (aContent[0] == SP)

            {

                if ((aContent.Length() > 1) &&

                        (aContent[1] != CR) && (aContent[1] != LF))

                {

                    aContent.Delete(0, 1);//for Manifest i JAD

                }

            }

            // CR LF SP case

            else

            {

                if ((aContent.Length() > 2) &&

                        (aContent[2] != CR) && (aContent[2] != LF))

                {

                    aContent.Delete(0, 2);//for Manifest i JAD

                }

                else

                {

                    aContent.Delete(0, 1);//for Manifest i JAD

                }

            }

            aIndex = ReadLineIndexL(ETrue);

            if (aIndex != KAllRead)

            {

                // Do not append whitespace combination. Only content.

                aValue.Append(aContent.Left(aIndex));

                aValue.TrimRight();

            }

            else

            {

                // Can't be continuation if all read. Not leaving

                // as last line can easilly contain unnecessary SPACEs.

                continuation = EFalse;

            }

        }

        else

        {

            continuation = EFalse;

        }

    }

}

void AppMngr2MidletManifestReader::ValidateAttributeNameL(TDesC16& aName)

{

    if (aName.Length() == 0)

    {

        ELOG(EJavaAppMngrPlugin, "Invalid attribute name");

        // User::Leave(KJavaParseInvalidAttributeName);

        User::Leave(KErrArgument);

    }

    TLex lexer(aName);

    TChar ch;

    // Manifest name cannot start with - and _ chars.

    ch = lexer.Get();

    if (ch == '_' || ch == '-')

    {

        ELOG(EJavaAppMngrPlugin, "Invalid attribute name start");

        //User::Leave(KJavaParseInvalidAttributeName);

        User::Leave(KErrArgument);

    }

    lexer.UnGet();

    while ((ch = lexer.Get()) != '\0')

    {

        // Allowed chars: {A-Z} | {a-z} | {0-9} | - | _

        if (!('0' <= ch && ch <= '9')

                && !(ch >= 'a' && ch <= 'z')

                && !(ch >= 'A' && ch <= 'Z')

                && !('-' == ch)

                && !('_' == ch)

                && !('.' == ch))

        {

            ELOG(EJavaAppMngrPlugin, "Invalid attribute name");

            //User::Leave(KJavaParseInvalidAttributeName);

            User::Leave(KErrArgument);

        }

    }

}