/*
* Copyright (c) 2010 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: Implementation of class CCertManUIContainerTrust.
* Maintains correct list of trusted clients depending
* on the certificate that was in focus in Authority
* certificates view when Trust Settings view was entered.
* Shows and changes correct Yes/No text for the Trusted client.
*
*/
// INCLUDE FILES
#include <certificateapps.h>
#include <mctcertapps.h>
#include <mctcertstore.h>
#include <QGraphicsLinearLayout>
#include <QString>
#include <QList>
#include <hbdataform.h>
#include <hbdataformmodel.h>
#include <hbdataformmodelitem.h>
#include <hblistwidgetitem.h>
#include <hblistwidget.h>
#include <memory>
#include <../../inc/cpsecplugins.h>
#include "cpcerttrustview.h"
#include "cpcertdatacontainer.h"
#include "cpcertmanuisyncwrapper.h"
#include "cpuitrustids.h"
const TInt KMidpCertStoreUid = 0x101F5B71;
// ============================= LOCAL FUNCTIONS ===============================
// ================= MEMBER FUNCTIONS =======================
CpCertTrustView::CpCertTrustView( TInt certificateIndex, CpCertDataContainer& certDataContainer, QGraphicsItem *parent /*= 0*/)
: CpBaseSettingView(0,parent), mCertDataContainer(certDataContainer), mCertificateIndex(certificateIndex)
{
setTitle(tr("Trust Settings"));
viewTrustSettings();
}
// ---------------------------------------------------------
// CpCertTrustView::~CpCertTrustView()
// Destructor
// ---------------------------------------------------------
//
CpCertTrustView::~CpCertTrustView()
{
delete mAppInfoManager;
mClientUids.Close();
delete mFormModel;
mTrustedClients.erase(mTrustedClients.begin(), mTrustedClients.end());
mTrustValues.erase(mTrustValues.begin(), mTrustValues.end());
}
void CpCertTrustView::viewTrustSettings()
{
RDEBUG("0", 0);
mTrustedClients << " \tWAP connection\t\t";
mTrustedClients << " \tMail and Image conn.\t\t";
mTrustedClients << " \tNative installing\t\t";
mTrustedClients << " \tJava installing\t\t";
mTrustedClients << " \tOCSP validation\t\t";
mTrustedClients << " \tVPN\t\t";
mTrustedClients << " \tWidget Installation\t\t";
mTrustValues << "On";
mTrustValues << "Off";
try
{
QT_TRAP_THROWING( mAppInfoManager =
CCertificateAppInfoManager::NewL( mCertDataContainer.iRfs, EFalse );
updateListBoxL();)
}
catch(std::exception& exception)
{
QString error(exception.what());
QT_TRAP_THROWING( mCertDataContainer.ShowErrorNoteL( error.toInt()) );
throw(exception);
}
}
// ---------------------------------------------------------------------------
// CpCertTrustView::UpdateListBoxL()
// Puts correct Trust Settings text to listbox and correct value (yes/no)
// to the setting, asks the value from CheckCertificateClientTrust
// For X509 certificates, only one Application is currently supported
// (Application controller), more applications maybe added later however,
// so one additional application has been left in comments as an example.
// WAP connection and Application installer have their names from resources
// and thus localized, other additional application get their names from
// TCertificateAppInfo's Name() function.
// ---------------------------------------------------------------------------
//
void CpCertTrustView::updateListBoxL()
{
RDEBUG("0", 0);
mClientUids.Reset();
TInt clientCount = 0;
// Use certificate index from previous view
CCTCertInfo* entry = mCertDataContainer.iCALabelEntries[ mCertificateIndex ]->iCAEntry;
// Here MCTCertApps should be used to get client options, but it is not properly
// supported in any cert store. It should be possible to get the MCTCertApps
// through token's GetInterface function.
if ( entry->Token().TokenType().Type() == TUid::Uid( KTokenTypeFileCertstore ) )
{
if ( !mAppInfoManager )
{
User::Leave( KErrArgument );
}
RArray<TCertificateAppInfo> apps;
apps = mAppInfoManager->Applications();
for ( TInt i = 0; i < apps.Count(); i++ )
{
if ( apps[i].Id() != KCertManUIViewTrustJavaInstallingId &&
apps[i].Id() != KCertManUIViewTrustApplicationControllerId )
{
mClientUids.Append( apps[i].Id() );
}
}
}
else
{
mCertDataContainer.iWrapper->GetApplicationsL(
mCertDataContainer.CertManager(), *entry, mClientUids );
}
// This is needed because MIDPCertStore does not support MCTCertApps
if ( mClientUids.Count() == 0 &&
entry->Token().TokenType().Type() == TUid::Uid( KMidpCertStoreUid ) )
{
mClientUids.Append( KCertManUIViewTrustJavaInstallingId );
}
clientCount = mClientUids.Count();
QList<int> itemArray;
for(int i=0;i<mTrustedClients.size();i++)
{
itemArray.insert(i,0);
}
if ( EX509Certificate != entry->CertificateFormat() )
{
return;
}
TInt resIndex = KErrNotFound;
if ( mClientUids.Count() > 0 )
{
for ( TInt k = 0; k < clientCount; k++ )
{
resIndex = trustIdIndex( mClientUids[k] );
if ( resIndex == KErrNotFound )
{
continue;
}
// based on the trust list update the array
TBool trustState = EFalse;
QString item = mTrustedClients[ resIndex ];
trustState = checkCertificateClientTrustL( mClientUids[k], *entry );
if ( trustState )
{
itemArray.replace(resIndex,1);
}
}
}
// display the list
QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical);
setLayout(layout);
std::auto_ptr<HbDataForm> form(new HbDataForm());
mFormModel = new HbDataFormModel();
HbListWidget* mCertLabelList = new HbListWidget(this);
std::auto_ptr<HbListWidgetItem> certLabel(q_check_ptr(new HbListWidgetItem()));
const TDesC& label = entry->Label();
certLabel->setText(QString( (QChar*)label.Ptr(),label.Length() ) );
mCertLabelList->addItem(certLabel.get());
certLabel.release();
RDEBUG("0", 0);
int count = mTrustedClients.size();
for( int index = 0 ;index < count; ++index)
{
std::auto_ptr<HbDataFormModelItem> item (q_check_ptr(new HbDataFormModelItem(
HbDataFormModelItem::ToggleValueItem,
mTrustedClients[index] ) ));
if( itemArray[index] == 1)
{
item->setContentWidgetData("text",mTrustValues[0]);
item->setContentWidgetData("additionalText",mTrustValues[1]);
}
else
{
item->setContentWidgetData("text",mTrustValues[1]);
item->setContentWidgetData("additionalText",mTrustValues[0]);
}
mFormModel->appendDataFormItem(item.get());
item.release();
}
form->setModel(mFormModel);
layout->addItem(mCertLabelList);
layout->addItem(form.get());
form.release();
}
void CpCertTrustView::saveTrustSettings()
{
RDEBUG("0", 0);
CCTCertInfo& entry = *( mCertDataContainer.iCALabelEntries[ mCertificateIndex ]->iCAEntry );
if ( entry.IsDeletable() )
{
TInt itemCount = mFormModel->rowCount();
RArray<TUid> newUids;
QT_TRAP_THROWING( CleanupClosePushL( newUids ));
for(int index = 0;index<itemCount;++index)
{
HbDataFormModelItem *item = mFormModel->item(index);
QString trustValue = item->contentWidgetData("text").toString();
if(trustValue == "On")
{
newUids.Append(trusterId(mTrustedClients[index]));
}
}
QT_TRAP_THROWING( mCertDataContainer.iWrapper->SetApplicabilityL( mCertDataContainer.CertManager(), entry, newUids ));
CleanupStack::PopAndDestroy(&newUids);
}
}
TUid CpCertTrustView::trusterId(const QString& clientDescription) const
{
RDEBUG("0", 0);
TUid retValue = TUid::Uid(0);
if( clientDescription == " \tWAP connection\t\t" )
retValue = KCertManUIViewTrustWapConnectionId;
else if( clientDescription == " \tMail and Image conn.\t\t" )
retValue = KCertManUIViewTrustMailAndImageConnId;
else if( clientDescription == " \tNative installing\t\t" )
retValue = KCertManUIViewTrustApplicationControllerId;
else if( clientDescription == " \tJava installing\t\t" )
retValue = KCertManUIViewTrustJavaInstallingId;
else if( clientDescription == " \tOCSP validation\t\t" )
retValue = KCertManUIViewOCSPCheckInstallingId;
else if( clientDescription == " \tVPN\t\t" )
retValue = KCertManUIViewTrustVPNId;
else if( clientDescription == " \tWidget Installation\t\t" )
retValue = KCertManUIViewTrustWidgetInstallId;
return retValue;
}
// ---------------------------------------------------------------------------
// CpCertTrustView::trustIdIndex( TUid trustUid )
// ---------------------------------------------------------------------------
//
TInt CpCertTrustView::trustIdIndex( TUid trustUid ) const
{
RDEBUG("0", 0);
TInt resIndex = KErrNotFound;
if ( trustUid == KCertManUIViewTrustApplicationControllerId )
{
resIndex = KTrustSettingsResourceIndexAppCtrl;
}
else if( trustUid == KCertManUIViewTrustWapConnectionId )
{
resIndex = KTrustSettingsResourceIndexWAP;
}
else if ( trustUid == KCertManUIViewTrustMailAndImageConnId )
{
resIndex = KTrustSettingsResourceIndexMailAndImageConn;
}
else if ( trustUid == KCertManUIViewTrustJavaInstallingId )
{
resIndex = KTrustSettingsResourceIndexJavaInstall;
}
else if ( trustUid == KCertManUIViewOCSPCheckInstallingId )
{
resIndex = KTrustSettingsResourceIndexOCSPCheck;
}
else if ( trustUid == KCertManUIViewTrustVPNId )
{
resIndex = KTrustSettingsResourceIndexVPN;
}
else if ( trustUid == KCertManUIViewTrustWidgetInstallId )
{
resIndex = KTrustSettingsResourceIndexWidget;
}
return resIndex;
}
// ---------------------------------------------------------------------------
// CpCertTrustView::CheckCertificateClientTrustL(const TUid aClientTUid,
// CCTCertInfo& aEntry) const
// Checks if a certificate trusts a client
// * Certificate format == ECrX509Certificate ECrX968Certificate ECrCertificateURL
// are not supported if certificate location == ECrCertLocationWIMCard
// * Certificate format == ECrX968Certificate ECrCertificateURL are not supported
// if certificate location == ECrCertLocationCertMan
// * Certificate location == ECrCertLocationWIMURL ECrCertLocationPhoneMemory
// ECrCertLocationPhoneMemoryURL are not supported
// ---------------------------------------------------------------------------
//
TBool CpCertTrustView::checkCertificateClientTrustL(
const TUid clientUid, const CCTCertInfo& entry ) const
{
RDEBUG("0", 0);
TBool trustSettingTrusted = EFalse;
TCertificateFormat format = entry.CertificateFormat();
if ( format == EX509Certificate )
{
RArray<TUid> trusterUids;
CleanupClosePushL( trusterUids );
//Owned by mCertDataContainer.
CUnifiedCertStore*& store = mCertDataContainer.CertManager();
// Get trusting applications' Uids for the one selected
// certificate entry
mCertDataContainer.iWrapper->GetApplicationsL( store, entry, trusterUids );
// get the number of trusting applications for one
// selected certificate entry
TInt trusterCount = trusterUids.Count();
// in this loop, for every trusting application in one
// selected certificate entry
for ( TInt i = 0; i < trusterCount; ++i )
{
// put the trusting application's Uid to TUid truster
if ( clientUid == trusterUids[i] )
{
trustSettingTrusted = ETrue;
break;
}
}
CleanupStack::PopAndDestroy(&trusterUids);
}
return trustSettingTrusted;
}
// End of File