diff options
Diffstat (limited to 'knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security_widget.cpp')
| -rw-r--r-- | knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security_widget.cpp | 999 |
1 files changed, 999 insertions, 0 deletions
diff --git a/knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security_widget.cpp b/knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security_widget.cpp new file mode 100644 index 0000000..5f508fc --- /dev/null +++ b/knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security_widget.cpp @@ -0,0 +1,999 @@ +/*************************************************************************** + * + * knetworkmanager-connection_setting_wireless_security_widget.cpp + * - A NetworkManager frontend for KDE + * + * Copyright (C) 2005, 2006 Novell, Inc. + * + * Author: Helmut Schaa <hschaa@suse.de>, <Helmut.Schaa@gmx.de> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + **************************************************************************/ + +/* qt headers */ +#include <tqwidget.h> +#include <tqlineedit.h> +#include <tqgroupbox.h> +#include <tqbuttongroup.h> +#include <tqwidgetstack.h> +#include <tqcombobox.h> +#include <tqradiobutton.h> +#include <tqlayout.h> +#include <tqcheckbox.h> + +/* kde headers */ +#include <kurlrequester.h> +#include <klocale.h> +#include <kdebug.h> +#include <kpassdlg.h> + +/* knetworkmanager headers */ +#include "knetworkmanager-accesspoint.h" +#include "knetworkmanager-wireless_device.h" +#include "knetworkmanager-device.h" +#include "knetworkmanager-connection.h" +#include "knetworkmanager-connection_setting_wireless_security_widget.h" +#include "knetworkmanager-connection_setting_wireless_security.h" +#include "knetworkmanager-connection_setting_wireless.h" +#include "knetworkmanager-connection_setting_8021x.h" +#include "sha1.h" +#include "md5.h" +#include "knetworkmanager-wireless_manager.h" + +#define WPA_PMK_LEN 32 + +using namespace ConnectionSettings; + +/* + class WirelessSecurityWEPImpl +*/ +WirelessSecurityWEPImpl::WirelessSecurityWEPImpl(WirelessSecurity* sec, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityWEP(parent, name, fl) + , _security_setting(sec) + , _wepKeyType( WEPKEY_TYPE_HEX ) +{ + cboAuthentication->insertItem(i18n("Open System"), 0); + cboAuthentication->insertItem(i18n("Shared Key"), 1); + if (_security_setting->getAuthAlg() == WirelessSecurity::AUTH_ALG_OPEN) + cboAuthentication->setCurrentItem(0); + else if (_security_setting->getAuthAlg() == WirelessSecurity::AUTH_ALG_SHARED) + cboAuthentication->setCurrentItem(1); + + cbKeyType->insertItem(i18n("WEP 40/128-bit ASCII"), WEPKEY_TYPE_ASCII); + cbKeyType->insertItem(i18n("WEP 40/128-bit Hexadecimal"), WEPKEY_TYPE_HEX); + cbKeyType->insertItem(i18n("WEP 128-bit passphrase"), WEPKEY_TYPE_PASSPHRASE); + cbKeyType->setCurrentItem(_wepKeyType ); + + txtWEPKey0->setText(_security_setting->getWepKey(0)); + txtWEPKey1->setText(_security_setting->getWepKey(1)); + txtWEPKey2->setText(_security_setting->getWepKey(2)); + txtWEPKey3->setText(_security_setting->getWepKey(3)); + + switch(_security_setting->getWepTxidx()) + { + case 0: + rbKeyIdx0->setChecked(true); + break; + case 1: + rbKeyIdx1->setChecked(true); + break; + case 2: + rbKeyIdx2->setChecked(true); + break; + case 3: + rbKeyIdx3->setChecked(true); + break; + default: + rbKeyIdx0->setChecked(true); + break; + } + + connect(cboAuthentication, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotAuthAlgChanged(int))); + connect(cbKeyType, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotKeyTypeChanged(int))); + connect(txtWEPKey0, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotWepKey0Changed(const TQString&))); + connect(txtWEPKey1, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotWepKey1Changed(const TQString&))); + connect(txtWEPKey2, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotWepKey2Changed(const TQString&))); + connect(txtWEPKey3, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotWepKey3Changed(const TQString&))); + + connect(rbKeyIdx0, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotWepIdx0Checked(bool))); + connect(rbKeyIdx1, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotWepIdx1Checked(bool))); + connect(rbKeyIdx2, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotWepIdx2Checked(bool))); + connect(rbKeyIdx3, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotWepIdx3Checked(bool))); +} + +void WirelessSecurityWEPImpl::slotAuthAlgChanged(int index) +{ + if (index == 0) + _security_setting->setAuthAlg(WirelessSecurity::AUTH_ALG_OPEN); + else if (index == 1) + _security_setting->setAuthAlg(WirelessSecurity::AUTH_ALG_SHARED); +} + +void WirelessSecurityWEPImpl::slotKeyTypeChanged(int index) +{ + _wepKeyType = (WEPKEY_TYPE)index; + + // update all WEP-Keys here due to the new key_type +} + +void WirelessSecurityWEPImpl::slotWepKey0Changed(const TQString &key) +{ + TQCString hashed = getHashedWEPKey(key, _wepKeyType); + _security_setting->setWepKey(0, hashed); +} + +void WirelessSecurityWEPImpl::slotWepKey1Changed(const TQString &key) +{ + TQCString hashed = getHashedWEPKey(key, _wepKeyType); + _security_setting->setWepKey(1, hashed); +} + +void WirelessSecurityWEPImpl::slotWepKey2Changed(const TQString &key) +{ + TQCString hashed = getHashedWEPKey(key, _wepKeyType); + _security_setting->setWepKey(2, hashed); +} + +void WirelessSecurityWEPImpl::slotWepKey3Changed(const TQString& key) +{ + TQCString hashed = getHashedWEPKey(key, _wepKeyType); + _security_setting->setWepKey(3, hashed); +} + +void WirelessSecurityWEPImpl::slotWepIdx0Checked(bool check) +{ + if (check) + _security_setting->setWepTxidx(0); +} + +void WirelessSecurityWEPImpl::slotWepIdx1Checked(bool check) +{ + if (check) + _security_setting->setWepTxidx(1); +} + +void WirelessSecurityWEPImpl::slotWepIdx2Checked(bool check) +{ + if (check) + _security_setting->setWepTxidx(2); +} + +void WirelessSecurityWEPImpl::slotWepIdx3Checked(bool check) +{ + if (check) + _security_setting->setWepTxidx(3); +} + +TQCString +WirelessSecurityWEPImpl::getHashedWEPKey(TQString key, WEPKEY_TYPE type) const +{ + TQCString hashed; + switch(type) + { + case WEPKEY_TYPE_HEX: + return TQCString(key); + break; + case WEPKEY_TYPE_ASCII: + hashed = String2Hex(TQCString(key), key.length() * 2); + return hashed; + break; + case WEPKEY_TYPE_PASSPHRASE: + return getWEP128PassphraseHash(TQCString(key)); + break; + } + return hashed; +} + +TQCString +WirelessSecurityWEPImpl::getWEP128PassphraseHash(TQCString input) const +{ + char md5_data[65]; + TQCString digest(16); + int input_len; + int i; + + if (input.isNull()) return input; + + input_len = input.length(); + if (input_len < 1) + return TQCString(); + + /* Get at least 64 bytes */ + for (i = 0; i < 64; i++) + md5_data [i] = input [i % input_len]; + + /* Null terminate md5 seed data and hash it */ + md5_data[64] = 0; + gnome_keyring_md5_string (md5_data, (unsigned char*)digest.data()); + return (String2Hex(TQByteArray(digest), 26)); + +} + +TQCString +WirelessSecurityWEPImpl::String2Hex(TQByteArray bytes, int final_len) const +{ + TQCString result(final_len+1); + static char hex_digits[] = "0123456789abcdef"; + result.resize(bytes.size() * 2 + 1); + for (uint i = 0; i < bytes.size(); i++) + { + result[2*i] = hex_digits[(bytes[i] >> 4) & 0xf]; + result[2*i+1] = hex_digits[bytes[i] & 0xf]; + } + /* Cut converted key off at the correct length for this cipher type */ + if (final_len > -1) + result[final_len] = '\0'; + return result; +} + + +/* + class WirelessSecurityWEPEncryptionImpl +*/ +WirelessSecurityWEPEncryptionImpl::WirelessSecurityWEPEncryptionImpl(WirelessSecurity* security_setting, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityWEPEncryption(parent, name, fl) + , _security_setting(security_setting) +{ + cboEncryption->insertItem(i18n("None")); + cboEncryption->insertItem(i18n("Dynamic WEP")); +} + + +/* + class WirelessSecurityWPAVersionImpl +*/ +WirelessSecurityWPAVersionImpl::WirelessSecurityWPAVersionImpl(WirelessSecurity* security_setting, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityWPAVersion(parent, name, fl) + , _security_setting(security_setting) +{ + cbWPA->setChecked(_security_setting->getProto() & WirelessSecurity::PROTO_WPA); + cbRSN->setChecked(_security_setting->getProto() & WirelessSecurity::PROTO_RSN); + + connect(cbWPA, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotWPA1(bool))); + connect(cbRSN, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotWPA2(bool))); + + connect(grpUseWPAVersion, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotAuto(bool))); +} + +void +WirelessSecurityWPAVersionImpl::slotAuto(bool on) +{ + if (!on) + { + // auto-select proto + _security_setting->setProto(WirelessSecurity::PROTO_AUTO); + } + else + { + // use selected wpa-version + TQ_UINT32 proto = WirelessSecurity::PROTO_NONE; + if (cbWPA->isChecked()) + proto |= WirelessSecurity::PROTO_WPA; + if (cbRSN->isChecked()) + proto |= WirelessSecurity::PROTO_RSN; + _security_setting->setProto(proto); + } +} + +void +WirelessSecurityWPAVersionImpl::slotWPA1(bool on) +{ + if (on) + _security_setting->addProto(WirelessSecurity::PROTO_WPA); + else + _security_setting->delProto(WirelessSecurity::PROTO_WPA); +} + +void +WirelessSecurityWPAVersionImpl::slotWPA2(bool on) +{ + if (on) + _security_setting->addProto(WirelessSecurity::PROTO_RSN); + else + _security_setting->delProto(WirelessSecurity::PROTO_RSN); +} + +/* + class WirelessSecurityWPACipherImpl +*/ +WirelessSecurityWPACipherImpl::WirelessSecurityWPACipherImpl(WirelessSecurity* security_setting, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityWPACipher(parent, name, fl) + , _security_setting(security_setting) +{ + connect(grpUseCipher, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotCipherChangedAuto(bool))); + + connect(chkGroupCipherTKIP, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotGroupCipherChangedTKIP(bool))); + connect(chkGroupCipherCCMP, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotGroupCipherChangedCCMP(bool))); + connect(chkGroupCipherWEP40, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotGroupCipherChangedWEP40(bool))); + connect(chkGroupCipherWEP104, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotGroupCipherChangedWEP104(bool))); + + connect(chkPairwiseCipherTKIP, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotPairwiseCipherChangedTKIP(bool))); + connect(chkPairwiseCipherCCMP, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotPairwiseCipherChangedCCMP(bool))); + + chkPairwiseCipherCCMP->setChecked(_security_setting->getPairwiseCiphers() & WirelessSecurity::CIPHER_CCMP); + chkPairwiseCipherTKIP->setChecked(_security_setting->getPairwiseCiphers() & WirelessSecurity::CIPHER_TKIP); + + chkGroupCipherCCMP->setChecked(_security_setting->getGroupCiphers() & WirelessSecurity::CIPHER_CCMP); + chkGroupCipherTKIP->setChecked(_security_setting->getGroupCiphers() & WirelessSecurity::CIPHER_TKIP); + chkGroupCipherWEP40->setChecked(_security_setting->getGroupCiphers() & WirelessSecurity::CIPHER_WEP40); + chkGroupCipherWEP104->setChecked(_security_setting->getGroupCiphers() & WirelessSecurity::CIPHER_WEP104); + +} + +void +WirelessSecurityWPACipherImpl::slotCipherChangedAuto(bool checked) +{ + if (!checked) + { + // select auto for both ciphers + _security_setting->setGroupCiphers(WirelessSecurity::CIPHER_AUTO); + _security_setting->setPairwiseCiphers(WirelessSecurity::CIPHER_AUTO); + } + else + { + // use the already selected ciphers + + // group cipher + TQ_UINT32 cipher = WirelessSecurity::CIPHER_NONE; + if (chkGroupCipherTKIP->isChecked()) + cipher |= WirelessSecurity::CIPHER_TKIP; + if (chkGroupCipherCCMP->isChecked()) + cipher |= WirelessSecurity::CIPHER_CCMP; + if (chkGroupCipherWEP40->isChecked()) + cipher |= WirelessSecurity::CIPHER_WEP40; + if (chkGroupCipherWEP104->isChecked()) + cipher |= WirelessSecurity::CIPHER_WEP104; + _security_setting->setGroupCiphers(cipher); + + // pairwise cipher + cipher = WirelessSecurity::CIPHER_NONE; + if (chkPairwiseCipherTKIP->isChecked()) + cipher |= WirelessSecurity::CIPHER_TKIP; + if (chkPairwiseCipherCCMP->isChecked()) + cipher |= WirelessSecurity::CIPHER_CCMP; + _security_setting->setPairwiseCiphers(cipher); + + } +} + +void +WirelessSecurityWPACipherImpl::slotGroupCipherChangedTKIP(bool checked) +{ + if (checked) + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() | WirelessSecurity::CIPHER_TKIP); + else + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() & (!WirelessSecurity::CIPHER_TKIP)); +} + +void +WirelessSecurityWPACipherImpl::slotGroupCipherChangedCCMP(bool checked) +{ + if (checked) + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() | WirelessSecurity::CIPHER_CCMP); + else + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() & (!WirelessSecurity::CIPHER_CCMP)); +} + +void +WirelessSecurityWPACipherImpl::slotGroupCipherChangedWEP40(bool checked) +{ + if (checked) + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() | WirelessSecurity::CIPHER_WEP40); + else + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() & (!WirelessSecurity::CIPHER_WEP40)); +} + +void +WirelessSecurityWPACipherImpl::slotGroupCipherChangedWEP104(bool checked) +{ + if (checked) + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() | WirelessSecurity::CIPHER_WEP104); + else + _security_setting->setGroupCiphers(_security_setting->getGroupCiphers() & (!WirelessSecurity::CIPHER_WEP104)); +} + +void +WirelessSecurityWPACipherImpl::slotPairwiseCipherChangedTKIP(bool checked) +{ + if (checked) + _security_setting->setPairwiseCiphers(_security_setting->getPairwiseCiphers() | WirelessSecurity::CIPHER_TKIP); + else + _security_setting->setPairwiseCiphers(_security_setting->getPairwiseCiphers() & (!WirelessSecurity::CIPHER_TKIP)); +} + +void +WirelessSecurityWPACipherImpl::slotPairwiseCipherChangedCCMP(bool checked) +{ + if (checked) + _security_setting->setPairwiseCiphers(_security_setting->getPairwiseCiphers() | WirelessSecurity::CIPHER_CCMP); + else + _security_setting->setPairwiseCiphers(_security_setting->getPairwiseCiphers() & (!WirelessSecurity::CIPHER_CCMP)); +} + +/* + class WirelessSecurityWPAPSK +*/ +WirelessSecurityWPAPSKImpl::WirelessSecurityWPAPSKImpl(WirelessSecurity* security_setting, Wireless* wireless_setting, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityWPAPSK(parent, name, fl) + , _security_setting(security_setting) + , _wireless_setting(wireless_setting) +{ + txtPSK->setText(_security_setting->getPSK()); + connect(txtPSK, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotPSKChanged(const TQString&))); +} + +void +WirelessSecurityWPAPSKImpl::slotPSKChanged(const TQString& psk) +{ + if (_wireless_setting) + { + _security_setting->setPSK(psk); + } +} + +TQCString +WirelessSecurityWPAPSKImpl::String2Hex(TQByteArray bytes, int final_len) const +{ + TQCString result(final_len+1); + static char hex_digits[] = "0123456789abcdef"; + result.resize(bytes.size() * 2 + 1); + for (uint i = 0; i < bytes.size(); i++) + { + result[2*i] = hex_digits[(bytes[i] >> 4) & 0xf]; + result[2*i+1] = hex_digits[bytes[i] & 0xf]; + } + /* Cut converted key off at the correct length for this cipher type */ + if (final_len > -1) + result[final_len] = '\0'; + return result; +} + +/* + class WirelessSecurityEAPImpl +*/ +WirelessSecurityEAPImpl::WirelessSecurityEAPImpl(IEEE8021x* security_setting, WirelessSecurityPhase2Impl* phase2_widget, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityEAP(parent, name, fl) + , _security_setting(security_setting) + , _phase2_widget(phase2_widget) +{ + // insert all EAP-Methods + int index = 0; + cboMethod->insertItem(i18n("None"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_NONE; + + cboMethod->insertItem(i18n("TTLS"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_TTLS; + + cboMethod->insertItem(i18n("PEAP"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_PEAP; + + cboMethod->insertItem(i18n("TLS"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_TLS; + + cboMethod->insertItem(i18n("Leap"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_LEAP; + + cboMethod->insertItem(i18n("MD5"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_MD5; + + cboMethod->insertItem(i18n("FAST"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_FAST; + + cboMethod->insertItem(i18n("SIM"), ++index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE1_SIM; + + // preselect the correct method + TQBiDirectionalMap<int, IEEE8021x::EAP_PHASE1>::Iterator it = _eapIndexMap.findData(_security_setting->getEAP()); + cboMethod->setCurrentItem(it.key()); + + // update phase2 combobox + _phase2_widget->setAllowedPhase2Methods(_security_setting->getAllowedPhase2Methods()); + + txtIdentity->setText(_security_setting->getIdentity()); + txtAnonIdentity->setText(_security_setting->getAnonIdentity()); + txtPassword->setText(_security_setting->getPassword()); + + chkCAStore->setChecked(_security_setting->getUseSystemCaCert()); + kURLCACert->setEnabled(!_security_setting->getUseSystemCaCert()); + + // get notified if the method changes + connect(cboMethod, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMethodChanged(int))); + connect(txtIdentity, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotIdentityChanged(const TQString&))); + connect(txtAnonIdentity, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotAnonIdentityChanged(const TQString&))); + connect(txtPassword, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotPasswordChanged(const TQString&))); + connect(chkCAStore, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotUseSystemCaCertChanged(bool))); +} + +void WirelessSecurityEAPImpl::slotUseSystemCaCertChanged(bool on) +{ + _security_setting->setUseSystemCaCert(on); + kURLCACert->setEnabled(!on); +} + +void WirelessSecurityEAPImpl::slotMethodChanged(int index) +{ + // new method choosen + IEEE8021x::EAP_PHASE1 eap = _eapIndexMap[index]; + _security_setting->setEAP(eap); + + _phase2_widget->setAllowedPhase2Methods(_security_setting->getAllowedPhase2Methods()); +} + +void WirelessSecurityEAPImpl::slotIdentityChanged(const TQString& identity) +{ + _security_setting->setIdentity(identity); +} + +void WirelessSecurityEAPImpl::slotAnonIdentityChanged(const TQString& identity) +{ + _security_setting->setAnonIdentity(identity); +} + +void WirelessSecurityEAPImpl::slotPasswordChanged(const TQString& pwd) +{ + _security_setting->setPassword(TQString(txtPassword->password())); +} + +/* + class WirelessSecurityPhase2Impl +*/ +WirelessSecurityPhase2Impl::WirelessSecurityPhase2Impl(IEEE8021x* security_setting, TQWidget* parent, const char* name, WFlags fl) + : ConnectionSettingWirelessSecurityPhase2(parent, name, fl) + , _security_setting(security_setting) +{ + _allowed_methods.append(IEEE8021x::EAP_PHASE2_AUTH_NONE); + updateMethodComboBox(); + + connect(cboPhase2Method, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotPhase2MethodChanged(int))); +} + +void WirelessSecurityPhase2Impl::updateMethodComboBox() +{ + // insert all phase2 EAP-Methods + int index = 0; + cboPhase2Method->clear(); + _eapIndexMap.clear(); + + for (TQValueList<IEEE8021x::EAP_PHASE2>::Iterator it = _allowed_methods.begin(); it != _allowed_methods.end(); ++it) + { + if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_NONE) + { + cboPhase2Method->insertItem(i18n("None"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_NONE; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_MSCHAPV2) + { + cboPhase2Method->insertItem(i18n("MSCHAPv2"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_MSCHAPV2; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_PAP) + { + cboPhase2Method->insertItem(i18n("PAP"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_PAP; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_CHAP) + { + cboPhase2Method->insertItem(i18n("CHAP"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_CHAP; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_MSCHAP) + { + cboPhase2Method->insertItem(i18n("MSCHAP"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_MSCHAP; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_GTC) + { + cboPhase2Method->insertItem(i18n("GTC"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_GTC; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_OTP) + { + cboPhase2Method->insertItem(i18n("OTP"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_OTP; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_MD5) + { + cboPhase2Method->insertItem(i18n("MD5"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_MD5; + index++; + } + else if ((*it) == IEEE8021x::EAP_PHASE2_AUTH_TLS) + { + cboPhase2Method->insertItem(i18n("TLS"), index); + _eapIndexMap[index] = IEEE8021x::EAP_PHASE2_AUTH_TLS; + index++; + } + } + + // preselect the correct method + TQBiDirectionalMap<int, IEEE8021x::EAP_PHASE2>::Iterator it = _eapIndexMap.findData(_security_setting->getPhase2EAP()); + if (it != _eapIndexMap.end()) + { + cboPhase2Method->setCurrentItem(it.key()); + _security_setting->setPhase2EAP(it.data()); + } + else + { + cboPhase2Method->setCurrentItem(0); + _security_setting->setPhase2EAP(_eapIndexMap[0]); + } +} + +void WirelessSecurityPhase2Impl::setAllowedPhase2Methods(const TQValueList<IEEE8021x::EAP_PHASE2>& list) +{ + _allowed_methods = list; + updateMethodComboBox(); +} + +void WirelessSecurityPhase2Impl::slotPhase2MethodChanged(int index) +{ + // new method choosen + IEEE8021x::EAP_PHASE2 eap = _eapIndexMap[index]; + _security_setting->setPhase2EAP(eap); +} + +/* + class WirelessSecurityWidgetImpl +*/ + +WirelessSecurityWidgetImpl::WirelessSecurityWidgetImpl(Connection* conn, bool new_conn, TQWidget* parent, const char* name, WFlags fl) + : WidgetInterface(parent, name, fl) +{ + _security_setting = dynamic_cast<WirelessSecurity*> (conn->getSetting(NM_SETTING_WIRELESS_SECURITY_SETTING_NAME)); + _wireless_setting = dynamic_cast<Wireless*> (conn->getSetting(NM_SETTING_WIRELESS_SETTING_NAME)); + _ieee8021x_setting = dynamic_cast<IEEE8021x*> (conn->getSetting(NM_SETTING_802_1X_SETTING_NAME)); + _new_conn = new_conn; + + TQVBoxLayout* tqlayout = new TQVBoxLayout(this, 1, 1); + _mainWid = new ConnectionSettingWirelessSecurityWidget(this); + tqlayout->addWidget(_mainWid); + + TQTimer::singleShot(0, this, TQT_SLOT(slotInit())); +} + +void +WirelessSecurityWidgetImpl::slotInit() +{ + // create all security widgets... + TQWidget* wep = new WirelessSecurityWEPImpl(_security_setting, _mainWid->groupUseEncryption); + TQWidget* phase2 = new WirelessSecurityPhase2Impl(_ieee8021x_setting, _mainWid->groupUseEncryption); + TQWidget* eap = new WirelessSecurityEAPImpl(_ieee8021x_setting, (WirelessSecurityPhase2Impl*)phase2, _mainWid->groupUseEncryption); + TQWidget* wpaversion = new WirelessSecurityWPAVersionImpl(_security_setting, _mainWid->groupUseEncryption); + TQWidget* wpacipher = new WirelessSecurityWPACipherImpl(_security_setting, _mainWid->groupUseEncryption); + TQWidget* wpapsk = new WirelessSecurityWPAPSKImpl(_security_setting, _wireless_setting, _mainWid->groupUseEncryption); + TQWidget* wepencryption = new WirelessSecurityWEPEncryptionImpl(_security_setting, _mainWid->groupUseEncryption); + + wep->setHidden(true); + eap->setHidden(true); + wpaversion->setHidden(true); + wpacipher->setHidden(true); + phase2->setHidden(true); + wpapsk->setHidden(true); + wepencryption->setHidden(true); + + _widgets[SECURITY_WEP].clear(); + _widgets[SECURITY_WPA_PSK].clear(); + _widgets[SECURITY_WPA_EAP].clear(); + _widgets[SECURITY_IEEE8021X].clear(); + + // create WEP widget list + _widgets[SECURITY_WEP].append(wep); + + // create WPA PSK widget list + _extra_widgets[SECURITY_WPA_PSK].append(wpaversion); + _extra_widgets[SECURITY_WPA_PSK].append(wpacipher); + _widgets[SECURITY_WPA_PSK].append(wpapsk); + + // create WPA EAP widget list + _extra_widgets[SECURITY_WPA_EAP].append(wpaversion); + _extra_widgets[SECURITY_WPA_EAP].append(wpacipher); + _widgets[SECURITY_WPA_EAP].append(eap); + _widgets[SECURITY_WPA_EAP].append(phase2); + + // create IEEE8021X widget list + _widgets[SECURITY_IEEE8021X].append(wepencryption); + _widgets[SECURITY_IEEE8021X].append(eap); + + connect(_mainWid->cboSecurity, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotComboSecurityActivated(int))); + connect(_mainWid->groupUseEncryption, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotUseEncryptionToggled(bool))); + connect(_mainWid->pbExtra, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotExtraSettingsToggled(bool))); + +} + +void +WirelessSecurityWidgetImpl::Activate() +{ + kdDebug() << "Activate " << (_new_conn ? "New" : "Edit") << endl; + comboSecurityInit(); +} + +void +WirelessSecurityWidgetImpl::comboSecurityInit() +{ + int index = 0; + + TQValueList<SecurityMethods> allowed_methods; + _mainWid->cboSecurity->clear(); + + // TODO: Preselect the right security method + // We should have an Essid already, fetch all possible APs + TQValueList<AccessPoint *> aps; + if (_new_conn && !_wireless_setting->getEssid().isEmpty()) + { + aps = WirelessManager::getAccessPointsForEssid(_wireless_setting->getEssid()); +#if 0 + kdDebug() << "Hugo " << TQString(TQCString(_wireless_setting->getEssid())).ascii() << endl; +#endif + } + if (!aps.isEmpty()) + { + // if at least one AP has this security setting show the entry in the combobox + for (TQValueList<AccessPoint*>::Iterator it = aps.begin(); it != aps.end(); ++it) + { + if((*it)->isEncrypted()) + { + kdDebug() << "AP " << (*it)->getDisplaySsid().ascii() << " is encrypted" << endl; + if ((*it)->getRsnFlags() != NM_802_11_AP_SEC_NONE || (*it)->getWpaFlags() != NM_802_11_AP_SEC_NONE) + { + // WPA or RSN + if ((*it)->getRsnFlags() & NM_802_11_AP_SEC_KEY_MGMT_PSK || (*it)->getWpaFlags() & NM_802_11_AP_SEC_KEY_MGMT_PSK) + if (!allowed_methods.contains(SECURITY_WPA_PSK)) + allowed_methods.append(SECURITY_WPA_PSK); + + + if ((*it)->getRsnFlags() & NM_802_11_AP_SEC_KEY_MGMT_802_1X || (*it)->getWpaFlags() & NM_802_11_AP_SEC_KEY_MGMT_802_1X) + if (!allowed_methods.contains(SECURITY_WPA_EAP)) + allowed_methods.append(SECURITY_WPA_EAP); + } + + // No WPA & RSN => WEP or dynamic WEP with 802.1x authentication + // TODO: an AP can provide WEP in addition to WPA + if (!allowed_methods.contains(SECURITY_WEP)) + allowed_methods.append(SECURITY_WEP); + if (!allowed_methods.contains(SECURITY_IEEE8021X)) + allowed_methods.append(SECURITY_IEEE8021X); + } + } + + // insert only allowed security methods + if (allowed_methods.contains(SECURITY_WPA_PSK)) + { + _securityComboMap.insert(index, SECURITY_WPA_PSK); + _mainWid->cboSecurity->insertItem(i18n("WPA Personal"), index++); + } + + if (allowed_methods.contains(SECURITY_WPA_EAP)) + { + _securityComboMap.insert(index, SECURITY_WPA_EAP); + _mainWid->cboSecurity->insertItem(i18n("WPA Enterprise"), index++); + } + + if (allowed_methods.contains(SECURITY_WEP)) + { + _securityComboMap.insert(index, SECURITY_WEP); + _mainWid->cboSecurity->insertItem(i18n("WEP"), index++); + } + + if (allowed_methods.contains(SECURITY_IEEE8021X)) + { + _securityComboMap.insert(index, SECURITY_IEEE8021X); + _mainWid->cboSecurity->insertItem(i18n("IEEE 802.1X"), index++); + } + } + else + { + // insert all possible authentication methods + _mainWid->cboSecurity->insertItem(i18n("WEP"),SECURITY_WEP ); + _mainWid->cboSecurity->insertItem(i18n("WPA Personal"), SECURITY_WPA_PSK); + _mainWid->cboSecurity->insertItem(i18n("WPA Enterprise"), SECURITY_WPA_EAP); + _mainWid->cboSecurity->insertItem(i18n("IEEE 802.1X"), SECURITY_IEEE8021X); + _securityComboMap.insert(SECURITY_WEP, SECURITY_WEP); + _securityComboMap.insert(SECURITY_WPA_PSK, SECURITY_WPA_PSK); + _securityComboMap.insert(SECURITY_WPA_EAP, SECURITY_WPA_EAP); + _securityComboMap.insert(SECURITY_IEEE8021X, SECURITY_IEEE8021X); + } + + if (!_new_conn) + { + switch(_security_setting->getKeyMgmt()) + { + case WirelessSecurity::KEY_MGMT_NONE: + if (_security_setting->getAuthAlg() == WirelessSecurity::AUTH_ALG_SHARED || + !_security_setting->getWepKey(0).isEmpty() || + !_security_setting->getWepKey(1).isEmpty() || + !_security_setting->getWepKey(2).isEmpty() || + !_security_setting->getWepKey(3).isEmpty() ) + { + _mainWid->groupUseEncryption->setChecked(true); + _mainWid->cboSecurity->setCurrentItem(SECURITY_WEP); + slotComboSecurityActivated(_securityComboMap[SECURITY_WEP]); + } + else + _mainWid->groupUseEncryption->setChecked(false); + break; + case WirelessSecurity::KEY_MGMT_WPA_PSK: + _mainWid->groupUseEncryption->setChecked(true); + _mainWid->cboSecurity->setCurrentItem(SECURITY_WPA_PSK); + slotComboSecurityActivated(_securityComboMap[SECURITY_WPA_PSK]); + break; + case WirelessSecurity::KEY_MGMT_WPA_EAP: + _mainWid->groupUseEncryption->setChecked(true); + _mainWid->cboSecurity->setCurrentItem(SECURITY_WPA_EAP); + slotComboSecurityActivated(_securityComboMap[SECURITY_WPA_EAP]); + break; + case WirelessSecurity::KEY_MGMT_IEEE8021X: + _mainWid->groupUseEncryption->setChecked(true); + _mainWid->cboSecurity->setCurrentItem(SECURITY_IEEE8021X); + slotComboSecurityActivated(_securityComboMap[SECURITY_IEEE8021X]); + break; + + default: + break; + } + } + else + { + // select first possible security method + if (_mainWid->cboSecurity->count() > 0) + { + _mainWid->groupUseEncryption->setChecked(true); + _mainWid->groupUseEncryption->setEnabled(true); + _mainWid->cboSecurity->setCurrentItem(0); + slotComboSecurityActivated(0); + } + else + { + _mainWid->groupUseEncryption->setChecked(false); + _mainWid->groupUseEncryption->setEnabled(false); + } + } +} + +void +WirelessSecurityWidgetImpl::slotUseEncryptionToggled(bool on) +{ + _wireless_setting->setSecurity(on ? _security_setting->getType() : NULL); +} + +void +WirelessSecurityWidgetImpl::slotComboSecurityActivated(int index) +{ + int i = _securityComboMap[index]; + + // authentication switched, we have to show the appropriate widgets and hide some others + switch(i) + { + case SECURITY_WEP: + configureForWEP(); + break; + + case SECURITY_WPA_PSK: + configureForWPAPSK(); + break; + + case SECURITY_WPA_EAP: + configureForWPAEAP(); + break; + + case SECURITY_IEEE8021X: + configureForIEEE8021X(); + break; + + default: + // should not happen, something is broken... + break; + } +} + +void +WirelessSecurityWidgetImpl::configureWidgets(SecurityMethods method) +{ + // store selected method + _currentMethod = method; + + for (int i = 0; i < SECURITY_COUNT; ++i) + { + // remove all current widgets that do not belong to the selected method + if (i != method) + { + for (TQValueList<TQWidget*>::iterator it = _widgets[i].begin(); it != _widgets[i].end(); ++it) + { + _mainWid->groupUseEncryption->tqlayout()->remove(*it); + (*it)->hide(); + } + // remove extra widgets too + for (TQValueList<TQWidget*>::iterator it = _extra_widgets[i].begin(); it != _extra_widgets[i].end(); ++it) + { + _mainWid->groupUseEncryption->tqlayout()->remove(*it); + (*it)->hide(); + } + } + } + + // show all widgets widgets for the selected security method + for (TQValueList<TQWidget*>::iterator it = _widgets[method].begin(); it != _widgets[method].end(); ++it) + { + _mainWid->groupUseEncryption->tqlayout()->add(*it); + (*it)->show(); + } + + if (_mainWid->pbExtra->isOn()) + for (TQValueList<TQWidget*>::iterator it = _extra_widgets[method].begin(); it != _extra_widgets[method].end(); ++it) + { + _mainWid->groupUseEncryption->tqlayout()->add(*it); + (*it)->show(); + } + + // deactivate button if no extra settings are available + _mainWid->pbExtra->setEnabled(!(_extra_widgets[method].begin() == _extra_widgets[method].end())); +} + +void +WirelessSecurityWidgetImpl::slotExtraSettingsToggled(bool on) +{ + if (on) + for (TQValueList<TQWidget*>::iterator it = _extra_widgets[_currentMethod].begin(); it != _extra_widgets[_currentMethod].end(); ++it) + { + _mainWid->groupUseEncryption->tqlayout()->add(*it); + (*it)->show(); + } + else + for (TQValueList<TQWidget*>::iterator it = _extra_widgets[_currentMethod].begin(); it != _extra_widgets[_currentMethod].end(); ++it) + { + _mainWid->groupUseEncryption->tqlayout()->remove(*it); + (*it)->hide(); + } +} + +void +WirelessSecurityWidgetImpl::configureForWEP() +{ + _security_setting->setKeyMgmt(WirelessSecurity::KEY_MGMT_NONE); + configureWidgets(SECURITY_WEP); +} + +void +WirelessSecurityWidgetImpl::configureForWPAPSK() +{ + _security_setting->setKeyMgmt(WirelessSecurity::KEY_MGMT_WPA_PSK); + configureWidgets(SECURITY_WPA_PSK); +} + +void +WirelessSecurityWidgetImpl::configureForWPAEAP() +{ + _security_setting->setKeyMgmt(WirelessSecurity::KEY_MGMT_WPA_EAP); + configureWidgets(SECURITY_WPA_EAP); +} + +void +WirelessSecurityWidgetImpl::configureForIEEE8021X() +{ + _security_setting->setKeyMgmt(WirelessSecurity::KEY_MGMT_IEEE8021X); + configureWidgets(SECURITY_IEEE8021X); +} + + + + +#include "knetworkmanager-connection_setting_wireless_security_widget.moc" |