1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include <e32std.h>

    19 #include <memory>

    20 

    21 #ifndef RD_JAVA_S60_RELEASE_5_0_IAD

    22 #include <javausermessages.rsg>

    23 #endif

    24 

    25 #include <avkon.rsg>

    26 #include <AknGlobalConfirmationQuery.h>

    27 #include <stringresourcereader.h>

    28 #include <StringLoader.h>

    29 #include <data_caging_path_literals.hrh>

    30 

    31 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

    32 #include <securitydefs.h>

    33 #else

    34 #include <securitydefs.h>

    35 #include <securitydefsconst.h>

    36 #endif

    37 

    38 #include "javacertstoreimpl.h"

    39 #include "javacertstoretoken.h"

    40 #include "logger.h"

    41 #include "javasymbianoslayer.h"

    42 #include "comms.h"

    43 #include "javacertstoretoken.h"

    44 #include "javacommonutils.h"

    45 #include "s60commonutils.h"

    46 #include "securitycommsmessagedefs.h"

    47 

    48 

    49 

    50 //_LIT(KMIDP2TrustRoot, "J2ME MIDP2 Trust Root");

    51 _LIT(KMIDP2TrustRoot, "Java Trust Root");

    52 #ifndef RD_JAVA_S60_RELEASE_5_0_IAD

    53 _LIT(KJavaUserMessagesResourceFileName, "javausermessages.rsc");

    54 #endif

    55 //_LIT( KRuntimeSecPolicyResourceFileName, "z:midp2runtimesecuritypolicy.rsc" );

    56 

    57 //const TUid KCertManUIViewTrustJavaInstallingId = { 0x101F9B28 };

    58 //const TUid KCertManUIViewTrustJavaInstallingId = { KMidletInstallApplicabilityUi };

    59 

    60 using namespace java::security;

    61 using namespace java::comms;

    62 

    63 /**

    64  *

    65  */

    66 CJavaCertStoreImpl::CJavaCertStoreImpl(CJavaCertStoreToken& aToken)

    67         : CActive(EPriorityNormal),mToken(aToken),mClientStatus(NULL),mState(EInitial),mQuery(0),mTempCertData(0)

    68 {

    69 }

    70 

    71 /**

    72  *

    73  */

    74 CJavaCertStoreImpl::~CJavaCertStoreImpl()

    75 {

    76 

    77     if (IsActive())

    78     {

    79         Cancel();

    80     }

    81 

    82     mComms.unregisterListener(PLUGIN_ID_JAVA_CERT_STORE_ECOM_C,this);

    83     mComms.unregisterDefaultListener(this);

    84     mComms.disconnect();

    85     mCertsData.ResetAndDestroy();

    86     mUiThread.Close();

    87 }

    88 

    89 /**

    90  *

    91  */

    92 CJavaCertStoreImpl* CJavaCertStoreImpl::NewL(CJavaCertStoreToken& aToken)

    93 {

    94     CJavaCertStoreImpl* impl = new(ELeave) CJavaCertStoreImpl(aToken);

    95     CleanupStack::PushL(impl);

    96     impl->ConstructL();

    97     CleanupStack::Pop(impl);

    98     return impl;

    99 }

   100 

   101 /**

   102  *

   103  */

   104 void CJavaCertStoreImpl::ConstructL()

   105 {

   106 

   107     CActiveScheduler::Add(this);

   108 

   109     int err = mComms.registerDefaultListener(this);

   110     if (0 != err)

   111     {

   112         std::string errTxt("Registering comms listener failed: ");

   113         errTxt.append(java::util::JavaCommonUtils::intToString(err));

   114         ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

   115         User::Leave(KErrCouldNotConnect);

   116     }

   117     err = mComms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

   118     if (0 != err)

   119     {

   120         std::string errTxt("Comms connection failed: ");

   121         errTxt.append(java::util::JavaCommonUtils::intToString(err));

   122         ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

   123         User::Leave(KErrCouldNotConnect);

   124     }

   125     err = mUiThread.Open(RThread().Id());

   126     if (KErrNone != err)

   127     {

   128         std::string errTxt("Initialization of thread failed: ");

   129         errTxt.append(java::util::JavaCommonUtils::intToString(err));

   130         ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

   131         User::Leave(err);

   132     }

   133 }

   134 

   135 /**

   136  *

   137  */

   138 MCTToken& CJavaCertStoreImpl::Token()

   139 {

   140     return mToken;

   141 }

   142 

   143 /**

   144  *

   145  */

   146 void CJavaCertStoreImpl::processMessage(java::comms::CommsMessage& aMessage)

   147 {

   148     //Request has been cancelled if it is not active anymore.

   149     if (!IsActive())

   150         return;

   151     mReceivedCommsMsg = aMessage;

   152     //ActiveScheduler calls RunL() operation after request has been completed.

   153     TRequestStatus* stat = &iStatus;

   154     mUiThread.RequestComplete(stat,KErrNone);

   155 }

   156 

   157 /**

   158  *

   159  */

   160 void CJavaCertStoreImpl::RunL()

   161 {

   162     TInt status = iStatus.Int();

   163 

   164     switch (mState)

   165     {

   166     case EListing:

   167         mState = EInitial;

   168         //In current implementation status cannot be any than KErrNone

   169         //in this state.

   170         if (KErrNone == status)

   171         {

   172             FillCertificateInfos(*mClientList);

   173         }

   174         break;

   175 

   176     case EPreDisabling:

   177         SendDisableMsg(status);

   178         return;

   179 

   180     default:

   181         //Do nothing.

   182         break;

   183     }

   184 

   185     User::RequestComplete(mClientStatus,status);

   186 }

   187 

   188 /**

   189  *

   190  */

   191 void CJavaCertStoreImpl::DoCancel()

   192 {

   193     if (IsActive() && mClientStatus)

   194     {

   195         User::RequestComplete(mClientStatus,KErrCancel);

   196     }

   197 }

   198 

   199 /**

   200  *

   201  */

   202 TInt CJavaCertStoreImpl::RunError(TInt /*aError*/)

   203 {

   204     return KErrNone;

   205 }

   206 

   207 /**

   208  *

   209  */

   210 void CJavaCertStoreImpl::Add(const TDesC& /*aLabel*/, TCertificateFormat,

   211                              TCertificateOwnerType,

   212                              const TKeyIdentifier* /*aSubjectKeyId*/,

   213                              const TKeyIdentifier* /*aIssuerKeyId*/,

   214                              const TDesC8& /*aCert*/, TRequestStatus& aStatus)

   215 {

   216     aStatus = KRequestPending;

   217     TRequestStatus* pRequestStatus = &aStatus;

   218     User::RequestComplete(pRequestStatus,KErrNotSupported);

   219 }

   220 

   221 /**

   222  *

   223  */

   224 void CJavaCertStoreImpl::CancelAdd()

   225 {

   226 }

   227 

   228 /**

   229  *

   230  */

   231 void CJavaCertStoreImpl::Remove(const CCTCertInfo& aCertInfo,TRequestStatus& aStatus)

   232 {

   233 

   234     aStatus = KRequestPending;

   235     TRequestStatus* pRequestStatus = &aStatus;

   236 

   237     TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);

   238     if (!flag)

   239     {

   240         return;

   241     }

   242 

   243     CJavaCertData* certData = 0;

   244     flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

   245     if (!flag)

   246     {

   247         return;

   248     }

   249 

   250     if (!certData->mCanDelete)

   251     {

   252         User::RequestComplete(pRequestStatus,KErrArgument);

   253         return;

   254     }

   255 

   256     CommsMessage commsMsg;

   257     commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);

   258     commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);

   259     commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);

   260     commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);

   261     commsMsg << JAVA_CERT_STORE_OPERATION_DELETE_CERT;

   262     commsMsg << certData->mId;

   263     int err = mComms.send(commsMsg);

   264     if (0 != err)

   265     {

   266         std::string errTxt("Sending a comms request failed: ");

   267         errTxt.append(java::util::JavaCommonUtils::intToString(err));

   268         ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

   269         User::RequestComplete(pRequestStatus,KErrCommsBreak);

   270     }

   271     certData->mDeleted = ETrue;

   272     User::RequestComplete(pRequestStatus,KErrNone);

   273 }

   274 

   275 /**

   276  *

   277  */

   278 void CJavaCertStoreImpl::CancelRemove()

   279 {

   280 }

   281 

   282 /**

   283  *

   284  */

   285 void CJavaCertStoreImpl::SetApplicability(const CCTCertInfo& aCertInfo,

   286         const RArray<TUid>& aApplications,

   287         TRequestStatus &aStatus)

   288 {

   289 

   290     aStatus = KRequestPending;

   291     TRequestStatus* pRequestStatus = &aStatus;

   292 

   293     TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);

   294     if (!flag)

   295     {

   296         return;

   297     }

   298 

   299     TState state = EPreDisabling;

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

   301     {

   302         if (KMidletInstallApplicabilityUid == aApplications[i])

   303         {

   304             state = EPreEnabling;

   305             break;

   306         }

   307     }

   308 

   309     CJavaCertData* certData = 0;

   310     //GetCertDataObj() operation checks whether cert is deleted.

   311     flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

   312     if (!flag)

   313     {

   314         return;

   315     }

   316 

   317     if ((EPreDisabling == state) && (!certData->mCanDisable))

   318     {

   319         User::RequestComplete(pRequestStatus,KErrArgument);

   320         return;

   321     }

   322 

   323     if (EPreDisabling == state)

   324     {

   325 //RD_JAVA_S60_RELEASE_5_0_IAD flag is needed because otherwise "disable cert" confirmation

   326 //prompt is shown twice. First time by unicertstore plugin of legacy java and second

   327 //time by unicertstore plugin of OMJ.

   328 #ifdef RD_JAVA_S60_RELEASE_5_0_IAD

   329         HandleSendingEnableDisableMsg(pRequestStatus,EPreDisabling,*certData);

   330 #else

   331         mState = state;

   332         mTempCertData = certData;

   333         HandleDisableQuery(aStatus);

   334 #endif

   335         return;

   336     }

   337     HandleSendingEnableDisableMsg(pRequestStatus,EPreEnabling,*certData);

   338 }

   339 

   340 /**

   341  *

   342  */

   343 void CJavaCertStoreImpl::CancelSetApplicability()

   344 {

   345 }

   346 

   347 /**

   348  *

   349  */

   350 void CJavaCertStoreImpl::SetTrust(const CCTCertInfo& aCertInfo, TBool aTrusted,

   351                                   TRequestStatus& aStatus)

   352 {

   353 

   354     aStatus = KRequestPending;

   355     TRequestStatus* pRequestStatus = &aStatus;

   356 

   357     TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);

   358     if (!flag)

   359     {

   360         return;

   361     }

   362 

   363     CJavaCertData* certData = 0;

   364     flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

   365     if (!flag)

   366     {

   367         return;

   368     }

   369 

   370     if (!aTrusted)

   371     {

   372         User::RequestComplete(pRequestStatus,KErrArgument);

   373         return;

   374     }

   375 

   376     User::RequestComplete(pRequestStatus,KErrNone);

   377 }

   378 

   379 /**

   380  *

   381  */

   382 void CJavaCertStoreImpl::CancelSetTrust()

   383 {

   384 }

   385 

   386 /**

   387  *

   388  */

   389 void CJavaCertStoreImpl::List(RMPointerArray<CCTCertInfo>& aCerts,

   390                               const CCertAttributeFilter& aFilter,

   391                               TRequestStatus& aStatus)

   392 {

   393 

   394     aStatus = KRequestPending;

   395     TRequestStatus* pRequestStatus = &aStatus;

   396 

   397     if (IsActive())

   398     {

   399         User::RequestComplete(pRequestStatus,KErrInUse);

   400         return;

   401     }

   402 

   403     TBool validRequest = validateCertAttrFilter(aFilter);

   404     if (!validRequest)

   405     {

   406         ELOG(EJavaSecurity,"No certificates matching the filter supplied");

   407         User::RequestComplete(pRequestStatus,KErrNone);

   408         return;

   409     }

   410 

   411     if (0 < mCertsData.Count())

   412     {

   413         TRAPD(err,FillCertInfoFromCacheL(aCerts));

   414         User::RequestComplete(pRequestStatus,err);

   415         return;

   416     }

   417 

   418     mClientStatus = &aStatus;

   419 

   420     mClientList = &aCerts;

   421     iStatus = KRequestPending;

   422     SetActive();

   423 

   424     CommsMessage commsMsg;

   425     commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);

   426     commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);

   427     commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);

   428     commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);

   429     commsMsg << JAVA_CERT_STORE_OPERATION_QUERY_CERTS;

   430     commsMsg << JAVA_CERT_STORE_QUERY_ID_FULL_DETAILS;

   431     commsMsg << JAVA_CERT_STORE_FILTER_ID_STATE

   432     << (JAVA_CERT_STORE_STATE_ENABLED | JAVA_CERT_STORE_STATE_DISABLED);

   433     int err = mComms.send(commsMsg);

   434     if (0 != err)

   435     {

   436         std::string errTxt("Sending a comms request failed: ");

   437         errTxt.append(java::util::JavaCommonUtils::intToString(err));

   438         ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

   439         User::RequestComplete(mClientStatus, KErrCommsBreak);

   440     }

   441     mState = EListing;

   442 }

   443 

   444 /**

   445  *

   446  */

   447 void CJavaCertStoreImpl::CancelList()

   448 {

   449     if (IsActive())

   450     {

   451         Cancel();

   452     }

   453 }

   454 

   455 /**

   456  *

   457  */

   458 void CJavaCertStoreImpl::GetCert(CCTCertInfo*& aCertInfo,

   459                                  const TCTTokenObjectHandle& aHandle,

   460                                  TRequestStatus& aStatus)

   461 {

   462 

   463     aStatus = KRequestPending;

   464     TRequestStatus* pRequestStatus = &aStatus;

   465 

   466     TInt index = GetIndexToCertData(aHandle);

   467     if (-1 == index)

   468     {

   469         User::RequestComplete(pRequestStatus,KErrArgument);

   470         return;

   471     }

   472 

   473     CJavaCertData* certData = mCertsData[index];

   474     TRAPD(err,

   475           aCertInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,

   476                                         ECACertificate,certData->mSizeOfCert,

   477                                         NULL,NULL,Token(),index,certData->mCanDelete);

   478          ); // TRAPD

   479 

   480     User::RequestComplete(pRequestStatus,err);

   481 }

   482 

   483 /**

   484  *

   485  */

   486 void CJavaCertStoreImpl::CancelGetCert()

   487 {

   488 }

   489 

   490 /**

   491  *

   492  */

   493 void CJavaCertStoreImpl::Applications(const CCTCertInfo& aCertInfo,RArray<TUid>& aApplications,

   494                                       TRequestStatus& aStatus)

   495 {

   496 

   497     aStatus = KRequestPending;

   498     TRequestStatus* pRequestStatus = &aStatus;

   499 

   500     //GetIndexToCertData() operation checks deleted case.

   501     CJavaCertData* certData = 0;

   502     TBool flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

   503     if (!flag)

   504     {

   505         return;

   506     }

   507 

   508     if (!certData->mIsDisabled)

   509     {

   510         aApplications.Append(KMidletInstallApplicabilityUid);

   511     }

   512 

   513     User::RequestComplete(pRequestStatus,KErrNone);

   514 }

   515 

   516 /**

   517  *

   518  */

   519 void CJavaCertStoreImpl::CancelApplications()

   520 {

   521 }

   522 

   523 /**

   524  *

   525  */

   526 void CJavaCertStoreImpl::IsApplicable(const CCTCertInfo& aCertInfo,TUid aApplication,

   527                                       TBool& aIsApplicable,TRequestStatus& aStatus)

   528 {

   529 

   530     aStatus = KRequestPending;

   531     TRequestStatus* pRequestStatus = &aStatus;

   532 

   533     if (KMidletInstallApplicabilityUid != aApplication)

   534     {

   535         aIsApplicable = EFalse;

   536         User::RequestComplete(pRequestStatus,KErrNone);

   537         return;

   538     }

   539 

   540     TCTTokenObjectHandle handle = aCertInfo.Handle();

   541     TInt certDataIndex = -1;

   542     if ((handle.iObjectId >= 0) && (handle.iObjectId < mCertsData.Count()))

   543     {

   544         if (mCertsData[handle.iObjectId]->mDeleted)

   545         {

   546             aIsApplicable = EFalse;

   547             User::RequestComplete(pRequestStatus,KErrNone);

   548             return;

   549         }

   550         certDataIndex = handle.iObjectId;

   551     }

   552     if (-1 == certDataIndex)

   553     {

   554         User::RequestComplete(pRequestStatus,KErrArgument);

   555         return;

   556     }

   557     CJavaCertData* certData = mCertsData[certDataIndex];

   558 

   559     aIsApplicable = ETrue;

   560     if (certData->mIsDisabled)

   561     {

   562         aIsApplicable = EFalse;

   563     }

   564     User::RequestComplete(pRequestStatus,KErrNone);

   565 }

   566 

   567 /**

   568  *

   569  */

   570 void CJavaCertStoreImpl::CancelIsApplicable()

   571 {

   572 }

   573 

   574 /**

   575  *

   576  */

   577 void CJavaCertStoreImpl::Trusted(const CCTCertInfo& aCertInfo,

   578                                  TBool& aTrusted,TRequestStatus& aStatus)

   579 {

   580 

   581     aStatus = KRequestPending;

   582     TRequestStatus* pRequestStatus = &aStatus;

   583 

   584     CJavaCertData* certData = 0;

   585     //GetCertDataObj() operation returns error if cert has been deleted.

   586     TBool flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

   587     if (!flag)

   588     {

   589         return;

   590     }

   591 

   592     //Java certificates can be always trusted because this operation is never called

   593     //for java certificate.

   594     aTrusted = ETrue;

   595     User::RequestComplete(pRequestStatus,KErrNone);

   596 }

   597 

   598 /**

   599  *

   600  */

   601 void CJavaCertStoreImpl::CancelTrusted()

   602 {

   603 }

   604 

   605 /**

   606  *

   607  */

   608 void CJavaCertStoreImpl::Retrieve(const CCTCertInfo& aCertInfo,

   609                                   TDes8& aEncodedCert,TRequestStatus& aStatus)

   610 {

   611 

   612     aStatus = KRequestPending;

   613     TRequestStatus* pRequestStatus = &aStatus;

   614 

   615     TBool flag = CheckCapability(ECapabilityReadUserData,pRequestStatus);

   616     if (!flag)

   617     {

   618         return;

   619     }

   620 

   621     if (IsActive())

   622     {

   623         User::RequestComplete(pRequestStatus,KErrInUse);

   624         return;

   625     }

   626 

   627     //mClientStatus = pRequestStatus;

   628 

   629     CJavaCertData* certData = 0;

   630     flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

   631     if (!flag)

   632     {

   633         return;

   634     }

   635 

   636     // copy certData->mCertContent into aEncodedCert

   637     //aEncodedCert = (const TUint8*)certData->mCertContent.c_str();

   638     TPtr8 ptr8((TUint8 *)(certData->mCertContent.c_str()), certData->mSizeOfCert);

   639     ptr8.SetLength(certData->mSizeOfCert);

   640     aEncodedCert.Copy(ptr8);

   641 

   642     User::RequestComplete(pRequestStatus, KErrNone);

   643 }

   644 

   645 /**

   646  *

   647  */

   648 void CJavaCertStoreImpl::CancelRetrieve()

   649 {

   650     if (IsActive())

   651     {

   652         Cancel();

   653     }

   654 }

   655 

   656 /**

   657  *

   658  */

   659 TBool CJavaCertStoreImpl::validateCertAttrFilter(const CCertAttributeFilter& aFilter) const

   660 {

   661 

   662     //0x101F9B28 - Midlet suite signing certificates

   663     //UID  taken from from security subsystem

   664     //(Applications for certificates from this cert store)

   665     TBool validRequest = ETrue;

   666     if (aFilter.iUidIsSet && aFilter.iUid.iUid != KMidletInstallApplicabilityUid.iUid)

   667     {

   668         validRequest = EFalse;

   669     }

   670     if (aFilter.iFormatIsSet && validRequest)

   671     {

   672         validRequest = (aFilter.iFormat == EX509Certificate);

   673     }

   674     if (aFilter.iOwnerTypeIsSet && validRequest)

   675     {

   676         validRequest = (aFilter.iOwnerType == ECACertificate);

   677     }

   678     if (aFilter.iSubjectKeyIdIsSet && validRequest)

   679     {

   680         validRequest = EFalse;//We do not have a subject key id

   681     }

   682     if (aFilter.iIssuerKeyIdIsSet && validRequest)

   683     {

   684         validRequest = EFalse;//We do not have a issuer key id

   685     }

   686     if (aFilter.iLabelIsSet && validRequest)

   687     {

   688         validRequest = (aFilter.iLabel == KMIDP2TrustRoot);

   689     }

   690     return validRequest;

   691 }

   692 

   693 /**

   694  *

   695  */

   696 void CJavaCertStoreImpl::FillCertificateInfos(RMPointerArray<CCTCertInfo>& aInfoArray)

   697 {

   698 

   699     std::vector<std::string> paths(10);

   700     long long certSize;

   701     TInt i = 0;

   702     CCTCertInfo* tmpCertInfo = 0;

   703 

   704     //Comms message contains the content's length, the content, the hash and the state

   705     while ((mReceivedCommsMsg >> certSize && certSize != 0))

   706     {

   707         std::string certContent;

   708         std::string idStr;

   709         int encodedState = -1;

   710         mReceivedCommsMsg >> certContent;

   711         mReceivedCommsMsg >> idStr;

   712         mReceivedCommsMsg >> encodedState;

   713         if (0 == idStr.size())

   714             continue;

   715         if (-1 == encodedState)

   716             continue;

   717 

   718         std::auto_ptr<CJavaCertData> certData

   719         (new CJavaCertData(certContent,certSize,idStr,encodedState));

   720         TEntry entry;

   721         int err;

   722         TRAP(err,tmpCertInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,

   723                                ECACertificate,certSize,

   724                                NULL,NULL,Token(),i,

   725                                certData->mCanDelete));

   726         if (KErrNone != err)

   727             continue;

   728         err = mCertsData.Insert(certData.release(),i);

   729         if (KErrNone != err)

   730         {

   731             tmpCertInfo->Release();

   732             continue;

   733         }

   734         err = aInfoArray.Append(tmpCertInfo);

   735         if (KErrNone != err)

   736         {

   737             tmpCertInfo->Release();

   738             delete mCertsData[i];

   739             mCertsData.Remove(i);

   740             continue;

   741         }

   742         i++;

   743     }//end while

   744 }

   745 

   746 /**

   747  *

   748  */

   749 void CJavaCertStoreImpl::FillCertInfoFromCacheL(RMPointerArray<CCTCertInfo>& aInfoArray)

   750 {

   751 

   752     CJavaCertData* certData = NULL;

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

   754     {

   755         certData = mCertsData[i];

   756         if (certData->mDeleted)

   757             continue;

   758 

   759         CCTCertInfo* certInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,

   760                                 ECACertificate,certData->mSizeOfCert,

   761                                 NULL,NULL,Token(),i,certData->mCanDelete);

   762         TInt err = aInfoArray.Append(certInfo);

   763         User::LeaveIfError(err);

   764     }//end for

   765 }

   766 

   767 /**

   768  *

   769  */

   770 TInt CJavaCertStoreImpl::GetIndexToCertData(const TCTTokenObjectHandle& aHandle)

   771 {

   772 

   773     if ((aHandle.iObjectId >= 0) && (aHandle.iObjectId < mCertsData.Count()))

   774     {

   775         if (mCertsData[aHandle.iObjectId]->mDeleted)

   776             return -1;

   777         return aHandle.iObjectId;

   778     }

   779     return -1;

   780 }

   781 

   782 /**

   783  *

   784  */

   785 TBool CJavaCertStoreImpl::GetCertDataObj(const CCTCertInfo& aCertInfo,

   786         TRequestStatus* aRequestStatus,

   787         CJavaCertData*& aOutCertDataObj)

   788 {

   789 

   790     TCTTokenObjectHandle handle = aCertInfo.Handle();

   791     TInt certDataIndex = GetIndexToCertData(handle);

   792     if (-1 == certDataIndex)

   793     {

   794         User::RequestComplete(aRequestStatus,KErrArgument);

   795         return EFalse;

   796     }

   797 

   798     aOutCertDataObj = mCertsData[certDataIndex];

   799     return ETrue;

   800 }

   801 

   802 /**

   803  *

   804  */

   805 TBool CJavaCertStoreImpl::SendDisableEnableCommsMsg(const std::string& aId,

   806         TState aState,

   807         TRequestStatus* aRequestStatus)

   808 {

   809 

   810     CommsMessage commsMsg;

   811     commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);

   812     commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);

   813     commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);

   814     commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);

   815     if (EPreEnabling == aState)

   816         commsMsg << JAVA_CERT_STORE_OPERATION_ENABLE_CERT;

   817     else

   818         commsMsg << JAVA_CERT_STORE_OPERATION_DISABLE_CERT;

   819     commsMsg << aId;

   820     int err = mComms.send(commsMsg);

   821     if (0 != err)

   822     {

   823         std::string errTxt("Sending a comms request failed: ");

   824         errTxt.append(java::util::JavaCommonUtils::intToString(err));

   825         ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

   826         User::RequestComplete(aRequestStatus,KErrCommsBreak);

   827         return EFalse;

   828     }

   829     return ETrue;

   830 }

   831 

   832 /**

   833  *

   834  */

   835 TBool CJavaCertStoreImpl::CheckCapability(const TCapability& aCapability,TRequestStatus* aRequestStatus)

   836 {

   837     RThread thread;

   838     if (!thread.HasCapability(aCapability,0))

   839     {

   840         ELOG(EJavaSecurity, "ERROR!!! List(): Not enough capabilities to call this operation");

   841         User::RequestComplete(aRequestStatus,KErrPermissionDenied);

   842         return EFalse;

   843     }

   844     return ETrue;

   845 }

   846 

   847 /**

   848  *

   849  */

   850 void CJavaCertStoreImpl::HandleDisableQuery(TRequestStatus &aRequestStatus)

   851 {

   852 

   853     TRAPD(leaveStatus,ShowQueryL());

   854     if (KErrNone == leaveStatus)

   855     {

   856         mClientStatus = &aRequestStatus;

   857         SetActive();

   858         return;

   859     }

   860     delete mQuery.release();

   861     mState = EInitial;

   862     TRequestStatus* pRequestStatus = &aRequestStatus;

   863     User::RequestComplete(pRequestStatus,KErrCancel);

   864 }

   865 

   866 /**

   867  *

   868  */

   869 void CJavaCertStoreImpl::ShowQueryL()

   870 {

   871 

   872 #ifndef RD_JAVA_S60_RELEASE_5_0_IAD

   873 

   874     TFileName resourceFileName = java::util::S60CommonUtils::ResourceLanguageFileNameL(

   875                                      KJavaUserMessagesResourceFileName);

   876 

   877     std::auto_ptr<CStringResourceReader> reader(CStringResourceReader::NewL(resourceFileName));

   878     std::auto_ptr<HBufC> queryPrompt(reader->ReadResourceString(R_JAVA_SECUR_CERT_DISABLING).AllocL());

   879 

   880     mQuery.reset(CAknGlobalConfirmationQuery::NewL());

   881     mQuery->ShowConfirmationQueryL(iStatus,queryPrompt->Des(),R_AVKON_SOFTKEYS_OK_CANCEL);

   882 

   883 #endif

   884 }

   885 

   886 /**

   887  *

   888  */

   889 void CJavaCertStoreImpl::SendDisableMsg(TInt aStatus)

   890 {

   891 

   892     mState = EInitial;

   893     delete mQuery.release();

   894     mState = EInitial;

   895     if (EAknSoftkeyOk != aStatus)

   896     {

   897         User::RequestComplete(mClientStatus,KErrCancel);

   898         return;

   899     }

   900     HandleSendingEnableDisableMsg(mClientStatus,EPreDisabling,*mTempCertData);

   901 }

   902 

   903 /**

   904  *

   905  */

   906 void CJavaCertStoreImpl::HandleSendingEnableDisableMsg(TRequestStatus* aRequestStatus,

   907         TState aState,CJavaCertData& aCertDataObj)

   908 {

   909 

   910     TBool flag = SendDisableEnableCommsMsg(aCertDataObj.mId,aState,aRequestStatus);

   911     if (!flag)

   912     {

   913         //SendDisableEnableCommsMsg() operation calls RequestComplete()

   914         //operation in the error situation.

   915         return;

   916     }

   917     if (EPreEnabling == aState)

   918     {

   919         aCertDataObj.mIsDisabled = EFalse;

   920     }

   921     else if (EPreDisabling == aState)

   922     {

   923         aCertDataObj.mIsDisabled = ETrue;

   924     }

   925 

   926     User::RequestComplete(aRequestStatus,KErrNone);

   927 }

   928 

   929 /////////////////////////////////////////////////////////////////////////////////

   930 //

   931 // IMPLEMENTATION OF CJavaCertData CLASS

   932 //

   933 //////////////////////////////////////////////////////////////////////////////////

   934 

   935 CJavaCertData::CJavaCertData(const std::string& aCertContent,

   936                              long long aCertSize,

   937                              const std::string& aId,TInt aEncodedState)

   938         : mCertContent(aCertContent),mId(aId),mDeleted(EFalse),mSizeOfCert(aCertSize)

   939 {

   940     mIsDisabled = ((aEncodedState & 0x1) == 0x1); // trust root is disabled if first bit is set

   941     mCanDisable = ((aEncodedState & 0x2) == 0x2);   // trust root can be disabled if second bit is set

   942     mCanDelete = ((aEncodedState & 0x4) == 0x4);    // trust root can be deleted if third bit is set

   943 }

   944 

   945 CJavaCertData::~CJavaCertData()

   946 {

   947 }

   948