1 /* |
|
2 * Copyright (c) 2009 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: |
|
15 */ |
|
16 #include <QTest> |
|
17 |
|
18 #include "eapqtconfiginterface_context.h" |
|
19 #include "eapqtvalidator_stub.h" |
|
20 #include "eapqtexpandedeaptype.h" |
|
21 |
|
22 EapQtConfigInterfaceContext::EapQtConfigInterfaceContext() : |
|
23 mEapQtConfig(NULL) |
|
24 { |
|
25 } |
|
26 |
|
27 EapQtConfigInterfaceContext::~EapQtConfigInterfaceContext() |
|
28 { |
|
29 mEapQtConfig->mValidator.clear(); |
|
30 } |
|
31 |
|
32 void EapQtConfigInterfaceContext::setObject(EapQtConfigInterface *eapQtConfig) |
|
33 { |
|
34 mEapQtConfig = eapQtConfig; |
|
35 } |
|
36 |
|
37 void EapQtConfigInterfaceContext::createEapAkaSim(int type) |
|
38 { |
|
39 QList<EapQtPluginHandle> types; |
|
40 types.append((EapQtPluginHandle::Plugin)type); |
|
41 setSupportedOuterTypes(types); |
|
42 |
|
43 setSelectectedOuterTypes(types, true); |
|
44 |
|
45 EapQtConfig config; |
|
46 config.setValue(EapQtConfig::UsernameAutomatic, true); |
|
47 config.setValue(EapQtConfig::RealmAutomatic, true); |
|
48 setOuterConfig((EapQtPluginHandle::Plugin)type, config, true); |
|
49 } |
|
50 |
|
51 void EapQtConfigInterfaceContext::createLeap( |
|
52 const QString& username, |
|
53 const QString& passwd) |
|
54 { |
|
55 QList<EapQtPluginHandle> types; |
|
56 types.append(EapQtPluginHandle::PluginLeap); |
|
57 setSupportedOuterTypes(types); |
|
58 |
|
59 setSelectectedOuterTypes(types, true); |
|
60 |
|
61 EapQtConfig config; |
|
62 config.setValue(EapQtConfig::UsernameAutomatic, false); |
|
63 config.setValue(EapQtConfig::Username, username); |
|
64 config.setValue(EapQtConfig::PasswordPrompt, false); |
|
65 config.setValue(EapQtConfig::Password, passwd); |
|
66 setOuterConfig(EapQtPluginHandle::PluginLeap, config, true); |
|
67 |
|
68 // validators |
|
69 createInnerTypeValidators(EapQtPluginHandle::PluginLeap); |
|
70 } |
|
71 |
|
72 void EapQtConfigInterfaceContext::createEapIdentifyValidators(EapQtPluginHandle::Plugin outerType) |
|
73 { |
|
74 EapQtPluginHandle typeHandle(outerType); |
|
75 |
|
76 EapQtValidatorStub *valStub = new EapQtValidatorStub(EapQtValidator::StatusOk); |
|
77 setValidator(typeHandle.type().type(), EapQtConfig::Username, valStub); |
|
78 |
|
79 valStub = new EapQtValidatorStub(EapQtValidator::StatusOk); |
|
80 setValidator(typeHandle.type().type(), EapQtConfig::Realm, valStub); |
|
81 } |
|
82 |
|
83 void EapQtConfigInterfaceContext::createEapTtlsPeap( |
|
84 EapQtPluginHandle::Plugin type, |
|
85 bool automaticCert, |
|
86 bool usernameAutomatic, |
|
87 const QString &username, |
|
88 bool realmAutomatic, |
|
89 const QString &realm, |
|
90 EapQtPluginHandle::Plugin innerType) |
|
91 { |
|
92 EapQtPluginHandle typeHandle(type); |
|
93 |
|
94 QList<EapQtPluginHandle> types; |
|
95 types.append(typeHandle); |
|
96 setSupportedOuterTypes(types); |
|
97 setSelectectedOuterTypes(types, true); |
|
98 |
|
99 // Certs |
|
100 QList<EapQtCertificateInfo> certs; |
|
101 EapQtCertificateInfo caCert; |
|
102 caCert.setValue(EapQtCertificateInfo::CertificateLabel, "My Super Cert"); |
|
103 certs.append(caCert); |
|
104 setCertsCa(certs); |
|
105 |
|
106 // CREATE VALIDATOR |
|
107 createEapIdentifyValidators(type); |
|
108 |
|
109 // CREATE CONFIGURATION FOR TTLS/PEAP |
|
110 |
|
111 EapQtConfig config; |
|
112 config.setValue(EapQtConfig::UseIdentityPrivacy, false); |
|
113 config.setValue(EapQtConfig::VerifyServerRealm, false); |
|
114 config.setValue(EapQtConfig::ClientAuthenticationRequired, false); |
|
115 |
|
116 config.setValue(EapQtConfig::UsernameAutomatic, usernameAutomatic); |
|
117 config.setValue(EapQtConfig::Username, username); |
|
118 config.setValue(EapQtConfig::RealmAutomatic, realmAutomatic); |
|
119 config.setValue(EapQtConfig::Realm, realm); |
|
120 if (automaticCert){ |
|
121 config.setValue(EapQtConfig::AuthorityCertificateAutomatic, true); |
|
122 } |
|
123 else { |
|
124 QList<QVariant> caCerts; |
|
125 caCerts.append(qVariantFromValue(caCert)); |
|
126 config.setValue(EapQtConfig::AuthorityCertificate, caCerts); |
|
127 config.setValue(EapQtConfig::AuthorityCertificateAutomatic, false); |
|
128 } |
|
129 if (type == EapQtPluginHandle::PluginPeap){ |
|
130 if (innerType == EapQtPluginHandle::PluginEapMschapv2){ |
|
131 config.setValue(EapQtConfig::PeapVersion0Allowed, true); |
|
132 config.setValue(EapQtConfig::PeapVersion1Allowed, false); |
|
133 } |
|
134 else { |
|
135 config.setValue(EapQtConfig::PeapVersion0Allowed, false); |
|
136 config.setValue(EapQtConfig::PeapVersion1Allowed, true); |
|
137 } |
|
138 config.setValue(EapQtConfig::PeapVersion2Allowed, false); |
|
139 } |
|
140 QList<QVariant> innerTypeList; |
|
141 EapQtPluginHandle inner(innerType); |
|
142 innerTypeList.append(qVariantFromValue(inner)); |
|
143 config.setValue(EapQtConfig::InnerType, innerTypeList); |
|
144 |
|
145 setOuterConfig(type, config, true); |
|
146 } |
|
147 |
|
148 void EapQtConfigInterfaceContext::createEapTls( |
|
149 QList<EapQtCertificateInfo> &caCerts, |
|
150 int indexForCaCert, |
|
151 QList<EapQtCertificateInfo> &userCerts, |
|
152 int indexForUserCert) |
|
153 { |
|
154 QList<EapQtPluginHandle> types; |
|
155 types.append(EapQtPluginHandle::PluginEapTls); |
|
156 setSupportedOuterTypes(types); |
|
157 setSelectectedOuterTypes(types, true); |
|
158 |
|
159 // Certs |
|
160 setCertsCa(caCerts); |
|
161 setCertsUser(userCerts); |
|
162 |
|
163 // CREATE VALIDATOR |
|
164 createEapIdentifyValidators(EapQtPluginHandle::PluginEapTls); |
|
165 |
|
166 // CREATE CONFIGURATION FOR TTLS/PEAP |
|
167 |
|
168 EapQtConfig config; |
|
169 config.setValue(EapQtConfig::UseIdentityPrivacy, false); |
|
170 config.setValue(EapQtConfig::VerifyServerRealm, false); |
|
171 config.setValue(EapQtConfig::ClientAuthenticationRequired, true); |
|
172 |
|
173 config.setValue(EapQtConfig::UsernameAutomatic, true); |
|
174 config.setValue(EapQtConfig::Username, QString()); |
|
175 config.setValue(EapQtConfig::RealmAutomatic, true); |
|
176 config.setValue(EapQtConfig::Realm, QString()); |
|
177 |
|
178 if (caCerts.length() == 0){ |
|
179 config.setValue(EapQtConfig::AuthorityCertificateAutomatic, true); |
|
180 } else { |
|
181 QList<QVariant> caCertsVariant; |
|
182 caCertsVariant.append(qVariantFromValue(caCerts[indexForCaCert])); |
|
183 config.setValue(EapQtConfig::AuthorityCertificate, caCertsVariant); |
|
184 config.setValue(EapQtConfig::AuthorityCertificateAutomatic, false); |
|
185 } |
|
186 |
|
187 if (indexForUserCert != -1) { |
|
188 QList<QVariant> certs; |
|
189 certs.append(qVariantFromValue(userCerts[indexForUserCert])); |
|
190 config.setValue(EapQtConfig::UserCertificate, certs); |
|
191 } |
|
192 |
|
193 setOuterConfig(EapQtPluginHandle::PluginEapTls, config, true); |
|
194 } |
|
195 |
|
196 void EapQtConfigInterfaceContext::createInner( |
|
197 EapQtPluginHandle::Plugin outerType, |
|
198 EapQtPluginHandle::Plugin innerType, |
|
199 const QString &username, |
|
200 const QString &password) |
|
201 { |
|
202 EapQtPluginHandle innerHandle(innerType); |
|
203 |
|
204 QList<EapQtPluginHandle> types; |
|
205 types.append(innerHandle); |
|
206 setSupportedInnerTypes(outerType, types); |
|
207 |
|
208 EapQtConfig config; |
|
209 EapQtPluginHandle outerTypeHandle(outerType); |
|
210 config.setValue(EapQtConfig::OuterType, qVariantFromValue(outerTypeHandle)); |
|
211 config.setValue(EapQtConfig::UsernameAutomatic, false); |
|
212 config.setValue(EapQtConfig::Username, username); |
|
213 config.setValue(EapQtConfig::PasswordPrompt, false); |
|
214 config.setValue(EapQtConfig::Password, password); |
|
215 setInnerConfig(innerType, config, true); |
|
216 |
|
217 createInnerTypeValidators(innerType); |
|
218 } |
|
219 |
|
220 void EapQtConfigInterfaceContext::createInnerTypeValidators(EapQtPluginHandle::Plugin innerType) |
|
221 { |
|
222 EapQtPluginHandle innerHandle(innerType); |
|
223 |
|
224 // validators |
|
225 EapQtValidatorStub *valStub = new EapQtValidatorStub(EapQtValidator::StatusOk); |
|
226 setValidator(innerHandle.type().type(), EapQtConfig::Username, valStub); |
|
227 |
|
228 valStub = new EapQtValidatorStub(EapQtValidator::StatusOk); |
|
229 setValidator(innerHandle.type().type(), EapQtConfig::Password, valStub); |
|
230 } |
|
231 |
|
232 void EapQtConfigInterfaceContext::createEapFast( |
|
233 int pacState, const QString &password) |
|
234 { |
|
235 QList<EapQtPluginHandle> types; |
|
236 types.append(EapQtPluginHandle::PluginEapFast); |
|
237 setSupportedOuterTypes(types); |
|
238 setSelectectedOuterTypes(types, true); |
|
239 |
|
240 EapQtPacStoreConfig pacStoreConfig; |
|
241 pacStoreConfig.setValue(EapQtPacStoreConfig::PacStoreState, pacState); |
|
242 setPacStoreConfigRead(pacStoreConfig, true); |
|
243 |
|
244 if (pacState == EapQtPacStoreConfig::PacStoreStateStoreNotExists || |
|
245 pacState == EapQtPacStoreConfig::PacStoreStatePasswordRequired) { |
|
246 pacStoreConfig.clear(); |
|
247 pacStoreConfig.setValue( |
|
248 EapQtPacStoreConfig::PacStorePassword, |
|
249 password); |
|
250 |
|
251 pacStoreConfig.setValue( |
|
252 EapQtPacStoreConfig::PacStoreSavePassword, |
|
253 true); |
|
254 |
|
255 setPacStoreConfigSave(pacStoreConfig, true); |
|
256 } |
|
257 |
|
258 if (pacState == EapQtPacStoreConfig::PacStoreStateStoreNotExists) { |
|
259 EapQtValidatorStub *validator = new EapQtValidatorStub(EapQtValidator::StatusOk); |
|
260 setValidatorPacStore(EapQtPacStoreConfig::PacStorePassword, validator); |
|
261 } |
|
262 |
|
263 if (pacState == EapQtPacStoreConfig::PacStoreStatePasswordRequired) { |
|
264 EapQtValidatorStub *validator = new EapQtValidatorStub(EapQtValidator::StatusOk); |
|
265 setValidatorPacStore(EapQtPacStoreConfig::PacStorePasswordConfirmation, validator); |
|
266 } |
|
267 |
|
268 EapQtConfig config; |
|
269 config.setValue(EapQtConfig::ProvisioningModeAuthenticated, false); |
|
270 config.setValue(EapQtConfig::ProvisioningModeUnauthenticated, true); |
|
271 config.setValue(EapQtConfig::VerifyServerRealm, false); |
|
272 config.setValue(EapQtConfig::UseIdentityPrivacy, false); |
|
273 |
|
274 QList<QVariant> innerTypeList; |
|
275 EapQtPluginHandle inner(EapQtPluginHandle::PluginEapMschapv2); |
|
276 innerTypeList.append(qVariantFromValue(inner)); |
|
277 config.setValue(EapQtConfig::InnerType, innerTypeList); |
|
278 |
|
279 setOuterConfig(EapQtPluginHandle::PluginEapFast, config, true); |
|
280 } |
|
281 |
|
282 QStringList EapQtConfigInterfaceContext::calledMethods() |
|
283 { |
|
284 QStringList methods = mEapQtConfig->mCalledMethods; |
|
285 mEapQtConfig->mCalledMethods.clear(); |
|
286 return methods; |
|
287 } |
|
288 |
|
289 void EapQtConfigInterfaceContext::setConfigurationReference( |
|
290 int iapId, |
|
291 bool retValue) |
|
292 { |
|
293 mEapQtConfig->mIapId = iapId; |
|
294 setConfigurationReferenceReturn(retValue); |
|
295 } |
|
296 |
|
297 void EapQtConfigInterfaceContext::setConfigurationReferenceReturn(bool retValue) |
|
298 { |
|
299 mEapQtConfig->mReturnSetConfigurationReference = retValue; |
|
300 } |
|
301 |
|
302 void EapQtConfigInterfaceContext::setCertsCa( |
|
303 QList<EapQtCertificateInfo> &certs) |
|
304 { |
|
305 mEapQtConfig->mCertsCa = certs; |
|
306 } |
|
307 |
|
308 void EapQtConfigInterfaceContext::setCertsUser( |
|
309 QList<EapQtCertificateInfo> &certs) |
|
310 { |
|
311 mEapQtConfig->mCertsUser = certs; |
|
312 } |
|
313 |
|
314 void EapQtConfigInterfaceContext::setSupportedOuterTypes( |
|
315 QList<EapQtPluginHandle> &outerTypes) |
|
316 { |
|
317 mEapQtConfig->mSupportedOuterTypes = outerTypes; |
|
318 } |
|
319 |
|
320 void EapQtConfigInterfaceContext::setSupportedInnerTypes( |
|
321 EapQtPluginHandle outerHandle, |
|
322 QList<EapQtPluginHandle> &innerTypes) |
|
323 { |
|
324 mEapQtConfig->mSupportedInnerTypes = innerTypes; |
|
325 mEapQtConfig->mSupportedInnerTypesOuterHandle = outerHandle.pluginId(); |
|
326 } |
|
327 |
|
328 void EapQtConfigInterfaceContext::setSelectectedOuterTypes( |
|
329 QList<EapQtPluginHandle> &types, |
|
330 bool retValue) |
|
331 { |
|
332 mEapQtConfig->mSetSelectectedOuterTypes = types; |
|
333 setSelectectedOuterTypesReturn(retValue); |
|
334 } |
|
335 |
|
336 void EapQtConfigInterfaceContext::setSelectectedOuterTypesReturn(bool retValue) |
|
337 { |
|
338 mEapQtConfig->mReturnSetSelectedOuterTypes = retValue; |
|
339 } |
|
340 |
|
341 void EapQtConfigInterfaceContext::setOuterConfig( |
|
342 EapQtPluginHandle::Plugin handle, |
|
343 EapQtConfig &config, |
|
344 bool retValue) |
|
345 { |
|
346 mEapQtConfig->mOuterPlugin = handle; |
|
347 mEapQtConfig->mSaveConfigurationsOuter = config; |
|
348 setOuterConfigReturn(retValue); |
|
349 } |
|
350 |
|
351 void EapQtConfigInterfaceContext::setOuterConfigReturn(bool retValue) |
|
352 { |
|
353 mEapQtConfig->mReturnSaveConfigurationOuter = retValue; |
|
354 } |
|
355 |
|
356 void EapQtConfigInterfaceContext::setInnerConfig( |
|
357 EapQtPluginHandle::Plugin handle, |
|
358 EapQtConfig &config, |
|
359 bool retValue) |
|
360 { |
|
361 mEapQtConfig->mInnerPlugin = handle; |
|
362 mEapQtConfig->mSaveConfigurationsInner = config; |
|
363 setInnerConfigReturn(retValue); |
|
364 } |
|
365 |
|
366 void EapQtConfigInterfaceContext::setInnerConfigReturn(bool retValue) |
|
367 { |
|
368 mEapQtConfig->mReturnSaveConfigurationInner = retValue; |
|
369 } |
|
370 |
|
371 void EapQtConfigInterfaceContext::setValidator( |
|
372 EapQtExpandedEapType::Type eapType, |
|
373 EapQtConfig::SettingsId id, |
|
374 EapQtValidator *validator) |
|
375 { |
|
376 QCOMPARE(mEapQtConfig->mValidator[eapType][id] == NULL, true); |
|
377 mEapQtConfig->mValidator[eapType][id] = validator; |
|
378 } |
|
379 |
|
380 |
|
381 EapQtValidator *EapQtConfigInterfaceContext::validator( |
|
382 EapQtExpandedEapType::Type eapType, |
|
383 EapQtConfig::SettingsId id) |
|
384 { |
|
385 return mEapQtConfig->mValidator[eapType][id]; |
|
386 } |
|
387 |
|
388 void EapQtConfigInterfaceContext::setPacStoreConfigRead( |
|
389 EapQtPacStoreConfig &config, |
|
390 bool retValue) |
|
391 { |
|
392 mEapQtConfig->mReadPacStoreConfiguration = config; |
|
393 setPacStoreConfigReadReturn(retValue); |
|
394 } |
|
395 |
|
396 void EapQtConfigInterfaceContext::setPacStoreConfigReadReturn(bool retValue) |
|
397 { |
|
398 mEapQtConfig->mReadPacStoreConfigurationReturn = retValue; |
|
399 } |
|
400 |
|
401 void EapQtConfigInterfaceContext::setPacStoreConfigSave( |
|
402 EapQtPacStoreConfig &config, |
|
403 bool retValue) |
|
404 { |
|
405 mEapQtConfig->mSavePacStoreConfiguration = config; |
|
406 setPacStoreConfigSaveReturn(retValue); |
|
407 } |
|
408 |
|
409 void EapQtConfigInterfaceContext::setPacStoreConfigSaveReturn(bool retValue) |
|
410 { |
|
411 mEapQtConfig->mSavePacStoreConfigurationReturn = retValue; |
|
412 } |
|
413 |
|
414 void EapQtConfigInterfaceContext::setValidatorPacStore(int id, EapQtValidator * validator) |
|
415 { |
|
416 mEapQtConfig->mValidatorPacStore[id] = validator; |
|
417 } |
|
418 |
|
419 EapQtValidator *EapQtConfigInterfaceContext::validatorPacStore(int id) |
|
420 { |
|
421 return mEapQtConfig->mValidatorPacStore[id]; |
|
422 } |
|