1 /*

     2 * Copyright (c) 2006 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:   Implementation of DevandTruSrvCertStore

    15 *

    16 */

    17 

    18 

    19 

    20 #include "DevandTruSrvCertStore.h"

    21 #include "DevTokenType.h"

    22 #include "DevToken.h"

    23 #include "DevTokenUtils.h"

    24 #include "DevTokenImplementationUID.hrh"

    25 

    26 // This is sized for roughly five cert infos, to ensure that the overflow

    27 // mechanism gets tested.

    28 const TInt KDefaultBufferSize = 256;

    29 

    30 // ======== MEMBER FUNCTIONS ========

    31 

    32 // -----------------------------------------------------------------------------

    33 // CDevandTruSrvCertStore::NewWritableInterfaceL()

    34 // -----------------------------------------------------------------------------

    35 //

    36 MCTTokenInterface* CDevandTruSrvCertStore::NewWritableInterfaceL(MCTToken& aToken, 

    37                          RDevTokenClientSession& aClient)

    38     {

    39     // Destroyed by MCTTokenInterface::DoRelease() (no refcounting)

    40     CDevandTruSrvCertStore* me = new (ELeave) CDevandTruSrvCertStore(KInterfaceWritableCertStore, 

    41                                                                      aToken, 

    42                                                                      aClient);

    43     CleanupStack::PushL(me);

    44     me->ConstructL();

    45     CleanupStack::Pop(me);

    46     return (me);

    47     }

    48 

    49 

    50 // -----------------------------------------------------------------------------

    51 // CDevandTruSrvCertStore::NewReadableInterfaceL()

    52 // -----------------------------------------------------------------------------

    53 //

    54 MCTTokenInterface* CDevandTruSrvCertStore::NewReadableInterfaceL(MCTToken& aToken, 

    55                          RDevTokenClientSession& aClient)

    56     {

    57     // Destroyed by MCTTokenInterface::DoRelease() (no refcounting)

    58     CDevandTruSrvCertStore* me = new (ELeave) CDevandTruSrvCertStore(KInterfaceCertStore,

    59                                                                      aToken, 

    60                                                                      aClient);

    61     CleanupStack::PushL(me);

    62     me->ConstructL();

    63     CleanupStack::Pop(me);

    64     return (me);

    65     }

    66 

    67 

    68 // -----------------------------------------------------------------------------

    69 // CDevandTruSrvCertStore::CDevandTruSrvCertStore()

    70 // -----------------------------------------------------------------------------

    71 //

    72 CDevandTruSrvCertStore::CDevandTruSrvCertStore(TInt aUID,

    73                                                MCTToken& aToken, 

    74                                                RDevTokenClientSession& aClient) :

    75     CDTClient(aUID, aToken, aClient)  

    76     {

    77     iFilter = NULL;

    78     }

    79 

    80 

    81 // -----------------------------------------------------------------------------

    82 // CDevandTruSrvCertStore::~CDevandTruSrvCertStore()

    83 // -----------------------------------------------------------------------------

    84 //

    85 CDevandTruSrvCertStore::~CDevandTruSrvCertStore()

    86     {

    87     if( iFilter )

    88         {

    89     	delete iFilter;

    90         }

    91     }

    92 

    93 

    94 // -----------------------------------------------------------------------------

    95 // CDevandTruSrvCertStore::ConstructL()

    96 // -----------------------------------------------------------------------------

    97 //

    98 void CDevandTruSrvCertStore::ConstructL()

    99     {

   100     CActiveScheduler::Add(this);

   101     }

   102 

   103 

   104 // -----------------------------------------------------------------------------

   105 // CDevandTruSrvCertStore::DoRelease()

   106 // -----------------------------------------------------------------------------

   107 //

   108 void CDevandTruSrvCertStore::DoRelease()

   109     {

   110     MCTTokenInterface::DoRelease();

   111     }

   112 

   113 

   114 // -----------------------------------------------------------------------------

   115 // CDevandTruSrvCertStore::Token()

   116 // -----------------------------------------------------------------------------

   117 //

   118 MCTToken& CDevandTruSrvCertStore::Token()

   119     {

   120     return iToken;

   121     }

   122 

   123 

   124 // -----------------------------------------------------------------------------

   125 // CDevandTruSrvCertStore::RunL()

   126 // -----------------------------------------------------------------------------

   127 //  

   128 void CDevandTruSrvCertStore::RunL()

   129     {

   130     // Never active, so should never get called

   131     DevTokenPanic(ENoRequestOutstanding);

   132     }

   133 

   134 

   135 //MCTCertStore 

   136 

   137 // -----------------------------------------------------------------------------

   138 // CDevandTruSrvCertStore::List()

   139 // -----------------------------------------------------------------------------

   140 //

   141 void CDevandTruSrvCertStore::List(RMPointerArray<CCTCertInfo>& aCerts, 

   142                                   const CCertAttributeFilter& aFilter,

   143                                   TRequestStatus& aStatus)

   144     {

   145     CDevToken* token = static_cast<CDevToken*>( &iToken ); 

   146     

   147     CDevTokenType* tokenType = static_cast<CDevTokenType*>( &(token->TokenType()) );

   148     

   149     if ( tokenType->iUid.iUid == DEVCERTSTORE_IMPLEMENTATION_UID )

   150         {

   151         if (aFilter.iOwnerType != EUserCertificate)

   152             {

   153             if( aFilter.iOwnerTypeIsSet )

   154                 {

   155                 TRequestStatus* status = &aStatus;

   156                 User::RequestComplete( status, KErrNone );

   157                 return;	

   158                 }

   159             //If the owner type is not set, we create a filter and 

   160             // set the type to EUserCertificate    

   161             else

   162                 {

   163                 //alway use new filter.

   164                 if( iFilter )

   165                     {

   166                 	delete iFilter;

   167                 	iFilter = NULL;

   168                     }

   169                 TRAPD( err, iFilter = CCertAttributeFilter::NewL() );	

   170                 if ( err != KErrNone )    

   171                     {

   172                     TRequestStatus* status = &aStatus;

   173                     User::RequestComplete( status, err ); 

   174                     return;	

   175                 	  }

   176                 

   177                 CopyFilter( iFilter, aFilter );

   178                 //Set owner type to user certificate

   179                 iFilter->SetOwnerType( EUserCertificate );

   180                 

   181                 TRAPD(r, DoListL(aCerts, *iFilter));

   182                 FreeRequestBuffer();

   183                 TRequestStatus* status = &aStatus;

   184                 User::RequestComplete(status, r); 

   185                 return;

   186                 }

   187             }

   188         }

   189     else if ( tokenType->iUid.iUid == TRUSRVCERTSTORE_IMPLEMENTATION_UID )

   190         {

   191         if (aFilter.iOwnerType != EPeerCertificate)

   192             {

   193             if( aFilter.iOwnerTypeIsSet )

   194                 {

   195                 TRequestStatus* status = &aStatus;

   196                 User::RequestComplete( status, KErrNone );

   197                 return;	

   198                 }

   199             //If the owner type is not set, we create a filter and 

   200             // set the type to EPeerCertificate      

   201             else

   202                 {

   203                 if( iFilter )

   204                     {

   205                 	delete iFilter;

   206                 	iFilter = NULL;

   207                     }

   208                     

   209                 TRAPD( er, iFilter = CCertAttributeFilter::NewL() );	

   210                 if ( er != KErrNone )    

   211                     {

   212                     TRequestStatus* status = &aStatus;

   213                     User::RequestComplete( status, er ); 

   214                     return;	

   215                 	  }    

   216 

   217                 CopyFilter( iFilter, aFilter );

   218                 

   219                 iFilter->SetOwnerType( EPeerCertificate );

   220                 TRAPD(r, DoListL(aCerts, *iFilter));

   221                 FreeRequestBuffer();

   222                 TRequestStatus* status = &aStatus;

   223                 User::RequestComplete(status, r); 

   224                 return;	

   225                 }

   226             }

   227         }

   228     else

   229         {

   230         TRequestStatus* status = &aStatus;

   231         User::RequestComplete( status, KErrNone );  

   232         return; 

   233         }    

   234 

   235     TRAPD(r, DoListL(aCerts, aFilter));

   236     FreeRequestBuffer();

   237     TRequestStatus* status = &aStatus;

   238     User::RequestComplete(status, r); 

   239     }

   240 

   241 

   242 // -----------------------------------------------------------------------------

   243 // CDevandTruSrvCertStore::CopyFilterL()

   244 // -----------------------------------------------------------------------------

   245 //

   246 void CDevandTruSrvCertStore::CopyFilter( CCertAttributeFilter* aDesFilter, const CCertAttributeFilter& aSrcFilter )

   247     {

   248     if ( aSrcFilter.iLabelIsSet )

   249         {

   250     	aDesFilter->SetLabel( aSrcFilter.iLabel );

   251         }

   252 

   253 	if ( aSrcFilter.iUidIsSet )

   254 	    {

   255 		aDesFilter->SetUid( aSrcFilter.iUid );

   256 	    }

   257 

   258 	if ( aSrcFilter.iFormatIsSet )

   259 	    {

   260 		aDesFilter->SetFormat( aSrcFilter.iFormat );

   261 	    }

   262 

   263 	if ( aSrcFilter.iOwnerTypeIsSet )

   264 	    {

   265 		aDesFilter->SetOwnerType( aSrcFilter.iOwnerType );

   266 	    }

   267 	

   268 

   269 	if ( aSrcFilter.iSubjectKeyIdIsSet )

   270 	   {

   271 	   aDesFilter->SetSubjectKeyId( aSrcFilter.iSubjectKeyId );	

   272 	   }

   273 

   274 	if ( aSrcFilter.iIssuerKeyIdIsSet )

   275 	    {

   276 		aDesFilter->SetIssuerKeyId( aSrcFilter.iIssuerKeyId );

   277 	    }

   278 	    

   279     aDesFilter->SetKeyUsage( aSrcFilter.iKeyUsage );    

   280     }

   281 

   282 

   283 // -----------------------------------------------------------------------------

   284 // CDevandTruSrvCertStore::DoListL()

   285 // -----------------------------------------------------------------------------

   286 //

   287 void CDevandTruSrvCertStore::DoListL(RMPointerArray<CCTCertInfo>& aCerts, 

   288                  const CCertAttributeFilter& aFilter)

   289     {

   290     HBufC8* filterBuf = HBufC8::NewLC(DevTokenDataMarshaller::Size(aFilter));

   291     TPtr8 ptr(filterBuf->Des());

   292     DevTokenDataMarshaller::WriteL(aFilter, ptr);

   293     TIpcArgs args(0, filterBuf, 0, &iRequestPtr);

   294     SendSyncRequestAndHandleOverflowL(EListCerts, KDefaultBufferSize, args);

   295     CleanupStack::PopAndDestroy(filterBuf);

   296     DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aCerts);

   297     }

   298 

   299 

   300 // -----------------------------------------------------------------------------

   301 // CDevandTruSrvCertStore::CancelList()

   302 // -----------------------------------------------------------------------------

   303 //

   304 void CDevandTruSrvCertStore::CancelList()

   305     {

   306     // synchronous, nothing to do

   307     }

   308 

   309 

   310 // -----------------------------------------------------------------------------

   311 // CDevandTruSrvCertStore::GetCert()

   312 // -----------------------------------------------------------------------------

   313 //

   314 void CDevandTruSrvCertStore::GetCert(CCTCertInfo*& aCertInfo, 

   315                                      const TCTTokenObjectHandle& aHandle,

   316                                      TRequestStatus& aStatus)

   317     {

   318     TRAPD(r, DoGetCertL(aCertInfo, aHandle));

   319     FreeRequestBuffer();

   320     TRequestStatus* stat = &aStatus;

   321     User::RequestComplete(stat, r); 

   322     }

   323 

   324 

   325 // -----------------------------------------------------------------------------

   326 // CDevandTruSrvCertStore::DoGetCertL()

   327 // -----------------------------------------------------------------------------

   328 //

   329 void CDevandTruSrvCertStore::DoGetCertL(CCTCertInfo*& aCertInfo, 

   330                                         const TCTTokenObjectHandle& aHandle)

   331     {

   332     User::LeaveIfError(AllocRequestBuffer(sizeof(CCTCertInfo))); // assumes serialized size <= sizeof class

   333     TIpcArgs args(aHandle.iObjectId, 0, 0, &iRequestPtr);

   334     User::LeaveIfError(iClientSession.SendRequest(EGetCert, args));

   335     DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aCertInfo);

   336     }

   337 

   338 

   339 // -----------------------------------------------------------------------------

   340 // CDevandTruSrvCertStore::CancelGetCert()

   341 // -----------------------------------------------------------------------------

   342 //

   343 void CDevandTruSrvCertStore::CancelGetCert()

   344     {

   345     // synchronous, nothing to do

   346     }

   347 

   348 

   349 // -----------------------------------------------------------------------------

   350 // CDevandTruSrvCertStore::Applications()

   351 // -----------------------------------------------------------------------------

   352 //

   353 void CDevandTruSrvCertStore::Applications(const CCTCertInfo& aCertInfo, 

   354                                           RArray<TUid>& aApplications,

   355                                           TRequestStatus& aStatus)

   356     {

   357     TRAPD(r, DoApplicationsL(aCertInfo, aApplications));

   358     FreeRequestBuffer();

   359     TRequestStatus* status = &aStatus;

   360     User::RequestComplete(status, r); 

   361     }

   362 

   363 

   364 // -----------------------------------------------------------------------------

   365 // CDevandTruSrvCertStore::DoApplicationsL()

   366 // -----------------------------------------------------------------------------

   367 //

   368 void CDevandTruSrvCertStore::DoApplicationsL(const CCTCertInfo& aCertInfo, 

   369                                              RArray<TUid>& aApplications)

   370     {

   371     TIpcArgs args(aCertInfo.Handle().iObjectId, 0, 0, &iRequestPtr);

   372     SendSyncRequestAndHandleOverflowL(EApplications, KDefaultBufferSize, args);

   373     DevTokenDataMarshaller::ReadL(iRequestPtr, aApplications);        

   374     }

   375 

   376 

   377 // -----------------------------------------------------------------------------

   378 // CDevandTruSrvCertStore::CancelApplications()

   379 // -----------------------------------------------------------------------------

   380 //

   381 void CDevandTruSrvCertStore::CancelApplications()

   382     {

   383     // synchronous, nothing to do

   384     }

   385 

   386 

   387 // -----------------------------------------------------------------------------

   388 // CDevandTruSrvCertStore::IsApplicable()

   389 // -----------------------------------------------------------------------------

   390 //

   391 void CDevandTruSrvCertStore::IsApplicable(const CCTCertInfo& aCertInfo, TUid aApplication, 

   392                     TBool& aIsApplicable, TRequestStatus& aStatus)

   393     {

   394     TIpcArgs args(aCertInfo.Handle().iObjectId, 0, aApplication.iUid);

   395     TInt r = iClientSession.SendRequest(EIsApplicable, args); 

   396     if (r >= 0)

   397         {

   398         aIsApplicable = !!r;  // Convert TInt to TBool

   399         r = KErrNone;

   400         }

   401 

   402     TRequestStatus* status = &aStatus;

   403     User::RequestComplete(status, r); 

   404     }

   405 

   406 

   407 // -----------------------------------------------------------------------------

   408 // CDevandTruSrvCertStore::CancelIsApplicable()

   409 // -----------------------------------------------------------------------------

   410 //

   411 void CDevandTruSrvCertStore::CancelIsApplicable()

   412     {

   413     // synchronous, nothing to do

   414     }

   415 

   416 

   417 // -----------------------------------------------------------------------------

   418 // CDevandTruSrvCertStore::Trusted()

   419 // -----------------------------------------------------------------------------

   420 //

   421 void CDevandTruSrvCertStore::Trusted(const CCTCertInfo& aCertInfo, TBool& aTrusted, 

   422                  TRequestStatus& aStatus)

   423     {

   424     TIpcArgs args(aCertInfo.Handle().iObjectId);

   425     TInt r = iClientSession.SendRequest(ETrusted, args);  

   426     if (r >= 0)

   427         {

   428         aTrusted = !!r;  // Convert TInt to TBool

   429         r = KErrNone;

   430         }

   431 

   432     TRequestStatus* status = &aStatus;

   433     User::RequestComplete(status, r); 

   434     }

   435 

   436 

   437 // -----------------------------------------------------------------------------

   438 // CDevandTruSrvCertStore::CancelTrusted()

   439 // -----------------------------------------------------------------------------

   440 //

   441 void CDevandTruSrvCertStore::CancelTrusted()

   442     {

   443     // synchronous, nothing to do

   444     }

   445 

   446 

   447 // -----------------------------------------------------------------------------

   448 // CDevandTruSrvCertStore::Retrieve()

   449 // -----------------------------------------------------------------------------

   450 //

   451 void CDevandTruSrvCertStore::Retrieve(const CCTCertInfo& aCertInfo, TDes8& aEncodedCert,

   452                   TRequestStatus& aStatus)

   453     {

   454     TInt err = DoRetrieve(aCertInfo, aEncodedCert);

   455     FreeRequestBuffer();

   456     TRequestStatus* stat = &aStatus;

   457     User::RequestComplete(stat, err);

   458     }

   459 

   460 

   461 // -----------------------------------------------------------------------------

   462 // CDevandTruSrvCertStore::DoRetrieve()

   463 // -----------------------------------------------------------------------------

   464 //

   465 TInt CDevandTruSrvCertStore::DoRetrieve(const CCTCertInfo& aCertInfo, TDes8& aEncodedCert)

   466     {

   467     if (aCertInfo.Size() <= 0)

   468         {

   469         return KErrArgument;

   470         }

   471 

   472     if (aEncodedCert.MaxSize() < aCertInfo.Size())

   473         {

   474         return KErrOverflow;

   475         }

   476 

   477     TInt r = AllocRequestBuffer(aEncodedCert.MaxSize());  

   478     if (KErrNone!=r)

   479         {

   480         return r;

   481         }

   482 

   483     TIpcArgs args(aCertInfo.Handle().iObjectId, 0, 0, &iRequestPtr);

   484     r = iClientSession.SendRequest(ERetrieve, args);

   485     if (r == KErrNone)

   486         {

   487         aEncodedCert.Copy(iRequestPtr);

   488         }

   489 

   490     return r;

   491     }

   492 

   493 

   494 // -----------------------------------------------------------------------------

   495 // CDevandTruSrvCertStore::CancelRetrieve()

   496 // -----------------------------------------------------------------------------

   497 //

   498 void CDevandTruSrvCertStore::CancelRetrieve()

   499     {

   500     // synchronous, nothing to do

   501     }

   502 

   503 

   504 //  MCTWritableCertStore interface

   505 

   506 // -----------------------------------------------------------------------------

   507 // CDevandTruSrvCertStore::Add()

   508 // -----------------------------------------------------------------------------

   509 //

   510 void CDevandTruSrvCertStore::Add(const TDesC& aLabel, TCertificateFormat aFormat,

   511                TCertificateOwnerType aCertificateOwnerType, 

   512                const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

   513                const TDesC8& aCert, TRequestStatus& aStatus)

   514     {

   515     Add(aLabel, aFormat, aCertificateOwnerType, aSubjectKeyId, aIssuerKeyId, aCert, 

   516     ETrue, aStatus);

   517     } 

   518 

   519 

   520 // -----------------------------------------------------------------------------

   521 // CDevandTruSrvCertStore::Add()

   522 // -----------------------------------------------------------------------------

   523 //

   524 void CDevandTruSrvCertStore::Add(const TDesC& aLabel, TCertificateFormat aFormat,

   525                TCertificateOwnerType aCertificateOwnerType, 

   526                const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

   527                const TDesC8& aCert, const TBool aDeletable,

   528                TRequestStatus& aStatus)

   529     {

   530     CDevToken* token = static_cast<CDevToken*>( &iToken ); 

   531 

   532     CDevTokenType* tokenType = static_cast<CDevTokenType*>( &(token->TokenType()) );

   533 

   534     if ( tokenType->iUid.iUid == DEVCERTSTORE_IMPLEMENTATION_UID )

   535         {

   536         if (aCertificateOwnerType != EUserCertificate)

   537             {

   538             TRequestStatus* status = &aStatus;

   539             User::RequestComplete( status, KErrArgument );  

   540             return; 

   541             }

   542         }

   543     else if ( tokenType->iUid.iUid == TRUSRVCERTSTORE_IMPLEMENTATION_UID )

   544         {

   545         if (aCertificateOwnerType != EPeerCertificate)

   546             {

   547             TRequestStatus* status = &aStatus;

   548             User::RequestComplete( status, KErrArgument );  

   549             return; 

   550             }

   551         }

   552     else

   553         {

   554         TRequestStatus* status = &aStatus;

   555         User::RequestComplete( status, KErrArgument );  

   556         return; 

   557         } 

   558 

   559 

   560     TRequestStatus* stat = &aStatus;

   561     if (aLabel.Length() > KMaxCertLabelLength)

   562         {

   563         //  Too long to be a label

   564         User::RequestComplete(stat, KErrOverflow);

   565         return;

   566         }

   567 

   568     TPckgBuf<TDevTokenAddCertDataStruct> data;

   569     data().iLabel.Zero();

   570     data().iSubjectKeyId.Zero();

   571     data().iIssuerKeyId.Zero();   

   572     data().iLabel.Copy(aLabel);   

   573     data().iFormat = aFormat;

   574     data().iCertificateOwnerType = aCertificateOwnerType;

   575     if (aSubjectKeyId)

   576         {

   577         data().iSubjectKeyId.Copy(*aSubjectKeyId);

   578         }

   579     if (aIssuerKeyId)

   580         {

   581         data().iIssuerKeyId.Copy(*aIssuerKeyId);

   582         }

   583     data().iDeletable = aDeletable;

   584 

   585     TInt r = AllocRequestBuffer(aCert.Size());

   586 

   587     if (r!=KErrNone)

   588         {

   589         User::RequestComplete(stat, r);

   590         return;

   591         }

   592 

   593     iRequestPtr.FillZ();

   594     iRequestPtr.Copy(aCert);

   595 

   596     TIpcArgs args(0, &data, 0, &iRequestPtr);

   597     r = iClientSession.SendRequest(EAddCert, args);

   598 

   599     FreeRequestBuffer();

   600     User::RequestComplete(stat, r);

   601     } 

   602 

   603 

   604 // -----------------------------------------------------------------------------

   605 // CDevandTruSrvCertStore::CancelAdd()

   606 // -----------------------------------------------------------------------------

   607 //

   608 void CDevandTruSrvCertStore::CancelAdd()

   609     {

   610     // synchronous, nothing to do

   611     }

   612 

   613 

   614 // -----------------------------------------------------------------------------

   615 // CDevandTruSrvCertStore::Remove()

   616 // -----------------------------------------------------------------------------

   617 //

   618 void CDevandTruSrvCertStore::Remove(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus)

   619     {

   620     TIpcArgs args(aCertInfo.Handle().iObjectId);

   621     TInt r = iClientSession.SendRequest(ERemoveCert, args); 

   622     TRequestStatus* stat = &aStatus;

   623     User::RequestComplete(stat, r);

   624     }

   625 

   626 

   627 // -----------------------------------------------------------------------------

   628 // CDevandTruSrvCertStore::CancelRemove()

   629 // -----------------------------------------------------------------------------

   630 //

   631 void CDevandTruSrvCertStore::CancelRemove()

   632     {

   633     // synchronous, nothing to do

   634     }

   635 

   636 

   637 // -----------------------------------------------------------------------------

   638 // CDevandTruSrvCertStore::SetApplicability()

   639 // -----------------------------------------------------------------------------

   640 //

   641 void CDevandTruSrvCertStore::SetApplicability(const CCTCertInfo& aCertInfo, 

   642                       const RArray<TUid>& aApplications,

   643                       TRequestStatus &aStatus)

   644     {

   645     TInt r = AllocRequestBuffer(DevTokenDataMarshaller::Size(aApplications));

   646     if (r != KErrNone)

   647         {

   648         TRequestStatus* stat = &aStatus;

   649         User::RequestComplete(stat, r);

   650         return;

   651         }

   652     DevTokenDataMarshaller::Write(aApplications, iRequestPtr);

   653 

   654     TIpcArgs args(aCertInfo.Handle().iObjectId, 0, &iRequestPtr);

   655     TInt err = iClientSession.SendRequest(ESetApplicability, args);

   656     TRequestStatus* status = &aStatus;

   657     User::RequestComplete(status, err);

   658     }

   659 

   660 

   661 // -----------------------------------------------------------------------------

   662 // CDevandTruSrvCertStore::CancelSetApplicability()

   663 // -----------------------------------------------------------------------------

   664 //

   665 void CDevandTruSrvCertStore::CancelSetApplicability()

   666     {

   667     // synchronous, nothing to do

   668     }

   669 

   670 

   671 // -----------------------------------------------------------------------------

   672 // CDevandTruSrvCertStore::SetTrust()

   673 // -----------------------------------------------------------------------------

   674 //

   675 void CDevandTruSrvCertStore::SetTrust(const CCTCertInfo& aCertInfo,

   676                   TBool aTrusted, 

   677                   TRequestStatus& aStatus)

   678     {

   679     TIpcArgs args(aCertInfo.Handle().iObjectId, 0, aTrusted);

   680     TInt err = iClientSession.SendRequest(ESetTrust, args);

   681     TRequestStatus* status = &aStatus;

   682     User::RequestComplete(status, err);

   683     }

   684 

   685 

   686 // -----------------------------------------------------------------------------

   687 // CDevandTruSrvCertStore::CancelSetTrust()

   688 // -----------------------------------------------------------------------------

   689 //

   690 void CDevandTruSrvCertStore::CancelSetTrust()

   691     {

   692     // synchronous, nothing to do

   693     }

   694     

   695 //EOF

   696