/*

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

*/

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

{

        {

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

        }

}

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

 *

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

    if(iCurrentStatus == KErrNone)

        {

        iCurrentState = EComplete;

        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;

                }

            }

        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;

    }

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

 *

 * ExecuteRemoveCertificateL

 *

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

void CPKIWrapper::ExecuteRemoveCertificateL()

    {

    TInt index;

    iCurrentStatus = iMapper.ResolveCertMappingL(iCurrentDescriptor(), 

                                        *iObjectName, index, iInfoOnly,

                                        iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        iCurrentState = EComplete;

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

            {            

            iCurrentState = EComplete;

            SetActive();

            }

        else

            {

            iCurrentStatus = KErrArgument;

            }

        }

    }

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

 *

 * ExecuteTrustedL

 *

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

void CPKIWrapper::ExecuteTrustedL()

    {

    TInt index;

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

                                                            index, iInfoOnly,

                                                            iPKISupport->CertStoreType());

    if(iCurrentStatus == KErrNone)

        {

        iCurrentState = EComplete;

        SetActive();

        }

    }

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

 *

 * ExecuteSetApplicabilityL

 *

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

void CPKIWrapper::ExecuteSetApplicabilityL()

    {

    TInt index(KErrNotFound);

	// Save index