/*

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

* A class wrapping symbian certificate storage for use by PKI service clients.

*

*/

#include <x509cert.h>

#include "pkiwrapper.h"

#include "PKIMapper.h"

#include "pkisession.h"

#include "pkisupport.h"

#include "log_r6.h"

CPKIWrapper* CPKIWrapper::NewL(CPKIMapper& aMapper)

    {

    CPKIWrapper* self = new (ELeave) CPKIWrapper(aMapper);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CPKIWrapper::~CPKIWrapper()

    {

    LOG_("-> CPKIWrapper::~CPKIWrapper()");

    Cancel();

    delete iCurrentMapping;

    delete iObjectName;

    delete iCertBuffer;

    iUidArray.Close();

    delete iPKISupport;    

    LOG_("<- CPKIWrapper::~CPKIWrapper()");

    }

CPKIWrapper::CPKIWrapper(CPKIMapper& aMapper)

    :CActive(CActive::EPriorityStandard), 

    iMapper(aMapper),

    iPtrCertBuffer(0,0)

    {

    CActiveScheduler::Add(this);

    }

void CPKIWrapper::ConstructL()

    {

    LOG_("-> CPKIWrapper::ConstructL()");   

    iObjectName = new (ELeave) TBuf<MAX_FILENAME_LENGTH>;

    iPKISupport = CPKISupport::NewL(iMapper, *this);

    SetCertStoreType(EPkiStoreTypeAny);

    SetInformational(EFalse);

    LOG_("<- CPKIWrapper::ConstructL()");

    }

//====================================================================================================================================    

/**

*   Initialize

*/

//====================================================================================================================================    

void CPKIWrapper::InitializeL(const RMessage2& aMessage)

{

    LOG_("CPKIWrapper::InitializeL()");    

    iPKISupport->StartInitializeL(aMessage);    

}

//====================================================================================================================================    

/**

*   Initialization routine

*/

//====================================================================================================================================    

TInt CPKIWrapper::InitOperation(const RMessage2& aMessage)

{

    if (IsActive())

        {

        LOG(Log::Printf(_L("Pkiservice busy. Function %d\n"), aMessage.Function()));

        return KPKIErrServiceBusy;

        }

    LOG(Log::Printf(_L("InitOperation function %d\n"), aMessage.Function()));

    iCurrentStatus = KErrNone;              // Clear status

    iCurrentState = EExecute;               // Set state

    iMessage = aMessage;                    // Save message

    iPKISupport->SetCurrentFunction(iMessage.Function());

    iIndex = KErrNotFound;

    // Trigger function

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

    return KErrNone;

}

/**---------------------------------------------------------

 *

 * CancelPendingOperation

 *

 *----------------------------------------------------------*/

void CPKIWrapper::CancelPendingOperation()

{

    Cancel();

    delete iCertBuffer;

    iCertBuffer = NULL;

}

/**---------------------------------------------------------

 *

 * GetRequiredBufferSize

 *

 *----------------------------------------------------------*/

TInt CPKIWrapper::GetRequiredBufferSizeL(const RMessage2& aMessage)

{

    iCurrentStatus = KErrNone;                      // Clear status

    LOG(Log::Printf(_L("Start Function %d\n"), iMessage.Function()));

    iMessage = aMessage;                            // Save message

    CompleteRequestAndCleanupL();

    return iCurrentStatus;

}

//====================================================================================================================================    

/**

*   Starter routines

*/

//====================================================================================================================================    

void CPKIWrapper::SetTrusted(TBool aValue)

{

    iTrusted = aValue;

}

void CPKIWrapper::SetApplications(const RArray<TUid>& aApplUids)

{

    iUidArray.Close();

	for(TInt i=0;i<aApplUids.Count();i++)

		{

		iUidArray.Append(aApplUids[i]);

		}

}

/**---------------------------------------------------------

 *

 * StartReadCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartReadCertificateL()

    {

    LOG(Log::Printf(_L("StartReadCertificate\n")));

    iMessage.ReadL(0, iCurrentDescriptor);

    TInt outDataSize = iMessage.GetDesMaxLength(1);

    iCertBuffer = HBufC8::NewL(outDataSize);

    iPtrCertBuffer.Set(iCertBuffer->Des()); // A pointer for changing the contents of buf

    }

/**---------------------------------------------------------

 *

 * StartStoreCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartStoreCertificateL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    iObjectName->Copy(iCurrentDescriptor().iObjectName);

    TInt inDataSize = iMessage.GetDesLength(1);

    iCertBuffer = HBufC8::NewL(inDataSize);

    iPtrCertBuffer.Set(iCertBuffer->Des()); // A pointer for changing the contents of buf

    iMessage.ReadL(1, iPtrCertBuffer); 

    }

/**---------------------------------------------------------

 *

 * StartAttachCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartAttachCertificateL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    iObjectName->Copy(iCurrentDescriptor().iObjectName);

    TInt inDataSize = iMessage.GetDesLength(1);

    iCertBuffer = HBufC8::NewL(inDataSize);

    iPtrCertBuffer.Set(iCertBuffer->Des()); // A pointer for changing the contents of buf

    iMessage.ReadL(1, iPtrCertBuffer); 

    }

/**---------------------------------------------------------

 *

 * StartRemoveCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartRemoveCertificateL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    }

/**---------------------------------------------------------

 *

 * StartSetTrustL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartSetTrustL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    TPckg<TBool> pckgTrusted(iTrusted);

    iMessage.ReadL(1, pckgTrusted, 0);

    }

/**---------------------------------------------------------

 *

 * StartTrustedL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartTrustedL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    }

/**---------------------------------------------------------

 *

 * StartSetApplicabilityL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartSetApplicabilityL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    TPckg<TUint> pckgCount(iCount);

    iMessage.ReadL(1, pckgCount);

    // Allocate list for applications

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

    CleanupStack::PushL(list);

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

    TPtr8 ptrList = list->Ptr(0);

    iMessage.ReadL(2, ptrList);

    iUidArray.Close();

    if(iCount > 0)

        {

        TUid tempUid;

        for (TUint i = 0; i < iCount; i++)

            {

            list->Read(i * sizeof(TUid), (TAny*)&tempUid, sizeof(TUid));

            iUidArray.Append(tempUid);

            }

        }

    CleanupStack::PopAndDestroy(1);     // list

    }

/**---------------------------------------------------------

 *

 * StartApplicationsL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::StartApplicationsL()

    {

    iMessage.ReadL(0, iCurrentDescriptor);

    TPckg<TUint> pckgCount(iMaxCount);

    iMessage.ReadL(1, pckgCount);

    }

//====================================================================================================================================    

/**

*   Continuation routines

*   Activate active object if necessary

*/

//====================================================================================================================================        

/**---------------------------------------------------------

 *

 * ExecuteReadCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteReadCertificateL()

    {

    TInt index;

    LOG(Log::Printf(_L("CPKIWrapper::ExecuteReadCertificateL()\n")));

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), *iObjectName, 

                                                           index, iInfoOnly, 

                                                           iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        TSecurityObjectDescriptor sdesc = iCurrentDescriptor();

        iCurrentState = EComplete;

        iPKISupport->RetrieveCertificateL(*iObjectName, iPtrCertBuffer, sdesc.iOwnerType, iStatus);

        SetActive();

        }

    LOG_1("CPKIWrapper::ExecuteReadCertificateL() exit:%d", iCurrentStatus);

    }

/**---------------------------------------------------------

 *

 * ExecuteStoreCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteStoreCertificateL()

    {

    LOG(Log::Printf(_L("CPKIWrapper::ExecuteStoreCertificateL()\n")));

    if (iPtrCertBuffer.Length() > 0) 

        {

        // See whether the certificate already exists in the store

        TBool certIsNew = iMapper.CertificateIsUniqueL(

            iPtrCertBuffer);

        if (certIsNew)

            {

            LOG(Log::Printf(_L("Creating new certificate entry\n")));

            delete iCurrentMapping;

            iCurrentMapping = NULL;

            iCurrentMapping = new (ELeave) CMapDescriptor(iCurrentDescriptor());

            iMapper.GenerateUniqueNameL(iPtrCertBuffer, *iObjectName);

            iCurrentMapping->SetMapObjectName(*iObjectName);

            SaveIdentityL(*iCurrentMapping, iPtrCertBuffer, (TCertificateOwnerType)iCurrentDescriptor().iOwnerType);

            TPkiServiceStoreType storeType = iPKISupport->CertStoreType();

            if (storeType == EPkiStoreTypeAny)

                {

                storeType = EPkiStoreTypeUser;

                }

            iCurrentMapping->SetCertStoreType(storeType);

            if(iCurrentStatus == KErrNone)

                {

                LOG(Log::Printf(_L("Status OK, identity saved\n")));

                iCurrentStatus = KErrNone;

                iCurrentState = EComplete;

                LOG(Log::Printf(_L("Storing CERT with LABEL:")));

                LOG(Log::Printf(iCurrentMapping->iObjectName));

                iPKISupport->StoreCertificateL(iCurrentMapping->iObjectName, 

                    (TCertificateOwnerType)iCurrentDescriptor().iOwnerType, 

                    iPtrCertBuffer, iCurrentDescriptor().iIsDeletable, iStatus);

                LOG(Log::Printf(_L("CERT stored\n")));

                SetActive();

                }

            }

        else 

            {

            // Identical certificate already existed, no need to add this one.

            // Set current status to KErrBadName so that the operations can

            // continue (any other error would halt the process)

            LOG(Log::Printf(_L("Certificate already exists, not adding")));

            iCurrentStatus = KErrBadName;

            }

        }

    else 

        {

        LOG(Log::Printf(_L("Certificate buffer invalid")));

        iCurrentStatus = KErrGeneral;

        }

    }

/**---------------------------------------------------------

 *

 * ExecuteAttachCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteAttachCertificateL()

    {

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

    iMapper.GenerateUniqueNameL(iPtrCertBuffer, *iObjectName, EUserCertificate);

    delete iCurrentMapping;

    iCurrentMapping = NULL;

    iCurrentMapping = new (ELeave) CMapDescriptor(iCurrentDescriptor());

    iCurrentMapping->SetMapObjectName(*iObjectName);

    SaveIdentityL(*iCurrentMapping, iPtrCertBuffer, (TCertificateOwnerType)iCurrentDescriptor().iOwnerType);

    TPkiServiceStoreType storeType = iPKISupport->CertStoreType();

    if (storeType == EPkiStoreTypeAny)

        {

        storeType = EPkiStoreTypeUser;

        }

    iCurrentMapping->SetCertStoreType(storeType);

    if(iCurrentStatus == KErrNone)

        {

        iCurrentStatus = KErrNone;

        iCurrentState = EComplete;

        LOG(Log::Printf(_L("Attaching certificate")));

        LOG(Log::Printf(iCurrentMapping->iObjectName));

        iPKISupport->AttachCertificateL(iCurrentMapping->iObjectName, iCurrentDescriptor().iSubjectKeyId, iPtrCertBuffer, iStatus);

        LOG(Log::Printf(_L("Certificate attached")));

        SetActive();

        }

    }

/**---------------------------------------------------------

 *

 * ExecuteRemoveCertificateL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteRemoveCertificateL()

    {

    TInt index;

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), 

                                        *iObjectName, index, iInfoOnly,

                                        iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        delete iCurrentMapping;

        iCurrentMapping = NULL;

        iCurrentMapping = new (ELeave) CMapDescriptor(iCurrentDescriptor());

        *iCurrentMapping = iMapper.GetMapDescriptorAtIndex(index);

        iCurrentState = EComplete;

        iPKISupport->RemoveCertificateL(*iObjectName, iStatus);

        SetActive();

        }

    }

/**---------------------------------------------------------

 *

 * ExecuteSetTrustL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteSetTrustL()

    {

    TInt index;

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), *iObjectName, 

                                                           index, iInfoOnly, 

                                                           iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        const CMapDescriptor& mapping = iMapper.GetMapDescriptorAtIndex(index);

        if (mapping.iOwnerType == EPKICACertificate)

            {            

            iCurrentState = EComplete;

            iPKISupport->SetTrustL(*iObjectName, iTrusted, iStatus);

            SetActive();

            }

        else

            {

            iCurrentStatus = KErrArgument;

            }

        }

    }

/**---------------------------------------------------------

 *

 * ExecuteTrustedL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteTrustedL()

    {

    TInt index;

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), *iObjectName, 

                                                            index, iInfoOnly,

                                                            iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        iCurrentState = EComplete;

        iPKISupport->TrustedL(*iObjectName, iStatus);

        SetActive();

        }

    }

/**---------------------------------------------------------

 *

 * ExecuteSetApplicabilityL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteSetApplicabilityL()

    {

    TInt index(KErrNotFound);

    iCurrentStatus = iMapper.ResolveCertMappingL(

        iCurrentDescriptor(), *iObjectName, 

        index, iInfoOnly,

        iPKISupport->CertStoreType());

	// Save index

	iIndex = index;

    if(iCurrentStatus == KErrNone)

        {

        LOG_1("ExecuteSetApplicabilityL:%d", iIndex);

        iCurrentState = EComplete;

        iPKISupport->SetApplicabilityL(*iObjectName, iUidArray, iStatus);

        SetActive();

        }

    }

/**---------------------------------------------------------

 *

 * ExecuteApplicationsL

 *

 *----------------------------------------------------------*/

void CPKIWrapper::ExecuteApplicationsL()

{

    TInt index;

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), *iObjectName, 

                                                           index, iInfoOnly,

                                                           iPKISupport->CertStoreType());

    iUidArray.Close();

    if(iCurrentStatus == KErrNone)

        {

        iCurrentState = EComplete;

        iPKISupport->ApplicationsL(*iObjectName, iStatus);