/*

* Copyright (c) 2003-2010 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:   PKI Service API

*

*/

#include <e32std.h>

#include <e32math.h>

#include "pkiserviceapi.h"

#include "clistatic.h"

#include "pkcs10.h"

#include "pkiserviceclientservercommon.h"

#include "pkisession.h"

#include <certificateapps.h>

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

 *

 * RPKIServiceAPI class constructor

 *

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

EXPORT_C RPKIServiceAPI::RPKIServiceAPI()

    {

    }

EXPORT_C TInt RPKIServiceAPI::Connect()

//

// Connect to the server attempting to start it if necessary

//

    {

    TInt retry=2;

    for (;;)

        {

        TInt r=CreateSession(KPkiServerName,

                             TVersion(KPkiMajorVersion,

                                      KPkiMinorVersion,

                                      KPkiBuildVersion),

                             KDefaultMessageSlots);

        if (r!=KErrNotFound && r!=KErrServerTerminated)

            {

            if (r == KErrNone)

                {

                r = SendReceive(PkiService::EInitialize,TIpcArgs(NULL));

                if (r != KErrNone)

                    {

                    RSessionBase::Close();

                    }

                }

            return r;

            }

        if (--retry==0)

            return r;

        r = Launcher::LaunchServer(KPkiServerName, KPkiServerImg,

                                   KPkiServiceUid3, KMyServerInitHeapSize,

                                   KMyServerMaxHeapSize, KMyServerStackSize);

        if (r!=KErrNone && r!=KErrAlreadyExists)

            return r;

        }

    }

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

 *

 * Logon(TRequestStatus& aRequestStatus)

 *

 * 

 *

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

EXPORT_C void RPKIServiceAPI::Logon(TRequestStatus& aRequestStatus)

    {

    SendReceive(PkiService::ELogon,TIpcArgs(NULL), aRequestStatus);

    }

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

* Lock keystore

* PIN code must be given again to unlock the keystore

*

* @param aRequestStatus [out] A reference to the request status object. On

* request completion, contains the return code of the request.

*

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

EXPORT_C void RPKIServiceAPI::Logoff(TRequestStatus& aRequestStatus)

	{

	SendReceive(PkiService::ELogoff,TIpcArgs(NULL), aRequestStatus);

	}

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

 *

 * ChangePassword(TRequestStatus& aRequestStatus)

 *

 * 

 *

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

EXPORT_C void RPKIServiceAPI::ChangePassword(TRequestStatus& aRequestStatus)

    {

    SendReceive(PkiService::EChangePassword,TIpcArgs(NULL), aRequestStatus);

    }

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

 *

 * SignL(const TDesC8& aKeyId, const TDesC8& aHashIn, TDes8& aSignature,

 *       TAny **aResourceObject, TRequestStatus& aRequestStatus)

 *

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

EXPORT_C TInt RPKIServiceAPI::Sign(const TPKIKeyIdentifier& aKeyId,

                                   const TDesC8& aHashIn,

                                   TDes8& aSignature) const

    {

    return SendReceive(PkiService::ESignWithKeyId, TIpcArgs(&aKeyId, &aHashIn, &aSignature));        

    }

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

 *

 * SignL(const TDesC8& aTrustedAuthority, const TPKICertificateOwnerType aOwnerType, const TPKIKeyUsage aKeyUsage,

 *      const TUint aKeySize, const TPKIKeyAlgorithm aKeyAlgorithm, const TDesC8& aHashIn, TDes8& aSignature, 

 *      TAny **aResourceObject, TRequestStatus& aRequestStatus)

 *

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

EXPORT_C TInt RPKIServiceAPI::Sign(const TDesC8& aTrustedAuthority,

                                   const TDesC8& aIdentitySubjectName,

                                   const TDesC8& aIdentityRfc822Name,

                                   const TPKIKeyUsage aKeyUsage,

                                   const TUint aKeySize,

                                   const TPKIKeyAlgorithm aKeyAlgorithm,

                                   const TDesC8& aHashIn,

                                   TDes8& aSignature) const    

    {

    TInt err = KErrNone;

    TSecurityObjectDescriptor *privateKeyDesc = new TSecurityObjectDescriptor;

    if (privateKeyDesc != NULL)

        {        

        privateKeyDesc->SetTrustedAuthority(aTrustedAuthority);

        privateKeyDesc->SetIdentitySubjectName(aIdentitySubjectName);

        privateKeyDesc->SetIdentityRfc822Name(aIdentityRfc822Name);

        privateKeyDesc->SetOwnerType(EPKIUserCertificate);  // Always user cert

        privateKeyDesc->SetKeyUsage(aKeyUsage);

        privateKeyDesc->SetKeySize(aKeySize);

        privateKeyDesc->SetKeyAlgorithm(aKeyAlgorithm);

        TPckg<TSecurityObjectDescriptor> pckgTSecurityObjectDescriptor(*privateKeyDesc);

        //Send request to the server

        err = SendReceive (PkiService::ESignWithCert, TIpcArgs(&pckgTSecurityObjectDescriptor, &aHashIn, &aSignature));

        delete privateKeyDesc;

        privateKeyDesc = NULL;

        }

    else

        {

        err = KErrNoMemory;

        }

    return err;        

    }

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

 *

 * TInt DecryptL(const TDesC8& aKeyId, const TDesC8& aDataIn, TDes8& aDataOut, 

 *      TAny **aResourceObject, TRequestStatus& aRequestStatus)

 *

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

EXPORT_C TInt RPKIServiceAPI::Decrypt(const TPKIKeyIdentifier& aKeyId,

                                      const TDesC8& aDataIn,

                                      TDes8& aDataOut) const

    {

    return SendReceive (PkiService::EDecrypt, TIpcArgs(&aKeyId, &aDataIn, &aDataOut));            

    }

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

 *

 * StoreKeypairL(TDesC8& aKeyId, const TUint aKeySize, const TPKIKeyAlgorithm aKeyAlgorithm,

 *               const TDesC8& aKeyDataIn, TBool aEncrypted, TRequestStatus& aRequestStatus)

 * 

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

EXPORT_C void RPKIServiceAPI::StoreKeypair(TPKIKeyIdentifier& aKeyId,

                                           const TDesC8& aKeyDataIn,

                                           TRequestStatus& aRequestStatus)

    {

    SendReceive (PkiService::EStoreKeypair, 

                 TIpcArgs(&aKeyId, &aKeyDataIn), 

                 aRequestStatus);

    }

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

 *

 * GenerateKeypairL(TDesC8& aKeyId, const TUint aKeySize, const TPKIKeyAlgorithm aKeyAlgorithm, 

 *                  TRequestStatus& requestStatus)

 * 

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

EXPORT_C void RPKIServiceAPI::GenerateKeypair(TPKIKeyIdentifier& aKeyId,

                                               const TUint aKeySize,

                                               const TPKIKeyAlgorithm aKeyAlgorithm,

                                               TRequestStatus& aRequestStatus)

    {

    __ASSERT_DEBUG(aKeyAlgorithm == EPKIRSA || aKeyAlgorithm == EPKIDSA, User::Invariant());

    SendReceive (PkiService::EGenerateKeypair, 

                 TIpcArgs(&aKeyId, aKeySize, static_cast<TUint>(aKeyAlgorithm)), 

                 aRequestStatus);   

    }

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

 *

 * CancelPendingOperation() 

 * 

 *

 * Returns: 

 *

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

EXPORT_C TInt RPKIServiceAPI::CancelPendingOperation()

    {

    //Send request to the server

    return SendReceive (PkiService::ECancelPendingOperation, TIpcArgs(NULL));            

    }

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

 *

 * GetRequiredBufferSize 

 * 

 *

 * Returns: 

 *

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

EXPORT_C TInt RPKIServiceAPI::GetRequiredBufferSize(TInt &aSize)

    {

    TInt size;

    TPckg<TInt> pckgSize(size);

    TInt ret = SendReceive (PkiService::EGetRequiredBufferSize, TIpcArgs(&pckgSize));

    aSize = size;

    return ret;

    }

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

 *

 * ReadPublicKeyL(const TDesC8& aKeyId, TDes8& aDataOut)

 *

 *

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

EXPORT_C TInt RPKIServiceAPI::ReadPublicKey(const TPKIKeyIdentifier& aKeyId,

                                            TDes8& aDataOut) const

    {        

    return  SendReceive (PkiService::EReadPublicKey, 

                         TIpcArgs(&aKeyId, &aDataOut));                                 

    }

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

 *

 * ReadCertificateL(const TDesC8& aTrustedAuthority, const TPKICertificateOwnerType aOwnerType, const TPKIKeyUsage aKeyUsage,

 *                   const TUint aKeySize, const TPKIKeyAlgorithm aKeyAlgorithm, HBufC8 *&aCert)

 * 

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

EXPORT_C void RPKIServiceAPI::ReadCertificateL(const TDesC8& aTrustedAuthority,

                                               const TDesC8& aIdentitySubjectName,

                                               const TDesC8& aIdentityRfc822Name,

                                               const TPKICertificateOwnerType aOwnerType,

                                               const TUint aKeySize,

                                               const TPKIKeyAlgorithm aKeyAlgorithm,

                                               TDes8 &aCert,

                                               TAny **aResourceObject,

                                               TRequestStatus& aRequestStatus)

    {

    TPckgBuf<TSecurityObjectDescriptor> *pckgTSecurityObjectDescriptor = new (ELeave) TPckgBuf<TSecurityObjectDescriptor>();

    CleanupStack::PushL(pckgTSecurityObjectDescriptor);

    TSecurityObjectDescriptor& certDesc = (*pckgTSecurityObjectDescriptor)();

    if (aTrustedAuthority.Length() > 0)

        {

        certDesc.SetTrustedAuthority(aTrustedAuthority);    

        }

    if (aIdentitySubjectName.Length() > 0)

        {

        certDesc.SetIdentitySubjectName(aIdentitySubjectName);

        }

    if (aIdentityRfc822Name.Length() > 0)

        {

        certDesc.SetIdentityRfc822Name(aIdentityRfc822Name);

        }

    if (aKeySize != 0)

        {

        certDesc.SetKeySize(aKeySize);

        }

    if(aOwnerType != EPKICACertificate)

        {

        certDesc.SetKeyUsage(EX509DigitalSignature);                        

        certDesc.SetKeyAlgorithm(aKeyAlgorithm);

        }

    certDesc.SetOwnerType(aOwnerType);

    //Send request to the server

    SendReceive (PkiService::EReadCertificate, TIpcArgs(pckgTSecurityObjectDescriptor, &aCert), aRequestStatus);            

    CleanupStack::Pop();

    *aResourceObject = pckgTSecurityObjectDescriptor;

    }

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

 *

 * ReadCertificateL

 *

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

EXPORT_C TInt RPKIServiceAPI::ReadCertificate(const TDesC8& aTrustedAuthority,

                                               const TDesC8& aSerialNumber,

                                               TDes8 &aCert)

{

    TInt err = KErrNone;

    TSecurityObjectDescriptor *certDesc = new TSecurityObjectDescriptor;

    if (certDesc != NULL)

        {        

        certDesc->SetTrustedAuthority(aTrustedAuthority);

        certDesc->SetSerialNumber(aSerialNumber);

        TPckg<TSecurityObjectDescriptor> pckgTSecurityObjectDescriptor(*certDesc);

        //Send request to the server

        err = SendReceive (PkiService::EReadCertificate, TIpcArgs(&pckgTSecurityObjectDescriptor, 

                                                                   &aCert));                   

        delete certDesc;

        }

    else

        {

        err = KErrNoMemory;

        }

    return err;

}

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

* Read a certificate having listed characteristics

* @param aKeyId SubjectKeyID.

* @param aCert [out] Returned ASN1 encoded certificate.

* @param aResourceObject [out] This returned object must be given as a parameter in the Finalize call when this function has completed.

* @param aRequestStatus [out] A reference to the request status object. On

* request completion, contains the return code of the request.

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

EXPORT_C void RPKIServiceAPI::ReadCertificateL(const TPKIKeyIdentifier& aKeyId,

                                                TDes8 &aCert,

                                                TAny **aResourceObject,

                                                TRequestStatus& aRequestStatus)

{

    TPckgBuf<TSecurityObjectDescriptor> *pckgTSecurityObjectDescriptor = new (ELeave) TPckgBuf<TSecurityObjectDescriptor>();

    CleanupStack::PushL(pckgTSecurityObjectDescriptor);

    TSecurityObjectDescriptor& certDesc = (*pckgTSecurityObjectDescriptor)();

    certDesc.SetSubjectKeyId(aKeyId);

    //Send request to the server

    SendReceive (PkiService::EReadCertificate, TIpcArgs(pckgTSecurityObjectDescriptor, &aCert), aRequestStatus);            

    CleanupStack::Pop();

    *aResourceObject = pckgTSecurityObjectDescriptor;

}

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

 *

 * ListCertificatesL

 *

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

EXPORT_C void RPKIServiceAPI::ListCertificatesL(CArrayFix<TCertificateListEntry> *&aCertList)

{

	TInt certCount = SendReceive(PkiService::ECertCount, TIpcArgs(NULL));

	TInt certListGranularity = certCount;

	if (certListGranularity == 0)

		{

		certListGranularity = 1;

		}

	CArrayFix<TCertificateListEntry>* certList;	

	certList = new (ELeave) CArrayFixFlat<TCertificateListEntry>(certListGranularity);

	if (certCount == 0)

		{

		aCertList = certList;

		return;

		}

	CleanupStack::PushL(certList);

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

	CleanupStack::PushL(list);

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

	TPtr8 ptrList = list->Ptr(0);

	User::LeaveIfError(SendReceive (PkiService::EGetCertList, TIpcArgs(&ptrList)));

	for (TInt i = 0; i < certCount; i++)

		{

		}

	CleanupStack::Pop();                // certList

	aCertList = certList;

}

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

* List CA certificates applicable for all requested applications  

* @param aApplications List of applications

* @param aCertList [out] Returned list of certificates.

* @param aRequestStatus [out] A reference to the request status object. On

* request completion, contains the return code of the request.

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

EXPORT_C void RPKIServiceAPI::ListApplicableCertificatesL(const RArray<TUid>& aApplications,

										  CArrayFix<TCertificateListEntry>*& aCertList)

{

	TPckgC<TInt> applCount(aApplications.Count());

	// Allocate a buffer for the application uid list

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

	CleanupStack::PushL(applList);

	applList->ResizeL(aApplications.Count() * sizeof(TUid));

	TInt i = 0;

	for(i=0;i<aApplications.Count();i++)

		{

		applList->Write(i * sizeof(TUid), (TAny*)&(aApplications[i]), sizeof(TUid));

		}

	// Application Uid list

	TPtr8 ptrList = applList->Ptr(0);

	TInt certCount = SendReceive(PkiService::EApplicableCertCount, TIpcArgs(&applCount, &ptrList));

	CleanupStack::PopAndDestroy(1);     // applList

	TInt certListGranularity = certCount;

	if (certListGranularity == 0)

		{

		certListGranularity = 1;

		}

	CArrayFix<TCertificateListEntry>* certList;	

	certList = new (ELeave) CArrayFixFlat<TCertificateListEntry>(certListGranularity);

	if (certCount == 0)

		{

		aCertList = certList;

		return;

		}

	CleanupStack::PushL(certList);

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

	CleanupStack::PushL(list);

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

	TPtr8 ptrList2 = list->Ptr(0);

	User::LeaveIfError(SendReceive (PkiService::EGetApplicableCertList, TIpcArgs(&ptrList2)));

	for (i = 0; i < certCount; i++)

		{

		}

	CleanupStack::Pop();                // certList

	aCertList = certList;

}

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

 *

 * ListKeysL

 *

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

EXPORT_C void RPKIServiceAPI::ListKeysL(CArrayFix<TKeyListEntry> *&aKeyList)

{

    TInt keyCount = SendReceive(PkiService::EKeyCount, TIpcArgs(NULL));

    User::LeaveIfError(keyCount);

    TInt keyListGranularity = keyCount;

    if (keyListGranularity == 0)

        {

        keyListGranularity = 1;

        }

    CArrayFix<TKeyListEntry>* keyList;	

    keyList = new (ELeave) CArrayFixFlat<TKeyListEntry>(keyListGranularity);

    if (keyCount == 0)

        {

        aKeyList = keyList;

        return;

        }