/*

* Copyright (c) 2003 - 2004 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:

*

*/

/**

 *

 * @file    XPFParser.cpp

 *

 * @internal

 *

 */

#include "j2me/midp2/security/MPermission.h"

#include "ConnectionFilterType.h"

#include "FunctionGroup.h"

#include "FunctionGroupBinding.h"

#include "FileSystemAccessPolicy.h"

#include "DriveAccessPolicy.h"

#include "PathAccessPolicy.h"

#include "ProtectionDomain.h"

#include "SecurityPolicy.h"

#include "XPFParser.h"

#include "BlanketPermissionPolicy.h"

#include "BlanketPermissionPolicyElement.h"

#include <j2me/jdebug.h>

#define MAX_LENGTH_DG_POLICY 40

namespace MIDP

{

CXPFParser* CXPFParser::NewLC(RFile& aFile, CSecurityPolicy& aPolicy)

{

    CXPFParser* xpfp = new(ELeave) CXPFParser(aFile, aPolicy);

    CleanupStack::PushL(xpfp);

    xpfp->ConstructL();

    return xpfp;

}

CXPFParser::CXPFParser(RFile& aFile, CSecurityPolicy& aPolicy):

        iFile(aFile),

        iPolicy(aPolicy)

{

}

CXPFParser::~CXPFParser()

{

    iFile.Close();

    iFunctionGroups.Close();

    delete iFileBuffer;

    delete iBuffer;

    delete iFunctionGroupName;

}

const TUint32 KFileBufferSize = 8192;

const TUint32 KLineBufferSize = 256;

void CXPFParser::ConstructL(void)

{

    iFileBuffer = HBufC8::NewL(KFileBufferSize);

    iBuffer = HBufC::NewL(KLineBufferSize);

}

_LIT(KFormatVersion, "FormatVersion: 1.0");

_LIT(KBlanket,  "Blanket");

_LIT(KOneshot,  "Oneshot");

_LIT(KSession,  "Session");

_LIT(KNo,       "No");

// Policy := Misc* FormatVersion Domains FunctionGroups Bindings Misc*

void CXPFParser::ParseL(void)

{

    MiscL();

    EnsureL(*iBuffer, KFormatVersion);

    DomainsL();

    FunctionGroupsL();

    BindingsL();

    while (ReadLineL() != -1)

    {

        if ((iLineLength > 0) && ((*iBuffer)[0] != '#'))

        {

            UnexpectedL(ECommentOrNewline, *iBuffer);

        }

    }

}

//

// Domains := Misc* ^'Domains' NewLine (Misc* Domain NewLine+)+  ^'EndDomain' NewLine

//

_LIT(KDomains,    "Domains");

_LIT(KEndDomains, "EndDomains");

void CXPFParser::DomainsL(void)

{

    MiscL();

    EnsureL(*iBuffer, KDomains);

    for (;;)

    {

        MiscL();

        DomainL();

        if (*iBuffer == KEndDomains)

        {

            break;

        }

        iNextLine = ETrue;

    }

}

//

// Domain := WS* 'Domain:' WS+ DomainName (NewLine ConnectionFilters 'EndDomain')? NewLine

//

// ConnectionFilters := WS* 'ConnectionFilters' NewLine

//                                (Misc* ConnectionFilter NewLine+)+

//                      WS* 'EndConnectionFilters' NewLine

//

_LIT(KDomain,               "Domain:");

_LIT(KEndDomain,            "EndDomain");

_LIT(KUntrusted,            "[UNTRUSTED]");

_LIT(KConnectionFilters,    "ConnectionFilters");

_LIT(KEndConnectionFilters, "EndConnectionFilters");

_LIT(KFileAccess,           "FileAccess");

_LIT(KEndFileAccess,        "EndFileAccess");

_LIT(KBlanketPermission,    "BlanketPermission");

_LIT(KEndBlanketPermission, "EndBlanketPermission");

void CXPFParser::DomainL(void)

{

    EnsureTokenL(KDomain);

    switch (TokenL())

    {

    case EString:

        if (iPolicy.FindProtectionDomain(iToken) != NULL)

        {

            DuplicateDeclarationL(EDomain, iToken);

        }

        iCurrentDomain = iPolicy.AddProtectionDomainL(iToken);

        break;

    case ESymbol:

        if (iToken == KUntrusted)

        {

            if (iUntrustedDomain != NULL)

            {

                DuplicateDeclarationL(EUntrustedDomain, iToken);

            }

            iUntrustedDomain = iPolicy.AddUntrustedProtectionDomainL();

            iCurrentDomain   = iUntrustedDomain;

            break;

        }

        // Fall-through

    default:

        UnexpectedL(EDomainName, iToken);

    }

    NewLinePlusL();

    TokenL();

    TBool endDomainExpected = EFalse;

    if (iToken == KConnectionFilters)

    {

        ConnectionFiltersL();

        endDomainExpected = ETrue;

        TokenL();

    }

    if (iToken == KFileAccess)

    {

        FileAccessL();

        endDomainExpected = ETrue;

        TokenL();

    }

    if (iToken == KBlanketPermission)

    {

        BlanketPermissionL();

        endDomainExpected = ETrue;

        TokenL();

    }

    if (endDomainExpected)

    {

        EnsureL(iToken, KEndDomain);

        NewLinePlusL();

    }

    else

    {

        iLineOffset = 0;

    }

}

void CXPFParser::ConnectionFiltersL(void)

{

    NewLineL();

    for (;;)

    {

        MiscL();

        ConnectionFilterL();

        NewLinePlusL();

        TokenL();

        if (iToken == KEndConnectionFilters)

        {

            break;

        }

        iNextLine = ETrue;

        iLineOffset = 0;

    }

    NewLinePlusL();

}

_LIT(KNegativePortFilter,       "NegativePortFilter:");

_LIT(KEndNegativePortFilter,    "EndNegativePortFilter");

_LIT(KPort,                     "Port:");

//

// ConnectionFilter   := NegativePortFilter

//

// NegativePortFilter := 'NegativePortFilter' Ports 'EndNegativePortFilter' NewLine

//

// Ports              := (Misc* 'Port:' port NewLine+)+

//

_LIT(KNegativePortFilterTypeName, "NegativePortFilter");

void CXPFParser::ConnectionFilterL(void)

{

    EnsureTokenL(KNegativePortFilter);

    HBufC* scheme = StringLC();

    NewLineL();

    for (;;)

    {

        MiscL();

        EnsureTokenL(KPort);

        HBufC* port = StringLC();

        User::LeaveIfError(iArgs.Append(port));

        CleanupStack::Pop(port);

        NewLinePlusL();

        TokenL();

        if (iToken == KEndNegativePortFilter)

        {

            break;

        }

        iNextLine   = ETrue;

        iLineOffset = 0;

    }

    NewLineL();

    iCurrentDomain->AddConnectionFilterL(

        KNegativePortFilterTypeName,

        ENegativePortFilter,

        *scheme,

        iArgs);

    iArgs.ResetAndDestroy();

    CleanupStack::PopAndDestroy(scheme);

}

_LIT(KDriveList,        "DriveList:");

_LIT(KEndDriveList,     "EndDriveList");

void CXPFParser::FileAccessL(void)

{

    CFileSystemAccessPolicy* fsap = CFileSystemAccessPolicy::NewL();

    iCurrentDomain->SetFileSystemAccessPolicy(fsap);

    for (;;)

    {

        NewLinePlusL();

        TokenL();

        if (iToken == KDriveList)

        {

            DriveListL(*fsap);

        }

        else if (iToken == KEndFileAccess)

        {

            break;

        }

    }

    NewLinePlusL();

}

_LIT(KMutualExclusionSet,       "MutualExclusionSet");

_LIT(KEndMutualExclusionSet,    "EndMutualExclusionSet");

_LIT(KRiskConfirmationSet,      "RiskConfirmationSet");

_LIT(KEndRiskConfirmationSet,   "EndRiskConfirmationSet");

void CXPFParser::BlanketPermissionL(void)

{

    DEBUG("CXPFParser::BlanketPermissionL() - Enter");

    CBlanketPermissionPolicy* bpp = CBlanketPermissionPolicy::NewL();

    CleanupStack::PushL(bpp);

    for (;;)

    {

        NewLinePlusL();

        TokenL();

        if (iToken == KMutualExclusionSet || iToken == KRiskConfirmationSet)

        {

            ExclusionSetL(bpp);

        }

        else if (iToken == KEndBlanketPermission)

        {

            break;

        }

    }

    NewLinePlusL();

    CleanupStack::Pop(bpp);

    iCurrentDomain->SetBlanketPermissionPolicy(bpp);

    DEBUG("CXPFParser::BlanketPermissionL() - Exit");

}

void CXPFParser::ExclusionSetL(CBlanketPermissionPolicy* aBlanketPermissionPolicy)

{

    //Parse mutually excusive blanket permission sets and the

    //downgrade policy for each such pair of sets

    DEBUG("CXPFParser::ExclusionSetL() - Enter");

    TBool endOfSetA= EFalse;

    CBlanketPermissionPolicyElement* pe = CBlanketPermissionPolicyElement::NewL();

    CleanupStack::PushL(pe);

    //Sets clash type in policy element to either KMutualExclusionSet or KRiskConfirmationSet

    pe->AppendDowngradeFunctionGroupListL(iToken.AllocL());

    NewLinePlusL();

    // Parse mutually excusive blanket permission sets

    for (;;)

    {

        TToken type = TokenL();

        if (type==EString)

        {

            if (!endOfSetA)

            {//Add token to set A

                pe->AppendFunctionGroupAL(iToken.AllocL());

            }

            else

            {//Add token to set B

                pe->AppendFunctionGroupBL(iToken.AllocL());

            }

        }

        else if ((type==ESymbol) && (iToken.Length() == 1))   // ':'

        {

            //create setB now

            endOfSetA=ETrue;

        }

        else if (iToken==KEndMutualExclusionSet || iToken==KEndRiskConfirmationSet)

            break;

        if (iToken.Length() == 0)

        {

            NewLinePlusL();

        }

    }

    //Add the sets and permission downgrade policy to the

    //CBlanketPermissionPolicy object for this domain

    CleanupStack::Pop(pe);

    DEBUG("CXPFParser::ExclusionSetL() - Exit");

}

_LIT(KPathAccess,       "PathAccess:");

_LIT(KEndPathAccess,    "EndPathAccess");

_LIT(KPathMapping,      "PathMapping:");

_LIT(KEndPathMapping,   "EndPathMapping");

//

// DriveList := 'DriveList:' ( PathAccess | PathMapping )+ 'EndDriveList'

//

void CXPFParser::DriveListL(CFileSystemAccessPolicy& aFileSystemAccessPolicy)

{

    CPathAccessPolicy* pap = CPathAccessPolicy::NewL();

    CleanupReleasePushL(*pap);

    // Parse drive letters

    for (;;)

    {

        TokenL();

        if (iToken.Length() == 1)

        {

            TDriveNumber drive = TDriveNumber(DriveTokenL());

            CDriveAccessPolicy& dap =

                aFileSystemAccessPolicy.GetDriveAccessPolicyL(drive);

            dap.SetPathAccessPolicy(pap);

        }

        else

        {

            // Anything other that a single character moves on to the paths.

            break;

        }

    }

    if (iToken.Length() == 0)

    {

        NewLinePlusL();

        TokenL();

    }

    for (;;)

    {

        if (iToken == KPathAccess)

        {

            PathAccessL(*pap);

        }

        else if (iToken == KPathMapping)

        {

            PathMappingL(*pap);

        }

        else if (iToken == KEndDriveList)

        {

            break;

        }

        NewLinePlusL();

        TokenL();

    }

    CleanupStack::PopAndDestroy(pap);    // Only actually deleted if not used.

}

//

// Drive := <Single character between A and Z inclusive>

//

_LIT(KDriveLetter, "drive letter");

TInt CXPFParser::DriveTokenL()

{

    TUint letter = iToken[0];

    if (letter >= 'A' && letter <= 'Z')

    {

        return (letter - 'A' + EDriveA);

    }

    if (letter >= 'a' && letter <= 'z')

    {

        return (letter - 'a' + EDriveA);

    }

    UnexpectedL(KDriveLetter, iToken);

    return -1;  // Keep compiler happy.

}

_LIT(KRead,             "Read");

_LIT(KWrite,            "Write");

//

// PathAccess := ‘PathAccess:’ ( ‘Read’ | ‘Write’ )* Path+ ‘EndPathAccess’

//

// Path := <String containing one or more path elements>

//

void CXPFParser::PathAccessL(CPathAccessPolicy& aPathAccessPolicy)

{

    TInt modeBits = 0;

    for (;;)

    {

        TokenL();

        if (iToken == KRead)

        {

            modeBits |= 1;

        }

        else if (iToken == KWrite)

        {

            modeBits |= 2;

        }

        else if (iToken.Length() == 0)

        {

            break;

        }

        else

        {

            UnexpectedL(EPathAccessMode, iToken);

        }

    }

    MDriveAccessPolicy::TAccessMode mode;

    switch (modeBits)

    {

    case 1:

        mode = MDriveAccessPolicy::ERead;

        break;

    case 2:

        mode = MDriveAccessPolicy::EWrite;

        break;

    case 3:

        mode = MDriveAccessPolicy::EReadWrite;

        break;

    default:

        mode = MDriveAccessPolicy::ENone;

    }