1 /*

     2 * Copyright (c) 2002-2008 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 DmAdStore

    15 *

    16 */

    17 

    18 

    19 

    20 #include "DmAdStore.h"

    21 #include "DmAdRtNodeData.h"

    22 #include "dmadutil.h"

    23 #include "vpnlogger.h"

    24 

    25 #include "pkcs12vpn.h"

    26     

    27 CDmAdStore* CDmAdStore::NewL(MDmAdCallBack* aDmAdCallBack)

    28     {

    29     TRACE("CDmAdStore::NewL");

    30     

    31     CDmAdStore *self = new (ELeave) CDmAdStore();

    32     CleanupStack::PushL(self);

    33     self->ConstructL(aDmAdCallBack);

    34     CleanupStack::Pop(self);

    35     return self;

    36     }

    37 

    38 void CDmAdStore::ConstructL(MDmAdCallBack* aDmAdCallBack)

    39     {

    40     TRACE("CDmAdStore::ConstructL");

    41             

    42     TInt status = iPkiServiceApi.Connect();

    43     DEBUG_LOG1(_L("Connect status: %d"), status);

    44     User::LeaveIfError(status);    

    45     iCert = CDmAdCert::NewL(iPkiServiceApi);

    46     iCertReq = CDmAdCertReq::NewL(iPkiServiceApi, aDmAdCallBack);

    47     iPrivKey = CDmAdPrivKey::NewL(iPkiServiceApi);    

    48     iPKCS12Obj = CDmAdPKCS12::NewL(iPkiServiceApi);

    49     }

    50     

    51 CDmAdStore::CDmAdStore()

    52     {

    53     TRACE("CDmAdStore::CDmAdStore");

    54     }

    55 

    56 CDmAdStore::~CDmAdStore()

    57     {

    58     TRACE("CDmAdStore::~CDmAdStore");

    59     

    60     iPkiServiceApi.Close();

    61     delete iCert;

    62     delete iCertReq;

    63     delete iPrivKey;

    64     delete iPKCS12Obj;

    65     }

    66     

    67 TBool CDmAdStore::FindRtNodeL(const TDesC8& aLuid, const TDesC8& aUri)

    68     {

    69     TRACE("CDmAdStore::FindRtNodeL");

    70     

    71     TDmAdUriType uriType = CDmAdRtNodeData::UriTypeL(aUri);

    72     switch (uriType)

    73         {

    74         case EDmAdUriTypeCert:

    75             return CertFindRtNodeL(aLuid, aUri);

    76         case EDmAdUriTypeCertReq:

    77             return CertReqFindRtNodeL(aLuid, aUri);

    78         case EDmAdUriTypePrivKey:

    79             return PrivKeyFindRtNodeL(aLuid, aUri);

    80         case EDmAdUriTypePKCS12:

    81             // For PKCS#12, a special case

    82             return EFalse;

    83         default:

    84             DEBUG_LOG(_L("Unexcepted URI type"));

    85             User::Leave(KErrGeneral);

    86             return EFalse;

    87         }

    88     }

    89 

    90 void CDmAdStore::LuidListL(const TDesC8& aUri, const TDesC8& aLuid, RPointerArray<HBufC8>& aLuidList)

    91     {

    92     TRACE("CDmAdStore::LuidListL");

    93     

    94     TDmAdUriType uriType = CDmAdRtNodeData::UriTypeL(aUri);

    95     switch (uriType)

    96         {

    97         case EDmAdUriTypeCert:

    98             CertLuidListL(aUri, aLuid, aLuidList);

    99             break;

   100         case EDmAdUriTypeCertReq:

   101             CertReqLuidListL(aUri, aLuid, aLuidList);

   102             break;

   103         case EDmAdUriTypePrivKey:

   104             PrivKeyLuidListL(aUri, aLuid, aLuidList);

   105             break;

   106         case EDmAdUriTypePKCS12:

   107             // For PKCS#12, a special case

   108             break;

   109         default:

   110             DEBUG_LOG(_L("CDmAdStore::LuidListLC: Unexcepted URI type"));

   111             User::Leave(KErrGeneral);

   112             break;

   113         }    

   114     }

   115     

   116 void CDmAdStore::FetchRtNodeL(CDmAdRtNode& aRtNode)

   117     {

   118     TRACE("CDmAdStore::FetchRtNodeL");

   119         

   120     TDmAdUriType uriType = aRtNode.Data()->UriType();

   121     switch (uriType)

   122         {

   123         case EDmAdUriTypeCert:

   124             CertFetchRtNodeL(aRtNode);

   125             break;

   126         case EDmAdUriTypeCertReq:

   127             CertReqFetchRtNodeL(aRtNode);

   128             break;

   129         case EDmAdUriTypePrivKey:

   130             PrivKeyFetchRtNodeL(aRtNode);

   131             break;

   132         case EDmAdUriTypePKCS12:

   133             // For PKCS#12, a special case

   134             break;

   135         default:

   136             DEBUG_LOG(_L("Unexcepted URI type"));

   137             User::Leave(KErrGeneral);

   138             break;

   139         }

   140     }

   141     

   142 void CDmAdStore::SaveTopLevelRtNodeL(CDmAdRtNode& aRtNode, CArrayPtr<CDmAdRtNode>& aChildRtNodes)

   143     {

   144     TRACE("CDmAdStore::SaveTopLevelRtNodeL");

   145     

   146     TDmAdUriType uriType = aRtNode.Data()->UriType();

   147     switch (uriType)

   148         {

   149         case EDmAdUriTypeCert:

   150             CertSaveTopLevelRtNodeL(aRtNode, aChildRtNodes);

   151             break;

   152         case EDmAdUriTypeCertReq:

   153             CertReqSaveTopLevelRtNodeL(aRtNode, aChildRtNodes);

   154             break;

   155         case EDmAdUriTypePKCS12:

   156             PKCS12SaveTopLevelRtNodeL(aRtNode, aChildRtNodes);

   157             break;

   158         default:

   159             DEBUG_LOG(_L("Unexcepted URI type"));

   160             User::Leave(KErrGeneral);

   161             break;

   162         }

   163     }

   164 

   165 void CDmAdStore::SaveChildLevelRtNodeL(CDmAdRtNode& aRtNode)

   166     {

   167     TRACE("CDmAdStore::SaveChildLevelRtNodeL");

   168     

   169     TDmAdUriType uriType = aRtNode.Data()->UriType();

   170     switch (uriType)

   171         {

   172         case EDmAdUriTypeCert:

   173             CertSaveChildLevelRtNodeL(aRtNode);

   174             break;

   175         case EDmAdUriTypeCertReq:

   176             CertReqSaveChildLevelRtNodeL(aRtNode);

   177             break;

   178         case EDmAdUriTypePKCS12:

   179             // For PKCS#12, a special case

   180             break;

   181         default:

   182             DEBUG_LOG(_L("Unexcepted URI type"));

   183             User::Leave(KErrGeneral);

   184             break;

   185         }

   186     }

   187 

   188 void CDmAdStore::DeleteRtNodeL(const TDesC8& aLuid, const TDesC8& aUri)

   189     {

   190     TRACE("CDmAdStore::DeleteRtNodeL");

   191     

   192     TDmAdUriType uriType = CDmAdRtNodeData::UriTypeL(aUri);

   193     switch (uriType)

   194         {

   195         case EDmAdUriTypeCert:

   196             CertDeleteRtNodeL(aLuid, aUri);

   197             break;

   198         case EDmAdUriTypeCertReq:

   199             CertReqDeleteRtNodeL(aLuid, aUri);

   200             break;

   201         case EDmAdUriTypePrivKey:

   202             PrivKeyDeleteRtNodeL(aLuid, aUri);

   203             break;

   204         case EDmAdUriTypePKCS12:

   205             // For PKCS#12, a special case

   206             break;

   207         default:

   208             DEBUG_LOG(_L("Unexcepted URI type"));

   209             User::Leave(KErrGeneral);

   210             break;

   211         }

   212     }

   213 

   214 //=========================================================================

   215 //=========================================================================

   216 

   217 TBool CDmAdStore::CertFindRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

   218     {

   219     TRACE("CDmAdStore::CertFindRtNodeL");

   220     

   221     TBool ret = EFalse;

   222     if (aLuid.Length() > 0)

   223         {

   224         if (iCert->FindL(aLuid))

   225             {

   226             ret = ETrue;

   227             }

   228         }

   229     return ret;

   230     }

   231 

   232 void CDmAdStore::CertLuidListL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/, RPointerArray<HBufC8>& aLuidList)

   233     {

   234     TRACE("CDmAdStore::CertLuidListL");

   235     

   236     iCert->ListL(aLuidList);

   237     }

   238     

   239 void CDmAdStore::CertFetchRtNodeL(CDmAdRtNode& aRtNode)

   240     {

   241     TRACE("CDmAdStore::CertFetchRtNodeL");

   242     

   243     TPtrC8 luid(aRtNode.Luid());

   244     if (luid.Length() == 0)

   245         {

   246         DEBUG_LOG(_L("Zero length luid"));

   247         User::Leave(KErrNotFound);

   248         }

   249 

   250     CDmAdCertData* data = aRtNode.Data()->CertData();

   251     CDmAdCertParms* certParms = CDmAdCertParms::NewL();

   252     CleanupStack::PushL(certParms);

   253     iCert->FetchL(luid, *certParms);

   254     data->RestoreL(*certParms);

   255     CleanupStack::PopAndDestroy(certParms);

   256     }

   257     

   258 void CDmAdStore::CertSaveTopLevelRtNodeL(CDmAdRtNode& aRtNode, CArrayPtr<CDmAdRtNode>& aChildRtNodes)

   259     {

   260     TRACE("CDmAdStore::CertSaveTopLevelRtNodeL");

   261     

   262     if (aChildRtNodes.Count() > 0)

   263         {

   264         DEBUG_LOG(_L("ChildRtNode count > 0"));        

   265         User::Leave(KErrGeneral);

   266         }

   267 

   268     if (aRtNode.IsJustFetched())

   269         {

   270         return;

   271         }

   272     

   273     CDmAdCertData* data = aRtNode.Data()->CertData();

   274     

   275     CDmAdCertParms* certParms = CDmAdCertParms::NewL();

   276     CleanupStack::PushL(certParms);

   277     

   278     data->ToStoreL(*certParms);

   279 

   280     if (aRtNode.IsSomeLeafAddedToRtNode())

   281         {

   282         HBufC8* luid = iCert->AddL(*certParms);

   283         CleanupStack::PushL(luid);

   284         aRtNode.SetLuidL(*luid);

   285         CleanupStack::PopAndDestroy(luid); 

   286         }

   287     else

   288         {

   289         iCert->UpdateL(aRtNode.Luid(), *certParms);

   290         }

   291     

   292     CleanupStack::PopAndDestroy(certParms);

   293     }

   294 

   295 void CDmAdStore::CertSaveChildLevelRtNodeL(CDmAdRtNode& /*aRtNode*/)

   296     {

   297     TRACE("CDmAdStore::CertSaveChildLevelRtNodeL");

   298     

   299     DEBUG_LOG(_L("Method not implemented"));

   300     User::Leave(KErrGeneral);

   301     }

   302 

   303 void CDmAdStore::CertDeleteRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

   304     {

   305     TRACE("CDmAdStore::CertDeleteRtNodeL");

   306     

   307     if (aLuid.Length() == 0)

   308         {

   309         DEBUG_LOG(_L("aLuid length is 0"));

   310         User::Leave(KErrNotFound);

   311         }

   312 

   313     iCert->DeleteL(aLuid);

   314     }

   315 

   316 //=========================================================================

   317 //=========================================================================

   318 

   319 TBool CDmAdStore::CertReqFindRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

   320     {

   321     TRACE("CDmAdStore::CertReqFindRtNodeL");

   322     

   323     TBool ret = EFalse;

   324     if (aLuid.Length() > 0)

   325         {

   326         if (iCertReq->FindL(aLuid))

   327             {

   328             ret = ETrue;

   329             }

   330         }

   331     return ret;

   332     }

   333 

   334 void CDmAdStore::CertReqLuidListL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/,RPointerArray<HBufC8>& aLuidList)

   335     {

   336     TRACE("CDmAdStore::CertReqLuidListL");

   337     

   338     iCertReq->ListL(aLuidList);

   339     }

   340     

   341 void CDmAdStore::CertReqFetchRtNodeL(CDmAdRtNode& aRtNode)

   342     {

   343     TRACE("CDmAdStore::CertReqFetchRtNodeL");

   344     

   345     TPtrC8 luid(aRtNode.Luid());

   346     if (luid.Length() == 0)

   347         {

   348         DEBUG_LOG(_L("luid length is 0"));

   349         User::Leave(KErrNotFound);

   350         }

   351 

   352     CDmAdCertReqData* data = aRtNode.Data()->CertReqData();

   353     CDmAdCertReqParms* CertReqParms = CDmAdCertReqParms::NewL();

   354     CleanupStack::PushL(CertReqParms);

   355     iCertReq->FetchL(luid, *CertReqParms);

   356     data->RestoreL(*CertReqParms);

   357     CleanupStack::PopAndDestroy(CertReqParms);

   358     }

   359     

   360 void CDmAdStore::CertReqSaveTopLevelRtNodeL(CDmAdRtNode& aRtNode, CArrayPtr<CDmAdRtNode>& aChildRtNodes)

   361     {

   362     TRACE("CDmAdStore::CertReqSaveTopLevelRtNodeL");

   363     

   364     if (aChildRtNodes.Count() > 0)

   365         {

   366         DEBUG_LOG(_L("aChildRtNodes count > 0"));

   367         User::Leave(KErrGeneral);

   368         }

   369 

   370     if (aRtNode.IsJustFetched())

   371         {

   372         return;

   373         }

   374     

   375     CDmAdCertReqData* data = aRtNode.Data()->CertReqData();

   376     

   377     CDmAdCertReqParms* CertReqParms = CDmAdCertReqParms::NewL();

   378     CleanupStack::PushL(CertReqParms);

   379     

   380     data->ToStoreL(*CertReqParms);

   381 

   382     if (aRtNode.IsSomeLeafAddedToRtNode())

   383         {

   384         HBufC8* luid = iCertReq->AddL(*CertReqParms);

   385         CleanupStack::PushL(luid);

   386         aRtNode.SetLuidL(*luid);

   387         CleanupStack::PopAndDestroy(luid);

   388         }

   389     else

   390         {

   391         DEBUG_LOG(_L("aRtNode.IsSomeLeafAddedToRtNode() returned false"));

   392         User::Leave(KErrGeneral);

   393         /*

   394         //iCertReq->UpdateL(aRtNode.Luid(), *CertReqParms);

   395         CertReqDeleteRtNodeL(aRtNode.Luid(), aRtNode.Uri());

   396         

   397         HBufC8* luid = iCertReq->AddL(*CertReqParms);

   398         CleanupStack::PushL(luid);

   399         aRtNode.SetLuidL(*luid);

   400         iCallBack->SetMappingL(aRtNode.Uri(), aRtNode.Luid());

   401         CleanupStack::PopAndDestroy(); //luid

   402         */

   403         }

   404     

   405     CleanupStack::PopAndDestroy(CertReqParms);

   406     }

   407 

   408 void CDmAdStore::CertReqSaveChildLevelRtNodeL(CDmAdRtNode& /*aRtNode*/)

   409     {

   410     TRACE("CDmAdStore::CertReqSaveChildLevelRtNodeL");

   411     

   412     DEBUG_LOG(_L("Method not implemented"));

   413     User::Leave(KErrGeneral);

   414     }

   415 

   416 void CDmAdStore::CertReqDeleteRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

   417     {

   418     TRACE("CDmAdStore::CertReqDeleteRtNodeL");

   419     

   420     if (aLuid.Length() == 0)

   421         {

   422         DEBUG_LOG(_L("aLuid length is 0"));        

   423         User::Leave(KErrNotFound);

   424         }

   425 

   426     iCertReq->DeleteL(aLuid);

   427     }

   428 

   429 //=========================================================================

   430 //=========================================================================

   431 

   432 TBool CDmAdStore::PrivKeyFindRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

   433     {

   434     TRACE("CDmAdStore::PrivKeyFindRtNodeL");

   435     

   436     TBool ret = EFalse;

   437     if (aLuid.Length() > 0)

   438         {

   439         if (iPrivKey->FindL(aLuid))

   440             {

   441             ret = ETrue;

   442             }

   443         }

   444     return ret;

   445     }

   446 

   447 void CDmAdStore::PrivKeyLuidListL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/, RPointerArray<HBufC8>& aLuidList)

   448     {

   449     TRACE("CDmAdStore::PrivKeyLuidListL");

   450     iPrivKey->ListL(aLuidList);

   451     }

   452     

   453 void CDmAdStore::PrivKeyFetchRtNodeL(CDmAdRtNode& aRtNode)

   454     {

   455     TRACE("CDmAdStore::PrivKeyFetchRtNodeL");

   456     

   457     TPtrC8 luid(aRtNode.Luid());

   458     if (luid.Length() == 0)

   459         {

   460         DEBUG_LOG(_L("aLuid length is 0"));        

   461         User::Leave(KErrNotFound);

   462         }

   463 

   464     CDmAdPrivKeyData* data = aRtNode.Data()->PrivKeyData();

   465     CDmAdPrivKeyParms* PrivKeyParms = CDmAdPrivKeyParms::NewL();

   466     CleanupStack::PushL(PrivKeyParms);

   467     iPrivKey->FetchL(luid, *PrivKeyParms);

   468     data->RestoreL(*PrivKeyParms);

   469     CleanupStack::PopAndDestroy(PrivKeyParms);

   470     }

   471     

   472 

   473 void CDmAdStore::PrivKeyDeleteRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

   474     {

   475     TRACE("CDmAdStore::PrivKeyDeleteRtNodeL");

   476     

   477     if (aLuid.Length() == 0)

   478         {

   479         DEBUG_LOG(_L("aLuid length is 0"));        

   480         User::Leave(KErrNotFound);

   481         }

   482 

   483     iPrivKey->DeleteL(aLuid);

   484     }

   485 

   486 //=========================================================================

   487 //=========================================================================

   488 

   489 // PKCS#12 handling

   490 void CDmAdStore::PKCS12SaveTopLevelRtNodeL(CDmAdRtNode& aRtNode,

   491                                CArrayPtr<CDmAdRtNode>& aChildRtNodes) 

   492     {

   493     TRACE("CDmAdStore::PKCS12SaveTopLevelRtNodeL");

   494 

   495     if (aChildRtNodes.Count() > 0)

   496         {

   497         DEBUG_LOG(_L("ChildRtNode count > 0"));        

   498         User::Leave(KErrGeneral);

   499         }

   500 

   501     CDmAdPKCS12Data* data = aRtNode.Data()->PKCS12Data();

   502     

   503     CDmAdPKCS12Parms* pkcs12Parms = CDmAdPKCS12Parms::NewL();

   504     CleanupStack::PushL(pkcs12Parms);

   505     

   506     // Extract parameters from data

   507     data->ToStoreL(*pkcs12Parms);

   508 

   509     // Store PKCS#12 object contents to PKI

   510     iPKCS12Obj->AddL(*pkcs12Parms);

   511 

   512     TPtrC8 uri = aRtNode.Uri();

   513     DEBUG_LOG1(_L8(" Setting LUID to '%S'"), &uri);

   514     aRtNode.SetLuidL(uri);

   515     

   516     CleanupStack::PopAndDestroy(pkcs12Parms);

   517     }

   518 

   519 //=========================================================================

   520 //=========================================================================

   521 void CDmAdStore::PkiLogonL()

   522     {

   523     TRACE("CDmAdStore::PkiLogonL");

   524     

   525     TRequestStatus requestStatus;

   526     iPkiServiceApi.Logon(requestStatus);

   527     User::WaitForRequest(requestStatus);

   528     TInt status = requestStatus.Int();

   529     if (status != KErrNone && status != KPKIErrKeyStoreEmpty)

   530         {

   531         DEBUG_LOG1(_L("status = %d"), status);        

   532         User::Leave(status);

   533         }

   534     }

   535 

   536 void CDmAdStore::PkiLogoffL()

   537     {

   538     TRACE("CDmAdStore::PkiLogoffL");

   539     

   540     TRequestStatus requestStatus;

   541     iPkiServiceApi.Logoff(requestStatus);

   542     User::WaitForRequest(requestStatus);

   543     TInt status = requestStatus.Int();

   544     if (status != KErrNone && status != KPKIErrKeyStoreEmpty)

   545         {

   546         DEBUG_LOG1(_L("status = %d"), status);        

   547         User::Leave(status);

   548         }

   549     }

   550 

   551 void CDmAdStore::SetStoreTypeL(TInt aStore, TPkiServiceStoreType aStoreType)

   552     {

   553     TRACE("CDmAdStore::SetStoreTypeL");

   554     

   555     TInt status = iPkiServiceApi.SetStoreType(aStore, aStoreType);

   556     if (status != KErrNone)

   557         {

   558         DEBUG_LOG1(_L("status = %d"), status);        

   559         User::Leave(status);

   560         }

   561     }