1 /*

     2 * Copyright (c) 2000-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 CDmAdRtNodeData

    15 *

    16 */

    17 

    18 

    19 

    20 #include <utf.h>

    21 

    22 #include <x509cert.h>

    23 #include <x509keys.h>

    24 #include <x500dn.h>

    25 #include <x509certext.h>

    26 

    27 #include "DmAdRtNodeData.h"

    28 #include "dmadddf.h"

    29 #include "dmadutil.h"

    30 #include "vpnlogger.h"

    31 #include "dmadstoreprivkey.h"

    32 #include "pkidefs.h"

    33 #include "XwImpl.h"

    34 #include "dmadcertxmldefs.h"

    35 #include "XppImpl.h"

    36 #include <vpnlogmessages.rsg>

    37 

    38 

    39 // Macro to encode key usage bits

    40 // See method CDmAdCertData::KeyUsageLC

    41 #define ENC_BIT(a)                         \

    42     if( EFalse == keyUsageExt->IsSet(a) )  \

    43         {                                  \

    44         keyUsagePtr.Append('0');           \

    45         }                                  \

    46     else                                   \

    47         {                                  \

    48         keyUsagePtr.Append('1');           \

    49         }

    50 

    51 

    52 CDmAdRtNodeData* CDmAdRtNodeData::NewL(const TDesC8& aUri, MDmAdCallBack* aCallBack)

    53     {

    54     TRACE("CDmAdRtNodeData::NewL");

    55     

    56     CDmAdRtNodeData *self = new (ELeave) CDmAdRtNodeData();

    57     CleanupStack::PushL(self);

    58     self->ConstructL(aUri, aCallBack);

    59     CleanupStack::Pop(self);

    60     return self;

    61     }

    62 

    63 void CDmAdRtNodeData::ConstructL(const TDesC8& aUri, MDmAdCallBack* aCallBack)

    64     {

    65     TRACE("CDmAdRtNodeData::ConstructL");

    66     

    67     iUriType = UriTypeL(aUri);

    68     

    69     switch (iUriType)

    70         {

    71         case EDmAdUriTypeCert:

    72             u.iCert = CDmAdCertData::NewL(aCallBack);

    73             break;

    74         case EDmAdUriTypeCertReq:

    75             u.iCertReq = CDmAdCertReqData::NewL(aCallBack);

    76             break;

    77         case EDmAdUriTypePrivKey:

    78             u.iPrivKey = CDmAdPrivKeyData::NewL();

    79             break;

    80         case EDmAdUriTypePKCS12:

    81             u.iPKCS12 = CDmAdPKCS12Data::NewL();

    82             break;

    83         default:

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

    85             User::Leave(KErrGeneral);

    86             break;

    87         }    

    88     }

    89     

    90 CDmAdRtNodeData::CDmAdRtNodeData()

    91     {

    92     }

    93 

    94 CDmAdRtNodeData::~CDmAdRtNodeData()

    95     {

    96     TRACE("CDmAdRtNodeData::~CDmAdRtNodeData");

    97     

    98     switch (iUriType)

    99         {

   100         case EDmAdUriTypeCert:

   101             delete u.iCert;

   102             break;

   103         case EDmAdUriTypeCertReq:

   104             delete u.iCertReq;

   105             break;

   106         case EDmAdUriTypePrivKey:

   107             delete u.iPrivKey;

   108             break;

   109         case EDmAdUriTypePKCS12:

   110             delete u.iPKCS12;

   111             break;

   112         default:

   113             DEBUG_LOG(_L("Unknown URI type"));

   114             break;

   115         }   

   116     }

   117     

   118 //--------------------------------------------------------------------------

   119 

   120 TDmAdUriType CDmAdRtNodeData::UriType() const

   121     {

   122     TRACE("CDmAdRtNodeData::UriType");

   123     

   124     return iUriType;

   125     }

   126     

   127 TDmAdUriType CDmAdRtNodeData::UriTypeL(const TDesC8& aUri)

   128     {

   129     TRACE("CDmAdRtNodeData::UriTypeL");

   130     

   131     TDmAdUriType ret = EDmAdUriTypeCert;

   132     CArrayFix<TPtrC8>* uriSegList;

   133     TDmAdUtil::ParseUriLC(aUri, uriSegList);

   134     

   135     if (uriSegList->Count() < 2)

   136         {

   137         DEBUG_LOG(_L("uriSegList->Count() is less than 2"));        

   138         User::Leave(KErrGeneral);

   139         }

   140 

   141     if (uriSegList->At(0).Compare(KDmAdNodeNokiaPki) == 0)

   142         {

   143         if (uriSegList->At(1).Compare(KDmAdNodeCert) == 0)

   144             {

   145             ret = EDmAdUriTypeCert;

   146             }

   147         else if (uriSegList->At(1).Compare(KDmAdNodeCertReq) == 0)

   148             {

   149             ret = EDmAdUriTypeCertReq;

   150             }

   151         else if (uriSegList->At(1).Compare(KDmAdNodePrivKey) == 0)

   152             {

   153             ret = EDmAdUriTypePrivKey;

   154             }

   155         else if (uriSegList->At(1).Compare(KDmAdNodePKCS12) == 0)

   156             {

   157             ret = EDmAdUriTypePKCS12;

   158             }

   159         else

   160             {

   161             DEBUG_LOG(_L("Unknown URI type"));

   162             User::Leave(KErrGeneral);

   163             }

   164         }

   165     else

   166         {

   167         DEBUG_LOG(_L("Unknown URI type"));

   168         User::Leave(KErrGeneral);

   169         }

   170 

   171     CleanupStack::PopAndDestroy(uriSegList);

   172     return ret;

   173     }

   174     

   175 //--------------------------------------------------------------------------

   176     

   177 void CDmAdRtNodeData::UpdateLeafDataL(const TDesC8& aUri, const TDesC8& aObject)

   178     {

   179     TRACE("CDmAdRtNodeData::UpdateLeafDataL");

   180     

   181     switch (iUriType)

   182         {

   183         case EDmAdUriTypeCert:

   184             TRAPD(err, UpdateLeafDataCertL(aUri, aObject));

   185             if(err != KErrNone)

   186                 User::Leave(err);

   187             break;

   188         case EDmAdUriTypeCertReq:

   189             UpdateLeafDataCertReqL(aUri, aObject);

   190             break;

   191         case EDmAdUriTypePrivKey:

   192             UpdateLeafDataPrivKeyL(aUri, aObject);

   193             break;

   194         case EDmAdUriTypePKCS12:

   195             UpdateLeafDataPKCS12L(aUri, aObject);

   196             break;

   197         default:

   198             DEBUG_LOG(_L("Unknown URI type"));

   199             User::Leave(KErrGeneral);

   200             break;

   201         }

   202     }

   203 

   204 void CDmAdRtNodeData::UpdateLeafDataCertL(const TDesC8& aUri, const TDesC8& aObject)

   205     {

   206     TRACE("CDmAdRtNodeData::UpdateLeafDataCertL");

   207     

   208     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   209     if (lastSeg.Compare(KDmAdLeafContent) == 0)

   210         {

   211         u.iCert->SetContentL(aObject);

   212         }

   213     else if (lastSeg.Compare(KDmAdLeafType) == 0)

   214         {

   215         u.iCert->SetTypeL(aObject);

   216         }

   217     else if (lastSeg.Compare(KDmAdLeafFormat) == 0)

   218         {

   219         u.iCert->SetFormatL(aObject);

   220         }

   221     else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)

   222         {

   223         u.iCert->SetDeletableL(aObject);

   224         }

   225     else if (lastSeg.Compare(KDmAdLeafTrusted) == 0)

   226         {

   227         u.iCert->SetTrustedL(aObject);

   228         }

   229     else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)

   230         {

   231         RArray<TUid> applicability;

   232         CleanupClosePushL(applicability);

   233         

   234         ParseApplicabilityL(aObject, applicability);                                                    

   235         u.iCert->SetApplicabilityL(applicability);

   236         

   237         CleanupStack::PopAndDestroy(); //applicability

   238         }

   239     else

   240         {

   241         DEBUG_LOG(_L("No match found"));        

   242         User::Leave(KErrNotFound);

   243         }

   244     }

   245 

   246 void CDmAdRtNodeData::UpdateLeafDataCertReqL(const TDesC8& aUri, const TDesC8& aObject)

   247     {

   248     TRACE("CDmAdRtNodeData::UpdateLeafDataCertReqL");

   249     

   250     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   251     if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)

   252         {

   253         u.iCertReq->SetSubjectNameL(aObject);

   254         }

   255     else if (lastSeg.Compare(KDmAdLeafRfc822Name) == 0)

   256         {

   257         u.iCertReq->SetRfc822NameL(aObject);

   258         }

   259     else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)

   260         {

   261         u.iCertReq->SetKeyUriL(aObject);

   262         }

   263     else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

   264         {

   265         u.iCertReq->SetKeyLength(aObject);

   266         }

   267     else

   268         {

   269         DEBUG_LOG(_L("No match found"));        

   270         User::Leave(KErrNotFound);

   271         }

   272     }

   273 

   274 void CDmAdRtNodeData::UpdateLeafDataPrivKeyL(const TDesC8& aUri, const TDesC8& aObject)

   275     {

   276     TRACE("CDmAdRtNodeData::UpdateLeafDataPrivKeyL");

   277     

   278     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   279     if (lastSeg.Compare(KDmAdLeafKeyType) == 0)

   280         {

   281         u.iPrivKey->SetKeyTypeL(aObject);

   282         }

   283     else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

   284         {

   285         u.iPrivKey->SetKeyLength(aObject);

   286         }

   287     else

   288         {        

   289         DEBUG_LOG(_L("No match found"));        

   290         User::Leave(KErrNotFound);

   291         }

   292     }

   293 

   294 void CDmAdRtNodeData::UpdateLeafDataPKCS12L(const TDesC8& aUri, const TDesC8& aObject)

   295     {

   296     TRACE("CDmAdRtNodeData::UpdateLeafDataPKCS12L");

   297     

   298     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   299     if (lastSeg.Compare(KDmAdLeafContent) == 0)

   300         {

   301         u.iPKCS12->SetContentL(aObject);

   302         }

   303     else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)

   304         {

   305         u.iPKCS12->SetDeletableL(aObject);

   306         }

   307     else if (lastSeg.Compare(KDmAdLeafPKCS12Password) == 0)

   308         {

   309         u.iPKCS12->SetPasswordL(aObject);

   310         }

   311     else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)

   312         {

   313         RArray<TUid> applicability;

   314         CleanupClosePushL(applicability);

   315         

   316         ParseApplicabilityL(aObject, applicability);                                                    

   317         u.iPKCS12->SetApplicabilityL(applicability);

   318         

   319         CleanupStack::PopAndDestroy(); //applicability

   320         }

   321     else

   322         {

   323         DEBUG_LOG(_L("No match found"));        

   324         User::Leave(KErrNotFound);

   325         }

   326 

   327     }

   328 

   329 void CDmAdRtNodeData::FetchLeafObjectLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject)

   330     {   

   331     switch (iUriType)

   332         {

   333         case EDmAdUriTypeCert:

   334             FetchLeafObjectCertLC(aUri, aLuid, aObject);

   335             break;

   336         case EDmAdUriTypeCertReq:

   337             FetchLeafObjectCertReqLC(aUri, aLuid, aObject);

   338             break;

   339         case EDmAdUriTypePrivKey:

   340             FetchLeafObjectPrivKeyLC(aUri, aLuid, aObject);

   341             break;

   342         case EDmAdUriTypePKCS12:

   343             // PKCS#12 special case

   344             break;

   345         default:

   346             DEBUG_LOG(_L("Unknown URI type"));

   347             User::Leave(KErrGeneral);

   348             break;

   349         }

   350     }

   351     

   352 void CDmAdRtNodeData::FetchLeafObjectCertLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)

   353     {    

   354     CBufBase* object = CBufFlat::NewL(32);

   355     CleanupStack::PushL(object);

   356 

   357     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   358     if (lastSeg.Compare(KDmAdLeafType) == 0)

   359         {

   360         HBufC8* obj = u.iCert->TypeLC();

   361         object->InsertL(0, *obj);

   362         CleanupStack::PopAndDestroy(obj);

   363         }

   364     else if (lastSeg.Compare(KDmAdLeafFormat) == 0)

   365         {

   366         HBufC8* obj = u.iCert->FormatLC();

   367         object->InsertL(0, *obj);

   368         CleanupStack::PopAndDestroy(obj);

   369         }

   370     else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)

   371         {

   372         HBufC8* obj = u.iCert->DeletableLC();

   373         object->InsertL(0, *obj);

   374         CleanupStack::PopAndDestroy(obj);

   375         }

   376     else if (lastSeg.Compare(KDmAdLeafTrusted) == 0)

   377         {

   378         HBufC8* obj = u.iCert->TrustedLC();

   379         object->InsertL(0, *obj);

   380         CleanupStack::PopAndDestroy(obj);

   381         }

   382     else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)

   383         {

   384         

   385         DEBUG_LOG(_L("Fetching applicability"));

   386         const RArray<TUid>& applicability = u.iCert->Applicability();

   387 

   388         CXmlWriter* writer = CXmlWriter::NewL();

   389         CleanupStack::PushL(static_cast<CBase*>(writer));

   390         writer->AddStartTagL(KXmlElemCertApps);

   391         

   392         DEBUG_LOG(_L("KXmlElemCertApps Start tag added"));

   393         

   394         for (TInt i = 0; i < applicability.Count(); ++i)

   395             {

   396             HBufC8* idInt = TDmAdUtil::IntToDes8LC((TInt)applicability[i].iUid);

   397             writer->OpenStartTagL(KXmlElemApp);

   398             writer->AddAttributeL(KXmlAttrId, *idInt);

   399             writer->CloseStartTagL(ETrue);

   400             CleanupStack::PopAndDestroy(idInt); 

   401             }

   402         writer->AddEndTagL(KXmlElemCertApps);

   403         

   404         DEBUG_LOG(_L("KXmlElemCertApps end tag added"));

   405         

   406         TPtrC8 docDataPtr(writer->DocPart(0, writer->Length()-1));                

   407         object->InsertL(0, docDataPtr);

   408         

   409         DEBUG_LOG(_L("document inserted"));

   410         

   411         CleanupStack::PopAndDestroy(static_cast<CBase*>(writer));

   412         

   413         DEBUG_LOG(_L("writer popped"));

   414         }

   415     else if (lastSeg.Compare(KDmAdLeafContent) == 0)

   416         {

   417         TPtrC8 obj(u.iCert->Content());

   418         object->InsertL(0, obj);

   419         }

   420     else if (lastSeg.Compare(KDmAdLeafSerialNumber) == 0)

   421         {

   422         HBufC8* obj = u.iCert->SerialNumberLC();

   423         object->InsertL(0, *obj);

   424         CleanupStack::PopAndDestroy(obj);

   425         }

   426     else if (lastSeg.Compare(KDmAdLeafIssuerName) == 0)

   427         {

   428         HBufC8* obj = u.iCert->IssuerNameLC();

   429         object->InsertL(0, *obj);

   430         CleanupStack::PopAndDestroy(obj);

   431         }

   432     else if (lastSeg.Compare(KDmAdLeafFingerprintAlg) == 0)

   433         {

   434         HBufC8* obj = u.iCert->FingerprintAlgLC();

   435         object->InsertL(0, *obj);

   436         CleanupStack::PopAndDestroy(obj);

   437         }

   438     else if (lastSeg.Compare(KDmAdLeafFingerprintValue) == 0)

   439         {

   440         HBufC8* obj = u.iCert->FingerprintValueLC();

   441         object->InsertL(0, *obj);

   442         CleanupStack::PopAndDestroy(obj);

   443         }

   444     else if (lastSeg.Compare(KDmAdLeafValidityBegin) == 0)

   445         {

   446         HBufC8* obj = u.iCert->ValidityBeginLC();

   447         object->InsertL(0, *obj);

   448         CleanupStack::PopAndDestroy(obj);

   449         }

   450     else if (lastSeg.Compare(KDmAdLeafValidityEnd) == 0)

   451         {

   452         HBufC8* obj = u.iCert->ValidityEndLC();

   453         object->InsertL(0, *obj);

   454         CleanupStack::PopAndDestroy(obj);

   455         }

   456     else if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)

   457         {

   458         HBufC8* obj = u.iCert->SubjectNameLC();

   459         object->InsertL(0, *obj);

   460         CleanupStack::PopAndDestroy(obj);

   461         }

   462     else if (lastSeg.Compare(KDmAdLeafSubjectAltName) == 0)

   463         {

   464         HBufC8* obj = u.iCert->SubjectAltNameLC();

   465         object->InsertL(0, *obj);

   466         CleanupStack::PopAndDestroy(obj);

   467         }

   468     else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)

   469         {

   470         HBufC8* obj = u.iCert->KeyUriLC();

   471         object->InsertL(0, *obj);

   472         CleanupStack::PopAndDestroy(obj);

   473         }

   474     else if (lastSeg.Compare(KDmAdLeafKeyId) == 0)

   475         {

   476         HBufC8* obj = u.iCert->KeyIdLC();

   477         object->InsertL(0, *obj);

   478         CleanupStack::PopAndDestroy(obj);

   479         }

   480     else if (lastSeg.Compare(KDmAdLeafKeyUsage) == 0)

   481         {

   482         HBufC8* obj = u.iCert->KeyUsageLC();

   483         object->InsertL(0, *obj);

   484         CleanupStack::PopAndDestroy(obj);

   485         }

   486     else

   487         {

   488         DEBUG_LOG(_L("No match found"));        

   489         User::Leave(KErrNotFound);

   490         }

   491     

   492     aObject = object;

   493     }

   494     

   495 void CDmAdRtNodeData::FetchLeafObjectCertReqLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)

   496     {

   497     CBufBase* object = CBufFlat::NewL(32);

   498     CleanupStack::PushL(object);

   499 

   500     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   501     if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)

   502         {

   503         TPtrC8 obj(u.iCertReq->SubjectName());

   504         object->InsertL(0, obj);

   505         }

   506     else if (lastSeg.Compare(KDmAdLeafRfc822Name) == 0)

   507         {

   508         TPtrC8 obj(u.iCertReq->Rfc822Name());

   509         object->InsertL(0, obj);

   510         }

   511     else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)

   512         {

   513         HBufC8* obj = u.iCertReq->KeyUriL();

   514         CleanupStack::PushL(obj);

   515         object->InsertL(0, *obj);

   516         CleanupStack::PopAndDestroy(obj);

   517         }

   518     else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

   519         {

   520         HBufC8* obj = u.iCertReq->KeyLengthLC();

   521         object->InsertL(0, *obj);

   522         CleanupStack::PopAndDestroy(); //obj

   523         }

   524     else if (lastSeg.Compare(KDmAdLeafContent) == 0)

   525         {

   526         TPtrC8 obj(u.iCertReq->Content());

   527         object->InsertL(0, obj);

   528         }

   529     else

   530         {

   531         DEBUG_LOG(_L("No match found"));        

   532         User::Leave(KErrNotFound);

   533         }

   534     

   535     aObject = object;

   536     }

   537     

   538 void CDmAdRtNodeData::FetchLeafObjectPrivKeyLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)

   539     {

   540     CBufBase* object = CBufFlat::NewL(32);

   541     CleanupStack::PushL(object);

   542 

   543     TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

   544     if (lastSeg.Compare(KDmAdLeafKeyType) == 0)

   545         {

   546         HBufC8* obj = u.iPrivKey->KeyTypeLC();

   547         object->InsertL(0, *obj);

   548         CleanupStack::PopAndDestroy(); //obj

   549         }

   550     else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

   551         {

   552         HBufC8* obj = u.iPrivKey->KeyLengthLC();

   553         object->InsertL(0, *obj);

   554         CleanupStack::PopAndDestroy(); //obj

   555         }

   556     else if (lastSeg.Compare(KDmAdLeafKeyId) == 0)

   557         {

   558         TPtrC8 obj(u.iPrivKey->KeyId());

   559         object->InsertL(0, obj);

   560         }

   561     else

   562         {

   563         DEBUG_LOG(_L("No match found"));        

   564         User::Leave(KErrNotFound);

   565         }

   566     

   567     aObject = object;

   568     }

   569     

   570 void CDmAdRtNodeData::SetDefaultSettingsL(const TDesC8& /*aUri*/)

   571     {

   572     TRACE("CDmAdRtNodeData::SetDefaultSettingsL");

   573     

   574     switch (iUriType)

   575         {

   576         case EDmAdUriTypeCert:

   577             u.iCert->SetDefaultSettings();

   578             break;

   579         case EDmAdUriTypeCertReq:

   580             u.iCertReq->SetDefaultSettings();

   581             break;

   582         case EDmAdUriTypePrivKey:

   583             u.iPrivKey->SetDefaultSettingsL();

   584             break;

   585         case EDmAdUriTypePKCS12:

   586             u.iPKCS12->SetDefaultSettings();

   587             break;

   588         default:

   589             DEBUG_LOG(_L("Unknown URI type"));

   590             User::Leave(KErrGeneral);

   591             break;

   592         }

   593     }

   594 

   595 

   596 void CDmAdRtNodeData::ParseApplicabilityL(const TDesC8& aApplicabilityData,

   597                                         RArray<TUid>& aApplicabilityList) const

   598     {       

   599     TRACE("CDmAdRtNodeData::ParseApplicabilityL");

   600     

   601     aApplicabilityList.Reset();

   602     

   603     if (aApplicabilityData.Length() == 0)

   604         {

   605         return;

   606         }

   607             

   608     CDesC8ArrayFlat* parserValueArray = new (ELeave) CDesC8ArrayFlat(10);

   609     CleanupStack::PushL(parserValueArray);

   610     CXmlPullParser* parser = CXmlPullParser::NewLC(*parserValueArray);

   611     TPtrC8 name;

   612     TPtrC8 attribute;

   613     

   614     parser->SetInput(aApplicabilityData);

   615     parser->NextL();

   616     parser->Name(name);

   617     

   618     if (parser->State() != CXmlPullParser::EStateStartTag || name != KXmlElemCertApps)

   619         {                        

   620         DEBUG_LOG(_L("Wrong state or name. (Expected EStateStartTag and CertApps"));        

   621         DEBUG_LOG2(_L8("State = %d, name = %S"), parser->State(), &name);

   622         User::Leave(KErrCorrupt);

   623         }

   624     

   625     parser->NextL();

   626     while (parser->State() == CXmlPullParser::EStateText)

   627         {

   628         DEBUG_LOG(_L8("Found text. Ignoring it..."));

   629         parser->NextL();

   630         }

   631     

   632     while (parser->State() == CXmlPullParser::EStateStartTag)

   633         {

   634         parser->Name(name);

   635         DEBUG_LOG1(_L8("Parsed: %S"), &name);

   636                         

   637         if (name != KXmlElemApp)

   638             {

   639             DEBUG_LOG1(_L8("Invalid name: %S"), &name);            

   640             User::Leave(KErrCorrupt);

   641             }

   642 

   643         parser->AttributeValueL(KXmlAttrId, attribute);

   644         TUid uid = { TDmAdUtil::DesToInt(attribute) };

   645         DEBUG_LOG1(_L("Uid: 0x%x"), uid.iUid);

   646         

   647         aApplicabilityList.Append(uid);

   648         parser->NextL();

   649         

   650         while (parser->State() == CXmlPullParser::EStateText)

   651             {

   652             DEBUG_LOG(_L8("Found text. Ignoring it..."));

   653             parser->NextL();

   654             }                

   655         }

   656     parser->Name(name);

   657     

   658     if (parser->State() != CXmlPullParser::EStateEndTag || name != KXmlElemCertApps)

   659         {        

   660         DEBUG_LOG(_L("Wrong state or name. (Expected EStateEndTag and CertApps)"));        

   661         DEBUG_LOG2(_L8("State = %d, name = %S"), parser->State(), &name);

   662         User::Leave(KErrCorrupt);

   663         }

   664     CleanupStack::PopAndDestroy(2); //parser, parserValueArray

   665     }

   666 

   667 

   668 //======================================================================================

   669 //======================================================================================

   670     

   671 CDmAdCertData* CDmAdCertData::NewL(MDmAdCallBack* aCallBack)

   672     {

   673     TRACE("CDmAdCertData::NewL");

   674     

   675     CDmAdCertData* self = new (ELeave) CDmAdCertData(aCallBack);

   676     CleanupStack::PushL(self);

   677     self->ConstructL();

   678     CleanupStack::Pop(self);

   679     return self;

   680     }

   681 

   682 void CDmAdCertData::ConstructL()

   683     {

   684     TRACE("CDmAdCertData::ConstructL");

   685     

   686     iCertParms = CDmAdCertParms::NewL();

   687     }

   688     

   689 CDmAdCertData::CDmAdCertData(MDmAdCallBack* aCallBack) : iCallBack(aCallBack)

   690     {    

   691     }

   692 

   693 CDmAdCertData::~CDmAdCertData()

   694     {

   695     TRACE("CDmAdCertData::~CDmAdCertData");

   696     

   697     delete iCertParms;

   698     delete iCertCx509;

   699     }

   700 

   701 void CDmAdCertData::SetDefaultSettings()

   702     {

   703     TRACE("CDmAdCertData::SetDefaultSettings");

   704     

   705     iCertParms->SetDeletable(ETrue);

   706     iCertParms->SetTrusted(ETrue);

   707     }

   708 

   709 //--------------------------------------------------------------------------

   710 

   711 void CDmAdCertData::SetTypeL(const TDesC8& aType)

   712     {

   713     TRACE("CDmAdCertData::SetType");

   714     

   715     TInt value = TDmAdUtil::DesToInt(aType);

   716     

   717     TPKICertificateOwnerType type = EPKICACertificate;        

   718     switch(value)

   719         {

   720         case 1:

   721             type = EPKICACertificate;

   722             break;

   723         case 2:

   724             type = EPKIUserCertificate;

   725             break;

   726         case 3:

   727             type = EPKIPeerCertificate;

   728             break;            

   729         default:

   730             User::Leave(KErrCorrupt);

   731             break;

   732         }

   733     

   734     iCertParms->SetType(type);

   735     }

   736 

   737 HBufC8* CDmAdCertData::TypeLC()

   738     {

   739     

   740     TPKICertificateOwnerType type = iCertParms->Type();

   741     TInt omaDmType = 0;

   742     switch(type)

   743         {

   744         case EPKICACertificate:

   745             omaDmType = 1;

   746             break;

   747         case EPKIUserCertificate:

   748             omaDmType = 2;

   749             break;

   750         case EPKIPeerCertificate:

   751             omaDmType = 3;

   752             break;

   753         default:

   754             User::Leave(KErrCorrupt);

   755             break;

   756         }

   757     

   758     return TDmAdUtil::IntToDes8LC(omaDmType);

   759     }

   760 

   761 void CDmAdCertData::SetFormatL(const TDesC8& aFormat)

   762     {

   763     TRACE("CDmAdCertData::SetFormat");

   764     TInt value = TDmAdUtil::DesToInt(aFormat);

   765     

   766     if (value != 1)

   767         {        

   768         User::Leave(KErrCorrupt);

   769         }        

   770     }

   771 

   772 HBufC8* CDmAdCertData::FormatLC()

   773     {

   774     //The format is always 1, which means X509 cert.    

   775     return TDmAdUtil::IntToDes8LC(1);

   776     }

   777 

   778 void CDmAdCertData::SetDeletableL(const TDesC8& aDeletable)

   779     {

   780     TRACE("CDmAdCertData::SetDeletableL");

   781     

   782     if (aDeletable.Compare(KDmAdDfFormatBoolTrue) == 0)

   783         {

   784         iCertParms->SetDeletable(ETrue);

   785         }

   786     else if (aDeletable.Compare(KDmAdDfFormatBoolFalse) == 0)

   787         {

   788         iCertParms->SetDeletable(EFalse);

   789         }

   790     else

   791         {

   792         DEBUG_LOG(_L("Comparization failed"));                

   793         User::Leave(KErrGeneral);

   794         }

   795     }

   796 

   797 HBufC8* CDmAdCertData::DeletableLC()

   798     {    

   799     if (iCertParms->Deletable())

   800         {

   801         return KDmAdDfFormatBoolTrue().AllocLC();

   802         }

   803     else

   804         {

   805         return KDmAdDfFormatBoolFalse().AllocLC();

   806         }

   807     }

   808 

   809 void CDmAdCertData::SetTrustedL(const TDesC8& aTrusted)

   810     {

   811     TRACE("CDmAdCertData::SetTrustedL");

   812     

   813     if (aTrusted.Compare(KDmAdDfFormatBoolTrue) == 0)

   814         {

   815         iCertParms->SetTrusted(ETrue);

   816         }

   817     else if (aTrusted.Compare(KDmAdDfFormatBoolFalse) == 0)

   818         {

   819         iCertParms->SetTrusted(EFalse);

   820         }

   821     else

   822         {

   823         DEBUG_LOG(_L("No match found")); 

   824         User::Leave(KErrGeneral);

   825         }

   826     }

   827 

   828 HBufC8* CDmAdCertData::TrustedLC()

   829     {

   830     if (iCertParms->Trusted())

   831         {

   832         return KDmAdDfFormatBoolTrue().AllocLC();

   833         }

   834     else

   835         {

   836         return KDmAdDfFormatBoolFalse().AllocLC();

   837         }

   838     }

   839 

   840 void CDmAdCertData::SetApplicabilityL(const RArray<TUid>& aApplicability)

   841     {

   842     TRACE("CDmAdCertData::SetApplicabilityL");

   843     

   844     iCertParms->SetApplicabilityL(aApplicability);

   845     }

   846 

   847 const RArray<TUid>& CDmAdCertData::Applicability() const

   848     {

   849     TRACE("CDmAdCertData::Applicability");

   850     

   851     return iCertParms->Applicability();

   852     }

   853 

   854 void CDmAdCertData::SetContentL(const TDesC8& aContent)

   855     {

   856     TRACE("CDmAdCertData::SetContentL");

   857     

   858     delete iCertCx509;

   859     iCertCx509 = NULL;

   860     iCertParms->SetContentL(aContent);

   861     if (iCertParms->Content().Length() > 0)

   862         {

   863         iCertCx509 = CX509Certificate::NewL(iCertParms->Content());

   864         }

   865     }

   866 

   867 TPtrC8 CDmAdCertData::Content()

   868     {

   869     TRACE("CDmAdCertData::Content");

   870     

   871     return iCertParms->Content();

   872     }

   873 

   874 //-----------------

   875     

   876 HBufC8* CDmAdCertData::SerialNumberLC()

   877     {

   878     HBufC8* ret = NULL;

   879     const TPtrC8 serialNumber(iCertCx509->SerialNumber());

   880     //const TPtrC8 serialNumber(*(iCertCx509->DataElementEncoding(CX509Certificate::ESerialNumber)));

   881     if (serialNumber.Length() == 0)

   882         {

   883         ret = HBufC8::NewLC(1);

   884         }

   885     else

   886         {

   887         ret = serialNumber.AllocLC();

   888         }

   889     return ret;

   890     }

   891     

   892 HBufC8* CDmAdCertData::IssuerNameLC()

   893     {

   894     HBufC8* ret = NULL;

   895     const TPtrC8 issuerName(*(iCertCx509->DataElementEncoding(CX509Certificate::EIssuerName)));

   896     if (issuerName.Length() == 0)

   897         {

   898         ret = HBufC8::NewLC(1);

   899         }

   900     else

   901         {

   902         ret = issuerName.AllocLC();

   903         }

   904     return ret;

   905     }

   906 

   907 HBufC8* CDmAdCertData::FingerprintAlgLC()

   908     {

   909     if (iCertCx509->Fingerprint().Length() == 16)

   910         {

   911         return TDmAdUtil::IntToDes8LC(1); // MD5

   912         }

   913     else

   914         {

   915         return TDmAdUtil::IntToDes8LC(2); // SHA1

   916         }

   917     }

   918     

   919 HBufC8* CDmAdCertData::FingerprintValueLC()

   920     {

   921     return iCertCx509->Fingerprint().AllocLC();

   922     }

   923     

   924 HBufC8* CDmAdCertData::ValidityBeginLC()

   925     {

   926     TTime beginTime = iCertCx509->ValidityPeriod().Start();

   927     return FormatCertValidityTimeLC(beginTime);

   928     }

   929     

   930 HBufC8* CDmAdCertData::ValidityEndLC()

   931     {

   932     TTime endTime = iCertCx509->ValidityPeriod().Finish();

   933     return FormatCertValidityTimeLC(endTime);

   934     }

   935     

   936 HBufC8* CDmAdCertData::SubjectNameLC()

   937     {

   938     HBufC8* ret = NULL;

   939     const TPtrC8 subjectName(*(iCertCx509->DataElementEncoding(CX509Certificate::ESubjectName)));

   940     if (subjectName.Length() == 0)

   941         {

   942         ret = HBufC8::NewLC(1);

   943         }

   944     else

   945         {

   946         ret = subjectName.AllocLC();

   947         }

   948     return ret;

   949     }

   950     

   951 HBufC8* CDmAdCertData::SubjectAltNameLC()

   952     {

   953     HBufC8* subjectAltNameExtRfc822 = HBufC8::NewLC(KMaxRfc822);

   954     TPtr8 subjectAltNameExtRfc822Ptr(subjectAltNameExtRfc822->Des());

   955 

   956     const CX509CertExtension* subjAltName;

   957     subjAltName = iCertCx509->Extension(KSubjectAltName);

   958     if (subjAltName)

   959         {

   960         CX509AltNameExt* subjectAlt = CX509AltNameExt::NewLC(subjAltName->Data());

   961         if (subjectAlt)

   962             {

   963             const CArrayPtrFlat<CX509GeneralName>* nameArray; 

   964             nameArray = &subjectAlt->AltName();

   965             // Search rfc822

   966             for (TInt i = 0; i < nameArray->Count(); i++)

   967                 {

   968                 if(nameArray->At(i)->Tag() == EX509RFC822Name)

   969                     {

   970                     TPtrC8 data = nameArray->At(i)->Data();

   971                     subjectAltNameExtRfc822Ptr.Copy(data.Right(data.Length() - 2));

   972                     break;

   973                     }

   974                 }

   975             CleanupStack::PopAndDestroy(subjectAlt);

   976             }

   977         }

   978     return subjectAltNameExtRfc822;

   979     }

   980     

   981 HBufC8* CDmAdCertData::KeyUriLC()

   982     {

   983     HBufC8* keyId = KeyIdLC();

   984     HBufC8* keyUri = FindKeyUriLC(*keyId);

   985     CleanupStack::Pop(keyUri);

   986     CleanupStack::PopAndDestroy(keyId); 

   987     CleanupStack::PushL(keyUri);

   988     return keyUri;

   989     }

   990     

   991 HBufC8* CDmAdCertData::KeyIdLC()

   992     {

   993 #if 0

   994     const CSubjectPublicKeyInfo* subjectPublicKeyInfo = &iCertCx509->PublicKey();

   995     if (subjectPublicKeyInfo->AlgorithmId() != ERSA)

   996         {

   997         return HBufC8::NewLC(1);

   998         }

   999     

  1000     return TDmAdCertUtil::RSAKeyIdentifierLC(subjectPublicKeyInfo->KeyData());

  1001 #else

  1002     return iCertCx509->KeyIdentifierL().AllocLC();

  1003 #endif

  1004     }

  1005 

  1006 

  1007 HBufC8* CDmAdCertData::KeyUsageLC()

  1008     {

  1009     const TInt KKeyUsageTxtLen = 12;   

  1010     HBufC8* keyUsage = HBufC8::NewLC(KKeyUsageTxtLen);

  1011     TPtr8 keyUsagePtr(keyUsage->Des());

  1012 

  1013     const CX509CertExtension* certExt = iCertCx509->Extension(KKeyUsage);

  1014 

  1015     if(0 == certExt)

  1016         {

  1017         return keyUsage;

  1018         }

  1019         

  1020     const CX509KeyUsageExt* keyUsageExt =

  1021         CX509KeyUsageExt::NewLC(certExt->Data());

  1022     

  1023     // Encode key usage values to bstring format

  1024     // See IETF RFC 3641.

  1025     keyUsagePtr.Append('\'');

  1026 

  1027     ENC_BIT( EX509DigitalSignature );

  1028     ENC_BIT( EX509NonRepudiation );

  1029     ENC_BIT( EX509KeyEncipherment );

  1030     ENC_BIT( EX509DataEncipherment );

  1031     ENC_BIT( EX509KeyAgreement );

  1032     ENC_BIT( EX509KeyCertSign );

  1033     ENC_BIT( EX509CRLSign );

  1034     ENC_BIT( EX509EncipherOnly );

  1035     ENC_BIT( EX509DecipherOnly );

  1036 

  1037     keyUsagePtr.Append(_L8("'B"));

  1038         

  1039     CleanupStack::PopAndDestroy();  // keyUsageExt

  1040     

  1041     return keyUsage;

  1042     }

  1043 

  1044 

  1045 HBufC8* CDmAdCertData::FormatCertValidityTimeLC(const TTime& aTime)

  1046     {

  1047     TDateTime time = aTime.DateTime();

  1048     

  1049     HBufC8* ret = HBufC8::NewLC(20);

  1050     TPtr8 retPtr(ret->Des());

  1051 

  1052     _LIT8(KFormatTxt,"%4d%02d%02dT%02d%02d%02dZ");

  1053     retPtr.Format(KFormatTxt,

  1054                   time.Year(),

  1055                   TInt(time.Month()+1), 

  1056                    // Format the month as a TInt to preserve locale independence

  1057                   time.Day()+1, 

  1058                    // Day and month ranges begin at zero (0-30 and 0-11), 

  1059                    // so add one when formatting

  1060                   time.Hour(),

  1061                   time.Minute(),

  1062                   time.Second());

  1063     return ret;

  1064     }

  1065 

  1066 HBufC8* CDmAdCertData::FindKeyUriLC(const TDesC8& aKeyId)

  1067     {

  1068     DEBUG_LOG(_L("CDmAdCertData::FindKeyUriLC:"));        

  1069     DEBUG_LOG_HEX(aKeyId);    

  1070     

  1071     _LIT8(KDmAdPrivKeyUri, "NokiaPKI/PrivKey");

  1072     

  1073 #if 1

  1074 

  1075     HBufC8* uri = iCallBack->FindChildUriL(KDmAdPrivKeyUri, aKeyId);

  1076     if (uri != 0)

  1077         {

  1078         DEBUG_LOG(_L("CDmAdCertData::FindKeyUriLC:"));

  1079         DEBUG_LOG_HEX(*uri);            

  1080         }

  1081     else

  1082         {

  1083         DEBUG_LOG(_L("URI not found"));        

  1084         uri = HBufC8::NewL(1);

  1085         }

  1086     

  1087     CleanupStack::PushL(uri);

  1088     return uri;

  1089     

  1090 #else

  1091     

  1092     HBufC8* ret = 0;

  1093     

  1094     CBufBase* childUriList = CBufFlat::NewL(16);

  1095     CleanupStack::PushL(childUriList);

  1096     MSmlDmAdapter::TError status;

  1097     iCallBack->FetchLinkL(KDmAdPrivKeyUri, *childUriList, status);

  1098     if (status != MSmlDmAdapter::EOk)

  1099         {

  1100         DMADERR(DmAdErr::Printf(_L("***CDmAdCertData::FindKeyUriLC: %d (line=%d)\n"), KDmAdErr1, __LINE__));

  1101         User::Leave(KErrGeneral);

  1102         }

  1103 

  1104     CArrayFix<TPtrC8>* uriSegList;

  1105     TDmAdUtil::ParseUriLC(childUriList->Ptr(0), uriSegList);

  1106 

  1107     TBool found = EFalse;

  1108     HBufC8* uri = 0;

  1109     HBufC8* uriKeyId = 0;

  1110     for (TInt i=0; i<uriSegList->Count(); ++i)

  1111         {

  1112         uri = TDmAdUtil::BuildUriLC(KDmAdPrivKeyUri, uriSegList->At(i));

  1113         uriKeyId = TDmAdUtil::BuildUriLC(*uri, KDmAdLeafKeyId);

  1114         

  1115         CBufBase* keyId = CBufFlat::NewL(16);

  1116         CleanupStack::PushL(keyId);

  1117         iCallBack->FetchLinkL(*uriKeyId, *keyId, status);

  1118         if (status != MSmlDmAdapter::EOk)

  1119             {

  1120             DMADERR(DmAdErr::Printf(_L("***CDmAdCertData::FindKeyUriLC: %d (line=%d)\n"), KDmAdErr1, __LINE__));

  1121             User::Leave(KErrGeneral);

  1122             }

  1123         if (keyId->Ptr(0).Compare(aKeyId) == 0)

  1124             {

  1125             found = ETrue;

  1126             CleanupStack::PopAndDestroy(2); // keyId, uriKeyId

  1127             break;

  1128             }

  1129         CleanupStack::PopAndDestroy(3); // keyId, uriKeyId, uri

  1130         }

  1131     

  1132     if (found)

  1133         {

  1134         DMADLOG(DmAdLog::Printf(_L("CDmAdCertData::FindKeyUriLC:\n")));