1 files changed, 451 insertions, 0 deletions
diff --git a/knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security.cpp b/knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security.cpp
new file mode 100644
index 0000000..a01f8f6
--- /dev/null
+++ b/knetworkmanager-0.8/src/knetworkmanager-connection_setting_wireless_security.cpp
@@ -0,0 +1,451 @@
+/**************************************************************************
+ *
+ * knetworkmanager-connection_setting_wireless_security.cpp - A NetworkManager frontend for KDE
+ *
+ * Copyright (C) 2005, 2006 Novell, Inc.
+ *
+ * Author: Helmut Schaa <[email protected]>, <[email protected]>
+ *
+ * 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 <tqhostaddress.h>
+#include <tqvariant.h>
+
+/* kde headers */
+#include <kdebug.h>
+#include <klocale.h>
+
+/* TQT_DBus headers*/
+#include <tqdbusdata.h>
+#include <tqdbusdatamap.h>
+
+/* knetworkmanager headers */
+#include "knetworkmanager.h"
+#include "knetworkmanager-connection_setting_wireless_security.h"
+#include "knetworkmanager-accesspoint.h"
+#include "knetworkmanager-connection_setting_wireless.h"
+#include "knetworkmanager-connection.h"
+#include "sha1.h"
+#include "md5.h"
+
+
+using namespace ConnectionSettings;
+
+/*
+	class WirelessSecurity
+*/
+WirelessSecurity::WirelessSecurity(Connection* conn)
+	: ConnectionSetting(conn, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME)
+	, _keyMgmt(KEY_MGMT_NONE)
+	, _wepTxKeyidx(0)
+	, _authAlg(AUTH_ALG_NONE)
+	, _proto(PROTO_NONE)
+	, _pairwise(CIPHER_TKIP | CIPHER_CCMP)
+	, _group(CIPHER_TKIP | CIPHER_CCMP)
+{
+	// init key_mgmt map
+	_keyMgmtMap[KEY_MGMT_NONE] = "none";
+	_keyMgmtMap[KEY_MGMT_WPA_PSK] = "wpa-psk";
+	_keyMgmtMap[KEY_MGMT_WPA_EAP] = "wpa-eap";
+	_keyMgmtMap[KEY_MGMT_IEEE8021X] = "ieee8021x";
+
+	// init auth_alg map
+	_authAlgMap[AUTH_ALG_NONE] = TQString(); // do not include auth alg if none is needed
+	_authAlgMap[AUTH_ALG_OPEN] = "open";
+	_authAlgMap[AUTH_ALG_SHARED] = "shared";
+	_authAlgMap[AUTH_ALG_LEAP] = "leap";
+
+	// proto map
+	_protoMap[PROTO_WPA] = "wpa";
+	_protoMap[PROTO_RSN] = "rsn"; // Info: rsn is wpa2
+
+	// cipher map
+	_cipherMap[CIPHER_TKIP] = "tkip";
+	_cipherMap[CIPHER_CCMP] = "ccmp";
+	_cipherMap[CIPHER_WEP40] = "wep40";
+	_cipherMap[CIPHER_WEP104] = "wep104";
+
+}
+
+bool WirelessSecurity::getEnabled() const
+{
+	Connection* conn = getConnection();
+	if (conn)
+	{
+		Wireless* wireless = dynamic_cast<Wireless*>(conn->getSetting(NM_SETTING_WIRELESS_SETTING_NAME));
+		if (wireless && wireless->getSecurity() != getType())
+		{
+			kdDebug() << "WirelessSecurity::getEnabled false " << wireless->getSecurity().ascii() << endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+int
+WirelessSecurity::getWepTxidx(void) const
+{
+	return _wepTxKeyidx;
+}
+
+void
+WirelessSecurity::setWepTxidx(int idx)
+{
+	if (idx >= 0 && idx < 4)
+		_wepTxKeyidx = idx;
+}
+
+void
+WirelessSecurity::setWepKey(int idx, TQString key)
+{
+	kdDebug() << "WirelessSecurity::setWepKey " << idx << " " << key.ascii() << endl;
+	if (idx >= 0 && idx < 4)
+		_wepKey[idx] = key;
+}
+
+TQString
+WirelessSecurity::getWepKey(int idx) const
+{
+	if (idx >= 0 && idx < 4)
+		return _wepKey[idx];
+	return TQString();
+}
+
+uint32_t
+WirelessSecurity::getGroupCiphers(void) const
+{
+	return _group;
+}
+
+void
+WirelessSecurity::setGroupCiphers(uint32_t ciphers)
+{
+	_group= ciphers & (CIPHER_TKIP | CIPHER_CCMP | CIPHER_WEP40 | CIPHER_WEP104);
+}
+
+uint32_t
+WirelessSecurity::getPairwiseCiphers(void) const
+{
+	return _pairwise;
+}
+
+void
+WirelessSecurity::setPairwiseCiphers(uint32_t ciphers)
+{
+	// only tkip and ccmp allowed
+	_pairwise = ciphers & (CIPHER_TKIP | CIPHER_CCMP);
+}
+
+uint32_t
+WirelessSecurity::getProto(void) const
+{
+	return _proto;
+}
+
+void
+WirelessSecurity::setProto(uint32_t proto)
+{
+	_proto = proto & (PROTO_WPA | PROTO_RSN);
+}
+
+void
+WirelessSecurity::addProto(uint32_t proto)
+{
+	setProto(_proto | proto);
+}
+
+void
+WirelessSecurity::delProto(uint32_t proto)
+{
+	setProto(_proto & ~proto);
+}
+
+TQString
+WirelessSecurity::getPSK(void) const
+{
+	return _psk;
+}
+
+void
+WirelessSecurity::setPSK(const TQString& psk)
+{
+	_psk = psk;
+}
+
+TQString
+WirelessSecurity::getLeapPassword(void) const
+{
+	return _leapPassword;
+}
+
+void
+WirelessSecurity::setLeapPassword(const TQString& p)
+{
+	_leapPassword = p;
+}
+
+TQString
+WirelessSecurity::getLeapUsername(void) const
+{
+	return _leapUsername;
+}
+
+void
+WirelessSecurity::setLeapUsername(const TQString& u)
+{
+	_leapUsername = u;
+}
+
+WirelessSecurity::KEY_MGMT
+WirelessSecurity::getKeyMgmt(void) const
+{
+	return _keyMgmt;
+}
+
+void
+WirelessSecurity::setKeyMgmt(KEY_MGMT keyMgmt)
+{
+	_keyMgmt = keyMgmt;
+}
+
+WirelessSecurity::AUTH_ALG
+WirelessSecurity::getAuthAlg(void) const
+{
+	return _authAlg;
+}
+
+void
+WirelessSecurity::setAuthAlg(AUTH_ALG authAlg)
+{
+	_authAlg = authAlg;
+}
+
+SettingsMap
+WirelessSecurity::toMap() const
+{
+	SettingsMap map;
+
+	// KEY MGMT
+	map.insert(NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, TQT_DBusData::fromString(_keyMgmtMap[_keyMgmt]));
+
+	// WEP TX KEYIDX is only needed if WEP is used
+	if (_keyMgmt == KEY_MGMT_NONE && _wepTxKeyidx >= 0 && _wepTxKeyidx <= 3)
+	{
+		// WEP TX KEYIDX
+		map.insert(NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX, TQT_DBusData::fromInt32(_wepTxKeyidx));
+	}
+
+	// AUTH ALG
+	if (_authAlg != AUTH_ALG_NONE)
+		map.insert(NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, TQT_DBusData::fromString(_authAlgMap[_authAlg]));
+
+	// PROTO is only needed for WPA connections 
+	if (_proto != PROTO_NONE && (_keyMgmt == KEY_MGMT_WPA_NONE || _keyMgmt == KEY_MGMT_WPA_PSK || _keyMgmt == KEY_MGMT_WPA_EAP))
+	{
+		TQValueList<TQT_DBusData> protos;
+		for (TQMap<PROTO, TQString>::ConstIterator it = _protoMap.begin(); it != _protoMap.end(); ++it)
+			if (_proto & it.key())
+				protos.append(TQT_DBusData::fromString(it.data()));
+		if (protos.size() > 0)
+			map.insert(NM_SETTING_WIRELESS_SECURITY_PROTO, TQT_DBusData::fromTQValueList(protos));
+	}
+
+	// groupcipher
+	if (_group != CIPHER_NONE)
+	{
+		TQValueList<TQT_DBusData> ciphers;
+		for (TQMap<CIPHERS, TQString>::ConstIterator it = _cipherMap.begin(); it != _cipherMap.end(); ++it)
+			if (_group & it.key())
+				ciphers.append(TQT_DBusData::fromString(it.data()));
+
+		if (ciphers.size() > 0)
+			map.insert(NM_SETTING_WIRELESS_SECURITY_GROUP, TQT_DBusData::fromTQValueList(ciphers));
+	}
+
+	// pairwise cipher
+	if (_pairwise != CIPHER_NONE)
+	{
+		TQValueList<TQT_DBusData> ciphers;
+
+		for (TQMap<CIPHERS, TQString>::ConstIterator it = _cipherMap.begin(); it != _cipherMap.end(); ++it)
+			if (_pairwise & it.key())
+				ciphers.append(TQT_DBusData::fromString(it.data()));
+
+		if (ciphers.size() > 0)
+			map.insert(NM_SETTING_WIRELESS_SECURITY_PAIRWISE, TQT_DBusData::fromTQValueList(ciphers));
+	}
+
+	if (!_leapUsername.isEmpty())
+		map.insert(NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME, TQT_DBusData::fromString(_leapUsername));
+
+	return map;
+}
+
+void
+WirelessSecurity::fromMap(const SettingsMap& map)
+{
+	kdDebug() << "WirelessSecurity::fromMap" << endl;
+
+	for (SettingsMap::ConstIterator it = map.begin(); it != map.end(); ++it)
+	{
+		if (it.key() == NM_SETTING_WIRELESS_SECURITY_KEY_MGMT)
+		{
+			TQBiDirectionalMap<KEY_MGMT, TQString>::Iterator it2;
+			if (_keyMgmtMap.end() != (it2 = _keyMgmtMap.findData(it.data().toString())))
+				setKeyMgmt(it2.key());
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX)
+		{
+			_wepTxKeyidx = it.data().toInt32();
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_AUTH_ALG)
+		{
+			TQBiDirectionalMap<AUTH_ALG, TQString>::Iterator it2;
+			if (_authAlgMap.end() != (it2 = _authAlgMap.findData(it.data().toString())))
+				setAuthAlg(it2.key());
+		}
+		else if(it.key() == NM_SETTING_WIRELESS_SECURITY_PROTO)
+		{
+			TQValueList<TQT_DBusData> proto_list = it.data().toTQValueList();
+			uint32_t protos = PROTO_NONE;
+			for (TQValueList<TQT_DBusData>::Iterator proto_it = proto_list.begin(); proto_it != proto_list.end(); ++proto_it)
+			{
+				TQBiDirectionalMap<PROTO, TQString>::Iterator it2;
+				if (_protoMap.end() != (it2 = _protoMap.findData( (*proto_it).toString() )))
+					protos |= it2.key();
+			}
+			setProto(protos);
+		}
+		else if(it.key() == NM_SETTING_WIRELESS_SECURITY_GROUP)
+		{
+			TQValueList<TQT_DBusData> cipher_list = it.data().toTQValueList();
+			uint32_t ciphers = CIPHER_NONE;
+			for (TQValueList<TQT_DBusData>::Iterator cipher_it = cipher_list.begin(); cipher_it != cipher_list.end(); ++cipher_it)
+			{
+				TQBiDirectionalMap<CIPHERS, TQString>::Iterator it2;
+				if (_cipherMap.end() != (it2 = _cipherMap.findData( (*cipher_it).toString() )))
+					ciphers |= it2.key();
+			}
+			setGroupCiphers(ciphers);
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_PAIRWISE)
+		{
+			TQValueList<TQT_DBusData> cipher_list = it.data().toTQValueList();
+			uint32_t ciphers = CIPHER_NONE;
+			for (TQValueList<TQT_DBusData>::Iterator cipher_it = cipher_list.begin(); cipher_it != cipher_list.end(); ++cipher_it)
+			{
+				TQBiDirectionalMap<CIPHERS, TQString>::Iterator it2;
+				if (_cipherMap.end() != (it2 = _cipherMap.findData( (*cipher_it).toString() )))
+					ciphers |= it2.key();
+			}
+			setPairwiseCiphers(ciphers);
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME)
+		{
+			_leapUsername = it.data().toString();
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD)
+		{
+			_leapPassword = it.data().toString();
+		}
+		else
+			kdWarning() << k_funcinfo << " Unknown setting: " << it.key() << endl;
+	}
+}
+
+SettingsMap
+WirelessSecurity::toSecretsMap(bool with_settings) const
+{
+	SettingsMap map;
+	kdDebug() << "WirelessSecurity::toSecretsMap" << endl;
+	// first serialize the settings if needed
+	if (with_settings)
+		map = toMap();
+
+	// add the hashed psk
+	if (!_psk.isNull())
+	{
+		map.insert(NM_SETTING_WIRELESS_SECURITY_PSK, TQT_DBusData::fromString(_psk), TRUE);
+	}
+
+	// wep keys
+	if (!_wepKey[0].isNull())
+	{
+		kdDebug() << "insert wep key0: " << _wepKey[0].ascii() << endl;
+		map.insert(NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, TQT_DBusData::fromString(_wepKey[0]));
+	}
+
+	if (!_wepKey[1].isNull())
+	{
+		map.insert(NM_SETTING_WIRELESS_SECURITY_WEP_KEY1, TQT_DBusData::fromString(_wepKey[1]));
+	}
+
+	if (!_wepKey[2].isNull())
+	{
+		map.insert(NM_SETTING_WIRELESS_SECURITY_WEP_KEY2, TQT_DBusData::fromString(_wepKey[2]));
+	}
+
+	if (!_wepKey[3].isNull())
+	{
+		map.insert(NM_SETTING_WIRELESS_SECURITY_WEP_KEY3, TQT_DBusData::fromString(_wepKey[3]));
+	}
+
+	if (!_leapPassword.isEmpty())
+		map.insert(NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD, TQT_DBusData::fromString(_leapPassword));
+
+	return map;
+}
+
+bool
+WirelessSecurity::fromSecretsMap(const SettingsMap& map)
+{
+	kdDebug() << "WirelessSecurity::fromMap" << endl;
+
+	for (SettingsMap::ConstIterator it = map.begin(); it != map.end(); ++it)
+	{
+		if (it.key() == NM_SETTING_WIRELESS_SECURITY_PSK)
+		{
+			_psk = it.data().toString();
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_WEP_KEY0)
+		{
+			_wepKey[0] = it.data().toString();
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_WEP_KEY1)
+		{
+			_wepKey[1] = it.data().toString();
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_WEP_KEY2)
+		{
+			_wepKey[2] = it.data().toString();
+		}
+		else if (it.key() == NM_SETTING_WIRELESS_SECURITY_WEP_KEY3)
+		{
+			_wepKey[3] = it.data().toString();
+		}
+		else
+			kdWarning() << k_funcinfo << " Unknown setting: " << it.key() << endl;
+	}
+	return true;
+}
+
+bool
+WirelessSecurity::isValid() const
+{
+	return true;
+}