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:   Class definition of CDmAdCertData

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef __DMADRTNODEDATA_H__

    21 #define __DMADRTNODEDATA_H__

    22 

    23 

    24 #include <e32base.h>

    25 #include <e32cmn.h>

    26 

    27 #include "dmadcallback.h"

    28 #include "dmadcertparms.h"

    29 #include "dmadcertreqparms.h"

    30 #include "dmadprivkeyparms.h"

    31 #include "dmadpkcs12parms.h"

    32 #include "eventlogger.h"

    33 

    34 class CX509Certificate;

    35 

    36 typedef enum

    37     {

    38     EDmAdUriTypeCert,

    39     EDmAdUriTypeCertReq,

    40     EDmAdUriTypePrivKey,

    41     EDmAdUriTypePKCS12

    42     } TDmAdUriType;

    43     

    44 //------------------------------------------------------------------------------------------------

    45 // CDmAdCertData

    46 //------------------------------------------------------------------------------------------------

    47 class CDmAdCertData : public CBase

    48     {

    49 public:

    50     static CDmAdCertData* NewL(MDmAdCallBack* aCallBack);

    51     ~CDmAdCertData();

    52     

    53     void SetDefaultSettings();

    54     

    55     void SetTypeL(const TDesC8& aType);

    56     HBufC8* TypeLC();

    57     void SetFormatL(const TDesC8& aFormat);

    58     HBufC8* FormatLC();

    59     void SetDeletableL(const TDesC8& aDeletable);

    60     HBufC8* DeletableLC();

    61     void SetTrustedL(const TDesC8& aTrusted);

    62     HBufC8* TrustedLC();

    63     void SetApplicabilityL(const RArray<TUid>& aApplicability);

    64     const RArray<TUid>& Applicability() const;

    65     void SetContentL(const TDesC8& aContent);

    66     TPtrC8 Content();

    67     HBufC8* SerialNumberLC();

    68     HBufC8* IssuerNameLC();

    69     HBufC8* FingerprintAlgLC();

    70     HBufC8* FingerprintValueLC();

    71     HBufC8* ValidityBeginLC();

    72     HBufC8* ValidityEndLC();

    73     HBufC8* SubjectNameLC();

    74     HBufC8* SubjectAltNameLC();

    75     HBufC8* KeyUriLC();

    76     HBufC8* KeyIdLC();

    77     HBufC8* KeyUsageLC();

    78     HBufC8* FormatCertValidityTimeLC(const TTime& aTime);

    79     HBufC8* FindKeyUriLC(const TDesC8& aKeyId);

    80     void RestoreL(const CDmAdCertParms& aCertParms);

    81     void ToStoreL(CDmAdCertParms& aCertParms);

    82 

    83 private:

    84     void ConstructL();

    85     CDmAdCertData(MDmAdCallBack* aCallBack);

    86         

    87 private:

    88     MDmAdCallBack*      iCallBack;

    89     

    90     CDmAdCertParms*     iCertParms;

    91     CX509Certificate*   iCertCx509;

    92     };

    93 

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

    95 // CDmAdCertReqData

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

    97 class CDmAdCertReqData : public CBase

    98     {

    99 public:

   100     static CDmAdCertReqData* NewL(MDmAdCallBack* aCallBack);

   101     ~CDmAdCertReqData();

   102     

   103     void SetDefaultSettings();

   104     void SetSubjectNameL(const TDesC8& aSubjectName);

   105     TPtrC8 SubjectName();

   106     void SetRfc822NameL(const TDesC8& aRfc822Name);

   107     TPtrC8 Rfc822Name();

   108     void SetKeyUriL(const TDesC8& aKeyUri);

   109     HBufC8* KeyUriL() const;

   110     void SetKeyLength(const TDesC8& aKeyLength);

   111     HBufC8* KeyLengthLC();

   112 

   113     TPtrC8 Content();

   114     

   115     void RestoreL(const CDmAdCertReqParms& aCertReqParms);

   116     void ToStoreL(CDmAdCertReqParms& aCertReqParms);

   117 

   118 private:

   119     void ConstructL();

   120     CDmAdCertReqData(MDmAdCallBack* aCallBack);

   121     

   122 private:

   123 

   124     MDmAdCallBack*          iCallBack;   

   125     CDmAdCertReqParms*      iCertReqParms;

   126     };

   127 

   128 //------------------------------------------------------------------------------------------------

   129 // CDmAdPrivKeyData

   130 //------------------------------------------------------------------------------------------------

   131 class CDmAdPrivKeyData : public CBase

   132     {

   133 public:

   134     static CDmAdPrivKeyData* NewL();

   135     ~CDmAdPrivKeyData();

   136     

   137     void SetDefaultSettingsL();

   138     void SetKeyTypeL(const TDesC8& aKeyType);

   139     HBufC8* KeyTypeLC();

   140     void SetKeyLength(const TDesC8& aKeyLength);

   141     HBufC8* KeyLengthLC();

   142     TPtrC8 KeyId();

   143     

   144     void RestoreL(const CDmAdPrivKeyParms& aPrivKeyParms);

   145     void ToStoreL(CDmAdPrivKeyParms& aPrivKeyParms);

   146 

   147 private:

   148     void ConstructL();

   149     CDmAdPrivKeyData();

   150     

   151 private:

   152     CDmAdPrivKeyParms*     iPrivKeyParms;

   153     };

   154     

   155 //------------------------------------------------------------------------------------------------

   156 // CDmAdPKCS12Data

   157 //------------------------------------------------------------------------------------------------

   158 class CDmAdPKCS12Data : public CBase

   159     {

   160 public:

   161     static CDmAdPKCS12Data* NewL(/*MDmAdCallBack* aCallBack*/);

   162     ~CDmAdPKCS12Data();

   163     

   164     void SetDefaultSettings();

   165     

   166     void SetDeletableL(const TDesC8& aDeletable);

   167     HBufC8* DeletableLC();

   168     void SetApplicabilityL(const RArray<TUid>& aApplicability);

   169     const RArray<TUid>& Applicability() const;

   170     void SetContentL(const TDesC8& aContent);

   171     TPtrC8 Content();

   172     void SetPasswordL(const TDesC8& aContent);

   173     TPtrC8 Password();

   174 

   175     void RestoreL(const CDmAdPKCS12Parms& aPKCS12Parms);

   176     void ToStoreL(CDmAdPKCS12Parms& aPKCS12Parms);

   177 

   178 private:

   179     void ConstructL();

   180     CDmAdPKCS12Data();

   181     

   182 private:

   183     CDmAdPKCS12Parms*     iPKCS12Parms;

   184     };

   185 

   186 //------------------------------------------------------------------------------------------------

   187 // CDmAdRtNodeData

   188 //------------------------------------------------------------------------------------------------

   189 class CDmAdRtNodeData : public CBase

   190     {

   191 public:

   192     static CDmAdRtNodeData* NewL(const TDesC8& aUri, MDmAdCallBack* aCallBack);

   193     ~CDmAdRtNodeData();

   194     TDmAdUriType UriType() const;

   195     static TDmAdUriType UriTypeL(const TDesC8& aUri);

   196     void UpdateLeafDataL(const TDesC8& aUri, const TDesC8& aObject);

   197     void FetchLeafObjectLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject);

   198     void SetDefaultSettingsL(const TDesC8& aUri);

   199 

   200     inline CDmAdCertData* CertData() const;

   201     inline CDmAdCertReqData* CertReqData() const;

   202     inline CDmAdPrivKeyData* PrivKeyData() const;

   203     inline CDmAdPKCS12Data* PKCS12Data() const;

   204     

   205 private:

   206     void ConstructL(const TDesC8& aUri, MDmAdCallBack* aCallBack);

   207     CDmAdRtNodeData();

   208     void UpdateLeafDataCertL(const TDesC8& aUri, const TDesC8& aObject);

   209     void UpdateLeafDataCertReqL(const TDesC8& aUri, const TDesC8& aObject);

   210     void UpdateLeafDataPrivKeyL(const TDesC8& aUri, const TDesC8& aObject);

   211     void FetchLeafObjectCertLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject);

   212     void FetchLeafObjectCertReqLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject);

   213     void FetchLeafObjectPrivKeyLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject);

   214         

   215     void UpdateLeafDataPKCS12L(const TDesC8& aUri, const TDesC8& aObject);

   216     void ParseApplicabilityL(const TDesC8& aApplicabilityData,

   217                              RArray<TUid>& aApplicabilityList) const; 

   218         

   219         

   220 private:

   221     TDmAdUriType    iUriType;

   222     union

   223         {

   224         CDmAdCertData*      iCert;

   225         CDmAdCertReqData*   iCertReq;

   226         CDmAdPrivKeyData*   iPrivKey;

   227         CDmAdPKCS12Data*    iPKCS12;

   228         } u;

   229     DEFINE_EVENT_LOGGER    

   230     };

   231 

   232 #include "DmAdRtNodeData.inl"

   233 

   234 #endif