/*

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

* CPKIMapper class holds the information required to map API set to 

* use the storage model which is not native for that API.

*

*/

#include <x500dn.h>

#include <x509cert.h>

#include "PKIMapper.h"

#include "pkcs10.h"

#include "log_r6.h"

#include "pkiserviceassert.h"

CMapDescriptor::CMapDescriptor(TSecurityObjectDescriptor &aDesc)

    {

    this->iSubjectKeyId = aDesc.iSubjectKeyId;

    this->iOwnerType = aDesc.iOwnerType;

    this->iKeySize = aDesc.iKeySize;            

    this->iKeyAlgorithm = aDesc.iKeyAlgorithm;      

    this->iIsDeletable = aDesc.iIsDeletable;      

    }

CMapDescriptor& CMapDescriptor::operator=(CMapDescriptor& aMapDesc)

{

    delete this->iTrustedAuthority;

    this->iTrustedAuthority = NULL;

    if(aMapDesc.iTrustedAuthority != NULL)

        {

        this->iTrustedAuthority     = aMapDesc.iTrustedAuthority->Des().AllocL();           // Cert TrustedAuthority

        }

    delete this->iIdentitySubjectName;

    this->iIdentitySubjectName = NULL;

    if(aMapDesc.iIdentitySubjectName != NULL)

        {

        this->iIdentitySubjectName  = aMapDesc.iIdentitySubjectName->Des().AllocL();        // Identity subject name

        }

    delete this->iIdentityRfc822Name;

    this->iIdentityRfc822Name = NULL;

    if(aMapDesc.iIdentityRfc822Name != NULL)

        {

        this->iIdentityRfc822Name   = aMapDesc.iIdentityRfc822Name->Des().AllocL();         // Identity subjectAltName rfc822 name

        }

    delete this->iSerialNumber;

    this->iSerialNumber = NULL;

    if(aMapDesc.iSerialNumber != NULL)

        {

        this->iSerialNumber         = aMapDesc.iSerialNumber->Des().AllocL();               // Serialnumber

        }

    this->iSubjectKeyId         = aMapDesc.iSubjectKeyId;                               // SHA1 hash of the corresponding private key

    this->iOwnerType            = aMapDesc.iOwnerType;                                  // User, CA or peer. If user certificate, at least key usage must be set

    this->iKeyUsageDer          = aMapDesc.iKeyUsageDer;                                // Der format flags

    this->iObjectName           = aMapDesc.iObjectName;

    this->iKeySize              = aMapDesc.iKeySize;                                    // Key size

    this->iKeyAlgorithm         = aMapDesc.iKeyAlgorithm;                               // RSA, DSA

    this->iStartTime            = aMapDesc.iStartTime;

    this->iEndTime              = aMapDesc.iEndTime;

    this->iIsDeletable          = aMapDesc.iIsDeletable;

    TInt i;

    for(i=0;i<aMapDesc.iApplUids.Count();i++)

        {

        this->iApplUids.Append(aMapDesc.iApplUids[i]);

        }

    this->iCertStoreType        = aMapDesc.iCertStoreType;

    return *this;

}

TBool CMapDescriptor::IsMatchingL(TSecurityObjectDescriptor &aDesc, 

                                  const TBool aInfoOnly, 

                                  TPkiServiceStoreType aCertStoreType) const

    {

    TBool match(EFalse);

    LOG(Log::Printf(_L("Matching")));

    LOG_1(" Pure informational: %d", aInfoOnly);

    LOG(Log::Printf(_L("Matching: certificate %S"), &iObjectName));

    for(;;)

        {

        if (aDesc.iOwnerType != EPKICACertificate &&

            aCertStoreType != EPkiStoreTypeAny) 

            {            

            if (iCertStoreType != aCertStoreType)

                {

                LOG(Log::Printf(_L("    Store doesn't match, aborting")));

                match = EFalse;

                break;                

                }

            }

        else 

            {

            LOG(Log::Printf(_L("Skipping store check, not relevant")));

            }

        if (aDesc.iSubjectKeyIdUsed)

            {            

			if(iSubjectKeyId == aDesc.iSubjectKeyId)

				{

				match = ETrue;

				}

			else

				{

				match = EFalse;

				break;

				}

			}

        if(aDesc.iTrustedAuthorityUsed)

            {

            if(iTrustedAuthority == NULL)

                {

                match = EFalse;

                break;

                }

            else

                {

                CX500DistinguishedName* dnSuffix1 = CX500DistinguishedName::NewLC(*iTrustedAuthority);

                CX500DistinguishedName* dnSuffix2;

                TInt popCount = 3;

                // ASN1 or plain text

                if((aDesc.iTrustedAuthority[0] != 0x30)

                   || ((aDesc.iTrustedAuthority[1] != 0x81)

                   && (aDesc.iTrustedAuthority[1] != 0x82)

                   && ((aDesc.iTrustedAuthority[1] + 2) != aDesc.iTrustedAuthority.Length())))

                    {

                    HBufC8* name2Der;

                    CPkcs10Req::BuildDistinguishedNameDerFromTextL(name2Der,

                                                                   aDesc.iTrustedAuthority,

                                                                   EFalse, KNullDesC8);

                    CleanupStack::PushL(name2Der);

                    dnSuffix2 = CX500DistinguishedName::NewLC(*name2Der);

                    }

                else

                    {

                    dnSuffix2 = CX500DistinguishedName::NewLC(aDesc.iTrustedAuthority);

                    popCount = 2;

                    }

                if(PkiUtil::MatchL(*dnSuffix1, *dnSuffix2))

                    {

                    match = ETrue;

                    CleanupStack::PopAndDestroy(popCount);

                    }

                else

                    {

                    match = EFalse;

                    CleanupStack::PopAndDestroy(popCount);

                    break;

                    }

                }

            }

        if(aDesc.iOwnerTypeUsed)

            {

            if(iOwnerType == aDesc.iOwnerType)

                {

                match = ETrue;

                }

            else

                {

                match = EFalse;

                break;

                }

            }

        if(aDesc.iSerialNumberUsed)

            {

            if ((iSerialNumber != NULL) && ((*iSerialNumber).Compare(aDesc.iSerialNumber) == 0))

                {

                match = ETrue;

                }

            else

                {

                match = EFalse;

                break;

                }

            }

        if(aDesc.iIdentitySubjectNameUsed)

            {

            if(iIdentitySubjectName == NULL)

                {

                match = EFalse;

                break;

                }

            else

                {

                CX500DistinguishedName* dnSuffix1 = CX500DistinguishedName::NewLC(*iIdentitySubjectName);

                CX500DistinguishedName* dnSuffix2;

                TInt popCount = 3;

                // ASN1 or plain text

                if((aDesc.iIdentitySubjectName[0] != 0x30)

                   || ((aDesc.iIdentitySubjectName[1] != 0x81)

                   && (aDesc.iIdentitySubjectName[1] != 0x82)

                   && ((aDesc.iIdentitySubjectName[1] + 2) != aDesc.iIdentitySubjectName.Length())))

                    {

                    HBufC8* name2Der;

                    CPkcs10Req::BuildDistinguishedNameDerFromTextL(name2Der,

                                                                   aDesc.iIdentitySubjectName,

                                                                   EFalse, KNullDesC8);

                    CleanupStack::PushL(name2Der);

                    dnSuffix2 = CX500DistinguishedName::NewLC(*name2Der);

                    }

                else

                    {

                    dnSuffix2 = CX500DistinguishedName::NewLC(aDesc.iIdentitySubjectName);

                    popCount = 2;

                    }

                if(PkiUtil::MatchL(*dnSuffix1, *dnSuffix2))

                    {

                    CleanupStack::PopAndDestroy(popCount);

                    match = ETrue;

                    }

                else

                    {

                    CleanupStack::PopAndDestroy(popCount);

                    match = EFalse;

                    break;

                    }

                }

            }

        if(aDesc.iIdentityRfc822NameUsed)

            {

            if(iIdentityRfc822Name == NULL)

                {

                match = EFalse;

                break;

                }

            else

                {

                TInt bytes = aDesc.iIdentityRfc822Name.Length();

                TPtrC8 tail = (*iIdentityRfc822Name).Right(bytes);

                if (tail.CompareF(aDesc.iIdentityRfc822Name) == 0)

                    {

                    match = ETrue;

                    }

                else

                    {

                    match = EFalse;

                    break;

                    }

                }

            }

        if(aDesc.iKeyUsageUsed)

            {

            CX509KeyUsageExt* tempUsage = NULL;

            if(iKeyUsageDer.Length() != 0)

                {

                tempUsage = CX509KeyUsageExt::NewL(iKeyUsageDer);

                }

            if((tempUsage == NULL) || tempUsage->IsSet(aDesc.iKeyUsage))       

                {

                delete tempUsage;

                match = ETrue;

                }

            else

                {

                delete tempUsage;

                match = EFalse;

                break;

                }

            }

        if(aDesc.iKeySizeUsed)

            {

            if(iKeySize == aDesc.iKeySize)

                {

                match = ETrue;

                }

            else

                {

                match = EFalse;

                break;

                }

            }

        if (match && !aInfoOnly)

            {            

            TValidity  val = CPKIMapper::CertValidity(iStartTime, iEndTime);

            // Treat future certificates as valid

            if((val == EValid) || (val == ENotValidYet))

                {

                match = ETrue;

                }

            else

                {

                LOG_("Matching: Expired, and not an informational request");

                match = EFalse;

                break;

                }

            }

        break;

        }

    return match;

    }

TBool CMapDescriptor::IsEqual(CMapDescriptor &aDesc)

    {

    TBool match = EFalse;

    for(;;)

        {

        if((iTrustedAuthority != NULL) && (aDesc.iTrustedAuthority != NULL) && (iTrustedAuthority->Des().Compare(*aDesc.iTrustedAuthority) == 0))

            {

            match = ETrue;

            }

        else

            {

            match = EFalse;

            break;

            }

        if((iSerialNumber != NULL) && (aDesc.iSerialNumber != NULL) && (iSerialNumber->Des().Compare(*aDesc.iSerialNumber) == 0))

            {

                match = ETrue;

                }

            else

                {

                match = EFalse;

                break;

                }

        break;

        }

    return match;

    }

void CMapDescriptor::SetCertStoreType(TPkiServiceStoreType aCertStoreType)

    {

    iCertStoreType = aCertStoreType;

    }

CPKIMapper* CPKIMapper::NewL()

    {

    CPKIMapper* self = new (ELeave) CPKIMapper();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CPKIMapper::~CPKIMapper()

    {

    if ( iMapping )

        {

        iMapping->ResetAndDestroy();

        delete iMapping;

        }

    }

CPKIMapper::CPKIMapper()

    {

    }

void CPKIMapper::ConstructL()

    {

    LOG_("CPKIMapper::ConstructL");

    // Allocate mapping vector. Approx granularity 20 

    iMapping = new (ELeave) RPointerArray<CMapDescriptor>(20);

    }

void CPKIMapper::SetCacheCreated()

    {

    iCacheCreated = ETrue;

    }

TBool CPKIMapper::CacheCreated()

    {

    return iCacheCreated;

    }

TInt CPKIMapper::AddMapping(CMapDescriptor& aMap)

    {

    // Insert as first element, so that newest object will be found first

    return iMapping->Insert(&aMap, 0);

    }

void CPKIMapper::LogMap(CMapDescriptor &aDescriptor) const 

    {

    TInt len = aDescriptor.iSubjectKeyId.Length();

    LOG(Log::Printf(_L("====CertificateObject====\n")));

    LOG(Log::Printf(_L("ObjectName: %S\n"), &(aDescriptor.iObjectName)));

    LOG(Log::Printf(_L("KeyId:")));

    LOG(Log::HexDump(NULL, NULL, aDescriptor.iSubjectKeyId.Ptr(), len));

    }

void CPKIMapper::DeleteMapping(TInt aIndex)

    {

    // Delete mapping at index

    LOG(Log::Printf(_L("Delete mapping entry")));

    LogMap(*(*iMapping)[aIndex]);

    delete (*iMapping)[aIndex]; 

    iMapping->Remove(aIndex);

    iMapping->Compress();

    }

TInt CPKIMapper::DeleteMapping(CMapDescriptor &aDesc)

    {

    TInt status(KErrNotFound);

    for(TInt i(0); i < iMapping->Count(); i++)

        {

        if((*iMapping)[i]->IsEqual(aDesc))

            {

            DeleteMapping(i);

            status = KErrNone;

            break;

            }

        }

    return status;

    }

TInt CPKIMapper::CertCount()

    {

    TInt count(0);    

    for(TInt i(0); i < iMapping->Count(); i++)

        {

        CMapDescriptor* mapping = (*iMapping)[i];

        count++;

        if (CertValidity(mapping->iStartTime, mapping->iEndTime) == EExpired)

            {

            // do not count expider certificates

            count--;

            }                

        }

    iCount = count;

    return count;            

    }

TInt CPKIMapper::ApplicableCertCount(const RArray<TUid>& aUidArray)

{

    TInt count(0);

    TBool uidMatch(EFalse);

    for(TInt i(0); i < iMapping->Count(); i++)

        {

        CMapDescriptor* mapping = (*iMapping)[i];

        if(mapping->iOwnerType == EPKICACertificate)

            {

            if(CertValidity(mapping->iStartTime, mapping->iEndTime) != EExpired)

                {

                uidMatch = EFalse;

                for(TInt j = 0; j < mapping->iApplUids.Count(); j++)

                    {

                    for(TInt k = 0; k < aUidArray.Count(); k++)

                        {

                        if(mapping->iApplUids[j].iUid == aUidArray[k].iUid)

                            {

                            uidMatch = ETrue;

                            break;

                            }

                        }

                    if(uidMatch)

                        {

                        count++;

                        break;

                        }

                    }

                }

            }

        }

    iCount = count;

    return count;

}

TInt CPKIMapper::GetCertListL(const RMessage2 &aMessage, TPkiServiceStoreType aStoreType, 

                              TBool aDescUsed)

{

    TInt pos = 0;

    TInt iLast = 0;

    TInt iFirst = 0;

    if(aDescUsed)

        {

        aMessage.ReadL(1, iCurrentDescriptor);

        TSecurityObjectDescriptor& secDesc = iCurrentDescriptor();

        TInt status = ResolveCertMappingL(

            iCurrentDescriptor(), iObjectName, iFirst, EFalse, aStoreType);

        if(status == KErrNone)

            {

            iCount = 1;

            iLast = iFirst + 1;

            }

        }

    else

        {

        iLast = iMapping->Count();

        }

    CBufFlat* list = CBufFlat::NewL(sizeof(TCertificateListEntry));

    CleanupStack::PushL(list);

    list->ResizeL(iCount * sizeof(TCertificateListEntry));

    TCertificateListEntry certInfo;

    for(TInt i = iFirst; i < iLast; i++)

        {

        CMapDescriptor* mapping = (*iMapping)[i];