/*
* Copyright (c) 2009 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:
*/
#include <QTest>
#include "eapqtconfiginterface_context.h"
#include "eapqtvalidator_stub.h"
#include "eapqtexpandedeaptype.h"
EapQtConfigInterfaceContext::EapQtConfigInterfaceContext() :
mEapQtConfig(NULL)
{
}
EapQtConfigInterfaceContext::~EapQtConfigInterfaceContext()
{
mEapQtConfig->mValidator.clear();
}
void EapQtConfigInterfaceContext::setObject(EapQtConfigInterface *eapQtConfig)
{
mEapQtConfig = eapQtConfig;
}
void EapQtConfigInterfaceContext::createEapAkaSim(int type)
{
QList<EapQtPluginHandle> types;
types.append((EapQtPluginHandle::Plugin)type);
setSupportedOuterTypes(types);
setSelectectedOuterTypes(types, true);
EapQtConfig config;
config.setValue(EapQtConfig::UsernameAutomatic, true);
config.setValue(EapQtConfig::RealmAutomatic, true);
setOuterConfig((EapQtPluginHandle::Plugin)type, config, true);
}
void EapQtConfigInterfaceContext::createLeap(
const QString& username,
const QString& passwd)
{
QList<EapQtPluginHandle> types;
types.append(EapQtPluginHandle::PluginLeap);
setSupportedOuterTypes(types);
setSelectectedOuterTypes(types, true);
EapQtConfig config;
config.setValue(EapQtConfig::UsernameAutomatic, false);
config.setValue(EapQtConfig::Username, username);
config.setValue(EapQtConfig::PasswordPrompt, false);
config.setValue(EapQtConfig::Password, passwd);
setOuterConfig(EapQtPluginHandle::PluginLeap, config, true);
// validators
createInnerTypeValidators(EapQtPluginHandle::PluginLeap);
}
void EapQtConfigInterfaceContext::createEapIdentifyValidators(EapQtPluginHandle::Plugin outerType)
{
EapQtPluginHandle typeHandle(outerType);
EapQtValidatorStub *valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
setValidator(typeHandle.type().type(), EapQtConfig::Username, valStub);
valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
setValidator(typeHandle.type().type(), EapQtConfig::Realm, valStub);
}
void EapQtConfigInterfaceContext::createEapTtlsPeap(
EapQtPluginHandle::Plugin type,
bool automaticCert,
bool usernameAutomatic,
const QString &username,
bool realmAutomatic,
const QString &realm,
EapQtPluginHandle::Plugin innerType)
{
EapQtPluginHandle typeHandle(type);
QList<EapQtPluginHandle> types;
types.append(typeHandle);
setSupportedOuterTypes(types);
setSelectectedOuterTypes(types, true);
// Certs
QList<EapQtCertificateInfo> certs;
EapQtCertificateInfo caCert;
caCert.setValue(EapQtCertificateInfo::CertificateLabel, "My Super Cert");
certs.append(caCert);
setCertsCa(certs);
// CREATE VALIDATOR
createEapIdentifyValidators(type);
// CREATE CONFIGURATION FOR TTLS/PEAP
EapQtConfig config;
config.setValue(EapQtConfig::UseIdentityPrivacy, false);
config.setValue(EapQtConfig::VerifyServerRealm, false);
config.setValue(EapQtConfig::ClientAuthenticationRequired, false);
config.setValue(EapQtConfig::UsernameAutomatic, usernameAutomatic);
config.setValue(EapQtConfig::Username, username);
config.setValue(EapQtConfig::RealmAutomatic, realmAutomatic);
config.setValue(EapQtConfig::Realm, realm);
if (automaticCert){
config.setValue(EapQtConfig::AuthorityCertificateAutomatic, true);
}
else {
QList<QVariant> caCerts;
caCerts.append(qVariantFromValue(caCert));
config.setValue(EapQtConfig::AuthorityCertificate, caCerts);
config.setValue(EapQtConfig::AuthorityCertificateAutomatic, false);
}
if (type == EapQtPluginHandle::PluginPeap){
if (innerType == EapQtPluginHandle::PluginEapMschapv2){
config.setValue(EapQtConfig::PeapVersion0Allowed, true);
config.setValue(EapQtConfig::PeapVersion1Allowed, false);
}
else {
config.setValue(EapQtConfig::PeapVersion0Allowed, false);
config.setValue(EapQtConfig::PeapVersion1Allowed, true);
}
config.setValue(EapQtConfig::PeapVersion2Allowed, false);
}
QList<QVariant> innerTypeList;
EapQtPluginHandle inner(innerType);
innerTypeList.append(qVariantFromValue(inner));
config.setValue(EapQtConfig::InnerType, innerTypeList);
setOuterConfig(type, config, true);
}
void EapQtConfigInterfaceContext::createEapTls(
QList<EapQtCertificateInfo> &caCerts,
int indexForCaCert,
QList<EapQtCertificateInfo> &userCerts,
int indexForUserCert)
{
QList<EapQtPluginHandle> types;
types.append(EapQtPluginHandle::PluginEapTls);
setSupportedOuterTypes(types);
setSelectectedOuterTypes(types, true);
// Certs
setCertsCa(caCerts);
setCertsUser(userCerts);
// CREATE VALIDATOR
createEapIdentifyValidators(EapQtPluginHandle::PluginEapTls);
// CREATE CONFIGURATION FOR TTLS/PEAP
EapQtConfig config;
config.setValue(EapQtConfig::UseIdentityPrivacy, false);
config.setValue(EapQtConfig::VerifyServerRealm, false);
config.setValue(EapQtConfig::ClientAuthenticationRequired, true);
config.setValue(EapQtConfig::UsernameAutomatic, true);
config.setValue(EapQtConfig::Username, QString());
config.setValue(EapQtConfig::RealmAutomatic, true);
config.setValue(EapQtConfig::Realm, QString());
if (caCerts.length() == 0){
config.setValue(EapQtConfig::AuthorityCertificateAutomatic, true);
} else {
QList<QVariant> caCertsVariant;
caCertsVariant.append(qVariantFromValue(caCerts[indexForCaCert]));
config.setValue(EapQtConfig::AuthorityCertificate, caCertsVariant);
config.setValue(EapQtConfig::AuthorityCertificateAutomatic, false);
}
if (indexForUserCert != -1) {
QList<QVariant> certs;
certs.append(qVariantFromValue(userCerts[indexForUserCert]));
config.setValue(EapQtConfig::UserCertificate, certs);
}
setOuterConfig(EapQtPluginHandle::PluginEapTls, config, true);
}
void EapQtConfigInterfaceContext::createInner(
EapQtPluginHandle::Plugin outerType,
EapQtPluginHandle::Plugin innerType,
const QString &username,
const QString &password)
{
EapQtPluginHandle innerHandle(innerType);
QList<EapQtPluginHandle> types;
types.append(innerHandle);
setSupportedInnerTypes(outerType, types);
EapQtConfig config;
EapQtPluginHandle outerTypeHandle(outerType);
config.setValue(EapQtConfig::OuterType, qVariantFromValue(outerTypeHandle));
config.setValue(EapQtConfig::UsernameAutomatic, false);
config.setValue(EapQtConfig::Username, username);
config.setValue(EapQtConfig::PasswordPrompt, false);
config.setValue(EapQtConfig::Password, password);
setInnerConfig(innerType, config, true);
createInnerTypeValidators(innerType);
}
void EapQtConfigInterfaceContext::createInnerTypeValidators(EapQtPluginHandle::Plugin innerType)
{
EapQtPluginHandle innerHandle(innerType);
// validators
EapQtValidatorStub *valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
setValidator(innerHandle.type().type(), EapQtConfig::Username, valStub);
valStub = new EapQtValidatorStub(EapQtValidator::StatusOk);
setValidator(innerHandle.type().type(), EapQtConfig::Password, valStub);
}
void EapQtConfigInterfaceContext::createEapFast(
int pacState, const QString &password)
{
QList<EapQtPluginHandle> types;
types.append(EapQtPluginHandle::PluginEapFast);
setSupportedOuterTypes(types);
setSelectectedOuterTypes(types, true);
EapQtPacStoreConfig pacStoreConfig;
pacStoreConfig.setValue(EapQtPacStoreConfig::PacStoreState, pacState);
setPacStoreConfigRead(pacStoreConfig, true);
if (pacState == EapQtPacStoreConfig::PacStoreStateStoreNotExists ||
pacState == EapQtPacStoreConfig::PacStoreStatePasswordRequired) {
pacStoreConfig.clear();
pacStoreConfig.setValue(
EapQtPacStoreConfig::PacStorePassword,
password);
pacStoreConfig.setValue(
EapQtPacStoreConfig::PacStoreSavePassword,
true);
setPacStoreConfigSave(pacStoreConfig, true);
}
if (pacState == EapQtPacStoreConfig::PacStoreStateStoreNotExists) {
EapQtValidatorStub *validator = new EapQtValidatorStub(EapQtValidator::StatusOk);
setValidatorPacStore(EapQtPacStoreConfig::PacStorePassword, validator);
}
if (pacState == EapQtPacStoreConfig::PacStoreStatePasswordRequired) {
EapQtValidatorStub *validator = new EapQtValidatorStub(EapQtValidator::StatusOk);
setValidatorPacStore(EapQtPacStoreConfig::PacStorePasswordConfirmation, validator);
}
EapQtConfig config;
config.setValue(EapQtConfig::ProvisioningModeAuthenticated, false);
config.setValue(EapQtConfig::ProvisioningModeUnauthenticated, true);
config.setValue(EapQtConfig::VerifyServerRealm, false);
config.setValue(EapQtConfig::UseIdentityPrivacy, false);
QList<QVariant> innerTypeList;
EapQtPluginHandle inner(EapQtPluginHandle::PluginEapMschapv2);
innerTypeList.append(qVariantFromValue(inner));
config.setValue(EapQtConfig::InnerType, innerTypeList);
setOuterConfig(EapQtPluginHandle::PluginEapFast, config, true);
}
QStringList EapQtConfigInterfaceContext::calledMethods()
{
QStringList methods = mEapQtConfig->mCalledMethods;
mEapQtConfig->mCalledMethods.clear();
return methods;
}
void EapQtConfigInterfaceContext::setConfigurationReference(
int iapId,
bool retValue)
{
mEapQtConfig->mIapId = iapId;
setConfigurationReferenceReturn(retValue);
}
void EapQtConfigInterfaceContext::setConfigurationReferenceReturn(bool retValue)
{
mEapQtConfig->mReturnSetConfigurationReference = retValue;
}
void EapQtConfigInterfaceContext::setCertsCa(
QList<EapQtCertificateInfo> &certs)
{
mEapQtConfig->mCertsCa = certs;
}
void EapQtConfigInterfaceContext::setCertsUser(
QList<EapQtCertificateInfo> &certs)
{
mEapQtConfig->mCertsUser = certs;
}
void EapQtConfigInterfaceContext::setSupportedOuterTypes(
QList<EapQtPluginHandle> &outerTypes)
{
mEapQtConfig->mSupportedOuterTypes = outerTypes;
}
void EapQtConfigInterfaceContext::setSupportedInnerTypes(
EapQtPluginHandle outerHandle,
QList<EapQtPluginHandle> &innerTypes)
{
mEapQtConfig->mSupportedInnerTypes = innerTypes;
mEapQtConfig->mSupportedInnerTypesOuterHandle = outerHandle.pluginId();
}
void EapQtConfigInterfaceContext::setSelectectedOuterTypes(
QList<EapQtPluginHandle> &types,
bool retValue)
{
mEapQtConfig->mSetSelectectedOuterTypes = types;
setSelectectedOuterTypesReturn(retValue);
}
void EapQtConfigInterfaceContext::setSelectectedOuterTypesReturn(bool retValue)
{
mEapQtConfig->mReturnSetSelectedOuterTypes = retValue;
}
void EapQtConfigInterfaceContext::setOuterConfig(
EapQtPluginHandle::Plugin handle,
EapQtConfig &config,
bool retValue)
{
mEapQtConfig->mOuterPlugin = handle;
mEapQtConfig->mSaveConfigurationsOuter = config;
setOuterConfigReturn(retValue);
}
void EapQtConfigInterfaceContext::setOuterConfigReturn(bool retValue)
{
mEapQtConfig->mReturnSaveConfigurationOuter = retValue;
}
void EapQtConfigInterfaceContext::setInnerConfig(
EapQtPluginHandle::Plugin handle,
EapQtConfig &config,
bool retValue)
{
mEapQtConfig->mInnerPlugin = handle;
mEapQtConfig->mSaveConfigurationsInner = config;
setInnerConfigReturn(retValue);
}
void EapQtConfigInterfaceContext::setInnerConfigReturn(bool retValue)
{
mEapQtConfig->mReturnSaveConfigurationInner = retValue;
}
void EapQtConfigInterfaceContext::setValidator(
EapQtExpandedEapType::Type eapType,
EapQtConfig::SettingsId id,
EapQtValidator *validator)
{
QCOMPARE(mEapQtConfig->mValidator[eapType][id] == NULL, true);
mEapQtConfig->mValidator[eapType][id] = validator;
}
EapQtValidator *EapQtConfigInterfaceContext::validator(
EapQtExpandedEapType::Type eapType,
EapQtConfig::SettingsId id)
{
return mEapQtConfig->mValidator[eapType][id];
}
void EapQtConfigInterfaceContext::setPacStoreConfigRead(
EapQtPacStoreConfig &config,
bool retValue)
{
mEapQtConfig->mReadPacStoreConfiguration = config;
setPacStoreConfigReadReturn(retValue);
}
void EapQtConfigInterfaceContext::setPacStoreConfigReadReturn(bool retValue)
{
mEapQtConfig->mReadPacStoreConfigurationReturn = retValue;
}
void EapQtConfigInterfaceContext::setPacStoreConfigSave(
EapQtPacStoreConfig &config,
bool retValue)
{
mEapQtConfig->mSavePacStoreConfiguration = config;
setPacStoreConfigSaveReturn(retValue);
}
void EapQtConfigInterfaceContext::setPacStoreConfigSaveReturn(bool retValue)
{
mEapQtConfig->mSavePacStoreConfigurationReturn = retValue;
}
void EapQtConfigInterfaceContext::setValidatorPacStore(int id, EapQtValidator * validator)
{
mEapQtConfig->mValidatorPacStore[id] = validator;
}
EapQtValidator *EapQtConfigInterfaceContext::validatorPacStore(int id)
{
return mEapQtConfig->mValidatorPacStore[id];
}