/*

* 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 "mapdescriptor.h"

#include "pkisession.h"

#include "pkisupport.h"

#include "pkiserviceassert.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 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

*/

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

void CPKIWrapper::InitOperation(const RMessage2& aMessage)

{

    if (iMessage.Handle() != 0)

        {

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

        aMessage.Complete(KPKIErrServiceBusy);

        }

    else

        {

        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);

        }

}

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

 *

 * 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;

}

{

    iUidArray.Close();

	for(TInt i=0;i<aApplUids.Count();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));

            }

        }

    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)

        {

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

        iCurrentState = EComplete;

        iPKISupport->RetrieveCertificateL(mapping.Label(),

                                          iPtrCertBuffer, mapping.OwnerType(), 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")));

            iMapper.GenerateUniqueNameL(iPtrCertBuffer, *iObjectName);

            TPkiServiceStoreType storeType = iPKISupport->CertStoreType();

            if (storeType == EPkiStoreTypeAny)

                {

                storeType = EPkiStoreTypeUser;

                }

            CX509Certificate* certificate = CX509Certificate::NewLC(iPtrCertBuffer);  

            PKISERVICE_ASSERT(iCurrentMapping == NULL);

            CMapDescriptor* newMapping = CMapDescriptor::NewL(*iObjectName,

                                                              *certificate,

                                                              iCurrentDescriptor().iOwnerType,

                                                              storeType);  

            CleanupStack::PushL(newMapping);            

            newMapping->SetMapDeletable(iCurrentDescriptor().iIsDeletable);            

            iCurrentStatus = KErrNone;

            iCurrentState = EComplete;

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

            LOG(Log::Printf(*iObjectName));

            iPKISupport->StoreCertificateL(*iObjectName, 

                (TCertificateOwnerType)iCurrentDescriptor().iOwnerType, 

                iPtrCertBuffer, iCurrentDescriptor().iIsDeletable, iStatus);

            iCurrentMapping = newMapping;

            CleanupStack::Pop(newMapping);

            CleanupStack::PopAndDestroy(certificate);

            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);

    TPkiServiceStoreType storeType = iPKISupport->CertStoreType();

    if (storeType == EPkiStoreTypeAny)

        {

        storeType = EPkiStoreTypeUser;

        }  

    PKISERVICE_ASSERT(iCurrentMapping == NULL);

    CX509Certificate* certificate = CX509Certificate::NewLC(iPtrCertBuffer);  

    CMapDescriptor* newMapping = CMapDescriptor::NewL(*iObjectName,

                                                      *certificate,

                                                      iCurrentDescriptor().iOwnerType,

                                                      storeType);  

    CleanupStack::PushL(newMapping);            

    newMapping->SetMapDeletable(iCurrentDescriptor().iIsDeletable);

    iCurrentStatus = KErrNone;

    iCurrentState = EComplete;

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

    LOG(Log::Printf(*iObjectName));

    iPKISupport->AttachCertificateL(*iObjectName, iPtrCertBuffer, iStatus);

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

    iCurrentMapping = newMapping;

    CleanupStack::Pop(newMapping);                 

    CleanupStack::PopAndDestroy(certificate);

    SetActive();

    }

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

 *

 * ExecuteRemoveCertificateL

 *

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

void CPKIWrapper::ExecuteRemoveCertificateL()

    {

    TInt index;

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), 

                                        *iObjectName, index, iInfoOnly,

                                        iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        iMapper.DeleteMapping(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.OwnerType() == 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);