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


// INCLUDE FILES
#include <asn1dec.h>

#include "cstsace.h"

namespace java
{
namespace satsa
{

// CONSTANTS
const TTagType KSTSPrincipalsTag = 0;
const TTagType KSTSPermissionsTag = 1;
const TTagType KSTSUserAuthenticationsTag = 2;
const TTagType KSTSApduMaskPermissionTag = 0;

const TInt KSTSDefaultGranularity = 5;

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

// -----------------------------------------------------------------------------
// CSTSAce::CSTSAce
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSTSAce::CSTSAce()
{
}

// -----------------------------------------------------------------------------
// CSTSAce::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSTSAce::ConstructL()
{
    // creating with empty values
    iPrincipals
    = new(ELeave) CArrayPtrFlat<CSTSPrincipal> (KSTSDefaultGranularity);

    iApduMaskPermissions
    = new(ELeave) CArrayPtrFlat<CSTSAPDUMaskPermission> (KSTSDefaultGranularity);

    iUserAuthentications
    = new(ELeave) CArrayPtrFlat<CSTSUserAuth> (KSTSDefaultGranularity);
}

// -----------------------------------------------------------------------------
// CSTSAce::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSTSAce* CSTSAce::NewLC()
{
    CSTSAce* self = new(ELeave) CSTSAce();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
}

// Destructor
CSTSAce::~CSTSAce()
{
    if (iPrincipals)
    {
        iPrincipals->ResetAndDestroy();
        delete iPrincipals;
    }
    if (iApduMaskPermissions)
    {
        iApduMaskPermissions->ResetAndDestroy();
        delete iApduMaskPermissions;
    }
    if (iUserAuthentications)
    {
        iUserAuthentications->ResetAndDestroy();
        delete iUserAuthentications;
    }
}

// -----------------------------------------------------------------------------
// CSTSAce::DecodeL
// Decrypts raw data to this instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
void CSTSAce::DecodeL(const TDesC8& aRawData)
{
    CArrayPtr<TASN1DecGeneric>* itemsData = DecodeSequenceLC(ETrue, aRawData); //must be sequence
    TInt pos = 0;
    //decode possible sequence of principal (in loop)
    if ((pos < itemsData->Count()) && (itemsData->At(pos)->Tag()
                                       == KSTSPrincipalsTag))
    {
        //no need to check sequence tag
        CArrayPtr<TASN1DecGeneric>* principals = DecodeSequenceLC(EFalse,
                itemsData->At(pos++)->Encoding());

        TInt numOfPrincipals = principals->Count();

        if (numOfPrincipals)
        {
            CArrayPtr<CSTSPrincipal>* princArray = new(ELeave) CArrayPtrFlat<
            CSTSPrincipal> (numOfPrincipals);
            CleanupStack::PushL(princArray);
            //if leave occures, array's ResetAndDestroy method will be called
            CleanupResetAndDestroyPushL(*princArray);

            for (TInt i = 0; i < numOfPrincipals; i++)
            {
                CSTSPrincipal* principal = CSTSPrincipal::NewLC();
                principal->DecodeL(principals->At(i)->Encoding());
                princArray->AppendL(principal);
                CleanupStack::Pop(principal);
            }

            if (iPrincipals)
            {
                iPrincipals->ResetAndDestroy();
            }
            delete iPrincipals;
            iPrincipals = princArray;

            CleanupStack::Pop(princArray);//ResetAndDestroy
            CleanupStack::Pop(princArray);
        }
        CleanupStack::PopAndDestroy(principals);
    }

    //decode possible sequence of permission (in loop)
    if ((pos < itemsData->Count()) && (itemsData->At(pos)->Tag()
                                       == KSTSPermissionsTag))
    {
        //no need to check sequence tag
        CArrayPtr<TASN1DecGeneric>* permissions = DecodeSequenceLC(EFalse,
                itemsData->At(pos++)->Encoding());

        TInt numOfPermissions = permissions->Count();
        if (numOfPermissions)
        {
            CArrayPtr<CSTSAPDUMaskPermission>
            * permissionArray = new(ELeave) CArrayPtrFlat<
            CSTSAPDUMaskPermission> (numOfPermissions);
            CleanupStack::PushL(permissionArray);
            //if leave occures, array's ResetAndDestroy method will be called
            CleanupResetAndDestroyPushL(*permissionArray);

            for (TInt i = 0; i < numOfPermissions; i++)
            {
                //we need only APDUMAskPermissions
                if (permissions->At(i)->Tag() == KSTSApduMaskPermissionTag)
                {
                    CSTSAPDUMaskPermission* permission =
                        CSTSAPDUMaskPermission::NewLC();
                    permission->DecodeL(permissions->At(i)->Encoding());
                    permissionArray->AppendL(permission);
                    CleanupStack::Pop(permission);
                }
            }

            if (iApduMaskPermissions)
            {
                iApduMaskPermissions->ResetAndDestroy();
            }
            delete iApduMaskPermissions;
            iApduMaskPermissions = permissionArray;

            CleanupStack::Pop(permissionArray); //ResetAndDestroy
            CleanupStack::Pop(permissionArray);
        }
        CleanupStack::PopAndDestroy(permissions);
    }

    //decode possible sequence of UserAuthentication (in loop)
    if ((pos < itemsData->Count()) && (itemsData->At(pos)->Tag()
                                       == KSTSUserAuthenticationsTag))
    {
        //no need to check sequence tag
        CArrayPtr<TASN1DecGeneric>* userAuthentications = DecodeSequenceLC(
                    EFalse, itemsData->At(pos++)->Encoding());

        TInt numOfUserAuthentications = userAuthentications->Count();
        if (numOfUserAuthentications)
        {

            CArrayPtr<CSTSUserAuth>
            * userAuthArray =
                new(ELeave) CArrayPtrFlat<CSTSUserAuth> (numOfUserAuthentications);
            CleanupStack::PushL(userAuthArray);
            //if leave occures, array's ResetAndDestroy method will be called
            CleanupResetAndDestroyPushL(*userAuthArray);

            for (TInt i = 0; i < numOfUserAuthentications; i++)
            {
                CSTSUserAuth* userAuthentication = CSTSUserAuth::NewLC();
                userAuthentication->DecodeL(
                    userAuthentications->At(i)->Encoding());
                //we need only EAPDUPinEntry
                if (userAuthentication->Type() == CSTSUserAuth::EAPDUPinEntry)
                {
                    userAuthArray->AppendL(userAuthentication);
                }
                CleanupStack::Pop(userAuthentication);
            }

            if (iUserAuthentications)
            {
                iUserAuthentications->ResetAndDestroy();
            }
            delete iUserAuthentications;
            iUserAuthentications = userAuthArray;
            CleanupStack::Pop(userAuthArray);//ResetAndDestroy
            CleanupStack::Pop(userAuthArray);
        }
        CleanupStack::PopAndDestroy(userAuthentications);
    }
    CleanupStack::PopAndDestroy(itemsData);
}

// -----------------------------------------------------------------------------
// CSTSAce::Principals
// Getter for principals
// (other items were commented in a header).
// -----------------------------------------------------------------------------
const CArrayPtr<CSTSPrincipal>& CSTSAce::Principals() const
{
    return *iPrincipals;
}

// -----------------------------------------------------------------------------
// CSTSAce::APDUMaskPermissions
// Getter for APDUMaskPermissions
// (other items were commented in a header).
// -----------------------------------------------------------------------------
const CArrayPtr<CSTSAPDUMaskPermission>& CSTSAce::APDUMaskPermissions() const
{
    return *iApduMaskPermissions;
}

// -----------------------------------------------------------------------------
// CSTSAce::UserAuthentications
// Getter for UserAuthentications
// (other items were commented in a header).
// -----------------------------------------------------------------------------
const CArrayPtr<CSTSUserAuth>& CSTSAce::UserAuthentications() const
{
    return *iUserAuthentications;
}

} // namespace satsa
} // namespace java
//  End of File