diff -r f5050f1da672 -r 04becd199f91 javacommons/security/javaunicertstoreplugin/src.s60/javacertstoreimpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/security/javaunicertstoreplugin/src.s60/javacertstoreimpl.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,948 @@
+/*
+* Copyright (c) 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:
+*
+*/
+
+#include <e32std.h>
+#include <memory>
+
+#ifndef RD_JAVA_S60_RELEASE_5_0_IAD
+#include <javausermessages.rsg>
+#endif
+
+#include <avkon.rsg>
+#include <AknGlobalConfirmationQuery.h>
+#include <stringresourcereader.h>
+#include <StringLoader.h>
+#include <data_caging_path_literals.hrh>
+
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <securitydefs.h>
+#else
+#include <securitydefs.h>
+#include <securitydefsconst.h>
+#endif
+
+#include "javacertstoreimpl.h"
+#include "javacertstoretoken.h"
+#include "logger.h"
+#include "javasymbianoslayer.h"
+#include "comms.h"
+#include "javacertstoretoken.h"
+#include "javacommonutils.h"
+#include "s60commonutils.h"
+#include "securitycommsmessagedefs.h"
+
+
+
+//_LIT(KMIDP2TrustRoot, "J2ME MIDP2 Trust Root");
+_LIT(KMIDP2TrustRoot, "Java Trust Root");
+#ifndef RD_JAVA_S60_RELEASE_5_0_IAD
+_LIT(KJavaUserMessagesResourceFileName, "javausermessages.rsc");
+#endif
+//_LIT( KRuntimeSecPolicyResourceFileName, "z:midp2runtimesecuritypolicy.rsc" );
+
+//const TUid KCertManUIViewTrustJavaInstallingId = { 0x101F9B28 };
+//const TUid KCertManUIViewTrustJavaInstallingId = { KMidletInstallApplicabilityUi };
+
+using namespace java::security;
+using namespace java::comms;
+
+/**
+ *
+ */
+CJavaCertStoreImpl::CJavaCertStoreImpl(CJavaCertStoreToken& aToken)
+        : CActive(EPriorityNormal),mToken(aToken),mClientStatus(NULL),mState(EInitial),mQuery(0),mTempCertData(0)
+{
+}
+
+/**
+ *
+ */
+CJavaCertStoreImpl::~CJavaCertStoreImpl()
+{
+
+    if (IsActive())
+    {
+        Cancel();
+    }
+
+    mComms.unregisterListener(PLUGIN_ID_JAVA_CERT_STORE_ECOM_C,this);
+    mComms.unregisterDefaultListener(this);
+    mComms.disconnect();
+    mCertsData.ResetAndDestroy();
+    mUiThread.Close();
+}
+
+/**
+ *
+ */
+CJavaCertStoreImpl* CJavaCertStoreImpl::NewL(CJavaCertStoreToken& aToken)
+{
+    CJavaCertStoreImpl* impl = new(ELeave) CJavaCertStoreImpl(aToken);
+    CleanupStack::PushL(impl);
+    impl->ConstructL();
+    CleanupStack::Pop(impl);
+    return impl;
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::ConstructL()
+{
+
+    CActiveScheduler::Add(this);
+
+    int err = mComms.registerDefaultListener(this);
+    if (0 != err)
+    {
+        std::string errTxt("Registering comms listener failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(err));
+        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());
+        User::Leave(KErrCouldNotConnect);
+    }
+    err = mComms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    if (0 != err)
+    {
+        std::string errTxt("Comms connection failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(err));
+        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());
+        User::Leave(KErrCouldNotConnect);
+    }
+    err = mUiThread.Open(RThread().Id());
+    if (KErrNone != err)
+    {
+        std::string errTxt("Initialization of thread failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(err));
+        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());
+        User::Leave(err);
+    }
+}
+
+/**
+ *
+ */
+MCTToken& CJavaCertStoreImpl::Token()
+{
+    return mToken;
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::processMessage(java::comms::CommsMessage& aMessage)
+{
+    //Request has been cancelled if it is not active anymore.
+    if (!IsActive())
+        return;
+    mReceivedCommsMsg = aMessage;
+    //ActiveScheduler calls RunL() operation after request has been completed.
+    TRequestStatus* stat = &iStatus;
+    mUiThread.RequestComplete(stat,KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::RunL()
+{
+    TInt status = iStatus.Int();
+
+    switch (mState)
+    {
+    case EListing:
+        mState = EInitial;
+        //In current implementation status cannot be any than KErrNone
+        //in this state.
+        if (KErrNone == status)
+        {
+            FillCertificateInfos(*mClientList);
+        }
+        break;
+
+    case EPreDisabling:
+        SendDisableMsg(status);
+        return;
+
+    default:
+        //Do nothing.
+        break;
+    }
+
+    User::RequestComplete(mClientStatus,status);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::DoCancel()
+{
+    if (IsActive() && mClientStatus)
+    {
+        User::RequestComplete(mClientStatus,KErrCancel);
+    }
+}
+
+/**
+ *
+ */
+TInt CJavaCertStoreImpl::RunError(TInt /*aError*/)
+{
+    return KErrNone;
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::Add(const TDesC& /*aLabel*/, TCertificateFormat,
+                             TCertificateOwnerType,
+                             const TKeyIdentifier* /*aSubjectKeyId*/,
+                             const TKeyIdentifier* /*aIssuerKeyId*/,
+                             const TDesC8& /*aCert*/, TRequestStatus& aStatus)
+{
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+    User::RequestComplete(pRequestStatus,KErrNotSupported);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelAdd()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::Remove(const CCTCertInfo& aCertInfo,TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);
+    if (!flag)
+    {
+        return;
+    }
+
+    CJavaCertData* certData = 0;
+    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);
+    if (!flag)
+    {
+        return;
+    }
+
+    if (!certData->mCanDelete)
+    {
+        User::RequestComplete(pRequestStatus,KErrArgument);
+        return;
+    }
+
+    CommsMessage commsMsg;
+    commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);
+    commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);
+    commsMsg << JAVA_CERT_STORE_OPERATION_DELETE_CERT;
+    commsMsg << certData->mId;
+    int err = mComms.send(commsMsg);
+    if (0 != err)
+    {
+        std::string errTxt("Sending a comms request failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(err));
+        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());
+        User::RequestComplete(pRequestStatus,KErrCommsBreak);
+    }
+    certData->mDeleted = ETrue;
+    User::RequestComplete(pRequestStatus,KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelRemove()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::SetApplicability(const CCTCertInfo& aCertInfo,
+        const RArray<TUid>& aApplications,
+        TRequestStatus &aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);
+    if (!flag)
+    {
+        return;
+    }
+
+    TState state = EPreDisabling;
+    for (TInt i = 0; i < aApplications.Count(); i++)
+    {
+        if (KMidletInstallApplicabilityUid == aApplications[i])
+        {
+            state = EPreEnabling;
+            break;
+        }
+    }
+
+    CJavaCertData* certData = 0;
+    //GetCertDataObj() operation checks whether cert is deleted.
+    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);
+    if (!flag)
+    {
+        return;
+    }
+
+    if ((EPreDisabling == state) && (!certData->mCanDisable))
+    {
+        User::RequestComplete(pRequestStatus,KErrArgument);
+        return;
+    }
+
+    if (EPreDisabling == state)
+    {
+//RD_JAVA_S60_RELEASE_5_0_IAD flag is needed because otherwise "disable cert" confirmation
+//prompt is shown twice. First time by unicertstore plugin of legacy java and second
+//time by unicertstore plugin of OMJ.
+#ifdef RD_JAVA_S60_RELEASE_5_0_IAD
+        HandleSendingEnableDisableMsg(pRequestStatus,EPreDisabling,*certData);
+#else
+        mState = state;
+        mTempCertData = certData;
+        HandleDisableQuery(aStatus);
+#endif
+        return;
+    }
+    HandleSendingEnableDisableMsg(pRequestStatus,EPreEnabling,*certData);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelSetApplicability()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::SetTrust(const CCTCertInfo& aCertInfo, TBool aTrusted,
+                                  TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);
+    if (!flag)
+    {
+        return;
+    }
+
+    CJavaCertData* certData = 0;
+    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);
+    if (!flag)
+    {
+        return;
+    }
+
+    if (!aTrusted)
+    {
+        User::RequestComplete(pRequestStatus,KErrArgument);
+        return;
+    }
+
+    User::RequestComplete(pRequestStatus,KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelSetTrust()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::List(RMPointerArray<CCTCertInfo>& aCerts,
+                              const CCertAttributeFilter& aFilter,
+                              TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    if (IsActive())
+    {
+        User::RequestComplete(pRequestStatus,KErrInUse);
+        return;
+    }
+
+    TBool validRequest = validateCertAttrFilter(aFilter);
+    if (!validRequest)
+    {
+        ELOG(EJavaSecurity,"No certificates matching the filter supplied");
+        User::RequestComplete(pRequestStatus,KErrNone);
+        return;
+    }
+
+    if (0 < mCertsData.Count())
+    {
+        TRAPD(err,FillCertInfoFromCacheL(aCerts));
+        User::RequestComplete(pRequestStatus,err);
+        return;
+    }
+
+    mClientStatus = &aStatus;
+
+    mClientList = &aCerts;
+    iStatus = KRequestPending;
+    SetActive();
+
+    CommsMessage commsMsg;
+    commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);
+    commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);
+    commsMsg << JAVA_CERT_STORE_OPERATION_QUERY_CERTS;
+    commsMsg << JAVA_CERT_STORE_QUERY_ID_FULL_DETAILS;
+    commsMsg << JAVA_CERT_STORE_FILTER_ID_STATE
+    << (JAVA_CERT_STORE_STATE_ENABLED | JAVA_CERT_STORE_STATE_DISABLED);
+    int err = mComms.send(commsMsg);
+    if (0 != err)
+    {
+        std::string errTxt("Sending a comms request failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(err));
+        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());
+        User::RequestComplete(mClientStatus, KErrCommsBreak);
+    }
+    mState = EListing;
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelList()
+{
+    if (IsActive())
+    {
+        Cancel();
+    }
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::GetCert(CCTCertInfo*& aCertInfo,
+                                 const TCTTokenObjectHandle& aHandle,
+                                 TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    TInt index = GetIndexToCertData(aHandle);
+    if (-1 == index)
+    {
+        User::RequestComplete(pRequestStatus,KErrArgument);
+        return;
+    }
+
+    CJavaCertData* certData = mCertsData[index];
+    TRAPD(err,
+          aCertInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,
+                                        ECACertificate,certData->mSizeOfCert,
+                                        NULL,NULL,Token(),index,certData->mCanDelete);
+         ); // TRAPD
+
+    User::RequestComplete(pRequestStatus,err);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelGetCert()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::Applications(const CCTCertInfo& aCertInfo,RArray<TUid>& aApplications,
+                                      TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    //GetIndexToCertData() operation checks deleted case.
+    CJavaCertData* certData = 0;
+    TBool flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);
+    if (!flag)
+    {
+        return;
+    }
+
+    if (!certData->mIsDisabled)
+    {
+        aApplications.Append(KMidletInstallApplicabilityUid);
+    }
+
+    User::RequestComplete(pRequestStatus,KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelApplications()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::IsApplicable(const CCTCertInfo& aCertInfo,TUid aApplication,
+                                      TBool& aIsApplicable,TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    if (KMidletInstallApplicabilityUid != aApplication)
+    {
+        aIsApplicable = EFalse;
+        User::RequestComplete(pRequestStatus,KErrNone);
+        return;
+    }
+
+    TCTTokenObjectHandle handle = aCertInfo.Handle();
+    TInt certDataIndex = -1;
+    if ((handle.iObjectId >= 0) && (handle.iObjectId < mCertsData.Count()))
+    {
+        if (mCertsData[handle.iObjectId]->mDeleted)
+        {
+            aIsApplicable = EFalse;
+            User::RequestComplete(pRequestStatus,KErrNone);
+            return;
+        }
+        certDataIndex = handle.iObjectId;
+    }
+    if (-1 == certDataIndex)
+    {
+        User::RequestComplete(pRequestStatus,KErrArgument);
+        return;
+    }
+    CJavaCertData* certData = mCertsData[certDataIndex];
+
+    aIsApplicable = ETrue;
+    if (certData->mIsDisabled)
+    {
+        aIsApplicable = EFalse;
+    }
+    User::RequestComplete(pRequestStatus,KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelIsApplicable()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::Trusted(const CCTCertInfo& aCertInfo,
+                                 TBool& aTrusted,TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    CJavaCertData* certData = 0;
+    //GetCertDataObj() operation returns error if cert has been deleted.
+    TBool flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);
+    if (!flag)
+    {
+        return;
+    }
+
+    //Java certificates can be always trusted because this operation is never called
+    //for java certificate.
+    aTrusted = ETrue;
+    User::RequestComplete(pRequestStatus,KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelTrusted()
+{
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::Retrieve(const CCTCertInfo& aCertInfo,
+                                  TDes8& aEncodedCert,TRequestStatus& aStatus)
+{
+
+    aStatus = KRequestPending;
+    TRequestStatus* pRequestStatus = &aStatus;
+
+    TBool flag = CheckCapability(ECapabilityReadUserData,pRequestStatus);
+    if (!flag)
+    {
+        return;
+    }
+
+    if (IsActive())
+    {
+        User::RequestComplete(pRequestStatus,KErrInUse);
+        return;
+    }
+
+    //mClientStatus = pRequestStatus;
+
+    CJavaCertData* certData = 0;
+    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);
+    if (!flag)
+    {
+        return;
+    }
+
+    // copy certData->mCertContent into aEncodedCert
+    //aEncodedCert = (const TUint8*)certData->mCertContent.c_str();
+    TPtr8 ptr8((TUint8 *)(certData->mCertContent.c_str()), certData->mSizeOfCert);
+    ptr8.SetLength(certData->mSizeOfCert);
+    aEncodedCert.Copy(ptr8);
+
+    User::RequestComplete(pRequestStatus, KErrNone);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::CancelRetrieve()
+{
+    if (IsActive())
+    {
+        Cancel();
+    }
+}
+
+/**
+ *
+ */
+TBool CJavaCertStoreImpl::validateCertAttrFilter(const CCertAttributeFilter& aFilter) const
+{
+
+    //0x101F9B28 - Midlet suite signing certificates
+    //UID  taken from from security subsystem
+    //(Applications for certificates from this cert store)
+    TBool validRequest = ETrue;
+    if (aFilter.iUidIsSet && aFilter.iUid.iUid != KMidletInstallApplicabilityUid.iUid)
+    {
+        validRequest = EFalse;
+    }
+    if (aFilter.iFormatIsSet && validRequest)
+    {
+        validRequest = (aFilter.iFormat == EX509Certificate);
+    }
+    if (aFilter.iOwnerTypeIsSet && validRequest)
+    {
+        validRequest = (aFilter.iOwnerType == ECACertificate);
+    }
+    if (aFilter.iSubjectKeyIdIsSet && validRequest)
+    {
+        validRequest = EFalse;//We do not have a subject key id
+    }
+    if (aFilter.iIssuerKeyIdIsSet && validRequest)
+    {
+        validRequest = EFalse;//We do not have a issuer key id
+    }
+    if (aFilter.iLabelIsSet && validRequest)
+    {
+        validRequest = (aFilter.iLabel == KMIDP2TrustRoot);
+    }
+    return validRequest;
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::FillCertificateInfos(RMPointerArray<CCTCertInfo>& aInfoArray)
+{
+
+    std::vector<std::string> paths(10);
+    long long certSize;
+    TInt i = 0;
+    CCTCertInfo* tmpCertInfo = 0;
+
+    //Comms message contains the content's length, the content, the hash and the state
+    while ((mReceivedCommsMsg >> certSize && certSize != 0))
+    {
+        std::string certContent;
+        std::string idStr;
+        int encodedState = -1;
+        mReceivedCommsMsg >> certContent;
+        mReceivedCommsMsg >> idStr;
+        mReceivedCommsMsg >> encodedState;
+        if (0 == idStr.size())
+            continue;
+        if (-1 == encodedState)
+            continue;
+
+        std::auto_ptr<CJavaCertData> certData
+        (new CJavaCertData(certContent,certSize,idStr,encodedState));
+        TEntry entry;
+        int err;
+        TRAP(err,tmpCertInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,
+                               ECACertificate,certSize,
+                               NULL,NULL,Token(),i,
+                               certData->mCanDelete));
+        if (KErrNone != err)
+            continue;
+        err = mCertsData.Insert(certData.release(),i);
+        if (KErrNone != err)
+        {
+            tmpCertInfo->Release();
+            continue;
+        }
+        err = aInfoArray.Append(tmpCertInfo);
+        if (KErrNone != err)
+        {
+            tmpCertInfo->Release();
+            delete mCertsData[i];
+            mCertsData.Remove(i);
+            continue;
+        }
+        i++;
+    }//end while
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::FillCertInfoFromCacheL(RMPointerArray<CCTCertInfo>& aInfoArray)
+{
+
+    CJavaCertData* certData = NULL;
+    for (TInt i = 0; i < mCertsData.Count(); ++i)
+    {
+        certData = mCertsData[i];
+        if (certData->mDeleted)
+            continue;
+
+        CCTCertInfo* certInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,
+                                ECACertificate,certData->mSizeOfCert,
+                                NULL,NULL,Token(),i,certData->mCanDelete);
+        TInt err = aInfoArray.Append(certInfo);
+        User::LeaveIfError(err);
+    }//end for
+}
+
+/**
+ *
+ */
+TInt CJavaCertStoreImpl::GetIndexToCertData(const TCTTokenObjectHandle& aHandle)
+{
+
+    if ((aHandle.iObjectId >= 0) && (aHandle.iObjectId < mCertsData.Count()))
+    {
+        if (mCertsData[aHandle.iObjectId]->mDeleted)
+            return -1;
+        return aHandle.iObjectId;
+    }
+    return -1;
+}
+
+/**
+ *
+ */
+TBool CJavaCertStoreImpl::GetCertDataObj(const CCTCertInfo& aCertInfo,
+        TRequestStatus* aRequestStatus,
+        CJavaCertData*& aOutCertDataObj)
+{
+
+    TCTTokenObjectHandle handle = aCertInfo.Handle();
+    TInt certDataIndex = GetIndexToCertData(handle);
+    if (-1 == certDataIndex)
+    {
+        User::RequestComplete(aRequestStatus,KErrArgument);
+        return EFalse;
+    }
+
+    aOutCertDataObj = mCertsData[certDataIndex];
+    return ETrue;
+}
+
+/**
+ *
+ */
+TBool CJavaCertStoreImpl::SendDisableEnableCommsMsg(const std::string& aId,
+        TState aState,
+        TRequestStatus* aRequestStatus)
+{
+
+    CommsMessage commsMsg;
+    commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);
+    commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);
+    commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);
+    if (EPreEnabling == aState)
+        commsMsg << JAVA_CERT_STORE_OPERATION_ENABLE_CERT;
+    else
+        commsMsg << JAVA_CERT_STORE_OPERATION_DISABLE_CERT;
+    commsMsg << aId;
+    int err = mComms.send(commsMsg);
+    if (0 != err)
+    {
+        std::string errTxt("Sending a comms request failed: ");
+        errTxt.append(java::util::JavaCommonUtils::intToString(err));
+        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());
+        User::RequestComplete(aRequestStatus,KErrCommsBreak);
+        return EFalse;
+    }
+    return ETrue;
+}
+
+/**
+ *
+ */
+TBool CJavaCertStoreImpl::CheckCapability(const TCapability& aCapability,TRequestStatus* aRequestStatus)
+{
+    RThread thread;
+    if (!thread.HasCapability(aCapability,0))
+    {
+        ELOG(EJavaSecurity, "ERROR!!! List(): Not enough capabilities to call this operation");
+        User::RequestComplete(aRequestStatus,KErrPermissionDenied);
+        return EFalse;
+    }
+    return ETrue;
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::HandleDisableQuery(TRequestStatus &aRequestStatus)
+{
+
+    TRAPD(leaveStatus,ShowQueryL());
+    if (KErrNone == leaveStatus)
+    {
+        mClientStatus = &aRequestStatus;
+        SetActive();
+        return;
+    }
+    delete mQuery.release();
+    mState = EInitial;
+    TRequestStatus* pRequestStatus = &aRequestStatus;
+    User::RequestComplete(pRequestStatus,KErrCancel);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::ShowQueryL()
+{
+
+#ifndef RD_JAVA_S60_RELEASE_5_0_IAD
+
+    TFileName resourceFileName = java::util::S60CommonUtils::ResourceLanguageFileNameL(
+                                     KJavaUserMessagesResourceFileName);
+
+    std::auto_ptr<CStringResourceReader> reader(CStringResourceReader::NewL(resourceFileName));
+    std::auto_ptr<HBufC> queryPrompt(reader->ReadResourceString(R_JAVA_SECUR_CERT_DISABLING).AllocL());
+
+    mQuery.reset(CAknGlobalConfirmationQuery::NewL());
+    mQuery->ShowConfirmationQueryL(iStatus,queryPrompt->Des(),R_AVKON_SOFTKEYS_OK_CANCEL);
+
+#endif
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::SendDisableMsg(TInt aStatus)
+{
+
+    mState = EInitial;
+    delete mQuery.release();
+    mState = EInitial;
+    if (EAknSoftkeyOk != aStatus)
+    {
+        User::RequestComplete(mClientStatus,KErrCancel);
+        return;
+    }
+    HandleSendingEnableDisableMsg(mClientStatus,EPreDisabling,*mTempCertData);
+}
+
+/**
+ *
+ */
+void CJavaCertStoreImpl::HandleSendingEnableDisableMsg(TRequestStatus* aRequestStatus,
+        TState aState,CJavaCertData& aCertDataObj)
+{
+
+    TBool flag = SendDisableEnableCommsMsg(aCertDataObj.mId,aState,aRequestStatus);
+    if (!flag)
+    {
+        //SendDisableEnableCommsMsg() operation calls RequestComplete()
+        //operation in the error situation.
+        return;
+    }
+    if (EPreEnabling == aState)
+    {
+        aCertDataObj.mIsDisabled = EFalse;
+    }
+    else if (EPreDisabling == aState)
+    {
+        aCertDataObj.mIsDisabled = ETrue;
+    }
+
+    User::RequestComplete(aRequestStatus,KErrNone);
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+// IMPLEMENTATION OF CJavaCertData CLASS
+//
+//////////////////////////////////////////////////////////////////////////////////
+
+CJavaCertData::CJavaCertData(const std::string& aCertContent,
+                             long long aCertSize,
+                             const std::string& aId,TInt aEncodedState)
+        : mCertContent(aCertContent),mId(aId),mDeleted(EFalse),mSizeOfCert(aCertSize)
+{
+    mIsDisabled = ((aEncodedState & 0x1) == 0x1); // trust root is disabled if first bit is set
+    mCanDisable = ((aEncodedState & 0x2) == 0x2);   // trust root can be disabled if second bit is set
+    mCanDelete = ((aEncodedState & 0x4) == 0x4);    // trust root can be deleted if third bit is set
+}
+
+CJavaCertData::~CJavaCertData()
+{
+}
+