/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Certificate trust settings information

*

*/

// INCLUDE FILES

#include "WimCertInfo.h"

#include "WimDummyToken.h"

#include <securitydefs.h>

#include "WimTrace.h"

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

// -----------------------------------------------------------------------------

// CWimCertInfo::CWimCertInfo( CCTCertInfo* aCCTCertInfo, 

//                            const TBuf8<KSHA1HashLengthBytes> aHash, 

//                            RArray<HBufC*> aTrustedUsages, 

//                            TUint8 aCDFRefs ) 

//                          : iCCTCertInfo( aCCTCertInfo ),

//                            iCertHash( aHash ),

//                            iTrustedUsage( aTrustedUsages ),

//                            iCDFRefs( aCDFRefs )

// Default constructor

// -----------------------------------------------------------------------------

//

CWimCertInfo::CWimCertInfo( CCTCertInfo* aCCTCertInfo, 

                            const TBuf8<KSHA1HashLengthBytes> aHash, 

                            RArray<HBufC*> aTrustedUsages, 

                            TUint8 aCDFRefs ) 

                          : iCCTCertInfo( aCCTCertInfo ),

                            iCertHash( aHash ),

                            iTrustedUsage( aTrustedUsages ),

                            iCDFRefs( aCDFRefs )

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::CWimCertInfo | Begin"));

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::ConstructL()

// Second phase constructor

// -----------------------------------------------------------------------------

//

void CWimCertInfo::ConstructL()

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::ConstructL | Begin"));

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::NewLNewL( CCTCertInfo* aCCTCertInfo,

//                         const TBuf8<KSHA1HashLengthBytes> aHash,

//                         RArray<HBufC*> aTrustedUsages,

//                         TUint8 aCDFRefs )

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CWimCertInfo* CWimCertInfo::NewL( CCTCertInfo* aCCTCertInfo,

                                     const TBuf8<KSHA1HashLengthBytes> aHash,

                                     RArray<HBufC*> aTrustedUsages,

                                     TUint8 aCDFRefs )

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::NewL | Begin"));

    CWimCertInfo* self = new( ELeave ) CWimCertInfo( aCCTCertInfo, 

                                                     aHash,

                                                     aTrustedUsages,

                                                     aCDFRefs );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::~CWimCertInfo()

// Destructor

// -----------------------------------------------------------------------------

//

CWimCertInfo::~CWimCertInfo()

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::~CWimCertInfo | Begin"));

    if ( iCCTCertInfo )

        {

        iCCTCertInfo->Release();

        iCCTCertInfo = NULL;

        }

    //Delete arrays of trusted usaga and extendedkeyusage

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

        {

        delete iTrustedUsage[i]; //Delete buffers

        }

    iTrustedUsage.Close();

    for ( TInt j = 0; j < iExtendedKeyUsage.Count(); j++ )

        {

        delete iExtendedKeyUsage[j]; //Delete buffers

        }

    iExtendedKeyUsage.Close();

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::AddTrustedUsage( HBufC* aTrustedUsage )

// Add TrustedUsage OID

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CWimCertInfo::AddTrustedUsage( HBufC* aTrustedUsage )

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::AddTrustedUsage | Begin"));

    return ( iTrustedUsage.Append( aTrustedUsage ) );

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::AddExtendedKeyUsage( HBufC* aExtendedKeyUsage )

// Add ExtendedKeyUsage OID

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CWimCertInfo::AddExtendedKeyUsage( HBufC* aExtendedKeyUsage )

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::AddExtendedKeyUsage | Begin"));

    return ( iExtendedKeyUsage.Append( aExtendedKeyUsage ) );

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::GetCertHash( TBuf8<KSHA1HashLengthBytes>& aHash ) const

// Get hash of certificate

// -----------------------------------------------------------------------------

//

EXPORT_C void CWimCertInfo::GetCertHash( 

                            TBuf8<KSHA1HashLengthBytes>& aHash ) const

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::GetCertHash | Begin"));

    aHash = iCertHash;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::CctCert() const

// Return pointer to CctCert (Symbian's certificate info )

// -----------------------------------------------------------------------------

//

EXPORT_C const CCTCertInfo* CWimCertInfo::CctCert() const

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::CctCert | Begin"));

    return iCCTCertInfo;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::TrustedUsage() const

// Get pointer array of TrustedUsage OID's

// -----------------------------------------------------------------------------

//

EXPORT_C RArray<HBufC*> CWimCertInfo::TrustedUsage() const

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::TrustedUsage | Begin"));

    return iTrustedUsage;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::ExtendedKeyUsage

// Get pointer array of ExtendedKeyUsage OID's

// -----------------------------------------------------------------------------

//

EXPORT_C RArray<HBufC*> CWimCertInfo::ExtendedKeyUsage() const

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::ExtendedKeyUsage | Begin"));

    return iExtendedKeyUsage;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::CDFRefs

// Get location of certificate

// -----------------------------------------------------------------------------

//

EXPORT_C TUint8 CWimCertInfo::CDFRefs() const

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::CDFRefs | Begin"));

    return iCDFRefs;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::SetCDFRefs

// Set location of certificate

// -----------------------------------------------------------------------------

//

EXPORT_C void CWimCertInfo::SetCDFRefs( TUint8 aCDFRefs )

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::SetCDFRefs | Begin"));

    iCDFRefs = aCDFRefs;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::Externalize

// Externalize CWimCertInfo data to flat buffer

// -----------------------------------------------------------------------------

//

EXPORT_C TWimCertInfoPckg* CWimCertInfo::ExternalizeL() const

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::ExternalizeL | Begin"));

    TWimCertInfoPckg* certPckg = new( ELeave ) TWimCertInfoPckg();

    GetCertHash( certPckg->iHash );

    certPckg->iCertLabel.Copy( iCCTCertInfo->Label() );

    certPckg->iCertificateOwnerType = iCCTCertInfo->CertificateOwnerType();

    certPckg->iSize = iCCTCertInfo->Size();

    certPckg->iFormat = iCCTCertInfo->CertificateFormat();

    certPckg->iSubjectKeyId = iCCTCertInfo->SubjectKeyId();

    certPckg->iIssuerKeyId = iCCTCertInfo->IssuerKeyId();

    certPckg->iCDFRefs = iCDFRefs;

    certPckg->iTokenSerialNbr = iCCTCertInfo->Token().Label();

    certPckg->iIndex = iCCTCertInfo->Handle().iObjectId;

    return certPckg;

    }

// -----------------------------------------------------------------------------

// CWimCertInfo::InternalizeL

// Instantiates CWimCertInfo of externalized data

// -----------------------------------------------------------------------------

//

EXPORT_C CWimCertInfo* CWimCertInfo::InternalizeL( 

    TWimCertInfoPckg& aExternalizedInfo )

    {

    _WIMTRACE(_L("WIM | WIMUtil | CWimCertInfo::InternalizeL | Begin"));

    RArray<HBufC*> trustedUsages;

    CWimDummyTokenType* tokenType = CWimDummyTokenType::NewL();

    CleanupReleasePushL( *tokenType );

    CWimDummyToken* token = CWimDummyToken::NewL( *tokenType );

	CleanupStack::Pop( tokenType );

    CleanupReleasePushL( *token );

    token->SetSerialNumber( aExternalizedInfo.iTokenSerialNbr );

    TInt certificateId = aExternalizedInfo.iIndex;

    TBool deletable = EFalse;

    CCTCertInfo* cctCertInfo = CCTCertInfo::NewL( 

                                        aExternalizedInfo.iCertLabel,

                                        aExternalizedInfo.iFormat,

                                        aExternalizedInfo.iCertificateOwnerType,

                                        aExternalizedInfo.iSize,

                                        &(aExternalizedInfo.iSubjectKeyId),

                                        &(aExternalizedInfo.iIssuerKeyId),

                                        *token,

                                        certificateId,

                                        deletable );

	CleanupStack::Pop( token );

	CleanupReleasePushL( *cctCertInfo );    

    CWimCertInfo* certInfo = CWimCertInfo::NewL( cctCertInfo,

                                                 aExternalizedInfo.iHash,

                                                 trustedUsages,

                                                 0 );

    CleanupStack::Pop( cctCertInfo );

    certInfo->SetCDFRefs( aExternalizedInfo.iCDFRefs );

    return certInfo;

    }

//  End of File